import * as Types from './global-types';
import * as Apollo from '@apollo/client';
import * as ApolloReactHooks from '@apollo/client/react';
export type ArchiveKnowledgeBaseArticleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type ArchiveKnowledgeBaseArticleMutation = {
    __typename?: 'Mutation';
    archiveKnowledgeBaseArticle: {
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        status: Types.ArticleStatus;
        archivedAt?: string | null;
    };
};
export type CreateKnowledgeBaseArticleMutationVariables = Types.Exact<{
    input: Types.CreateKnowledgeBaseArticleInput;
}>;
export type CreateKnowledgeBaseArticleMutation = {
    __typename?: 'Mutation';
    createKnowledgeBaseArticle: {
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        title: string;
        slug: string;
        content: string;
        excerpt?: string | null;
        status: Types.ArticleStatus;
        categoryId?: string | null;
        tags: Array<string>;
        metaDescription?: string | null;
        authorId: string;
        createdAt: string;
    };
};
export type CreateTicketCategoryMutationVariables = Types.Exact<{
    input: Types.CreateTicketCategoryInput;
}>;
export type CreateTicketCategoryMutation = {
    __typename?: 'Mutation';
    createTicketCategory: {
        __typename?: 'TicketCategory';
        id: string;
        name: string;
        slug: string;
        description?: string | null;
        color?: string | null;
        icon?: string | null;
        isActive: boolean;
    };
};
export type DeleteKnowledgeBaseArticleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteKnowledgeBaseArticleMutation = {
    __typename?: 'Mutation';
    deleteKnowledgeBaseArticle: boolean;
};
export type DeleteTicketCategoryMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteTicketCategoryMutation = {
    __typename?: 'Mutation';
    deleteTicketCategory: boolean;
};
export type PublishKnowledgeBaseArticleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type PublishKnowledgeBaseArticleMutation = {
    __typename?: 'Mutation';
    publishKnowledgeBaseArticle: {
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        status: Types.ArticleStatus;
        publishedAt?: string | null;
    };
};
export type UnpublishKnowledgeBaseArticleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type UnpublishKnowledgeBaseArticleMutation = {
    __typename?: 'Mutation';
    unpublishKnowledgeBaseArticle: {
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        status: Types.ArticleStatus;
    };
};
export type UpdateKnowledgeBaseArticleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateKnowledgeBaseArticleInput;
}>;
export type UpdateKnowledgeBaseArticleMutation = {
    __typename?: 'Mutation';
    updateKnowledgeBaseArticle: {
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        title: string;
        slug: string;
        content: string;
        excerpt?: string | null;
        status: Types.ArticleStatus;
        categoryId?: string | null;
        tags: Array<string>;
        metaDescription?: string | null;
        updatedAt: string;
    };
};
export type UpdateTicketCategoryMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateTicketCategoryInput;
}>;
export type UpdateTicketCategoryMutation = {
    __typename?: 'Mutation';
    updateTicketCategory: {
        __typename?: 'TicketCategory';
        id: string;
        name: string;
        slug: string;
        description?: string | null;
        color?: string | null;
        icon?: string | null;
        isActive: boolean;
    };
};
export type CreateSupportMessageMutationVariables = Types.Exact<{
    input: Types.CreateSupportMessageInput;
}>;
export type CreateSupportMessageMutation = {
    __typename?: 'Mutation';
    createSupportMessage: {
        __typename?: 'SupportMessage';
        id: string;
        ticketId: string;
        authorId: string;
        message: string;
        type: Types.MessageType;
        attachments: Array<string>;
        attachmentCount: number;
        isInternal: boolean;
        createdAt: string;
        updatedAt: string;
    };
};
export type AssignInterviewersToRoundMutationVariables = Types.Exact<{
    input: Types.AssignInterviewersToRoundInput;
}>;
export type AssignInterviewersToRoundMutation = {
    __typename?: 'Mutation';
    assignInterviewersToRound: {
        __typename?: 'InterviewRound';
        id: string;
        applicationId: string;
        roundConfigId?: string | null;
        name: string;
        roundType: Types.InterviewRoundType;
        status: Types.InterviewRoundStatus;
        scheduledAt?: string | null;
        notes?: string | null;
        candidateMessage?: string | null;
        candidateMessageSentAt?: string | null;
        assignmentId?: string | null;
        submittedRepoUrl?: string | null;
        submittedVideoUrl?: string | null;
        submittedAt?: string | null;
        submittedNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
        interviewers: Array<{
            __typename?: 'InterviewRoundInterviewer';
            id: string;
            role: Types.InterviewerRole;
            assignedAt: string;
            interviewer: {
                __typename?: 'Interviewer';
                id: string;
                name: string;
                email: string;
                title?: string | null;
            };
        }>;
    };
};
export type AssignSupportTicketMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    assignedTo: Types.Scalars['String']['input'];
}>;
export type AssignSupportTicketMutation = {
    __typename?: 'Mutation';
    assignSupportTicket: {
        __typename?: 'SupportTicket';
        id: string;
        ticketNumber: string;
        assignedTo?: string | null;
        updatedAt: string;
    };
};
export type BulkEnsureInterviewRoundsMutationVariables = Types.Exact<{
    input: Types.BulkEnsureInterviewRoundsInput;
}>;
export type BulkEnsureInterviewRoundsMutation = {
    __typename?: 'Mutation';
    bulkEnsureInterviewRounds: {
        __typename?: 'BulkEnsureInterviewRoundsResult';
        created: Array<{
            __typename?: 'BulkEnsureInterviewRoundItem';
            applicationId: string;
            round: {
                __typename?: 'InterviewRound';
                id: string;
            };
        }>;
        alreadyPresent: Array<{
            __typename?: 'BulkEnsureInterviewRoundItem';
            applicationId: string;
            round: {
                __typename?: 'InterviewRound';
                id: string;
            };
        }>;
        failed: Array<{
            __typename?: 'BulkEnsureInterviewRoundFailed';
            applicationId: string;
            code: Types.BulkEnsureInterviewRoundFailureCode;
            message: string;
        }>;
    };
};
export type BulkRandomizeAndSendAssignmentMutationVariables = Types.Exact<{
    input: Types.BulkRandomizeAndSendAssignmentInput;
}>;
export type BulkRandomizeAndSendAssignmentMutation = {
    __typename?: 'Mutation';
    bulkRandomizeAndSendAssignment: {
        __typename?: 'BulkSendResult';
        succeeded: Array<{
            __typename?: 'InterviewRound';
            id: string;
            applicationId: string;
            assignmentId?: string | null;
            status: Types.InterviewRoundStatus;
        }>;
        skipped: Array<{
            __typename?: 'BulkSendSkipped';
            applicationId: string;
            roundId: string;
            reason: Types.BulkSendSkipReason;
            message: string;
        }>;
        failed: Array<{
            __typename?: 'BulkSendFailed';
            applicationId: string;
            roundId: string;
            message: string;
        }>;
    };
};
export type BulkSendCustomEmailMutationVariables = Types.Exact<{
    input: Types.BulkSendCustomEmailInput;
}>;
export type BulkSendCustomEmailMutation = {
    __typename?: 'Mutation';
    bulkSendCustomEmail: {
        __typename?: 'BulkCustomEmailResult';
        succeeded: Array<{
            __typename?: 'JobApplication';
            id: string;
            email: string;
        }>;
        failed: Array<{
            __typename?: 'BulkCustomEmailFailed';
            applicationId: string;
            message: string;
        }>;
    };
};
export type BulkSendRoundMessageMutationVariables = Types.Exact<{
    input: Types.BulkSendRoundMessageInput;
}>;
export type BulkSendRoundMessageMutation = {
    __typename?: 'Mutation';
    bulkSendRoundMessage: {
        __typename?: 'BulkSendResult';
        succeeded: Array<{
            __typename?: 'InterviewRound';
            id: string;
            applicationId: string;
            candidateMessageSentAt?: string | null;
            status: Types.InterviewRoundStatus;
        }>;
        skipped: Array<{
            __typename?: 'BulkSendSkipped';
            applicationId: string;
            roundId: string;
            reason: Types.BulkSendSkipReason;
            message: string;
        }>;
        failed: Array<{
            __typename?: 'BulkSendFailed';
            applicationId: string;
            roundId: string;
            message: string;
        }>;
    };
};
export type BulkUpdateApplicationStatusMutationVariables = Types.Exact<{
    input: Types.BulkUpdateApplicationStatusInput;
}>;
export type BulkUpdateApplicationStatusMutation = {
    __typename?: 'Mutation';
    bulkUpdateApplicationStatus: {
        __typename?: 'BulkUpdateApplicationStatusResult';
        succeeded: Array<{
            __typename?: 'JobApplication';
            id: string;
            status: Types.JobApplicationStatus;
            updatedAt: string;
        }>;
        failed: Array<{
            __typename?: 'BulkUpdateApplicationStatusFailed';
            applicationId: string;
            message: string;
        }>;
    };
};
export type UpdateSupportTicketStatusMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    status: Types.SupportTicketStatus;
}>;
export type UpdateSupportTicketStatusMutation = {
    __typename?: 'Mutation';
    updateSupportTicketStatus: {
        __typename?: 'SupportTicket';
        id: string;
        ticketNumber: string;
        status: Types.SupportTicketStatus;
        resolvedAt?: string | null;
        closedAt?: string | null;
        updatedAt: string;
    };
};
export type CloseSupportTicketMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type CloseSupportTicketMutation = {
    __typename?: 'Mutation';
    closeSupportTicket: {
        __typename?: 'SupportTicket';
        id: string;
        ticketNumber: string;
        status: Types.SupportTicketStatus;
        resolvedAt?: string | null;
        closedAt?: string | null;
        updatedAt: string;
        surveys: Array<{
            __typename?: 'CustomerSatisfactionSurvey';
            id: string;
            rating: number;
            comment?: string | null;
            feedbackType?: Types.FeedbackCategory | null;
            submittedAt?: string | null;
            createdAt: string;
        }>;
    };
};
export type CreateCannedResponseMutationVariables = Types.Exact<{
    input: Types.CreateCannedResponseInput;
}>;
export type CreateCannedResponseMutation = {
    __typename?: 'Mutation';
    createCannedResponse: {
        __typename?: 'CannedResponse';
        id: string;
        tenantId?: string | null;
        title: string;
        content: string;
        tags: Array<string>;
        createdAt: string;
        updatedAt: string;
    };
};
export type CreateInterviewRoundMutationVariables = Types.Exact<{
    input: Types.CreateInterviewRoundInput;
}>;
export type CreateInterviewRoundMutation = {
    __typename?: 'Mutation';
    createInterviewRound: {
        __typename?: 'InterviewRound';
        id: string;
        applicationId: string;
        roundConfigId?: string | null;
        name: string;
        roundType: Types.InterviewRoundType;
        status: Types.InterviewRoundStatus;
        scheduledAt?: string | null;
        notes?: string | null;
        candidateMessage?: string | null;
        candidateMessageSentAt?: string | null;
        assignmentId?: string | null;
        submittedRepoUrl?: string | null;
        submittedVideoUrl?: string | null;
        submittedAt?: string | null;
        submittedNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type CreateInterviewRoundConfigMutationVariables = Types.Exact<{
    input: Types.CreateInterviewRoundConfigInput;
}>;
export type CreateInterviewRoundConfigMutation = {
    __typename?: 'Mutation';
    createInterviewRoundConfig: {
        __typename?: 'InterviewRoundConfig';
        id: string;
        jobPostingId: string;
        roundNumber: number;
        name: string;
        description?: string | null;
        roundType: Types.InterviewRoundType;
        isAssignmentRound: boolean;
        isRequired: boolean;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type CreateInterviewerMutationVariables = Types.Exact<{
    input: Types.CreateInterviewerInput;
}>;
export type CreateInterviewerMutation = {
    __typename?: 'Mutation';
    createInterviewer: {
        __typename?: 'Interviewer';
        id: string;
        name: string;
        email: string;
        userId?: string | null;
        department?: string | null;
        title?: string | null;
        isActive: boolean;
        notes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type CreateJobApplicationMutationVariables = Types.Exact<{
    input: Types.CreateJobApplicationInput;
}>;
export type CreateJobApplicationMutation = {
    __typename?: 'Mutation';
    createJobApplication: {
        __typename?: 'JobApplication';
        id: string;
        firstName: string;
        lastName: string;
        email: string;
        phone?: string | null;
        position: string;
        department?: string | null;
        source: string;
        status: Types.JobApplicationStatus;
        jobPostingId?: string | null;
        resumeFileName?: string | null;
        createdAt: string;
    };
};
export type CreateJobAssignmentMutationVariables = Types.Exact<{
    input: Types.CreateJobAssignmentInput;
}>;
export type CreateJobAssignmentMutation = {
    __typename?: 'Mutation';
    createJobAssignment: {
        __typename?: 'JobAssignment';
        id: string;
        jobPostingId: string;
        title: string;
        description: string;
        problemStatement?: string | null;
        difficulty?: string | null;
        isActive: boolean;
        ownerEmail?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type CreateJobPostingMutationVariables = Types.Exact<{
    input: Types.CreateJobPostingInput;
}>;
export type CreateJobPostingMutation = {
    __typename?: 'Mutation';
    createJobPosting: {
        __typename?: 'JobPosting';
        id: string;
        title: string;
        department?: string | null;
        location?: string | null;
        employmentType?: Types.EmploymentType | null;
        description?: string | null;
        productId?: string | null;
        status: Types.JobPostingStatus;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type CreateSlaPolicyMutationVariables = Types.Exact<{
    input: Types.CreateSlaPolicyInput;
}>;
export type CreateSlaPolicyMutation = {
    __typename?: 'Mutation';
    createSLAPolicy: {
        __typename?: 'SLAPolicy';
        id: string;
        tenantId?: string | null;
        name: string;
        description?: string | null;
        priority: Types.SupportTicketPriority;
        firstResponseMinutes: number;
        resolutionMinutes: number;
        businessHours?: Record<string, unknown> | null;
        isActive: boolean;
        isDefault: boolean;
        createdAt: string;
        updatedAt: string;
    };
};
export type CreateSupportTicketMutationVariables = Types.Exact<{
    input: Types.CreateSupportTicketInput;
}>;
export type CreateSupportTicketMutation = {
    __typename?: 'Mutation';
    createSupportTicket: {
        __typename?: 'SupportTicket';
        id: string;
        ticketNumber: string;
        subject: string;
        description: string;
        status: Types.SupportTicketStatus;
        priority: Types.SupportTicketPriority;
        category?: Types.SupportTicketCategory | null;
        categoryId?: string | null;
        source: Types.TicketSource;
        tags: Array<string>;
        dueAt?: string | null;
        slaBreachStatus: Types.SlaBreachStatus;
        createdAt: string;
        updatedAt: string;
        user: {
            __typename?: 'User';
            id: string;
        };
        ticketCategory?: {
            __typename?: 'TicketCategory';
            id: string;
            name: string;
            color?: string | null;
        } | null;
    };
};
export type DeleteCannedResponseMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteCannedResponseMutation = {
    __typename?: 'Mutation';
    deleteCannedResponse: boolean;
};
export type DeleteInterviewFeedbackMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteInterviewFeedbackMutation = {
    __typename?: 'Mutation';
    deleteInterviewFeedback: boolean;
};
export type DeleteInterviewRoundMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteInterviewRoundMutation = {
    __typename?: 'Mutation';
    deleteInterviewRound: boolean;
};
export type DeleteInterviewRoundConfigMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteInterviewRoundConfigMutation = {
    __typename?: 'Mutation';
    deleteInterviewRoundConfig: boolean;
};
export type DeleteInterviewerMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteInterviewerMutation = {
    __typename?: 'Mutation';
    deleteInterviewer: boolean;
};
export type DeleteJobAssignmentMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteJobAssignmentMutation = {
    __typename?: 'Mutation';
    deleteJobAssignment: boolean;
};
export type DeleteJobPostingMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteJobPostingMutation = {
    __typename?: 'Mutation';
    deleteJobPosting: boolean;
};
export type DeleteSlaPolicyMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteSlaPolicyMutation = {
    __typename?: 'Mutation';
    deleteSLAPolicy: boolean;
};
export type NotifyDuplicateApplicantsMutationVariables = Types.Exact<{
    input: Types.NotifyDuplicateApplicantsInput;
}>;
export type NotifyDuplicateApplicantsMutation = {
    __typename?: 'Mutation';
    notifyDuplicateApplicants: {
        __typename?: 'DuplicateNoticeResult';
        succeeded: Array<{
            __typename?: 'JobApplication';
            id: string;
            email: string;
        }>;
        skipped: Array<{
            __typename?: 'DuplicateNoticeSkipped';
            email: string;
            reason: Types.BulkSendSkipReason;
            message: string;
        }>;
        failed: Array<{
            __typename?: 'DuplicateNoticeFailed';
            email: string;
            message: string;
        }>;
    };
};
export type RandomizeAndSendAssignmentMutationVariables = Types.Exact<{
    input: Types.RandomizeAndSendAssignmentInput;
}>;
export type RandomizeAndSendAssignmentMutation = {
    __typename?: 'Mutation';
    randomizeAndSendAssignment: {
        __typename?: 'InterviewRound';
        id: string;
        applicationId: string;
        roundConfigId?: string | null;
        name: string;
        roundType: Types.InterviewRoundType;
        status: Types.InterviewRoundStatus;
        scheduledAt?: string | null;
        notes?: string | null;
        candidateMessage?: string | null;
        candidateMessageSentAt?: string | null;
        assignmentId?: string | null;
        submittedRepoUrl?: string | null;
        submittedVideoUrl?: string | null;
        submittedAt?: string | null;
        submittedNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
        assignment?: {
            __typename?: 'JobAssignment';
            id: string;
            title: string;
            description: string;
            problemStatement?: string | null;
            difficulty?: string | null;
        } | null;
    };
};
export type RateArticleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    helpful: Types.Scalars['Boolean']['input'];
}>;
export type RateArticleMutation = {
    __typename?: 'Mutation';
    rateArticle: {
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        helpfulCount: number;
        notHelpfulCount: number;
    };
};
export type RecordArticleViewMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type RecordArticleViewMutation = {
    __typename?: 'Mutation';
    recordArticleView: {
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        viewCount: number;
    };
};
export type RecordAssignmentSubmissionMutationVariables = Types.Exact<{
    input: Types.RecordAssignmentSubmissionInput;
}>;
export type RecordAssignmentSubmissionMutation = {
    __typename?: 'Mutation';
    recordAssignmentSubmission: {
        __typename?: 'InterviewRound';
        id: string;
        applicationId: string;
        roundConfigId?: string | null;
        name: string;
        roundType: Types.InterviewRoundType;
        status: Types.InterviewRoundStatus;
        scheduledAt?: string | null;
        notes?: string | null;
        candidateMessage?: string | null;
        candidateMessageSentAt?: string | null;
        assignmentId?: string | null;
        submittedRepoUrl?: string | null;
        submittedVideoUrl?: string | null;
        submittedAt?: string | null;
        submittedNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type RemoveInterviewerFromRoundMutationVariables = Types.Exact<{
    roundId: Types.Scalars['ID']['input'];
    interviewerId: Types.Scalars['ID']['input'];
}>;
export type RemoveInterviewerFromRoundMutation = {
    __typename?: 'Mutation';
    removeInterviewerFromRound: boolean;
};
export type ReplyToContactInquiryMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    message: Types.Scalars['String']['input'];
}>;
export type ReplyToContactInquiryMutation = {
    __typename?: 'Mutation';
    replyToContactInquiry: {
        __typename?: 'ContactInquiryReplyResult';
        success: boolean;
        message?: string | null;
    };
};
export type ReplyToJobApplicationMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    message: Types.Scalars['String']['input'];
}>;
export type ReplyToJobApplicationMutation = {
    __typename?: 'Mutation';
    replyToJobApplication: {
        __typename?: 'JobApplicationReplyResult';
        success: boolean;
        message?: string | null;
    };
};
export type ResolveSupportTicketMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    resolution?: Types.InputMaybe<Types.Scalars['String']['input']>;
}>;
export type ResolveSupportTicketMutation = {
    __typename?: 'Mutation';
    resolveSupportTicket: {
        __typename?: 'SupportTicket';
        id: string;
        ticketNumber: string;
        status: Types.SupportTicketStatus;
        resolvedAt?: string | null;
        updatedAt: string;
    };
};
export type SendRoundMessageToCandidateMutationVariables = Types.Exact<{
    input: Types.SendRoundMessageToCandidateInput;
}>;
export type SendRoundMessageToCandidateMutation = {
    __typename?: 'Mutation';
    sendRoundMessageToCandidate: {
        __typename?: 'InterviewRound';
        id: string;
        applicationId: string;
        roundConfigId?: string | null;
        name: string;
        roundType: Types.InterviewRoundType;
        status: Types.InterviewRoundStatus;
        scheduledAt?: string | null;
        notes?: string | null;
        candidateMessage?: string | null;
        candidateMessageSentAt?: string | null;
        assignmentId?: string | null;
        submittedRepoUrl?: string | null;
        submittedVideoUrl?: string | null;
        submittedAt?: string | null;
        submittedNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type SubmitInterviewFeedbackMutationVariables = Types.Exact<{
    input: Types.SubmitInterviewFeedbackInput;
}>;
export type SubmitInterviewFeedbackMutation = {
    __typename?: 'Mutation';
    submitInterviewFeedback: {
        __typename?: 'InterviewFeedback';
        id: string;
        roundId: string;
        interviewerId: string;
        rating?: number | null;
        verdict?: Types.InterviewVerdict | null;
        internalNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
        interviewer: {
            __typename?: 'Interviewer';
            id: string;
            name: string;
            email: string;
            title?: string | null;
        };
    };
};
export type SubmitSatisfactionSurveyMutationVariables = Types.Exact<{
    input: Types.SubmitSatisfactionSurveyInput;
}>;
export type SubmitSatisfactionSurveyMutation = {
    __typename?: 'Mutation';
    submitSatisfactionSurvey: {
        __typename?: 'CustomerSatisfactionSurvey';
        id: string;
        rating: number;
        feedbackType?: Types.FeedbackCategory | null;
        comment?: string | null;
        submittedAt?: string | null;
    };
};
export type UpdateCannedResponseMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateCannedResponseInput;
}>;
export type UpdateCannedResponseMutation = {
    __typename?: 'Mutation';
    updateCannedResponse: {
        __typename?: 'CannedResponse';
        id: string;
        tenantId?: string | null;
        title: string;
        content: string;
        tags: Array<string>;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateContactInquiryStatusMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateContactInquiryStatusInput;
}>;
export type UpdateContactInquiryStatusMutation = {
    __typename?: 'Mutation';
    updateContactInquiryStatus: {
        __typename?: 'ContactInquiry';
        id: string;
        status: Types.ContactInquiryStatus;
        convertedTicketId?: string | null;
        updatedAt: string;
    };
};
export type UpdateInterviewFeedbackMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateInterviewFeedbackInput;
}>;
export type UpdateInterviewFeedbackMutation = {
    __typename?: 'Mutation';
    updateInterviewFeedback: {
        __typename?: 'InterviewFeedback';
        id: string;
        roundId: string;
        interviewerId: string;
        rating?: number | null;
        verdict?: Types.InterviewVerdict | null;
        internalNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
        interviewer: {
            __typename?: 'Interviewer';
            id: string;
            name: string;
            email: string;
            title?: string | null;
        };
    };
};
export type UpdateInterviewRoundMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateInterviewRoundInput;
}>;
export type UpdateInterviewRoundMutation = {
    __typename?: 'Mutation';
    updateInterviewRound: {
        __typename?: 'InterviewRound';
        id: string;
        applicationId: string;
        roundConfigId?: string | null;
        name: string;
        roundType: Types.InterviewRoundType;
        status: Types.InterviewRoundStatus;
        scheduledAt?: string | null;
        notes?: string | null;
        candidateMessage?: string | null;
        candidateMessageSentAt?: string | null;
        assignmentId?: string | null;
        submittedRepoUrl?: string | null;
        submittedVideoUrl?: string | null;
        submittedAt?: string | null;
        submittedNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type UpdateInterviewRoundConfigMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateInterviewRoundConfigInput;
}>;
export type UpdateInterviewRoundConfigMutation = {
    __typename?: 'Mutation';
    updateInterviewRoundConfig: {
        __typename?: 'InterviewRoundConfig';
        id: string;
        jobPostingId: string;
        roundNumber: number;
        name: string;
        description?: string | null;
        roundType: Types.InterviewRoundType;
        isAssignmentRound: boolean;
        isRequired: boolean;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type UpdateInterviewerMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateInterviewerInput;
}>;
export type UpdateInterviewerMutation = {
    __typename?: 'Mutation';
    updateInterviewer: {
        __typename?: 'Interviewer';
        id: string;
        name: string;
        email: string;
        userId?: string | null;
        department?: string | null;
        title?: string | null;
        isActive: boolean;
        notes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type UpdateJobApplicationStatusMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateJobApplicationStatusInput;
}>;
export type UpdateJobApplicationStatusMutation = {
    __typename?: 'Mutation';
    updateJobApplicationStatus: {
        __typename?: 'JobApplication';
        id: string;
        status: Types.JobApplicationStatus;
        updatedAt: string;
    };
};
export type UpdateJobAssignmentMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateJobAssignmentInput;
}>;
export type UpdateJobAssignmentMutation = {
    __typename?: 'Mutation';
    updateJobAssignment: {
        __typename?: 'JobAssignment';
        id: string;
        jobPostingId: string;
        title: string;
        description: string;
        problemStatement?: string | null;
        difficulty?: string | null;
        isActive: boolean;
        ownerEmail?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type UpdateJobPostingMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateJobPostingInput;
}>;
export type UpdateJobPostingMutation = {
    __typename?: 'Mutation';
    updateJobPosting: {
        __typename?: 'JobPosting';
        id: string;
        title: string;
        department?: string | null;
        location?: string | null;
        employmentType?: Types.EmploymentType | null;
        description?: string | null;
        productId?: string | null;
        status: Types.JobPostingStatus;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    };
};
export type UpdateSlaPolicyMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateSlaPolicyInput;
}>;
export type UpdateSlaPolicyMutation = {
    __typename?: 'Mutation';
    updateSLAPolicy: {
        __typename?: 'SLAPolicy';
        id: string;
        tenantId?: string | null;
        name: string;
        description?: string | null;
        priority: Types.SupportTicketPriority;
        firstResponseMinutes: number;
        resolutionMinutes: number;
        businessHours?: Record<string, unknown> | null;
        isActive: boolean;
        isDefault: boolean;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateSupportTicketMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateSupportTicketInput;
}>;
export type UpdateSupportTicketMutation = {
    __typename?: 'Mutation';
    updateSupportTicket: {
        __typename?: 'SupportTicket';
        id: string;
        ticketNumber: string;
        subject: string;
        description: string;
        status: Types.SupportTicketStatus;
        priority: Types.SupportTicketPriority;
        category?: Types.SupportTicketCategory | null;
        categoryId?: string | null;
        assignedTo?: string | null;
        tags: Array<string>;
        customFields?: Record<string, unknown> | null;
        updatedAt: string;
    };
};
export type GetAgentLeaderboardQueryVariables = Types.Exact<{
    period?: Types.InputMaybe<Types.TimePeriod>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetAgentLeaderboardQuery = {
    __typename?: 'Query';
    agentLeaderboard: {
        __typename?: 'AgentLeaderboard';
        period: Types.TimePeriod;
        agents: Array<{
            __typename?: 'AgentRanking';
            rank: number;
            agentId: string;
            score: number;
            ticketsResolved: number;
            averageRating?: number | null;
            slaComplianceRate: number;
            agent: {
                __typename?: 'AgentProfile';
                id: string;
                userId: string;
                status: Types.AgentStatus;
            };
        }>;
    };
};
export type GetSlaReportQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.SlaReportFilterInput>;
}>;
export type GetSlaReportQuery = {
    __typename?: 'Query';
    slaReport: {
        __typename?: 'SLAReport';
        period: Types.TimePeriod;
        startDate: string;
        endDate: string;
        totalTickets: number;
        ticketsWithSLA: number;
        totalBreaches: number;
        breachRate: number;
        firstResponseCompliance: number;
        resolutionCompliance: number;
        averageFirstResponseMinutes?: number | null;
        averageResolutionMinutes?: number | null;
        byPriority: Array<{
            __typename?: 'SLAPriorityBreakdown';
            priority: Types.SupportTicketPriority;
            totalTickets: number;
            firstResponseCompliance: number;
            resolutionCompliance: number;
            averageFirstResponseMinutes?: number | null;
            averageResolutionMinutes?: number | null;
        }>;
    };
};
export type GetSatisfactionMetricsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.SatisfactionMetricsFilterInput>;
}>;
export type GetSatisfactionMetricsQuery = {
    __typename?: 'Query';
    satisfactionMetrics: {
        __typename?: 'SatisfactionMetrics';
        period: Types.TimePeriod;
        startDate: string;
        endDate: string;
        averageRating?: number | null;
        csatScore?: number | null;
        npsScore?: number | null;
        responseRate: number;
        totalResponses: number;
        totalSurveysSent: number;
        ratingDistribution: Array<{
            __typename?: 'RatingDistribution';
            rating: number;
            count: number;
            percentage: number;
        }>;
        feedbackBreakdown: Array<{
            __typename?: 'FeedbackBreakdown';
            category: Types.FeedbackCategory;
            count: number;
            percentage: number;
        }>;
        trendData: Array<{
            __typename?: 'SatisfactionTrend';
            date: string;
            averageRating?: number | null;
            csatScore?: number | null;
            responseCount: number;
        }>;
    };
};
export type GetAgentProfilesQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.AgentProfileFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetAgentProfilesQuery = {
    __typename?: 'Query';
    agentProfiles: {
        __typename?: 'AgentProfileConnection';
        totalCount: number;
        hasMore: boolean;
        nodes: Array<{
            __typename?: 'AgentProfile';
            id: string;
            userId: string;
            displayAlias?: string | null;
            status: Types.AgentStatus;
            isAvailable: boolean;
            user: {
                __typename?: 'User';
                id: string;
                name?: string | null;
                email: string;
            };
        }>;
    };
};
export type GetArticleQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetArticleQuery = {
    __typename?: 'Query';
    knowledgeBaseArticle?: {
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        slug: string;
        title: string;
        content: string;
        excerpt?: string | null;
        status: Types.ArticleStatus;
        viewCount: number;
        helpfulCount: number;
        notHelpfulCount: number;
        publishedAt?: string | null;
        categoryId?: string | null;
        authorId: string;
        tags: Array<string>;
        metaDescription?: string | null;
        version: number;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type GetArticlesQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.KnowledgeBaseArticleFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetArticlesQuery = {
    __typename?: 'Query';
    knowledgeBaseArticles: {
        __typename?: 'KnowledgeBaseArticleConnection';
        totalCount: number;
        hasMore: boolean;
        nodes: Array<{
            __typename?: 'KnowledgeBaseArticle';
            id: string;
            slug: string;
            title: string;
            excerpt?: string | null;
            status: Types.ArticleStatus;
            viewCount: number;
            helpfulCount: number;
            notHelpfulCount: number;
            publishedAt?: string | null;
            categoryId?: string | null;
            authorId: string;
            tags: Array<string>;
            createdAt: string;
            updatedAt: string;
            category?: {
                __typename?: 'TicketCategory';
                id: string;
                name: string;
                color?: string | null;
            } | null;
        }>;
    };
};
export type GetBulkCandidateTargetsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.JobApplicationFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetBulkCandidateTargetsQuery = {
    __typename?: 'Query';
    jobApplications: {
        __typename?: 'JobApplicationList';
        total: number;
        hasMore: boolean;
        items: Array<{
            __typename?: 'JobApplication';
            id: string;
            jobPostingId?: string | null;
            interviewRounds: Array<{
                __typename?: 'InterviewRound';
                id: string;
                roundConfigId?: string | null;
                name: string;
                roundType: Types.InterviewRoundType;
                emailLogs: Array<{
                    __typename?: 'CandidateEmailLog';
                    emailType: Types.CandidateEmailType;
                }>;
            }>;
        }>;
    };
};
export type GetCannedResponsesQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.CannedResponseFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetCannedResponsesQuery = {
    __typename?: 'Query';
    cannedResponses: {
        __typename?: 'CannedResponseConnection';
        totalCount: number;
        nodes: Array<{
            __typename?: 'CannedResponse';
            id: string;
            tenantId?: string | null;
            title: string;
            content: string;
            shortcut?: string | null;
            category?: string | null;
            tags: Array<string>;
            usageCount: number;
            isActive: boolean;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type GetContactInquiriesQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.ContactInquiryFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetContactInquiriesQuery = {
    __typename?: 'Query';
    contactInquiries: {
        __typename?: 'ContactInquiryList';
        total: number;
        hasMore: boolean;
        items: Array<{
            __typename?: 'ContactInquiry';
            id: string;
            name: string;
            email: string;
            company?: string | null;
            subject: string;
            category?: string | null;
            message: string;
            status: Types.ContactInquiryStatus;
            source: string;
            productId?: string | null;
            convertedTicketId?: string | null;
            metadata?: Record<string, unknown> | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type GetContactInquiryQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetContactInquiryQuery = {
    __typename?: 'Query';
    contactInquiry?: {
        __typename?: 'ContactInquiry';
        id: string;
        name: string;
        email: string;
        company?: string | null;
        subject: string;
        category?: string | null;
        message: string;
        status: Types.ContactInquiryStatus;
        source: string;
        productId?: string | null;
        convertedTicketId?: string | null;
        metadata?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type GetInterviewerQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetInterviewerQuery = {
    __typename?: 'Query';
    interviewer?: {
        __typename?: 'Interviewer';
        id: string;
        name: string;
        email: string;
        userId?: string | null;
        department?: string | null;
        title?: string | null;
        isActive: boolean;
        notes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
    } | null;
};
export type GetInterviewersQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.InterviewerFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetInterviewersQuery = {
    __typename?: 'Query';
    interviewers: {
        __typename?: 'InterviewerList';
        total: number;
        hasMore: boolean;
        items: Array<{
            __typename?: 'Interviewer';
            id: string;
            name: string;
            email: string;
            userId?: string | null;
            department?: string | null;
            title?: string | null;
            isActive: boolean;
            notes?: string | null;
            createdAt: string;
        }>;
    };
};
export type GetJobApplicationQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetJobApplicationQuery = {
    __typename?: 'Query';
    jobApplication?: {
        __typename?: 'JobApplication';
        id: string;
        firstName: string;
        lastName: string;
        email: string;
        phone?: string | null;
        position: string;
        department?: string | null;
        linkedinUrl?: string | null;
        portfolioUrl?: string | null;
        coverLetter?: string | null;
        resumeFileName?: string | null;
        resumeFileSize?: number | null;
        resumeMimeType?: string | null;
        productId?: string | null;
        jobPostingId?: string | null;
        source: string;
        status: Types.JobApplicationStatus;
        metadata?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        jobPosting?: {
            __typename?: 'JobPosting';
            id: string;
            title: string;
            department?: string | null;
        } | null;
        interviewRounds: Array<{
            __typename?: 'InterviewRound';
            id: string;
            roundConfigId?: string | null;
            name: string;
            roundType: Types.InterviewRoundType;
            status: Types.InterviewRoundStatus;
            scheduledAt?: string | null;
            notes?: string | null;
            candidateMessage?: string | null;
            candidateMessageSentAt?: string | null;
            submittedRepoUrl?: string | null;
            submittedVideoUrl?: string | null;
            submittedAt?: string | null;
            submittedNotes?: string | null;
        }>;
    } | null;
};
export type GetJobApplicationInterviewRoundsQueryVariables = Types.Exact<{
    applicationId: Types.Scalars['ID']['input'];
}>;
export type GetJobApplicationInterviewRoundsQuery = {
    __typename?: 'Query';
    jobApplicationInterviewRounds: Array<{
        __typename?: 'InterviewRound';
        id: string;
        applicationId: string;
        roundConfigId?: string | null;
        name: string;
        roundType: Types.InterviewRoundType;
        status: Types.InterviewRoundStatus;
        scheduledAt?: string | null;
        notes?: string | null;
        candidateMessage?: string | null;
        candidateMessageSentAt?: string | null;
        submittedRepoUrl?: string | null;
        submittedVideoUrl?: string | null;
        submittedAt?: string | null;
        submittedNotes?: string | null;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
        roundConfig?: {
            __typename?: 'InterviewRoundConfig';
            id: string;
            isAssignmentRound: boolean;
        } | null;
        interviewers: Array<{
            __typename?: 'InterviewRoundInterviewer';
            id: string;
            role: Types.InterviewerRole;
            assignedAt: string;
            interviewer: {
                __typename?: 'Interviewer';
                id: string;
                name: string;
                email: string;
                title?: string | null;
            };
        }>;
        feedback: Array<{
            __typename?: 'InterviewFeedback';
            id: string;
            interviewerId: string;
            rating?: number | null;
            verdict?: Types.InterviewVerdict | null;
            internalNotes?: string | null;
            createdAt: string;
            interviewer: {
                __typename?: 'Interviewer';
                id: string;
                name: string;
            };
        }>;
        assignment?: {
            __typename?: 'JobAssignment';
            id: string;
            title: string;
            description: string;
        } | null;
        emailLogs: Array<{
            __typename?: 'CandidateEmailLog';
            id: string;
            emailType: Types.CandidateEmailType;
            subject?: string | null;
            sentAt: string;
            sentBy: string;
        }>;
    }>;
};
export type GetJobApplicationResumePreviewUrlQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetJobApplicationResumePreviewUrlQuery = {
    __typename?: 'Query';
    jobApplicationResumePreviewUrl: string;
};
export type GetJobApplicationResumeUrlQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetJobApplicationResumeUrlQuery = {
    __typename?: 'Query';
    jobApplicationResumeUrl: string;
};
export type GetJobApplicationsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.JobApplicationFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetJobApplicationsQuery = {
    __typename?: 'Query';
    jobApplications: {
        __typename?: 'JobApplicationList';
        total: number;
        hasMore: boolean;
        items: Array<{
            __typename?: 'JobApplication';
            id: string;
            firstName: string;
            lastName: string;
            email: string;
            position: string;
            department?: string | null;
            resumeFileName?: string | null;
            productId?: string | null;
            jobPostingId?: string | null;
            status: Types.JobApplicationStatus;
            createdAt: string;
            interviewRounds: Array<{
                __typename?: 'InterviewRound';
                id: string;
                roundConfigId?: string | null;
                name: string;
                roundType: Types.InterviewRoundType;
                emailLogs: Array<{
                    __typename?: 'CandidateEmailLog';
                    emailType: Types.CandidateEmailType;
                }>;
            }>;
        }>;
    };
};
export type GetJobAssignmentsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.JobAssignmentFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetJobAssignmentsQuery = {
    __typename?: 'Query';
    jobAssignments: {
        __typename?: 'JobAssignmentList';
        total: number;
        hasMore: boolean;
        items: Array<{
            __typename?: 'JobAssignment';
            id: string;
            jobPostingId: string;
            title: string;
            description: string;
            problemStatement?: string | null;
            difficulty?: string | null;
            isActive: boolean;
            ownerEmail?: string | null;
        }>;
    };
};
export type GetJobPostingQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetJobPostingQuery = {
    __typename?: 'Query';
    jobPosting?: {
        __typename?: 'JobPosting';
        id: string;
        title: string;
        department?: string | null;
        location?: string | null;
        employmentType?: Types.EmploymentType | null;
        description?: string | null;
        productId?: string | null;
        status: Types.JobPostingStatus;
        slug?: string | null;
        openings: number;
        overview: string;
        responsibilities: Array<string>;
        learnings: Array<string>;
        qualifications: Array<string>;
        context?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        createdBy: string;
        onBehalfOf: string;
        updatedBy?: string | null;
        rounds: Array<{
            __typename?: 'InterviewRoundConfig';
            id: string;
            roundNumber: number;
            name: string;
            description?: string | null;
            roundType: Types.InterviewRoundType;
            isAssignmentRound: boolean;
            isRequired: boolean;
        }>;
        assignments: Array<{
            __typename?: 'JobAssignment';
            id: string;
            title: string;
            description: string;
            problemStatement?: string | null;
            difficulty?: string | null;
            isActive: boolean;
            ownerEmail?: string | null;
        }>;
        applications: Array<{
            __typename?: 'JobApplication';
            id: string;
            firstName: string;
            lastName: string;
            email: string;
            status: Types.JobApplicationStatus;
            createdAt: string;
        }>;
    } | null;
};
export type GetJobPostingsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.JobPostingFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetJobPostingsQuery = {
    __typename?: 'Query';
    jobPostings: {
        __typename?: 'JobPostingList';
        total: number;
        hasMore: boolean;
        items: Array<{
            __typename?: 'JobPosting';
            id: string;
            title: string;
            department?: string | null;
            location?: string | null;
            employmentType?: Types.EmploymentType | null;
            status: Types.JobPostingStatus;
            description?: string | null;
            productId?: string | null;
            slug?: string | null;
            openings: number;
            overview: string;
            responsibilities: Array<string>;
            learnings: Array<string>;
            qualifications: Array<string>;
            createdAt: string;
            updatedAt: string;
            applications: Array<{
                __typename?: 'JobApplication';
                id: string;
            }>;
        }>;
    };
};
export type GetMyTicketsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.SupportTicketFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetMyTicketsQuery = {
    __typename?: 'Query';
    supportTickets: {
        __typename?: 'SupportTicketConnection';
        totalCount: number;
        hasMore: boolean;
        nodes: Array<{
            __typename?: 'SupportTicket';
            id: string;
            ticketNumber: string;
            subject: string;
            status: Types.SupportTicketStatus;
            priority: Types.SupportTicketPriority;
            category?: Types.SupportTicketCategory | null;
            categoryId?: string | null;
            assignedTo?: string | null;
            slaBreachStatus: Types.SlaBreachStatus;
            createdAt: string;
            updatedAt: string;
            context?: {
                __typename?: 'SupportContext';
                productId?: string | null;
            } | null;
            ticketCategory?: {
                __typename?: 'TicketCategory';
                id: string;
                name: string;
                color?: string | null;
            } | null;
        }>;
    };
};
export type GetPopularArticlesQueryVariables = Types.Exact<{
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetPopularArticlesQuery = {
    __typename?: 'Query';
    popularArticles: Array<{
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        slug: string;
        title: string;
        excerpt?: string | null;
        viewCount: number;
        helpfulCount: number;
        categoryId?: string | null;
        tags: Array<string>;
    }>;
};
export type GetSlaPoliciesQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.SlaPolicyFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetSlaPoliciesQuery = {
    __typename?: 'Query';
    slaPolicies: {
        __typename?: 'SLAPolicyConnection';
        totalCount: number;
        nodes: Array<{
            __typename?: 'SLAPolicy';
            id: string;
            tenantId?: string | null;
            name: string;
            description?: string | null;
            priority: Types.SupportTicketPriority;
            firstResponseMinutes: number;
            resolutionMinutes: number;
            businessHours?: Record<string, unknown> | null;
            isActive: boolean;
            isDefault: boolean;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type GetSupportAnalyticsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.AnalyticsFilterInput>;
}>;
export type GetSupportAnalyticsQuery = {
    __typename?: 'Query';
    supportAnalytics: {
        __typename?: 'SupportAnalytics';
        stats: {
            __typename?: 'SupportStats';
            totalTickets: number;
            openTickets: number;
            resolvedTickets: number;
            closedTickets: number;
            newTickets: number;
            inProgressTickets: number;
            waitingOnCustomerTickets: number;
            reopenedTickets: number;
            averageFirstResponseTimeHours?: number | null;
            averageResolutionTimeHours?: number | null;
            slaComplianceRate?: number | null;
        };
        priorityBreakdown: Array<{
            __typename?: 'PriorityBreakdown';
            priority: Types.SupportTicketPriority;
            count: number;
            percentage: number;
        }>;
        categoryBreakdown: Array<{
            __typename?: 'CategoryBreakdown';
            category: Types.SupportTicketCategory;
            count: number;
            percentage: number;
        }>;
        sourceBreakdown: Array<{
            __typename?: 'SourceBreakdown';
            source: Types.TicketSource;
            count: number;
            percentage: number;
        }>;
        ticketTrends: Array<{
            __typename?: 'TicketTrend';
            date: string;
            count: number;
            groupBy: Types.TrendGroupBy;
        }>;
    };
};
export type GetTicketCategoriesQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.TicketCategoryFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetTicketCategoriesQuery = {
    __typename?: 'Query';
    ticketCategories: {
        __typename?: 'TicketCategoryConnection';
        totalCount: number;
        hasMore: boolean;
        nodes: Array<{
            __typename?: 'TicketCategory';
            id: string;
            name: string;
            slug: string;
            color?: string | null;
            icon?: string | null;
            description?: string | null;
            isActive: boolean;
            displayOrder: number;
            articleCount: number;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type GetTicketDetailQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetTicketDetailQuery = {
    __typename?: 'Query';
    supportTicket?: {
        __typename?: 'SupportTicket';
        id: string;
        ticketNumber: string;
        subject: string;
        description: string;
        status: Types.SupportTicketStatus;
        priority: Types.SupportTicketPriority;
        category?: Types.SupportTicketCategory | null;
        categoryId?: string | null;
        source: Types.TicketSource;
        assignedTo?: string | null;
        tags: Array<string>;
        dueAt?: string | null;
        firstResponseAt?: string | null;
        firstResponseDue?: string | null;
        resolutionDue?: string | null;
        slaBreachStatus: Types.SlaBreachStatus;
        escalationLevel: number;
        resolvedAt?: string | null;
        closedAt?: string | null;
        reopenedAt?: string | null;
        metadata?: Record<string, unknown> | null;
        customFields?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
        context?: {
            __typename?: 'SupportContext';
            workspaceId?: string | null;
            organizationId?: string | null;
            productId?: string | null;
            custom?: Record<string, unknown> | null;
        } | null;
        user: {
            __typename?: 'User';
            id: string;
            name?: string | null;
            firstName?: string | null;
            lastName?: string | null;
            email: string;
            isSupportAgent: boolean;
        };
        ticketCategory?: {
            __typename?: 'TicketCategory';
            id: string;
            name: string;
            color?: string | null;
        } | null;
        slaPolicy?: {
            __typename?: 'SLAPolicy';
            id: string;
            name: string;
            firstResponseMinutes: number;
            resolutionMinutes: number;
            isActive: boolean;
        } | null;
        messages: Array<{
            __typename?: 'SupportMessage';
            id: string;
            ticketId: string;
            authorId: string;
            message: string;
            type: Types.MessageType;
            attachments: Array<string>;
            attachmentCount: number;
            isInternal: boolean;
            createdAt: string;
            updatedAt: string;
            author: {
                __typename?: 'SupportAuthor';
                id: string;
                displayName: string;
                avatar: string;
                kind: Types.SupportAuthorKind;
                isAnonymized: boolean;
            };
            context?: {
                __typename?: 'SupportContext';
                workspaceId?: string | null;
                organizationId?: string | null;
                productId?: string | null;
                custom?: Record<string, unknown> | null;
            } | null;
        }>;
        linkedTickets: Array<{
            __typename?: 'TicketLink';
            id: string;
            fromTicketId: string;
            toTicketId: string;
            linkType: Types.LinkType;
            createdBy: string;
            createdAt: string;
        }>;
        surveys: Array<{
            __typename?: 'CustomerSatisfactionSurvey';
            id: string;
            rating: number;
            comment?: string | null;
            feedbackType?: Types.FeedbackCategory | null;
            submittedAt?: string | null;
            createdAt: string;
        }>;
    } | null;
};
export type GetTicketTrendsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.AnalyticsFilterInput>;
}>;
export type GetTicketTrendsQuery = {
    __typename?: 'Query';
    ticketTrends: Array<{
        __typename?: 'TicketTrend';
        date: string;
        count: number;
        groupBy: Types.TrendGroupBy;
    }>;
};
export type GetTicketsQueryVariables = Types.Exact<{
    filter?: Types.InputMaybe<Types.SupportTicketFilterInput>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type GetTicketsQuery = {
    __typename?: 'Query';
    supportTickets: {
        __typename?: 'SupportTicketConnection';
        totalCount: number;
        hasMore: boolean;
        nodes: Array<{
            __typename?: 'SupportTicket';
            id: string;
            ticketNumber: string;
            subject: string;
            status: Types.SupportTicketStatus;
            priority: Types.SupportTicketPriority;
            category?: Types.SupportTicketCategory | null;
            categoryId?: string | null;
            assignedTo?: string | null;
            slaBreachStatus: Types.SlaBreachStatus;
            createdAt: string;
            updatedAt: string;
            context?: {
                __typename?: 'SupportContext';
                productId?: string | null;
            } | null;
            ticketCategory?: {
                __typename?: 'TicketCategory';
                id: string;
                name: string;
                color?: string | null;
            } | null;
        }>;
    };
};
export type SearchKnowledgeBaseQueryVariables = Types.Exact<{
    query: Types.Scalars['String']['input'];
    categoryId?: Types.InputMaybe<Types.Scalars['String']['input']>;
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type SearchKnowledgeBaseQuery = {
    __typename?: 'Query';
    searchKnowledgeBase: Array<{
        __typename?: 'KnowledgeBaseArticle';
        id: string;
        slug: string;
        title: string;
        excerpt?: string | null;
        viewCount: number;
        helpfulCount: number;
        notHelpfulCount: number;
        publishedAt?: string | null;
        categoryId?: string | null;
        tags: Array<string>;
        category?: {
            __typename?: 'TicketCategory';
            id: string;
            name: string;
            color?: string | null;
        } | null;
    }>;
};
export type SearchTicketsQueryVariables = Types.Exact<{
    query: Types.Scalars['String']['input'];
    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
}>;
export type SearchTicketsQuery = {
    __typename?: 'Query';
    searchTickets: Array<{
        __typename?: 'SupportTicket';
        id: string;
        ticketNumber: string;
        subject: string;
        status: Types.SupportTicketStatus;
        priority: Types.SupportTicketPriority;
        category?: Types.SupportTicketCategory | null;
        categoryId?: string | null;
        assignedTo?: string | null;
        slaBreachStatus: Types.SlaBreachStatus;
        createdAt: string;
        updatedAt: string;
        context?: {
            __typename?: 'SupportContext';
            productId?: string | null;
        } | null;
        ticketCategory?: {
            __typename?: 'TicketCategory';
            id: string;
            name: string;
            color?: string | null;
        } | null;
    }>;
};
export type SubscribeTicketMessageAddedSubscriptionVariables = Types.Exact<{
    ticketId: Types.Scalars['ID']['input'];
}>;
export type SubscribeTicketMessageAddedSubscription = {
    __typename?: 'Subscription';
    ticketMessageAdded: {
        __typename?: 'SupportMessage';
        id: string;
        ticketId: string;
        authorId: string;
        message: string;
        type: Types.MessageType;
        attachments: Array<string>;
        attachmentCount: number;
        isInternal: boolean;
        createdAt: string;
        updatedAt: string;
        author: {
            __typename?: 'SupportAuthor';
            id: string;
            displayName: string;
            avatar: string;
            kind: Types.SupportAuthorKind;
            isAnonymized: boolean;
        };
    };
};
export type SubscribeTicketUpdatedSubscriptionVariables = Types.Exact<{
    ticketId: Types.Scalars['ID']['input'];
}>;
export type SubscribeTicketUpdatedSubscription = {
    __typename?: 'Subscription';
    ticketUpdated: {
        __typename?: 'SupportTicket';
        id: string;
        status: Types.SupportTicketStatus;
        priority: Types.SupportTicketPriority;
        assignedTo?: string | null;
        updatedAt: string;
    };
};
export declare const ArchiveKnowledgeBaseArticleDocument: Apollo.DocumentNode;
export type ArchiveKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.ArchiveKnowledgeBaseArticleMutation, Types.ArchiveKnowledgeBaseArticleMutationVariables>;
/**
 * __useArchiveKnowledgeBaseArticleMutation__
 *
 * To run a mutation, you first call `useArchiveKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useArchiveKnowledgeBaseArticleMutation` 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 [archiveKnowledgeBaseArticleMutation, { data, loading, error }] = useArchiveKnowledgeBaseArticleMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useArchiveKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ArchiveKnowledgeBaseArticleMutation, Types.ArchiveKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ArchiveKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
export type ArchiveKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useArchiveKnowledgeBaseArticleMutation>;
export type ArchiveKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.ArchiveKnowledgeBaseArticleMutation>;
export type ArchiveKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.ArchiveKnowledgeBaseArticleMutation, Types.ArchiveKnowledgeBaseArticleMutationVariables>;
export declare const CreateKnowledgeBaseArticleDocument: Apollo.DocumentNode;
export type CreateKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.CreateKnowledgeBaseArticleMutation, Types.CreateKnowledgeBaseArticleMutationVariables>;
/**
 * __useCreateKnowledgeBaseArticleMutation__
 *
 * To run a mutation, you first call `useCreateKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateKnowledgeBaseArticleMutation` 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 [createKnowledgeBaseArticleMutation, { data, loading, error }] = useCreateKnowledgeBaseArticleMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateKnowledgeBaseArticleMutation, Types.CreateKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
export type CreateKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useCreateKnowledgeBaseArticleMutation>;
export type CreateKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.CreateKnowledgeBaseArticleMutation>;
export type CreateKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.CreateKnowledgeBaseArticleMutation, Types.CreateKnowledgeBaseArticleMutationVariables>;
export declare const CreateTicketCategoryDocument: Apollo.DocumentNode;
export type CreateTicketCategoryMutationFn = Apollo.MutationFunction<Types.CreateTicketCategoryMutation, Types.CreateTicketCategoryMutationVariables>;
/**
 * __useCreateTicketCategoryMutation__
 *
 * To run a mutation, you first call `useCreateTicketCategoryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateTicketCategoryMutation` 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 [createTicketCategoryMutation, { data, loading, error }] = useCreateTicketCategoryMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateTicketCategoryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTicketCategoryMutation, Types.CreateTicketCategoryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateTicketCategoryMutation, any, Apollo.ApolloCache, undefined>;
export type CreateTicketCategoryMutationHookResult = ReturnType<typeof useCreateTicketCategoryMutation>;
export type CreateTicketCategoryMutationResult = Apollo.MutationResult<Types.CreateTicketCategoryMutation>;
export type CreateTicketCategoryMutationOptions = Apollo.BaseMutationOptions<Types.CreateTicketCategoryMutation, Types.CreateTicketCategoryMutationVariables>;
export declare const DeleteKnowledgeBaseArticleDocument: Apollo.DocumentNode;
export type DeleteKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.DeleteKnowledgeBaseArticleMutation, Types.DeleteKnowledgeBaseArticleMutationVariables>;
/**
 * __useDeleteKnowledgeBaseArticleMutation__
 *
 * To run a mutation, you first call `useDeleteKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteKnowledgeBaseArticleMutation` 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 [deleteKnowledgeBaseArticleMutation, { data, loading, error }] = useDeleteKnowledgeBaseArticleMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteKnowledgeBaseArticleMutation, Types.DeleteKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useDeleteKnowledgeBaseArticleMutation>;
export type DeleteKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.DeleteKnowledgeBaseArticleMutation>;
export type DeleteKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.DeleteKnowledgeBaseArticleMutation, Types.DeleteKnowledgeBaseArticleMutationVariables>;
export declare const DeleteTicketCategoryDocument: Apollo.DocumentNode;
export type DeleteTicketCategoryMutationFn = Apollo.MutationFunction<Types.DeleteTicketCategoryMutation, Types.DeleteTicketCategoryMutationVariables>;
/**
 * __useDeleteTicketCategoryMutation__
 *
 * To run a mutation, you first call `useDeleteTicketCategoryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteTicketCategoryMutation` 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 [deleteTicketCategoryMutation, { data, loading, error }] = useDeleteTicketCategoryMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteTicketCategoryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteTicketCategoryMutation, Types.DeleteTicketCategoryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteTicketCategoryMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteTicketCategoryMutationHookResult = ReturnType<typeof useDeleteTicketCategoryMutation>;
export type DeleteTicketCategoryMutationResult = Apollo.MutationResult<Types.DeleteTicketCategoryMutation>;
export type DeleteTicketCategoryMutationOptions = Apollo.BaseMutationOptions<Types.DeleteTicketCategoryMutation, Types.DeleteTicketCategoryMutationVariables>;
export declare const PublishKnowledgeBaseArticleDocument: Apollo.DocumentNode;
export type PublishKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.PublishKnowledgeBaseArticleMutation, Types.PublishKnowledgeBaseArticleMutationVariables>;
/**
 * __usePublishKnowledgeBaseArticleMutation__
 *
 * To run a mutation, you first call `usePublishKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `usePublishKnowledgeBaseArticleMutation` 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 [publishKnowledgeBaseArticleMutation, { data, loading, error }] = usePublishKnowledgeBaseArticleMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function usePublishKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.PublishKnowledgeBaseArticleMutation, Types.PublishKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.PublishKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
export type PublishKnowledgeBaseArticleMutationHookResult = ReturnType<typeof usePublishKnowledgeBaseArticleMutation>;
export type PublishKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.PublishKnowledgeBaseArticleMutation>;
export type PublishKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.PublishKnowledgeBaseArticleMutation, Types.PublishKnowledgeBaseArticleMutationVariables>;
export declare const UnpublishKnowledgeBaseArticleDocument: Apollo.DocumentNode;
export type UnpublishKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.UnpublishKnowledgeBaseArticleMutation, Types.UnpublishKnowledgeBaseArticleMutationVariables>;
/**
 * __useUnpublishKnowledgeBaseArticleMutation__
 *
 * To run a mutation, you first call `useUnpublishKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUnpublishKnowledgeBaseArticleMutation` 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 [unpublishKnowledgeBaseArticleMutation, { data, loading, error }] = useUnpublishKnowledgeBaseArticleMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useUnpublishKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnpublishKnowledgeBaseArticleMutation, Types.UnpublishKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnpublishKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
export type UnpublishKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useUnpublishKnowledgeBaseArticleMutation>;
export type UnpublishKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.UnpublishKnowledgeBaseArticleMutation>;
export type UnpublishKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.UnpublishKnowledgeBaseArticleMutation, Types.UnpublishKnowledgeBaseArticleMutationVariables>;
export declare const UpdateKnowledgeBaseArticleDocument: Apollo.DocumentNode;
export type UpdateKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.UpdateKnowledgeBaseArticleMutation, Types.UpdateKnowledgeBaseArticleMutationVariables>;
/**
 * __useUpdateKnowledgeBaseArticleMutation__
 *
 * To run a mutation, you first call `useUpdateKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateKnowledgeBaseArticleMutation` 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 [updateKnowledgeBaseArticleMutation, { data, loading, error }] = useUpdateKnowledgeBaseArticleMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateKnowledgeBaseArticleMutation, Types.UpdateKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useUpdateKnowledgeBaseArticleMutation>;
export type UpdateKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.UpdateKnowledgeBaseArticleMutation>;
export type UpdateKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.UpdateKnowledgeBaseArticleMutation, Types.UpdateKnowledgeBaseArticleMutationVariables>;
export declare const UpdateTicketCategoryDocument: Apollo.DocumentNode;
export type UpdateTicketCategoryMutationFn = Apollo.MutationFunction<Types.UpdateTicketCategoryMutation, Types.UpdateTicketCategoryMutationVariables>;
/**
 * __useUpdateTicketCategoryMutation__
 *
 * To run a mutation, you first call `useUpdateTicketCategoryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateTicketCategoryMutation` 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 [updateTicketCategoryMutation, { data, loading, error }] = useUpdateTicketCategoryMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateTicketCategoryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateTicketCategoryMutation, Types.UpdateTicketCategoryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateTicketCategoryMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateTicketCategoryMutationHookResult = ReturnType<typeof useUpdateTicketCategoryMutation>;
export type UpdateTicketCategoryMutationResult = Apollo.MutationResult<Types.UpdateTicketCategoryMutation>;
export type UpdateTicketCategoryMutationOptions = Apollo.BaseMutationOptions<Types.UpdateTicketCategoryMutation, Types.UpdateTicketCategoryMutationVariables>;
export declare const CreateSupportMessageDocument: Apollo.DocumentNode;
export type CreateSupportMessageMutationFn = Apollo.MutationFunction<Types.CreateSupportMessageMutation, Types.CreateSupportMessageMutationVariables>;
/**
 * __useCreateSupportMessageMutation__
 *
 * To run a mutation, you first call `useCreateSupportMessageMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateSupportMessageMutation` 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 [createSupportMessageMutation, { data, loading, error }] = useCreateSupportMessageMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateSupportMessageMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateSupportMessageMutation, Types.CreateSupportMessageMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateSupportMessageMutation, any, Apollo.ApolloCache, undefined>;
export type CreateSupportMessageMutationHookResult = ReturnType<typeof useCreateSupportMessageMutation>;
export type CreateSupportMessageMutationResult = Apollo.MutationResult<Types.CreateSupportMessageMutation>;
export type CreateSupportMessageMutationOptions = Apollo.BaseMutationOptions<Types.CreateSupportMessageMutation, Types.CreateSupportMessageMutationVariables>;
export declare const AssignInterviewersToRoundDocument: Apollo.DocumentNode;
export type AssignInterviewersToRoundMutationFn = Apollo.MutationFunction<Types.AssignInterviewersToRoundMutation, Types.AssignInterviewersToRoundMutationVariables>;
/**
 * __useAssignInterviewersToRoundMutation__
 *
 * To run a mutation, you first call `useAssignInterviewersToRoundMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAssignInterviewersToRoundMutation` 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 [assignInterviewersToRoundMutation, { data, loading, error }] = useAssignInterviewersToRoundMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useAssignInterviewersToRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AssignInterviewersToRoundMutation, Types.AssignInterviewersToRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AssignInterviewersToRoundMutation, any, Apollo.ApolloCache, undefined>;
export type AssignInterviewersToRoundMutationHookResult = ReturnType<typeof useAssignInterviewersToRoundMutation>;
export type AssignInterviewersToRoundMutationResult = Apollo.MutationResult<Types.AssignInterviewersToRoundMutation>;
export type AssignInterviewersToRoundMutationOptions = Apollo.BaseMutationOptions<Types.AssignInterviewersToRoundMutation, Types.AssignInterviewersToRoundMutationVariables>;
export declare const AssignSupportTicketDocument: Apollo.DocumentNode;
export type AssignSupportTicketMutationFn = Apollo.MutationFunction<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>;
/**
 * __useAssignSupportTicketMutation__
 *
 * To run a mutation, you first call `useAssignSupportTicketMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAssignSupportTicketMutation` 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 [assignSupportTicketMutation, { data, loading, error }] = useAssignSupportTicketMutation({
 *   variables: {
 *      id: // value for 'id'
 *      assignedTo: // value for 'assignedTo'
 *   },
 * });
 */
export declare function useAssignSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AssignSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
export type AssignSupportTicketMutationHookResult = ReturnType<typeof useAssignSupportTicketMutation>;
export type AssignSupportTicketMutationResult = Apollo.MutationResult<Types.AssignSupportTicketMutation>;
export type AssignSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>;
export declare const BulkEnsureInterviewRoundsDocument: Apollo.DocumentNode;
export type BulkEnsureInterviewRoundsMutationFn = Apollo.MutationFunction<Types.BulkEnsureInterviewRoundsMutation, Types.BulkEnsureInterviewRoundsMutationVariables>;
/**
 * __useBulkEnsureInterviewRoundsMutation__
 *
 * To run a mutation, you first call `useBulkEnsureInterviewRoundsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useBulkEnsureInterviewRoundsMutation` 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 [bulkEnsureInterviewRoundsMutation, { data, loading, error }] = useBulkEnsureInterviewRoundsMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useBulkEnsureInterviewRoundsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkEnsureInterviewRoundsMutation, Types.BulkEnsureInterviewRoundsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkEnsureInterviewRoundsMutation, any, Apollo.ApolloCache, undefined>;
export type BulkEnsureInterviewRoundsMutationHookResult = ReturnType<typeof useBulkEnsureInterviewRoundsMutation>;
export type BulkEnsureInterviewRoundsMutationResult = Apollo.MutationResult<Types.BulkEnsureInterviewRoundsMutation>;
export type BulkEnsureInterviewRoundsMutationOptions = Apollo.BaseMutationOptions<Types.BulkEnsureInterviewRoundsMutation, Types.BulkEnsureInterviewRoundsMutationVariables>;
export declare const BulkRandomizeAndSendAssignmentDocument: Apollo.DocumentNode;
export type BulkRandomizeAndSendAssignmentMutationFn = Apollo.MutationFunction<Types.BulkRandomizeAndSendAssignmentMutation, Types.BulkRandomizeAndSendAssignmentMutationVariables>;
/**
 * __useBulkRandomizeAndSendAssignmentMutation__
 *
 * To run a mutation, you first call `useBulkRandomizeAndSendAssignmentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useBulkRandomizeAndSendAssignmentMutation` 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 [bulkRandomizeAndSendAssignmentMutation, { data, loading, error }] = useBulkRandomizeAndSendAssignmentMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useBulkRandomizeAndSendAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkRandomizeAndSendAssignmentMutation, Types.BulkRandomizeAndSendAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkRandomizeAndSendAssignmentMutation, any, Apollo.ApolloCache, undefined>;
export type BulkRandomizeAndSendAssignmentMutationHookResult = ReturnType<typeof useBulkRandomizeAndSendAssignmentMutation>;
export type BulkRandomizeAndSendAssignmentMutationResult = Apollo.MutationResult<Types.BulkRandomizeAndSendAssignmentMutation>;
export type BulkRandomizeAndSendAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.BulkRandomizeAndSendAssignmentMutation, Types.BulkRandomizeAndSendAssignmentMutationVariables>;
export declare const BulkSendCustomEmailDocument: Apollo.DocumentNode;
export type BulkSendCustomEmailMutationFn = Apollo.MutationFunction<Types.BulkSendCustomEmailMutation, Types.BulkSendCustomEmailMutationVariables>;
/**
 * __useBulkSendCustomEmailMutation__
 *
 * To run a mutation, you first call `useBulkSendCustomEmailMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useBulkSendCustomEmailMutation` 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 [bulkSendCustomEmailMutation, { data, loading, error }] = useBulkSendCustomEmailMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useBulkSendCustomEmailMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkSendCustomEmailMutation, Types.BulkSendCustomEmailMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkSendCustomEmailMutation, any, Apollo.ApolloCache, undefined>;
export type BulkSendCustomEmailMutationHookResult = ReturnType<typeof useBulkSendCustomEmailMutation>;
export type BulkSendCustomEmailMutationResult = Apollo.MutationResult<Types.BulkSendCustomEmailMutation>;
export type BulkSendCustomEmailMutationOptions = Apollo.BaseMutationOptions<Types.BulkSendCustomEmailMutation, Types.BulkSendCustomEmailMutationVariables>;
export declare const BulkSendRoundMessageDocument: Apollo.DocumentNode;
export type BulkSendRoundMessageMutationFn = Apollo.MutationFunction<Types.BulkSendRoundMessageMutation, Types.BulkSendRoundMessageMutationVariables>;
/**
 * __useBulkSendRoundMessageMutation__
 *
 * To run a mutation, you first call `useBulkSendRoundMessageMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useBulkSendRoundMessageMutation` 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 [bulkSendRoundMessageMutation, { data, loading, error }] = useBulkSendRoundMessageMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useBulkSendRoundMessageMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkSendRoundMessageMutation, Types.BulkSendRoundMessageMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkSendRoundMessageMutation, any, Apollo.ApolloCache, undefined>;
export type BulkSendRoundMessageMutationHookResult = ReturnType<typeof useBulkSendRoundMessageMutation>;
export type BulkSendRoundMessageMutationResult = Apollo.MutationResult<Types.BulkSendRoundMessageMutation>;
export type BulkSendRoundMessageMutationOptions = Apollo.BaseMutationOptions<Types.BulkSendRoundMessageMutation, Types.BulkSendRoundMessageMutationVariables>;
export declare const BulkUpdateApplicationStatusDocument: Apollo.DocumentNode;
export type BulkUpdateApplicationStatusMutationFn = Apollo.MutationFunction<Types.BulkUpdateApplicationStatusMutation, Types.BulkUpdateApplicationStatusMutationVariables>;
/**
 * __useBulkUpdateApplicationStatusMutation__
 *
 * To run a mutation, you first call `useBulkUpdateApplicationStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useBulkUpdateApplicationStatusMutation` 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 [bulkUpdateApplicationStatusMutation, { data, loading, error }] = useBulkUpdateApplicationStatusMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useBulkUpdateApplicationStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkUpdateApplicationStatusMutation, Types.BulkUpdateApplicationStatusMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkUpdateApplicationStatusMutation, any, Apollo.ApolloCache, undefined>;
export type BulkUpdateApplicationStatusMutationHookResult = ReturnType<typeof useBulkUpdateApplicationStatusMutation>;
export type BulkUpdateApplicationStatusMutationResult = Apollo.MutationResult<Types.BulkUpdateApplicationStatusMutation>;
export type BulkUpdateApplicationStatusMutationOptions = Apollo.BaseMutationOptions<Types.BulkUpdateApplicationStatusMutation, Types.BulkUpdateApplicationStatusMutationVariables>;
export declare const UpdateSupportTicketStatusDocument: Apollo.DocumentNode;
export type UpdateSupportTicketStatusMutationFn = Apollo.MutationFunction<Types.UpdateSupportTicketStatusMutation, Types.UpdateSupportTicketStatusMutationVariables>;
/**
 * __useUpdateSupportTicketStatusMutation__
 *
 * To run a mutation, you first call `useUpdateSupportTicketStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateSupportTicketStatusMutation` 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 [updateSupportTicketStatusMutation, { data, loading, error }] = useUpdateSupportTicketStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      status: // value for 'status'
 *   },
 * });
 */
export declare function useUpdateSupportTicketStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateSupportTicketStatusMutation, Types.UpdateSupportTicketStatusMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateSupportTicketStatusMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateSupportTicketStatusMutationHookResult = ReturnType<typeof useUpdateSupportTicketStatusMutation>;
export type UpdateSupportTicketStatusMutationResult = Apollo.MutationResult<Types.UpdateSupportTicketStatusMutation>;
export type UpdateSupportTicketStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateSupportTicketStatusMutation, Types.UpdateSupportTicketStatusMutationVariables>;
export declare const CloseSupportTicketDocument: Apollo.DocumentNode;
export type CloseSupportTicketMutationFn = Apollo.MutationFunction<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>;
/**
 * __useCloseSupportTicketMutation__
 *
 * To run a mutation, you first call `useCloseSupportTicketMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCloseSupportTicketMutation` 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 [closeSupportTicketMutation, { data, loading, error }] = useCloseSupportTicketMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useCloseSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CloseSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
export type CloseSupportTicketMutationHookResult = ReturnType<typeof useCloseSupportTicketMutation>;
export type CloseSupportTicketMutationResult = Apollo.MutationResult<Types.CloseSupportTicketMutation>;
export type CloseSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>;
export declare const CreateCannedResponseDocument: Apollo.DocumentNode;
export type CreateCannedResponseMutationFn = Apollo.MutationFunction<Types.CreateCannedResponseMutation, Types.CreateCannedResponseMutationVariables>;
/**
 * __useCreateCannedResponseMutation__
 *
 * To run a mutation, you first call `useCreateCannedResponseMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateCannedResponseMutation` 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 [createCannedResponseMutation, { data, loading, error }] = useCreateCannedResponseMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateCannedResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateCannedResponseMutation, Types.CreateCannedResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateCannedResponseMutation, any, Apollo.ApolloCache, undefined>;
export type CreateCannedResponseMutationHookResult = ReturnType<typeof useCreateCannedResponseMutation>;
export type CreateCannedResponseMutationResult = Apollo.MutationResult<Types.CreateCannedResponseMutation>;
export type CreateCannedResponseMutationOptions = Apollo.BaseMutationOptions<Types.CreateCannedResponseMutation, Types.CreateCannedResponseMutationVariables>;
export declare const CreateInterviewRoundDocument: Apollo.DocumentNode;
export type CreateInterviewRoundMutationFn = Apollo.MutationFunction<Types.CreateInterviewRoundMutation, Types.CreateInterviewRoundMutationVariables>;
/**
 * __useCreateInterviewRoundMutation__
 *
 * To run a mutation, you first call `useCreateInterviewRoundMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateInterviewRoundMutation` 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 [createInterviewRoundMutation, { data, loading, error }] = useCreateInterviewRoundMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateInterviewRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateInterviewRoundMutation, Types.CreateInterviewRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateInterviewRoundMutation, any, Apollo.ApolloCache, undefined>;
export type CreateInterviewRoundMutationHookResult = ReturnType<typeof useCreateInterviewRoundMutation>;
export type CreateInterviewRoundMutationResult = Apollo.MutationResult<Types.CreateInterviewRoundMutation>;
export type CreateInterviewRoundMutationOptions = Apollo.BaseMutationOptions<Types.CreateInterviewRoundMutation, Types.CreateInterviewRoundMutationVariables>;
export declare const CreateInterviewRoundConfigDocument: Apollo.DocumentNode;
export type CreateInterviewRoundConfigMutationFn = Apollo.MutationFunction<Types.CreateInterviewRoundConfigMutation, Types.CreateInterviewRoundConfigMutationVariables>;
/**
 * __useCreateInterviewRoundConfigMutation__
 *
 * To run a mutation, you first call `useCreateInterviewRoundConfigMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateInterviewRoundConfigMutation` 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 [createInterviewRoundConfigMutation, { data, loading, error }] = useCreateInterviewRoundConfigMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateInterviewRoundConfigMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateInterviewRoundConfigMutation, Types.CreateInterviewRoundConfigMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateInterviewRoundConfigMutation, any, Apollo.ApolloCache, undefined>;
export type CreateInterviewRoundConfigMutationHookResult = ReturnType<typeof useCreateInterviewRoundConfigMutation>;
export type CreateInterviewRoundConfigMutationResult = Apollo.MutationResult<Types.CreateInterviewRoundConfigMutation>;
export type CreateInterviewRoundConfigMutationOptions = Apollo.BaseMutationOptions<Types.CreateInterviewRoundConfigMutation, Types.CreateInterviewRoundConfigMutationVariables>;
export declare const CreateInterviewerDocument: Apollo.DocumentNode;
export type CreateInterviewerMutationFn = Apollo.MutationFunction<Types.CreateInterviewerMutation, Types.CreateInterviewerMutationVariables>;
/**
 * __useCreateInterviewerMutation__
 *
 * To run a mutation, you first call `useCreateInterviewerMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateInterviewerMutation` 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 [createInterviewerMutation, { data, loading, error }] = useCreateInterviewerMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateInterviewerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateInterviewerMutation, Types.CreateInterviewerMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateInterviewerMutation, any, Apollo.ApolloCache, undefined>;
export type CreateInterviewerMutationHookResult = ReturnType<typeof useCreateInterviewerMutation>;
export type CreateInterviewerMutationResult = Apollo.MutationResult<Types.CreateInterviewerMutation>;
export type CreateInterviewerMutationOptions = Apollo.BaseMutationOptions<Types.CreateInterviewerMutation, Types.CreateInterviewerMutationVariables>;
export declare const CreateJobApplicationDocument: Apollo.DocumentNode;
export type CreateJobApplicationMutationFn = Apollo.MutationFunction<Types.CreateJobApplicationMutation, Types.CreateJobApplicationMutationVariables>;
/**
 * __useCreateJobApplicationMutation__
 *
 * To run a mutation, you first call `useCreateJobApplicationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateJobApplicationMutation` 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 [createJobApplicationMutation, { data, loading, error }] = useCreateJobApplicationMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateJobApplicationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateJobApplicationMutation, Types.CreateJobApplicationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateJobApplicationMutation, any, Apollo.ApolloCache, undefined>;
export type CreateJobApplicationMutationHookResult = ReturnType<typeof useCreateJobApplicationMutation>;
export type CreateJobApplicationMutationResult = Apollo.MutationResult<Types.CreateJobApplicationMutation>;
export type CreateJobApplicationMutationOptions = Apollo.BaseMutationOptions<Types.CreateJobApplicationMutation, Types.CreateJobApplicationMutationVariables>;
export declare const CreateJobAssignmentDocument: Apollo.DocumentNode;
export type CreateJobAssignmentMutationFn = Apollo.MutationFunction<Types.CreateJobAssignmentMutation, Types.CreateJobAssignmentMutationVariables>;
/**
 * __useCreateJobAssignmentMutation__
 *
 * To run a mutation, you first call `useCreateJobAssignmentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateJobAssignmentMutation` 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 [createJobAssignmentMutation, { data, loading, error }] = useCreateJobAssignmentMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateJobAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateJobAssignmentMutation, Types.CreateJobAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateJobAssignmentMutation, any, Apollo.ApolloCache, undefined>;
export type CreateJobAssignmentMutationHookResult = ReturnType<typeof useCreateJobAssignmentMutation>;
export type CreateJobAssignmentMutationResult = Apollo.MutationResult<Types.CreateJobAssignmentMutation>;
export type CreateJobAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.CreateJobAssignmentMutation, Types.CreateJobAssignmentMutationVariables>;
export declare const CreateJobPostingDocument: Apollo.DocumentNode;
export type CreateJobPostingMutationFn = Apollo.MutationFunction<Types.CreateJobPostingMutation, Types.CreateJobPostingMutationVariables>;
/**
 * __useCreateJobPostingMutation__
 *
 * To run a mutation, you first call `useCreateJobPostingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateJobPostingMutation` 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 [createJobPostingMutation, { data, loading, error }] = useCreateJobPostingMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateJobPostingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateJobPostingMutation, Types.CreateJobPostingMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateJobPostingMutation, any, Apollo.ApolloCache, undefined>;
export type CreateJobPostingMutationHookResult = ReturnType<typeof useCreateJobPostingMutation>;
export type CreateJobPostingMutationResult = Apollo.MutationResult<Types.CreateJobPostingMutation>;
export type CreateJobPostingMutationOptions = Apollo.BaseMutationOptions<Types.CreateJobPostingMutation, Types.CreateJobPostingMutationVariables>;
export declare const CreateSlaPolicyDocument: Apollo.DocumentNode;
export type CreateSlaPolicyMutationFn = Apollo.MutationFunction<Types.CreateSlaPolicyMutation, Types.CreateSlaPolicyMutationVariables>;
/**
 * __useCreateSlaPolicyMutation__
 *
 * To run a mutation, you first call `useCreateSlaPolicyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateSlaPolicyMutation` 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 [createSlaPolicyMutation, { data, loading, error }] = useCreateSlaPolicyMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateSlaPolicyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateSlaPolicyMutation, Types.CreateSlaPolicyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateSlaPolicyMutation, any, Apollo.ApolloCache, undefined>;
export type CreateSlaPolicyMutationHookResult = ReturnType<typeof useCreateSlaPolicyMutation>;
export type CreateSlaPolicyMutationResult = Apollo.MutationResult<Types.CreateSlaPolicyMutation>;
export type CreateSlaPolicyMutationOptions = Apollo.BaseMutationOptions<Types.CreateSlaPolicyMutation, Types.CreateSlaPolicyMutationVariables>;
export declare const CreateSupportTicketDocument: Apollo.DocumentNode;
export type CreateSupportTicketMutationFn = Apollo.MutationFunction<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>;
/**
 * __useCreateSupportTicketMutation__
 *
 * To run a mutation, you first call `useCreateSupportTicketMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateSupportTicketMutation` 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 [createSupportTicketMutation, { data, loading, error }] = useCreateSupportTicketMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
export type CreateSupportTicketMutationHookResult = ReturnType<typeof useCreateSupportTicketMutation>;
export type CreateSupportTicketMutationResult = Apollo.MutationResult<Types.CreateSupportTicketMutation>;
export type CreateSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>;
export declare const DeleteCannedResponseDocument: Apollo.DocumentNode;
export type DeleteCannedResponseMutationFn = Apollo.MutationFunction<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>;
/**
 * __useDeleteCannedResponseMutation__
 *
 * To run a mutation, you first call `useDeleteCannedResponseMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteCannedResponseMutation` 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 [deleteCannedResponseMutation, { data, loading, error }] = useDeleteCannedResponseMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteCannedResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteCannedResponseMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteCannedResponseMutationHookResult = ReturnType<typeof useDeleteCannedResponseMutation>;
export type DeleteCannedResponseMutationResult = Apollo.MutationResult<Types.DeleteCannedResponseMutation>;
export type DeleteCannedResponseMutationOptions = Apollo.BaseMutationOptions<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>;
export declare const DeleteInterviewFeedbackDocument: Apollo.DocumentNode;
export type DeleteInterviewFeedbackMutationFn = Apollo.MutationFunction<Types.DeleteInterviewFeedbackMutation, Types.DeleteInterviewFeedbackMutationVariables>;
/**
 * __useDeleteInterviewFeedbackMutation__
 *
 * To run a mutation, you first call `useDeleteInterviewFeedbackMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteInterviewFeedbackMutation` 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 [deleteInterviewFeedbackMutation, { data, loading, error }] = useDeleteInterviewFeedbackMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteInterviewFeedbackMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInterviewFeedbackMutation, Types.DeleteInterviewFeedbackMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInterviewFeedbackMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteInterviewFeedbackMutationHookResult = ReturnType<typeof useDeleteInterviewFeedbackMutation>;
export type DeleteInterviewFeedbackMutationResult = Apollo.MutationResult<Types.DeleteInterviewFeedbackMutation>;
export type DeleteInterviewFeedbackMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInterviewFeedbackMutation, Types.DeleteInterviewFeedbackMutationVariables>;
export declare const DeleteInterviewRoundDocument: Apollo.DocumentNode;
export type DeleteInterviewRoundMutationFn = Apollo.MutationFunction<Types.DeleteInterviewRoundMutation, Types.DeleteInterviewRoundMutationVariables>;
/**
 * __useDeleteInterviewRoundMutation__
 *
 * To run a mutation, you first call `useDeleteInterviewRoundMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteInterviewRoundMutation` 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 [deleteInterviewRoundMutation, { data, loading, error }] = useDeleteInterviewRoundMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteInterviewRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInterviewRoundMutation, Types.DeleteInterviewRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInterviewRoundMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteInterviewRoundMutationHookResult = ReturnType<typeof useDeleteInterviewRoundMutation>;
export type DeleteInterviewRoundMutationResult = Apollo.MutationResult<Types.DeleteInterviewRoundMutation>;
export type DeleteInterviewRoundMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInterviewRoundMutation, Types.DeleteInterviewRoundMutationVariables>;
export declare const DeleteInterviewRoundConfigDocument: Apollo.DocumentNode;
export type DeleteInterviewRoundConfigMutationFn = Apollo.MutationFunction<Types.DeleteInterviewRoundConfigMutation, Types.DeleteInterviewRoundConfigMutationVariables>;
/**
 * __useDeleteInterviewRoundConfigMutation__
 *
 * To run a mutation, you first call `useDeleteInterviewRoundConfigMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteInterviewRoundConfigMutation` 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 [deleteInterviewRoundConfigMutation, { data, loading, error }] = useDeleteInterviewRoundConfigMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteInterviewRoundConfigMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInterviewRoundConfigMutation, Types.DeleteInterviewRoundConfigMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInterviewRoundConfigMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteInterviewRoundConfigMutationHookResult = ReturnType<typeof useDeleteInterviewRoundConfigMutation>;
export type DeleteInterviewRoundConfigMutationResult = Apollo.MutationResult<Types.DeleteInterviewRoundConfigMutation>;
export type DeleteInterviewRoundConfigMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInterviewRoundConfigMutation, Types.DeleteInterviewRoundConfigMutationVariables>;
export declare const DeleteInterviewerDocument: Apollo.DocumentNode;
export type DeleteInterviewerMutationFn = Apollo.MutationFunction<Types.DeleteInterviewerMutation, Types.DeleteInterviewerMutationVariables>;
/**
 * __useDeleteInterviewerMutation__
 *
 * To run a mutation, you first call `useDeleteInterviewerMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteInterviewerMutation` 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 [deleteInterviewerMutation, { data, loading, error }] = useDeleteInterviewerMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteInterviewerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInterviewerMutation, Types.DeleteInterviewerMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInterviewerMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteInterviewerMutationHookResult = ReturnType<typeof useDeleteInterviewerMutation>;
export type DeleteInterviewerMutationResult = Apollo.MutationResult<Types.DeleteInterviewerMutation>;
export type DeleteInterviewerMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInterviewerMutation, Types.DeleteInterviewerMutationVariables>;
export declare const DeleteJobAssignmentDocument: Apollo.DocumentNode;
export type DeleteJobAssignmentMutationFn = Apollo.MutationFunction<Types.DeleteJobAssignmentMutation, Types.DeleteJobAssignmentMutationVariables>;
/**
 * __useDeleteJobAssignmentMutation__
 *
 * To run a mutation, you first call `useDeleteJobAssignmentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteJobAssignmentMutation` 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 [deleteJobAssignmentMutation, { data, loading, error }] = useDeleteJobAssignmentMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteJobAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteJobAssignmentMutation, Types.DeleteJobAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteJobAssignmentMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteJobAssignmentMutationHookResult = ReturnType<typeof useDeleteJobAssignmentMutation>;
export type DeleteJobAssignmentMutationResult = Apollo.MutationResult<Types.DeleteJobAssignmentMutation>;
export type DeleteJobAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.DeleteJobAssignmentMutation, Types.DeleteJobAssignmentMutationVariables>;
export declare const DeleteJobPostingDocument: Apollo.DocumentNode;
export type DeleteJobPostingMutationFn = Apollo.MutationFunction<Types.DeleteJobPostingMutation, Types.DeleteJobPostingMutationVariables>;
/**
 * __useDeleteJobPostingMutation__
 *
 * To run a mutation, you first call `useDeleteJobPostingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteJobPostingMutation` 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 [deleteJobPostingMutation, { data, loading, error }] = useDeleteJobPostingMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteJobPostingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteJobPostingMutation, Types.DeleteJobPostingMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteJobPostingMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteJobPostingMutationHookResult = ReturnType<typeof useDeleteJobPostingMutation>;
export type DeleteJobPostingMutationResult = Apollo.MutationResult<Types.DeleteJobPostingMutation>;
export type DeleteJobPostingMutationOptions = Apollo.BaseMutationOptions<Types.DeleteJobPostingMutation, Types.DeleteJobPostingMutationVariables>;
export declare const DeleteSlaPolicyDocument: Apollo.DocumentNode;
export type DeleteSlaPolicyMutationFn = Apollo.MutationFunction<Types.DeleteSlaPolicyMutation, Types.DeleteSlaPolicyMutationVariables>;
/**
 * __useDeleteSlaPolicyMutation__
 *
 * To run a mutation, you first call `useDeleteSlaPolicyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteSlaPolicyMutation` 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 [deleteSlaPolicyMutation, { data, loading, error }] = useDeleteSlaPolicyMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteSlaPolicyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteSlaPolicyMutation, Types.DeleteSlaPolicyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteSlaPolicyMutation, any, Apollo.ApolloCache, undefined>;
export type DeleteSlaPolicyMutationHookResult = ReturnType<typeof useDeleteSlaPolicyMutation>;
export type DeleteSlaPolicyMutationResult = Apollo.MutationResult<Types.DeleteSlaPolicyMutation>;
export type DeleteSlaPolicyMutationOptions = Apollo.BaseMutationOptions<Types.DeleteSlaPolicyMutation, Types.DeleteSlaPolicyMutationVariables>;
export declare const NotifyDuplicateApplicantsDocument: Apollo.DocumentNode;
export type NotifyDuplicateApplicantsMutationFn = Apollo.MutationFunction<Types.NotifyDuplicateApplicantsMutation, Types.NotifyDuplicateApplicantsMutationVariables>;
/**
 * __useNotifyDuplicateApplicantsMutation__
 *
 * To run a mutation, you first call `useNotifyDuplicateApplicantsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyDuplicateApplicantsMutation` 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 [notifyDuplicateApplicantsMutation, { data, loading, error }] = useNotifyDuplicateApplicantsMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useNotifyDuplicateApplicantsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.NotifyDuplicateApplicantsMutation, Types.NotifyDuplicateApplicantsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.NotifyDuplicateApplicantsMutation, any, Apollo.ApolloCache, undefined>;
export type NotifyDuplicateApplicantsMutationHookResult = ReturnType<typeof useNotifyDuplicateApplicantsMutation>;
export type NotifyDuplicateApplicantsMutationResult = Apollo.MutationResult<Types.NotifyDuplicateApplicantsMutation>;
export type NotifyDuplicateApplicantsMutationOptions = Apollo.BaseMutationOptions<Types.NotifyDuplicateApplicantsMutation, Types.NotifyDuplicateApplicantsMutationVariables>;
export declare const RandomizeAndSendAssignmentDocument: Apollo.DocumentNode;
export type RandomizeAndSendAssignmentMutationFn = Apollo.MutationFunction<Types.RandomizeAndSendAssignmentMutation, Types.RandomizeAndSendAssignmentMutationVariables>;
/**
 * __useRandomizeAndSendAssignmentMutation__
 *
 * To run a mutation, you first call `useRandomizeAndSendAssignmentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRandomizeAndSendAssignmentMutation` 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 [randomizeAndSendAssignmentMutation, { data, loading, error }] = useRandomizeAndSendAssignmentMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useRandomizeAndSendAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RandomizeAndSendAssignmentMutation, Types.RandomizeAndSendAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RandomizeAndSendAssignmentMutation, any, Apollo.ApolloCache, undefined>;
export type RandomizeAndSendAssignmentMutationHookResult = ReturnType<typeof useRandomizeAndSendAssignmentMutation>;
export type RandomizeAndSendAssignmentMutationResult = Apollo.MutationResult<Types.RandomizeAndSendAssignmentMutation>;
export type RandomizeAndSendAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.RandomizeAndSendAssignmentMutation, Types.RandomizeAndSendAssignmentMutationVariables>;
export declare const RateArticleDocument: Apollo.DocumentNode;
export type RateArticleMutationFn = Apollo.MutationFunction<Types.RateArticleMutation, Types.RateArticleMutationVariables>;
/**
 * __useRateArticleMutation__
 *
 * To run a mutation, you first call `useRateArticleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRateArticleMutation` 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 [rateArticleMutation, { data, loading, error }] = useRateArticleMutation({
 *   variables: {
 *      id: // value for 'id'
 *      helpful: // value for 'helpful'
 *   },
 * });
 */
export declare function useRateArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RateArticleMutation, Types.RateArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RateArticleMutation, any, Apollo.ApolloCache, undefined>;
export type RateArticleMutationHookResult = ReturnType<typeof useRateArticleMutation>;
export type RateArticleMutationResult = Apollo.MutationResult<Types.RateArticleMutation>;
export type RateArticleMutationOptions = Apollo.BaseMutationOptions<Types.RateArticleMutation, Types.RateArticleMutationVariables>;
export declare const RecordArticleViewDocument: Apollo.DocumentNode;
export type RecordArticleViewMutationFn = Apollo.MutationFunction<Types.RecordArticleViewMutation, Types.RecordArticleViewMutationVariables>;
/**
 * __useRecordArticleViewMutation__
 *
 * To run a mutation, you first call `useRecordArticleViewMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRecordArticleViewMutation` 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 [recordArticleViewMutation, { data, loading, error }] = useRecordArticleViewMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useRecordArticleViewMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RecordArticleViewMutation, Types.RecordArticleViewMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RecordArticleViewMutation, any, Apollo.ApolloCache, undefined>;
export type RecordArticleViewMutationHookResult = ReturnType<typeof useRecordArticleViewMutation>;
export type RecordArticleViewMutationResult = Apollo.MutationResult<Types.RecordArticleViewMutation>;
export type RecordArticleViewMutationOptions = Apollo.BaseMutationOptions<Types.RecordArticleViewMutation, Types.RecordArticleViewMutationVariables>;
export declare const RecordAssignmentSubmissionDocument: Apollo.DocumentNode;
export type RecordAssignmentSubmissionMutationFn = Apollo.MutationFunction<Types.RecordAssignmentSubmissionMutation, Types.RecordAssignmentSubmissionMutationVariables>;
/**
 * __useRecordAssignmentSubmissionMutation__
 *
 * To run a mutation, you first call `useRecordAssignmentSubmissionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRecordAssignmentSubmissionMutation` 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 [recordAssignmentSubmissionMutation, { data, loading, error }] = useRecordAssignmentSubmissionMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useRecordAssignmentSubmissionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RecordAssignmentSubmissionMutation, Types.RecordAssignmentSubmissionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RecordAssignmentSubmissionMutation, any, Apollo.ApolloCache, undefined>;
export type RecordAssignmentSubmissionMutationHookResult = ReturnType<typeof useRecordAssignmentSubmissionMutation>;
export type RecordAssignmentSubmissionMutationResult = Apollo.MutationResult<Types.RecordAssignmentSubmissionMutation>;
export type RecordAssignmentSubmissionMutationOptions = Apollo.BaseMutationOptions<Types.RecordAssignmentSubmissionMutation, Types.RecordAssignmentSubmissionMutationVariables>;
export declare const RemoveInterviewerFromRoundDocument: Apollo.DocumentNode;
export type RemoveInterviewerFromRoundMutationFn = Apollo.MutationFunction<Types.RemoveInterviewerFromRoundMutation, Types.RemoveInterviewerFromRoundMutationVariables>;
/**
 * __useRemoveInterviewerFromRoundMutation__
 *
 * To run a mutation, you first call `useRemoveInterviewerFromRoundMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveInterviewerFromRoundMutation` 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 [removeInterviewerFromRoundMutation, { data, loading, error }] = useRemoveInterviewerFromRoundMutation({
 *   variables: {
 *      roundId: // value for 'roundId'
 *      interviewerId: // value for 'interviewerId'
 *   },
 * });
 */
export declare function useRemoveInterviewerFromRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveInterviewerFromRoundMutation, Types.RemoveInterviewerFromRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveInterviewerFromRoundMutation, any, Apollo.ApolloCache, undefined>;
export type RemoveInterviewerFromRoundMutationHookResult = ReturnType<typeof useRemoveInterviewerFromRoundMutation>;
export type RemoveInterviewerFromRoundMutationResult = Apollo.MutationResult<Types.RemoveInterviewerFromRoundMutation>;
export type RemoveInterviewerFromRoundMutationOptions = Apollo.BaseMutationOptions<Types.RemoveInterviewerFromRoundMutation, Types.RemoveInterviewerFromRoundMutationVariables>;
export declare const ReplyToContactInquiryDocument: Apollo.DocumentNode;
export type ReplyToContactInquiryMutationFn = Apollo.MutationFunction<Types.ReplyToContactInquiryMutation, Types.ReplyToContactInquiryMutationVariables>;
/**
 * __useReplyToContactInquiryMutation__
 *
 * To run a mutation, you first call `useReplyToContactInquiryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useReplyToContactInquiryMutation` 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 [replyToContactInquiryMutation, { data, loading, error }] = useReplyToContactInquiryMutation({
 *   variables: {
 *      id: // value for 'id'
 *      message: // value for 'message'
 *   },
 * });
 */
export declare function useReplyToContactInquiryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReplyToContactInquiryMutation, Types.ReplyToContactInquiryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReplyToContactInquiryMutation, any, Apollo.ApolloCache, undefined>;
export type ReplyToContactInquiryMutationHookResult = ReturnType<typeof useReplyToContactInquiryMutation>;
export type ReplyToContactInquiryMutationResult = Apollo.MutationResult<Types.ReplyToContactInquiryMutation>;
export type ReplyToContactInquiryMutationOptions = Apollo.BaseMutationOptions<Types.ReplyToContactInquiryMutation, Types.ReplyToContactInquiryMutationVariables>;
export declare const ReplyToJobApplicationDocument: Apollo.DocumentNode;
export type ReplyToJobApplicationMutationFn = Apollo.MutationFunction<Types.ReplyToJobApplicationMutation, Types.ReplyToJobApplicationMutationVariables>;
/**
 * __useReplyToJobApplicationMutation__
 *
 * To run a mutation, you first call `useReplyToJobApplicationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useReplyToJobApplicationMutation` 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 [replyToJobApplicationMutation, { data, loading, error }] = useReplyToJobApplicationMutation({
 *   variables: {
 *      id: // value for 'id'
 *      message: // value for 'message'
 *   },
 * });
 */
export declare function useReplyToJobApplicationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReplyToJobApplicationMutation, Types.ReplyToJobApplicationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReplyToJobApplicationMutation, any, Apollo.ApolloCache, undefined>;
export type ReplyToJobApplicationMutationHookResult = ReturnType<typeof useReplyToJobApplicationMutation>;
export type ReplyToJobApplicationMutationResult = Apollo.MutationResult<Types.ReplyToJobApplicationMutation>;
export type ReplyToJobApplicationMutationOptions = Apollo.BaseMutationOptions<Types.ReplyToJobApplicationMutation, Types.ReplyToJobApplicationMutationVariables>;
export declare const ResolveSupportTicketDocument: Apollo.DocumentNode;
export type ResolveSupportTicketMutationFn = Apollo.MutationFunction<Types.ResolveSupportTicketMutation, Types.ResolveSupportTicketMutationVariables>;
/**
 * __useResolveSupportTicketMutation__
 *
 * To run a mutation, you first call `useResolveSupportTicketMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResolveSupportTicketMutation` 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 [resolveSupportTicketMutation, { data, loading, error }] = useResolveSupportTicketMutation({
 *   variables: {
 *      id: // value for 'id'
 *      resolution: // value for 'resolution'
 *   },
 * });
 */
export declare function useResolveSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ResolveSupportTicketMutation, Types.ResolveSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ResolveSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
export type ResolveSupportTicketMutationHookResult = ReturnType<typeof useResolveSupportTicketMutation>;
export type ResolveSupportTicketMutationResult = Apollo.MutationResult<Types.ResolveSupportTicketMutation>;
export type ResolveSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.ResolveSupportTicketMutation, Types.ResolveSupportTicketMutationVariables>;
export declare const SendRoundMessageToCandidateDocument: Apollo.DocumentNode;
export type SendRoundMessageToCandidateMutationFn = Apollo.MutationFunction<Types.SendRoundMessageToCandidateMutation, Types.SendRoundMessageToCandidateMutationVariables>;
/**
 * __useSendRoundMessageToCandidateMutation__
 *
 * To run a mutation, you first call `useSendRoundMessageToCandidateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSendRoundMessageToCandidateMutation` 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 [sendRoundMessageToCandidateMutation, { data, loading, error }] = useSendRoundMessageToCandidateMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSendRoundMessageToCandidateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SendRoundMessageToCandidateMutation, Types.SendRoundMessageToCandidateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SendRoundMessageToCandidateMutation, any, Apollo.ApolloCache, undefined>;
export type SendRoundMessageToCandidateMutationHookResult = ReturnType<typeof useSendRoundMessageToCandidateMutation>;
export type SendRoundMessageToCandidateMutationResult = Apollo.MutationResult<Types.SendRoundMessageToCandidateMutation>;
export type SendRoundMessageToCandidateMutationOptions = Apollo.BaseMutationOptions<Types.SendRoundMessageToCandidateMutation, Types.SendRoundMessageToCandidateMutationVariables>;
export declare const SubmitInterviewFeedbackDocument: Apollo.DocumentNode;
export type SubmitInterviewFeedbackMutationFn = Apollo.MutationFunction<Types.SubmitInterviewFeedbackMutation, Types.SubmitInterviewFeedbackMutationVariables>;
/**
 * __useSubmitInterviewFeedbackMutation__
 *
 * To run a mutation, you first call `useSubmitInterviewFeedbackMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSubmitInterviewFeedbackMutation` 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 [submitInterviewFeedbackMutation, { data, loading, error }] = useSubmitInterviewFeedbackMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSubmitInterviewFeedbackMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SubmitInterviewFeedbackMutation, Types.SubmitInterviewFeedbackMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SubmitInterviewFeedbackMutation, any, Apollo.ApolloCache, undefined>;
export type SubmitInterviewFeedbackMutationHookResult = ReturnType<typeof useSubmitInterviewFeedbackMutation>;
export type SubmitInterviewFeedbackMutationResult = Apollo.MutationResult<Types.SubmitInterviewFeedbackMutation>;
export type SubmitInterviewFeedbackMutationOptions = Apollo.BaseMutationOptions<Types.SubmitInterviewFeedbackMutation, Types.SubmitInterviewFeedbackMutationVariables>;
export declare const SubmitSatisfactionSurveyDocument: Apollo.DocumentNode;
export type SubmitSatisfactionSurveyMutationFn = Apollo.MutationFunction<Types.SubmitSatisfactionSurveyMutation, Types.SubmitSatisfactionSurveyMutationVariables>;
/**
 * __useSubmitSatisfactionSurveyMutation__
 *
 * To run a mutation, you first call `useSubmitSatisfactionSurveyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSubmitSatisfactionSurveyMutation` 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 [submitSatisfactionSurveyMutation, { data, loading, error }] = useSubmitSatisfactionSurveyMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSubmitSatisfactionSurveyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SubmitSatisfactionSurveyMutation, Types.SubmitSatisfactionSurveyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SubmitSatisfactionSurveyMutation, any, Apollo.ApolloCache, undefined>;
export type SubmitSatisfactionSurveyMutationHookResult = ReturnType<typeof useSubmitSatisfactionSurveyMutation>;
export type SubmitSatisfactionSurveyMutationResult = Apollo.MutationResult<Types.SubmitSatisfactionSurveyMutation>;
export type SubmitSatisfactionSurveyMutationOptions = Apollo.BaseMutationOptions<Types.SubmitSatisfactionSurveyMutation, Types.SubmitSatisfactionSurveyMutationVariables>;
export declare const UpdateCannedResponseDocument: Apollo.DocumentNode;
export type UpdateCannedResponseMutationFn = Apollo.MutationFunction<Types.UpdateCannedResponseMutation, Types.UpdateCannedResponseMutationVariables>;
/**
 * __useUpdateCannedResponseMutation__
 *
 * To run a mutation, you first call `useUpdateCannedResponseMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateCannedResponseMutation` 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 [updateCannedResponseMutation, { data, loading, error }] = useUpdateCannedResponseMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateCannedResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCannedResponseMutation, Types.UpdateCannedResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateCannedResponseMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateCannedResponseMutationHookResult = ReturnType<typeof useUpdateCannedResponseMutation>;
export type UpdateCannedResponseMutationResult = Apollo.MutationResult<Types.UpdateCannedResponseMutation>;
export type UpdateCannedResponseMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCannedResponseMutation, Types.UpdateCannedResponseMutationVariables>;
export declare const UpdateContactInquiryStatusDocument: Apollo.DocumentNode;
export type UpdateContactInquiryStatusMutationFn = Apollo.MutationFunction<Types.UpdateContactInquiryStatusMutation, Types.UpdateContactInquiryStatusMutationVariables>;
/**
 * __useUpdateContactInquiryStatusMutation__
 *
 * To run a mutation, you first call `useUpdateContactInquiryStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateContactInquiryStatusMutation` 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 [updateContactInquiryStatusMutation, { data, loading, error }] = useUpdateContactInquiryStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateContactInquiryStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateContactInquiryStatusMutation, Types.UpdateContactInquiryStatusMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateContactInquiryStatusMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateContactInquiryStatusMutationHookResult = ReturnType<typeof useUpdateContactInquiryStatusMutation>;
export type UpdateContactInquiryStatusMutationResult = Apollo.MutationResult<Types.UpdateContactInquiryStatusMutation>;
export type UpdateContactInquiryStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateContactInquiryStatusMutation, Types.UpdateContactInquiryStatusMutationVariables>;
export declare const UpdateInterviewFeedbackDocument: Apollo.DocumentNode;
export type UpdateInterviewFeedbackMutationFn = Apollo.MutationFunction<Types.UpdateInterviewFeedbackMutation, Types.UpdateInterviewFeedbackMutationVariables>;
/**
 * __useUpdateInterviewFeedbackMutation__
 *
 * To run a mutation, you first call `useUpdateInterviewFeedbackMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateInterviewFeedbackMutation` 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 [updateInterviewFeedbackMutation, { data, loading, error }] = useUpdateInterviewFeedbackMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateInterviewFeedbackMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInterviewFeedbackMutation, Types.UpdateInterviewFeedbackMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInterviewFeedbackMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateInterviewFeedbackMutationHookResult = ReturnType<typeof useUpdateInterviewFeedbackMutation>;
export type UpdateInterviewFeedbackMutationResult = Apollo.MutationResult<Types.UpdateInterviewFeedbackMutation>;
export type UpdateInterviewFeedbackMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInterviewFeedbackMutation, Types.UpdateInterviewFeedbackMutationVariables>;
export declare const UpdateInterviewRoundDocument: Apollo.DocumentNode;
export type UpdateInterviewRoundMutationFn = Apollo.MutationFunction<Types.UpdateInterviewRoundMutation, Types.UpdateInterviewRoundMutationVariables>;
/**
 * __useUpdateInterviewRoundMutation__
 *
 * To run a mutation, you first call `useUpdateInterviewRoundMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateInterviewRoundMutation` 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 [updateInterviewRoundMutation, { data, loading, error }] = useUpdateInterviewRoundMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateInterviewRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInterviewRoundMutation, Types.UpdateInterviewRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInterviewRoundMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateInterviewRoundMutationHookResult = ReturnType<typeof useUpdateInterviewRoundMutation>;
export type UpdateInterviewRoundMutationResult = Apollo.MutationResult<Types.UpdateInterviewRoundMutation>;
export type UpdateInterviewRoundMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInterviewRoundMutation, Types.UpdateInterviewRoundMutationVariables>;
export declare const UpdateInterviewRoundConfigDocument: Apollo.DocumentNode;
export type UpdateInterviewRoundConfigMutationFn = Apollo.MutationFunction<Types.UpdateInterviewRoundConfigMutation, Types.UpdateInterviewRoundConfigMutationVariables>;
/**
 * __useUpdateInterviewRoundConfigMutation__
 *
 * To run a mutation, you first call `useUpdateInterviewRoundConfigMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateInterviewRoundConfigMutation` 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 [updateInterviewRoundConfigMutation, { data, loading, error }] = useUpdateInterviewRoundConfigMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateInterviewRoundConfigMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInterviewRoundConfigMutation, Types.UpdateInterviewRoundConfigMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInterviewRoundConfigMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateInterviewRoundConfigMutationHookResult = ReturnType<typeof useUpdateInterviewRoundConfigMutation>;
export type UpdateInterviewRoundConfigMutationResult = Apollo.MutationResult<Types.UpdateInterviewRoundConfigMutation>;
export type UpdateInterviewRoundConfigMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInterviewRoundConfigMutation, Types.UpdateInterviewRoundConfigMutationVariables>;
export declare const UpdateInterviewerDocument: Apollo.DocumentNode;
export type UpdateInterviewerMutationFn = Apollo.MutationFunction<Types.UpdateInterviewerMutation, Types.UpdateInterviewerMutationVariables>;
/**
 * __useUpdateInterviewerMutation__
 *
 * To run a mutation, you first call `useUpdateInterviewerMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateInterviewerMutation` 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 [updateInterviewerMutation, { data, loading, error }] = useUpdateInterviewerMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateInterviewerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInterviewerMutation, Types.UpdateInterviewerMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInterviewerMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateInterviewerMutationHookResult = ReturnType<typeof useUpdateInterviewerMutation>;
export type UpdateInterviewerMutationResult = Apollo.MutationResult<Types.UpdateInterviewerMutation>;
export type UpdateInterviewerMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInterviewerMutation, Types.UpdateInterviewerMutationVariables>;
export declare const UpdateJobApplicationStatusDocument: Apollo.DocumentNode;
export type UpdateJobApplicationStatusMutationFn = Apollo.MutationFunction<Types.UpdateJobApplicationStatusMutation, Types.UpdateJobApplicationStatusMutationVariables>;
/**
 * __useUpdateJobApplicationStatusMutation__
 *
 * To run a mutation, you first call `useUpdateJobApplicationStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateJobApplicationStatusMutation` 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 [updateJobApplicationStatusMutation, { data, loading, error }] = useUpdateJobApplicationStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateJobApplicationStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateJobApplicationStatusMutation, Types.UpdateJobApplicationStatusMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateJobApplicationStatusMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateJobApplicationStatusMutationHookResult = ReturnType<typeof useUpdateJobApplicationStatusMutation>;
export type UpdateJobApplicationStatusMutationResult = Apollo.MutationResult<Types.UpdateJobApplicationStatusMutation>;
export type UpdateJobApplicationStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateJobApplicationStatusMutation, Types.UpdateJobApplicationStatusMutationVariables>;
export declare const UpdateJobAssignmentDocument: Apollo.DocumentNode;
export type UpdateJobAssignmentMutationFn = Apollo.MutationFunction<Types.UpdateJobAssignmentMutation, Types.UpdateJobAssignmentMutationVariables>;
/**
 * __useUpdateJobAssignmentMutation__
 *
 * To run a mutation, you first call `useUpdateJobAssignmentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateJobAssignmentMutation` 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 [updateJobAssignmentMutation, { data, loading, error }] = useUpdateJobAssignmentMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateJobAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateJobAssignmentMutation, Types.UpdateJobAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateJobAssignmentMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateJobAssignmentMutationHookResult = ReturnType<typeof useUpdateJobAssignmentMutation>;
export type UpdateJobAssignmentMutationResult = Apollo.MutationResult<Types.UpdateJobAssignmentMutation>;
export type UpdateJobAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.UpdateJobAssignmentMutation, Types.UpdateJobAssignmentMutationVariables>;
export declare const UpdateJobPostingDocument: Apollo.DocumentNode;
export type UpdateJobPostingMutationFn = Apollo.MutationFunction<Types.UpdateJobPostingMutation, Types.UpdateJobPostingMutationVariables>;
/**
 * __useUpdateJobPostingMutation__
 *
 * To run a mutation, you first call `useUpdateJobPostingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateJobPostingMutation` 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 [updateJobPostingMutation, { data, loading, error }] = useUpdateJobPostingMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateJobPostingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateJobPostingMutation, Types.UpdateJobPostingMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateJobPostingMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateJobPostingMutationHookResult = ReturnType<typeof useUpdateJobPostingMutation>;
export type UpdateJobPostingMutationResult = Apollo.MutationResult<Types.UpdateJobPostingMutation>;
export type UpdateJobPostingMutationOptions = Apollo.BaseMutationOptions<Types.UpdateJobPostingMutation, Types.UpdateJobPostingMutationVariables>;
export declare const UpdateSlaPolicyDocument: Apollo.DocumentNode;
export type UpdateSlaPolicyMutationFn = Apollo.MutationFunction<Types.UpdateSlaPolicyMutation, Types.UpdateSlaPolicyMutationVariables>;
/**
 * __useUpdateSlaPolicyMutation__
 *
 * To run a mutation, you first call `useUpdateSlaPolicyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateSlaPolicyMutation` 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 [updateSlaPolicyMutation, { data, loading, error }] = useUpdateSlaPolicyMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateSlaPolicyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateSlaPolicyMutation, Types.UpdateSlaPolicyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateSlaPolicyMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateSlaPolicyMutationHookResult = ReturnType<typeof useUpdateSlaPolicyMutation>;
export type UpdateSlaPolicyMutationResult = Apollo.MutationResult<Types.UpdateSlaPolicyMutation>;
export type UpdateSlaPolicyMutationOptions = Apollo.BaseMutationOptions<Types.UpdateSlaPolicyMutation, Types.UpdateSlaPolicyMutationVariables>;
export declare const UpdateSupportTicketDocument: Apollo.DocumentNode;
export type UpdateSupportTicketMutationFn = Apollo.MutationFunction<Types.UpdateSupportTicketMutation, Types.UpdateSupportTicketMutationVariables>;
/**
 * __useUpdateSupportTicketMutation__
 *
 * To run a mutation, you first call `useUpdateSupportTicketMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateSupportTicketMutation` 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 [updateSupportTicketMutation, { data, loading, error }] = useUpdateSupportTicketMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateSupportTicketMutation, Types.UpdateSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
export type UpdateSupportTicketMutationHookResult = ReturnType<typeof useUpdateSupportTicketMutation>;
export type UpdateSupportTicketMutationResult = Apollo.MutationResult<Types.UpdateSupportTicketMutation>;
export type UpdateSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.UpdateSupportTicketMutation, Types.UpdateSupportTicketMutationVariables>;
export declare const GetAgentLeaderboardDocument: Apollo.DocumentNode;
/**
 * __useGetAgentLeaderboardQuery__
 *
 * To run a query within a React component, call `useGetAgentLeaderboardQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAgentLeaderboardQuery` 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 } = useGetAgentLeaderboardQuery({
 *   variables: {
 *      period: // value for 'period'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export declare function useGetAgentLeaderboardQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables, "empty" | "complete" | "streaming", Types.GetAgentLeaderboardQueryVariables>;
export declare function useGetAgentLeaderboardLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetAgentLeaderboardSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>;
export declare function useGetAgentLeaderboardSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAgentLeaderboardQuery | undefined, Types.GetAgentLeaderboardQueryVariables>;
export type GetAgentLeaderboardQueryHookResult = ReturnType<typeof useGetAgentLeaderboardQuery>;
export type GetAgentLeaderboardLazyQueryHookResult = ReturnType<typeof useGetAgentLeaderboardLazyQuery>;
export type GetAgentLeaderboardSuspenseQueryHookResult = ReturnType<typeof useGetAgentLeaderboardSuspenseQuery>;
export type GetAgentLeaderboardQueryResult = Apollo.QueryResult<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>;
export declare const GetSlaReportDocument: Apollo.DocumentNode;
/**
 * __useGetSlaReportQuery__
 *
 * To run a query within a React component, call `useGetSlaReportQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSlaReportQuery` 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 } = useGetSlaReportQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *   },
 * });
 */
export declare function useGetSlaReportQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables, "empty" | "complete" | "streaming", Types.GetSlaReportQueryVariables>;
export declare function useGetSlaReportLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetSlaReportSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>;
export declare function useGetSlaReportSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSlaReportQuery | undefined, Types.GetSlaReportQueryVariables>;
export type GetSlaReportQueryHookResult = ReturnType<typeof useGetSlaReportQuery>;
export type GetSlaReportLazyQueryHookResult = ReturnType<typeof useGetSlaReportLazyQuery>;
export type GetSlaReportSuspenseQueryHookResult = ReturnType<typeof useGetSlaReportSuspenseQuery>;
export type GetSlaReportQueryResult = Apollo.QueryResult<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>;
export declare const GetSatisfactionMetricsDocument: Apollo.DocumentNode;
/**
 * __useGetSatisfactionMetricsQuery__
 *
 * To run a query within a React component, call `useGetSatisfactionMetricsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSatisfactionMetricsQuery` 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 } = useGetSatisfactionMetricsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *   },
 * });
 */
export declare function useGetSatisfactionMetricsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables, "empty" | "complete" | "streaming", Types.GetSatisfactionMetricsQueryVariables>;
export declare function useGetSatisfactionMetricsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetSatisfactionMetricsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>;
export declare function useGetSatisfactionMetricsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSatisfactionMetricsQuery | undefined, Types.GetSatisfactionMetricsQueryVariables>;
export type GetSatisfactionMetricsQueryHookResult = ReturnType<typeof useGetSatisfactionMetricsQuery>;
export type GetSatisfactionMetricsLazyQueryHookResult = ReturnType<typeof useGetSatisfactionMetricsLazyQuery>;
export type GetSatisfactionMetricsSuspenseQueryHookResult = ReturnType<typeof useGetSatisfactionMetricsSuspenseQuery>;
export type GetSatisfactionMetricsQueryResult = Apollo.QueryResult<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>;
export declare const GetAgentProfilesDocument: Apollo.DocumentNode;
/**
 * __useGetAgentProfilesQuery__
 *
 * To run a query within a React component, call `useGetAgentProfilesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAgentProfilesQuery` 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 } = useGetAgentProfilesQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetAgentProfilesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables, "empty" | "complete" | "streaming", Types.GetAgentProfilesQueryVariables>;
export declare function useGetAgentProfilesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetAgentProfilesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>;
export declare function useGetAgentProfilesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAgentProfilesQuery | undefined, Types.GetAgentProfilesQueryVariables>;
export type GetAgentProfilesQueryHookResult = ReturnType<typeof useGetAgentProfilesQuery>;
export type GetAgentProfilesLazyQueryHookResult = ReturnType<typeof useGetAgentProfilesLazyQuery>;
export type GetAgentProfilesSuspenseQueryHookResult = ReturnType<typeof useGetAgentProfilesSuspenseQuery>;
export type GetAgentProfilesQueryResult = Apollo.QueryResult<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>;
export declare const GetArticleDocument: Apollo.DocumentNode;
/**
 * __useGetArticleQuery__
 *
 * To run a query within a React component, call `useGetArticleQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetArticleQuery` 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 } = useGetArticleQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetArticleQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetArticleQuery, Types.GetArticleQueryVariables> & ({
    variables: Types.GetArticleQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetArticleQuery, Types.GetArticleQueryVariables, "empty" | "complete" | "streaming", Types.GetArticleQueryVariables>;
export declare function useGetArticleLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetArticleQuery, Types.GetArticleQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetArticleQuery, Types.GetArticleQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetArticleSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetArticleQuery, Types.GetArticleQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetArticleQuery, Types.GetArticleQueryVariables>;
export declare function useGetArticleSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetArticleQuery, Types.GetArticleQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetArticleQuery | undefined, Types.GetArticleQueryVariables>;
export type GetArticleQueryHookResult = ReturnType<typeof useGetArticleQuery>;
export type GetArticleLazyQueryHookResult = ReturnType<typeof useGetArticleLazyQuery>;
export type GetArticleSuspenseQueryHookResult = ReturnType<typeof useGetArticleSuspenseQuery>;
export type GetArticleQueryResult = Apollo.QueryResult<Types.GetArticleQuery, Types.GetArticleQueryVariables>;
export declare const GetArticlesDocument: Apollo.DocumentNode;
/**
 * __useGetArticlesQuery__
 *
 * To run a query within a React component, call `useGetArticlesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetArticlesQuery` 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 } = useGetArticlesQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetArticlesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetArticlesQuery, Types.GetArticlesQueryVariables, "empty" | "complete" | "streaming", Types.GetArticlesQueryVariables>;
export declare function useGetArticlesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetArticlesQuery, Types.GetArticlesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetArticlesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>;
export declare function useGetArticlesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetArticlesQuery | undefined, Types.GetArticlesQueryVariables>;
export type GetArticlesQueryHookResult = ReturnType<typeof useGetArticlesQuery>;
export type GetArticlesLazyQueryHookResult = ReturnType<typeof useGetArticlesLazyQuery>;
export type GetArticlesSuspenseQueryHookResult = ReturnType<typeof useGetArticlesSuspenseQuery>;
export type GetArticlesQueryResult = Apollo.QueryResult<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>;
export declare const GetBulkCandidateTargetsDocument: Apollo.DocumentNode;
/**
 * __useGetBulkCandidateTargetsQuery__
 *
 * To run a query within a React component, call `useGetBulkCandidateTargetsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetBulkCandidateTargetsQuery` 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 } = useGetBulkCandidateTargetsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetBulkCandidateTargetsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetBulkCandidateTargetsQuery, Types.GetBulkCandidateTargetsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetBulkCandidateTargetsQuery, Types.GetBulkCandidateTargetsQueryVariables, "empty" | "complete" | "streaming", Types.GetBulkCandidateTargetsQueryVariables>;
export declare function useGetBulkCandidateTargetsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetBulkCandidateTargetsQuery, Types.GetBulkCandidateTargetsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetBulkCandidateTargetsQuery, Types.GetBulkCandidateTargetsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetBulkCandidateTargetsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetBulkCandidateTargetsQuery, Types.GetBulkCandidateTargetsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetBulkCandidateTargetsQuery, Types.GetBulkCandidateTargetsQueryVariables>;
export declare function useGetBulkCandidateTargetsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetBulkCandidateTargetsQuery, Types.GetBulkCandidateTargetsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetBulkCandidateTargetsQuery | undefined, Types.GetBulkCandidateTargetsQueryVariables>;
export type GetBulkCandidateTargetsQueryHookResult = ReturnType<typeof useGetBulkCandidateTargetsQuery>;
export type GetBulkCandidateTargetsLazyQueryHookResult = ReturnType<typeof useGetBulkCandidateTargetsLazyQuery>;
export type GetBulkCandidateTargetsSuspenseQueryHookResult = ReturnType<typeof useGetBulkCandidateTargetsSuspenseQuery>;
export type GetBulkCandidateTargetsQueryResult = Apollo.QueryResult<Types.GetBulkCandidateTargetsQuery, Types.GetBulkCandidateTargetsQueryVariables>;
export declare const GetCannedResponsesDocument: Apollo.DocumentNode;
/**
 * __useGetCannedResponsesQuery__
 *
 * To run a query within a React component, call `useGetCannedResponsesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetCannedResponsesQuery` 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 } = useGetCannedResponsesQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetCannedResponsesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables, "empty" | "complete" | "streaming", Types.GetCannedResponsesQueryVariables>;
export declare function useGetCannedResponsesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetCannedResponsesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>;
export declare function useGetCannedResponsesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCannedResponsesQuery | undefined, Types.GetCannedResponsesQueryVariables>;
export type GetCannedResponsesQueryHookResult = ReturnType<typeof useGetCannedResponsesQuery>;
export type GetCannedResponsesLazyQueryHookResult = ReturnType<typeof useGetCannedResponsesLazyQuery>;
export type GetCannedResponsesSuspenseQueryHookResult = ReturnType<typeof useGetCannedResponsesSuspenseQuery>;
export type GetCannedResponsesQueryResult = Apollo.QueryResult<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>;
export declare const GetContactInquiriesDocument: Apollo.DocumentNode;
/**
 * __useGetContactInquiriesQuery__
 *
 * To run a query within a React component, call `useGetContactInquiriesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetContactInquiriesQuery` 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 } = useGetContactInquiriesQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetContactInquiriesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables, "empty" | "complete" | "streaming", Types.GetContactInquiriesQueryVariables>;
export declare function useGetContactInquiriesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetContactInquiriesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>;
export declare function useGetContactInquiriesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetContactInquiriesQuery | undefined, Types.GetContactInquiriesQueryVariables>;
export type GetContactInquiriesQueryHookResult = ReturnType<typeof useGetContactInquiriesQuery>;
export type GetContactInquiriesLazyQueryHookResult = ReturnType<typeof useGetContactInquiriesLazyQuery>;
export type GetContactInquiriesSuspenseQueryHookResult = ReturnType<typeof useGetContactInquiriesSuspenseQuery>;
export type GetContactInquiriesQueryResult = Apollo.QueryResult<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>;
export declare const GetContactInquiryDocument: Apollo.DocumentNode;
/**
 * __useGetContactInquiryQuery__
 *
 * To run a query within a React component, call `useGetContactInquiryQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetContactInquiryQuery` 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 } = useGetContactInquiryQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetContactInquiryQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables> & ({
    variables: Types.GetContactInquiryQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables, "empty" | "complete" | "streaming", Types.GetContactInquiryQueryVariables>;
export declare function useGetContactInquiryLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetContactInquirySuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>;
export declare function useGetContactInquirySuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetContactInquiryQuery | undefined, Types.GetContactInquiryQueryVariables>;
export type GetContactInquiryQueryHookResult = ReturnType<typeof useGetContactInquiryQuery>;
export type GetContactInquiryLazyQueryHookResult = ReturnType<typeof useGetContactInquiryLazyQuery>;
export type GetContactInquirySuspenseQueryHookResult = ReturnType<typeof useGetContactInquirySuspenseQuery>;
export type GetContactInquiryQueryResult = Apollo.QueryResult<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>;
export declare const GetInterviewerDocument: Apollo.DocumentNode;
/**
 * __useGetInterviewerQuery__
 *
 * To run a query within a React component, call `useGetInterviewerQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetInterviewerQuery` 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 } = useGetInterviewerQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetInterviewerQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables> & ({
    variables: Types.GetInterviewerQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables, "empty" | "complete" | "streaming", Types.GetInterviewerQueryVariables>;
export declare function useGetInterviewerLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetInterviewerSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>;
export declare function useGetInterviewerSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInterviewerQuery | undefined, Types.GetInterviewerQueryVariables>;
export type GetInterviewerQueryHookResult = ReturnType<typeof useGetInterviewerQuery>;
export type GetInterviewerLazyQueryHookResult = ReturnType<typeof useGetInterviewerLazyQuery>;
export type GetInterviewerSuspenseQueryHookResult = ReturnType<typeof useGetInterviewerSuspenseQuery>;
export type GetInterviewerQueryResult = Apollo.QueryResult<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>;
export declare const GetInterviewersDocument: Apollo.DocumentNode;
/**
 * __useGetInterviewersQuery__
 *
 * To run a query within a React component, call `useGetInterviewersQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetInterviewersQuery` 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 } = useGetInterviewersQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetInterviewersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables, "empty" | "complete" | "streaming", Types.GetInterviewersQueryVariables>;
export declare function useGetInterviewersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetInterviewersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>;
export declare function useGetInterviewersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInterviewersQuery | undefined, Types.GetInterviewersQueryVariables>;
export type GetInterviewersQueryHookResult = ReturnType<typeof useGetInterviewersQuery>;
export type GetInterviewersLazyQueryHookResult = ReturnType<typeof useGetInterviewersLazyQuery>;
export type GetInterviewersSuspenseQueryHookResult = ReturnType<typeof useGetInterviewersSuspenseQuery>;
export type GetInterviewersQueryResult = Apollo.QueryResult<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>;
export declare const GetJobApplicationDocument: Apollo.DocumentNode;
/**
 * __useGetJobApplicationQuery__
 *
 * To run a query within a React component, call `useGetJobApplicationQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetJobApplicationQuery` 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 } = useGetJobApplicationQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetJobApplicationQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables> & ({
    variables: Types.GetJobApplicationQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationQueryVariables>;
export declare function useGetJobApplicationLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetJobApplicationSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>;
export declare function useGetJobApplicationSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationQuery | undefined, Types.GetJobApplicationQueryVariables>;
export type GetJobApplicationQueryHookResult = ReturnType<typeof useGetJobApplicationQuery>;
export type GetJobApplicationLazyQueryHookResult = ReturnType<typeof useGetJobApplicationLazyQuery>;
export type GetJobApplicationSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationSuspenseQuery>;
export type GetJobApplicationQueryResult = Apollo.QueryResult<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>;
export declare const GetJobApplicationInterviewRoundsDocument: Apollo.DocumentNode;
/**
 * __useGetJobApplicationInterviewRoundsQuery__
 *
 * To run a query within a React component, call `useGetJobApplicationInterviewRoundsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetJobApplicationInterviewRoundsQuery` 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 } = useGetJobApplicationInterviewRoundsQuery({
 *   variables: {
 *      applicationId: // value for 'applicationId'
 *   },
 * });
 */
export declare function useGetJobApplicationInterviewRoundsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables> & ({
    variables: Types.GetJobApplicationInterviewRoundsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationInterviewRoundsQueryVariables>;
export declare function useGetJobApplicationInterviewRoundsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetJobApplicationInterviewRoundsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>;
export declare function useGetJobApplicationInterviewRoundsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationInterviewRoundsQuery | undefined, Types.GetJobApplicationInterviewRoundsQueryVariables>;
export type GetJobApplicationInterviewRoundsQueryHookResult = ReturnType<typeof useGetJobApplicationInterviewRoundsQuery>;
export type GetJobApplicationInterviewRoundsLazyQueryHookResult = ReturnType<typeof useGetJobApplicationInterviewRoundsLazyQuery>;
export type GetJobApplicationInterviewRoundsSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationInterviewRoundsSuspenseQuery>;
export type GetJobApplicationInterviewRoundsQueryResult = Apollo.QueryResult<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>;
export declare const GetJobApplicationResumePreviewUrlDocument: Apollo.DocumentNode;
/**
 * __useGetJobApplicationResumePreviewUrlQuery__
 *
 * To run a query within a React component, call `useGetJobApplicationResumePreviewUrlQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetJobApplicationResumePreviewUrlQuery` 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 } = useGetJobApplicationResumePreviewUrlQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetJobApplicationResumePreviewUrlQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationResumePreviewUrlQuery, Types.GetJobApplicationResumePreviewUrlQueryVariables> & ({
    variables: Types.GetJobApplicationResumePreviewUrlQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationResumePreviewUrlQuery, Types.GetJobApplicationResumePreviewUrlQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationResumePreviewUrlQueryVariables>;
export declare function useGetJobApplicationResumePreviewUrlLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationResumePreviewUrlQuery, Types.GetJobApplicationResumePreviewUrlQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationResumePreviewUrlQuery, Types.GetJobApplicationResumePreviewUrlQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetJobApplicationResumePreviewUrlSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationResumePreviewUrlQuery, Types.GetJobApplicationResumePreviewUrlQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationResumePreviewUrlQuery, Types.GetJobApplicationResumePreviewUrlQueryVariables>;
export declare function useGetJobApplicationResumePreviewUrlSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationResumePreviewUrlQuery, Types.GetJobApplicationResumePreviewUrlQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationResumePreviewUrlQuery | undefined, Types.GetJobApplicationResumePreviewUrlQueryVariables>;
export type GetJobApplicationResumePreviewUrlQueryHookResult = ReturnType<typeof useGetJobApplicationResumePreviewUrlQuery>;
export type GetJobApplicationResumePreviewUrlLazyQueryHookResult = ReturnType<typeof useGetJobApplicationResumePreviewUrlLazyQuery>;
export type GetJobApplicationResumePreviewUrlSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationResumePreviewUrlSuspenseQuery>;
export type GetJobApplicationResumePreviewUrlQueryResult = Apollo.QueryResult<Types.GetJobApplicationResumePreviewUrlQuery, Types.GetJobApplicationResumePreviewUrlQueryVariables>;
export declare const GetJobApplicationResumeUrlDocument: Apollo.DocumentNode;
/**
 * __useGetJobApplicationResumeUrlQuery__
 *
 * To run a query within a React component, call `useGetJobApplicationResumeUrlQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetJobApplicationResumeUrlQuery` 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 } = useGetJobApplicationResumeUrlQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetJobApplicationResumeUrlQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables> & ({
    variables: Types.GetJobApplicationResumeUrlQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationResumeUrlQueryVariables>;
export declare function useGetJobApplicationResumeUrlLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetJobApplicationResumeUrlSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>;
export declare function useGetJobApplicationResumeUrlSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationResumeUrlQuery | undefined, Types.GetJobApplicationResumeUrlQueryVariables>;
export type GetJobApplicationResumeUrlQueryHookResult = ReturnType<typeof useGetJobApplicationResumeUrlQuery>;
export type GetJobApplicationResumeUrlLazyQueryHookResult = ReturnType<typeof useGetJobApplicationResumeUrlLazyQuery>;
export type GetJobApplicationResumeUrlSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationResumeUrlSuspenseQuery>;
export type GetJobApplicationResumeUrlQueryResult = Apollo.QueryResult<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>;
export declare const GetJobApplicationsDocument: Apollo.DocumentNode;
/**
 * __useGetJobApplicationsQuery__
 *
 * To run a query within a React component, call `useGetJobApplicationsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetJobApplicationsQuery` 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 } = useGetJobApplicationsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetJobApplicationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationsQueryVariables>;
export declare function useGetJobApplicationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetJobApplicationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>;
export declare function useGetJobApplicationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationsQuery | undefined, Types.GetJobApplicationsQueryVariables>;
export type GetJobApplicationsQueryHookResult = ReturnType<typeof useGetJobApplicationsQuery>;
export type GetJobApplicationsLazyQueryHookResult = ReturnType<typeof useGetJobApplicationsLazyQuery>;
export type GetJobApplicationsSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationsSuspenseQuery>;
export type GetJobApplicationsQueryResult = Apollo.QueryResult<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>;
export declare const GetJobAssignmentsDocument: Apollo.DocumentNode;
/**
 * __useGetJobAssignmentsQuery__
 *
 * To run a query within a React component, call `useGetJobAssignmentsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetJobAssignmentsQuery` 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 } = useGetJobAssignmentsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetJobAssignmentsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables, "empty" | "complete" | "streaming", Types.GetJobAssignmentsQueryVariables>;
export declare function useGetJobAssignmentsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetJobAssignmentsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>;
export declare function useGetJobAssignmentsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobAssignmentsQuery | undefined, Types.GetJobAssignmentsQueryVariables>;
export type GetJobAssignmentsQueryHookResult = ReturnType<typeof useGetJobAssignmentsQuery>;
export type GetJobAssignmentsLazyQueryHookResult = ReturnType<typeof useGetJobAssignmentsLazyQuery>;
export type GetJobAssignmentsSuspenseQueryHookResult = ReturnType<typeof useGetJobAssignmentsSuspenseQuery>;
export type GetJobAssignmentsQueryResult = Apollo.QueryResult<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>;
export declare const GetJobPostingDocument: Apollo.DocumentNode;
/**
 * __useGetJobPostingQuery__
 *
 * To run a query within a React component, call `useGetJobPostingQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetJobPostingQuery` 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 } = useGetJobPostingQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetJobPostingQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables> & ({
    variables: Types.GetJobPostingQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables, "empty" | "complete" | "streaming", Types.GetJobPostingQueryVariables>;
export declare function useGetJobPostingLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetJobPostingSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>;
export declare function useGetJobPostingSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobPostingQuery | undefined, Types.GetJobPostingQueryVariables>;
export type GetJobPostingQueryHookResult = ReturnType<typeof useGetJobPostingQuery>;
export type GetJobPostingLazyQueryHookResult = ReturnType<typeof useGetJobPostingLazyQuery>;
export type GetJobPostingSuspenseQueryHookResult = ReturnType<typeof useGetJobPostingSuspenseQuery>;
export type GetJobPostingQueryResult = Apollo.QueryResult<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>;
export declare const GetJobPostingsDocument: Apollo.DocumentNode;
/**
 * __useGetJobPostingsQuery__
 *
 * To run a query within a React component, call `useGetJobPostingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetJobPostingsQuery` 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 } = useGetJobPostingsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetJobPostingsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables, "empty" | "complete" | "streaming", Types.GetJobPostingsQueryVariables>;
export declare function useGetJobPostingsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetJobPostingsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>;
export declare function useGetJobPostingsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobPostingsQuery | undefined, Types.GetJobPostingsQueryVariables>;
export type GetJobPostingsQueryHookResult = ReturnType<typeof useGetJobPostingsQuery>;
export type GetJobPostingsLazyQueryHookResult = ReturnType<typeof useGetJobPostingsLazyQuery>;
export type GetJobPostingsSuspenseQueryHookResult = ReturnType<typeof useGetJobPostingsSuspenseQuery>;
export type GetJobPostingsQueryResult = Apollo.QueryResult<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>;
export declare const GetMyTicketsDocument: Apollo.DocumentNode;
/**
 * __useGetMyTicketsQuery__
 *
 * To run a query within a React component, call `useGetMyTicketsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMyTicketsQuery` 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 } = useGetMyTicketsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetMyTicketsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables, "empty" | "complete" | "streaming", Types.GetMyTicketsQueryVariables>;
export declare function useGetMyTicketsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetMyTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>;
export declare function useGetMyTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyTicketsQuery | undefined, Types.GetMyTicketsQueryVariables>;
export type GetMyTicketsQueryHookResult = ReturnType<typeof useGetMyTicketsQuery>;
export type GetMyTicketsLazyQueryHookResult = ReturnType<typeof useGetMyTicketsLazyQuery>;
export type GetMyTicketsSuspenseQueryHookResult = ReturnType<typeof useGetMyTicketsSuspenseQuery>;
export type GetMyTicketsQueryResult = Apollo.QueryResult<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>;
export declare const GetPopularArticlesDocument: Apollo.DocumentNode;
/**
 * __useGetPopularArticlesQuery__
 *
 * To run a query within a React component, call `useGetPopularArticlesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetPopularArticlesQuery` 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 } = useGetPopularArticlesQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *   },
 * });
 */
export declare function useGetPopularArticlesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables, "empty" | "complete" | "streaming", Types.GetPopularArticlesQueryVariables>;
export declare function useGetPopularArticlesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetPopularArticlesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>;
export declare function useGetPopularArticlesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPopularArticlesQuery | undefined, Types.GetPopularArticlesQueryVariables>;
export type GetPopularArticlesQueryHookResult = ReturnType<typeof useGetPopularArticlesQuery>;
export type GetPopularArticlesLazyQueryHookResult = ReturnType<typeof useGetPopularArticlesLazyQuery>;
export type GetPopularArticlesSuspenseQueryHookResult = ReturnType<typeof useGetPopularArticlesSuspenseQuery>;
export type GetPopularArticlesQueryResult = Apollo.QueryResult<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>;
export declare const GetSlaPoliciesDocument: Apollo.DocumentNode;
/**
 * __useGetSlaPoliciesQuery__
 *
 * To run a query within a React component, call `useGetSlaPoliciesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSlaPoliciesQuery` 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 } = useGetSlaPoliciesQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetSlaPoliciesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables, "empty" | "complete" | "streaming", Types.GetSlaPoliciesQueryVariables>;
export declare function useGetSlaPoliciesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetSlaPoliciesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>;
export declare function useGetSlaPoliciesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSlaPoliciesQuery | undefined, Types.GetSlaPoliciesQueryVariables>;
export type GetSlaPoliciesQueryHookResult = ReturnType<typeof useGetSlaPoliciesQuery>;
export type GetSlaPoliciesLazyQueryHookResult = ReturnType<typeof useGetSlaPoliciesLazyQuery>;
export type GetSlaPoliciesSuspenseQueryHookResult = ReturnType<typeof useGetSlaPoliciesSuspenseQuery>;
export type GetSlaPoliciesQueryResult = Apollo.QueryResult<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>;
export declare const GetSupportAnalyticsDocument: Apollo.DocumentNode;
/**
 * __useGetSupportAnalyticsQuery__
 *
 * To run a query within a React component, call `useGetSupportAnalyticsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSupportAnalyticsQuery` 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 } = useGetSupportAnalyticsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *   },
 * });
 */
export declare function useGetSupportAnalyticsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables, "empty" | "complete" | "streaming", Types.GetSupportAnalyticsQueryVariables>;
export declare function useGetSupportAnalyticsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetSupportAnalyticsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>;
export declare function useGetSupportAnalyticsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSupportAnalyticsQuery | undefined, Types.GetSupportAnalyticsQueryVariables>;
export type GetSupportAnalyticsQueryHookResult = ReturnType<typeof useGetSupportAnalyticsQuery>;
export type GetSupportAnalyticsLazyQueryHookResult = ReturnType<typeof useGetSupportAnalyticsLazyQuery>;
export type GetSupportAnalyticsSuspenseQueryHookResult = ReturnType<typeof useGetSupportAnalyticsSuspenseQuery>;
export type GetSupportAnalyticsQueryResult = Apollo.QueryResult<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>;
export declare const GetTicketCategoriesDocument: Apollo.DocumentNode;
/**
 * __useGetTicketCategoriesQuery__
 *
 * To run a query within a React component, call `useGetTicketCategoriesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetTicketCategoriesQuery` 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 } = useGetTicketCategoriesQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetTicketCategoriesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables, "empty" | "complete" | "streaming", Types.GetTicketCategoriesQueryVariables>;
export declare function useGetTicketCategoriesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetTicketCategoriesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>;
export declare function useGetTicketCategoriesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketCategoriesQuery | undefined, Types.GetTicketCategoriesQueryVariables>;
export type GetTicketCategoriesQueryHookResult = ReturnType<typeof useGetTicketCategoriesQuery>;
export type GetTicketCategoriesLazyQueryHookResult = ReturnType<typeof useGetTicketCategoriesLazyQuery>;
export type GetTicketCategoriesSuspenseQueryHookResult = ReturnType<typeof useGetTicketCategoriesSuspenseQuery>;
export type GetTicketCategoriesQueryResult = Apollo.QueryResult<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>;
export declare const GetTicketDetailDocument: Apollo.DocumentNode;
/**
 * __useGetTicketDetailQuery__
 *
 * To run a query within a React component, call `useGetTicketDetailQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetTicketDetailQuery` 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 } = useGetTicketDetailQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetTicketDetailQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables> & ({
    variables: Types.GetTicketDetailQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables, "empty" | "complete" | "streaming", Types.GetTicketDetailQueryVariables>;
export declare function useGetTicketDetailLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetTicketDetailSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>;
export declare function useGetTicketDetailSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketDetailQuery | undefined, Types.GetTicketDetailQueryVariables>;
export type GetTicketDetailQueryHookResult = ReturnType<typeof useGetTicketDetailQuery>;
export type GetTicketDetailLazyQueryHookResult = ReturnType<typeof useGetTicketDetailLazyQuery>;
export type GetTicketDetailSuspenseQueryHookResult = ReturnType<typeof useGetTicketDetailSuspenseQuery>;
export type GetTicketDetailQueryResult = Apollo.QueryResult<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>;
export declare const GetTicketTrendsDocument: Apollo.DocumentNode;
/**
 * __useGetTicketTrendsQuery__
 *
 * To run a query within a React component, call `useGetTicketTrendsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetTicketTrendsQuery` 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 } = useGetTicketTrendsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *   },
 * });
 */
export declare function useGetTicketTrendsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables, "empty" | "complete" | "streaming", Types.GetTicketTrendsQueryVariables>;
export declare function useGetTicketTrendsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetTicketTrendsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>;
export declare function useGetTicketTrendsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketTrendsQuery | undefined, Types.GetTicketTrendsQueryVariables>;
export type GetTicketTrendsQueryHookResult = ReturnType<typeof useGetTicketTrendsQuery>;
export type GetTicketTrendsLazyQueryHookResult = ReturnType<typeof useGetTicketTrendsLazyQuery>;
export type GetTicketTrendsSuspenseQueryHookResult = ReturnType<typeof useGetTicketTrendsSuspenseQuery>;
export type GetTicketTrendsQueryResult = Apollo.QueryResult<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>;
export declare const GetTicketsDocument: Apollo.DocumentNode;
/**
 * __useGetTicketsQuery__
 *
 * To run a query within a React component, call `useGetTicketsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetTicketsQuery` 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 } = useGetTicketsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export declare function useGetTicketsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetTicketsQuery, Types.GetTicketsQueryVariables, "empty" | "complete" | "streaming", Types.GetTicketsQueryVariables>;
export declare function useGetTicketsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTicketsQuery, Types.GetTicketsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>;
export declare function useGetTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketsQuery | undefined, Types.GetTicketsQueryVariables>;
export type GetTicketsQueryHookResult = ReturnType<typeof useGetTicketsQuery>;
export type GetTicketsLazyQueryHookResult = ReturnType<typeof useGetTicketsLazyQuery>;
export type GetTicketsSuspenseQueryHookResult = ReturnType<typeof useGetTicketsSuspenseQuery>;
export type GetTicketsQueryResult = Apollo.QueryResult<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>;
export declare const SearchKnowledgeBaseDocument: Apollo.DocumentNode;
/**
 * __useSearchKnowledgeBaseQuery__
 *
 * To run a query within a React component, call `useSearchKnowledgeBaseQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchKnowledgeBaseQuery` 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 } = useSearchKnowledgeBaseQuery({
 *   variables: {
 *      query: // value for 'query'
 *      categoryId: // value for 'categoryId'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export declare function useSearchKnowledgeBaseQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables> & ({
    variables: Types.SearchKnowledgeBaseQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables, "empty" | "complete" | "streaming", Types.SearchKnowledgeBaseQueryVariables>;
export declare function useSearchKnowledgeBaseLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables, "empty" | "complete" | "streaming">;
export declare function useSearchKnowledgeBaseSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>;
export declare function useSearchKnowledgeBaseSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchKnowledgeBaseQuery | undefined, Types.SearchKnowledgeBaseQueryVariables>;
export type SearchKnowledgeBaseQueryHookResult = ReturnType<typeof useSearchKnowledgeBaseQuery>;
export type SearchKnowledgeBaseLazyQueryHookResult = ReturnType<typeof useSearchKnowledgeBaseLazyQuery>;
export type SearchKnowledgeBaseSuspenseQueryHookResult = ReturnType<typeof useSearchKnowledgeBaseSuspenseQuery>;
export type SearchKnowledgeBaseQueryResult = Apollo.QueryResult<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>;
export declare const SearchTicketsDocument: Apollo.DocumentNode;
/**
 * __useSearchTicketsQuery__
 *
 * To run a query within a React component, call `useSearchTicketsQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchTicketsQuery` 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 } = useSearchTicketsQuery({
 *   variables: {
 *      query: // value for 'query'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export declare function useSearchTicketsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables> & ({
    variables: Types.SearchTicketsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables, "empty" | "complete" | "streaming", Types.SearchTicketsQueryVariables>;
export declare function useSearchTicketsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useSearchTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>;
export declare function useSearchTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchTicketsQuery | undefined, Types.SearchTicketsQueryVariables>;
export type SearchTicketsQueryHookResult = ReturnType<typeof useSearchTicketsQuery>;
export type SearchTicketsLazyQueryHookResult = ReturnType<typeof useSearchTicketsLazyQuery>;
export type SearchTicketsSuspenseQueryHookResult = ReturnType<typeof useSearchTicketsSuspenseQuery>;
export type SearchTicketsQueryResult = Apollo.QueryResult<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>;
export declare const SubscribeTicketMessageAddedDocument: Apollo.DocumentNode;
/**
 * __useSubscribeTicketMessageAddedSubscription__
 *
 * To run a query within a React component, call `useSubscribeTicketMessageAddedSubscription` and pass it any options that fit your needs.
 * When your component renders, `useSubscribeTicketMessageAddedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useSubscribeTicketMessageAddedSubscription({
 *   variables: {
 *      ticketId: // value for 'ticketId'
 *   },
 * });
 */
export declare function useSubscribeTicketMessageAddedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.SubscribeTicketMessageAddedSubscription, Types.SubscribeTicketMessageAddedSubscriptionVariables> & ({
    variables: Types.SubscribeTicketMessageAddedSubscriptionVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useSubscription.Result<Types.SubscribeTicketMessageAddedSubscription>;
export type SubscribeTicketMessageAddedSubscriptionHookResult = ReturnType<typeof useSubscribeTicketMessageAddedSubscription>;
export type SubscribeTicketMessageAddedSubscriptionResult = Apollo.SubscriptionResult<Types.SubscribeTicketMessageAddedSubscription>;
export declare const SubscribeTicketUpdatedDocument: Apollo.DocumentNode;
/**
 * __useSubscribeTicketUpdatedSubscription__
 *
 * To run a query within a React component, call `useSubscribeTicketUpdatedSubscription` and pass it any options that fit your needs.
 * When your component renders, `useSubscribeTicketUpdatedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useSubscribeTicketUpdatedSubscription({
 *   variables: {
 *      ticketId: // value for 'ticketId'
 *   },
 * });
 */
export declare function useSubscribeTicketUpdatedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.SubscribeTicketUpdatedSubscription, Types.SubscribeTicketUpdatedSubscriptionVariables> & ({
    variables: Types.SubscribeTicketUpdatedSubscriptionVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useSubscription.Result<Types.SubscribeTicketUpdatedSubscription>;
export type SubscribeTicketUpdatedSubscriptionHookResult = ReturnType<typeof useSubscribeTicketUpdatedSubscription>;
export type SubscribeTicketUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.SubscribeTicketUpdatedSubscription>;