@learnorama/mozaik-sdk 0.1.0

package/dist/react/admin-tutoring.d.ts

@@ -0,0 +1,556 @@
+
+import { Cn as ListExpiringDocumentsParams, Dt as PractitionerDocumentListRead, En as ListAllRequestsParams, Et as PractitionerRead, F as SubjectRead, Gn as HTTPExceptionResponse, In as LevelRead, N as SubjectWrite, Pn as LevelWrite, Sn as ListFeedbackParams, Tt as PractitionerPage, Xr as AiDraftRead, Yr as AiDraftReviewWrite, cr as EducationalGoalRead, d as TutoringQueuePage, fn as ListPractitionersParams, g as TutoringFeedbackModerationWrite, l as TutoringRequestAdminWrite, m as TutoringFeedbackPage, o as TutoringRequestStaffRead, or as EducationalGoalWrite, t as ValidationErrorResponse, u as TutoringRequestAdminCloseWrite, wt as PractitionerWrite } from "../index-wL_20vR8.js";
+import { a as ErrorType, c as request, n as BodyType } from "../client-BDwBZYB0.js";
+import { DataTag, DefinedInitialDataOptions, DefinedUseQueryResult, QueryClient, QueryKey, UndefinedInitialDataOptions, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+//#region src/react/admin-tutoring/admin-tutoring.d.ts
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+export declare const getListExpiringDocumentsUrl: (params?: ListExpiringDocumentsParams) => string;
+/**
+ * Whose attestation lapses soon, as a query rather than a filing cabinet.
+ *
+ * An URSSAF *attestation de vigilance* is valid for six months and a lapsed one
+ * is a compliance problem. The legacy stores it as a ``text`` column with one
+ * ``ursaff_date`` beside it, so this question has no answer there at all.
+ * @summary List Expiring Documents
+ */
+export declare const listExpiringDocuments: (params?: ListExpiringDocumentsParams, options?: Parameters<typeof request>[1]) => Promise<PractitionerDocumentListRead>;
+export declare const getListExpiringDocumentsQueryKey: (params?: ListExpiringDocumentsParams) => readonly ["/admin/tutoring/documents/expiring", ...ListExpiringDocumentsParams[]];
+export declare const getListExpiringDocumentsQueryOptions: <TData = Awaited<ReturnType<typeof listExpiringDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListExpiringDocumentsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listExpiringDocuments>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listExpiringDocuments>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListExpiringDocumentsQueryResult = NonNullable<Awaited<ReturnType<typeof listExpiringDocuments>>>;
+export type ListExpiringDocumentsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useListExpiringDocuments<TData = Awaited<ReturnType<typeof listExpiringDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params: undefined | ListExpiringDocumentsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listExpiringDocuments>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listExpiringDocuments>>, TError, Awaited<ReturnType<typeof listExpiringDocuments>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListExpiringDocuments<TData = Awaited<ReturnType<typeof listExpiringDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListExpiringDocumentsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listExpiringDocuments>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listExpiringDocuments>>, TError, Awaited<ReturnType<typeof listExpiringDocuments>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListExpiringDocuments<TData = Awaited<ReturnType<typeof listExpiringDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListExpiringDocumentsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listExpiringDocuments>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getListFeedbackUrl: (params?: ListFeedbackParams) => string;
+/**
+ * Ratings, newest first. ``?publishable=false`` is the moderation queue.
+ *
+ * Tenant-scoped through the request it belongs to: a rating is a child's free
+ * text, so it is reachable only by an operator who reaches the tenant.
+ * @summary List Feedback
+ */
+export declare const listFeedback: (params?: ListFeedbackParams, options?: Parameters<typeof request>[1]) => Promise<TutoringFeedbackPage>;
+export declare const getListFeedbackQueryKey: (params?: ListFeedbackParams) => readonly ["/admin/tutoring/feedback", ...ListFeedbackParams[]];
+export declare const getListFeedbackQueryOptions: <TData = Awaited<ReturnType<typeof listFeedback>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListFeedbackParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listFeedback>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listFeedback>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListFeedbackQueryResult = NonNullable<Awaited<ReturnType<typeof listFeedback>>>;
+export type ListFeedbackQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useListFeedback<TData = Awaited<ReturnType<typeof listFeedback>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params: undefined | ListFeedbackParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listFeedback>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listFeedback>>, TError, Awaited<ReturnType<typeof listFeedback>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListFeedback<TData = Awaited<ReturnType<typeof listFeedback>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListFeedbackParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listFeedback>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listFeedback>>, TError, Awaited<ReturnType<typeof listFeedback>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListFeedback<TData = Awaited<ReturnType<typeof listFeedback>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListFeedbackParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listFeedback>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getModerateFeedbackUrl: (feedbackId: number) => string;
+/**
+ * Clear a rating for the public showcase, or withhold it.
+ *
+ * ``PUT`` on a sub-resource rather than ``PATCH`` on the rating, mirroring
+ * ``/admin/reviews/{id}/moderation``: the decision is the resource, and it is
+ * idempotent.
+ * @summary Moderate Feedback
+ */
+export declare const moderateFeedback: (feedbackId: number, tutoringFeedbackModerationWrite: TutoringFeedbackModerationWrite, options?: Parameters<typeof request>[1]) => Promise<void>;
+export declare const getModerateFeedbackMutationKey: () => readonly ['moderateFeedback'];
+export declare const getModerateFeedbackMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof moderateFeedback>>, TError, ModerateFeedbackMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof moderateFeedback>>, TError, ModerateFeedbackMutationVariables, TContext>;
+export type ModerateFeedbackMutationResult = NonNullable<Awaited<ReturnType<typeof moderateFeedback>>>;
+export type ModerateFeedbackMutationBody = BodyType<TutoringFeedbackModerationWrite>;
+export type ModerateFeedbackMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type ModerateFeedbackMutationVariables = {
+  feedbackId: number;
+  data: BodyType<TutoringFeedbackModerationWrite>;
+};
+/**
+ * @summary Moderate Feedback
+ */
+export declare const useModerateFeedback: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof moderateFeedback>>, TError, ModerateFeedbackMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof moderateFeedback>>, TError, ModerateFeedbackMutationVariables, TContext>;
+export declare const getCreateGoalUrl: () => string;
+/**
+ * @summary Create Goal
+ */
+export declare const createGoal: (educationalGoalWrite: EducationalGoalWrite, options?: Parameters<typeof request>[1]) => Promise<EducationalGoalRead>;
+export declare const getCreateGoalMutationKey: () => readonly ['createGoal'];
+export declare const getCreateGoalMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof createGoal>>, TError, CreateGoalMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createGoal>>, TError, CreateGoalMutationVariables, TContext>;
+export type CreateGoalMutationResult = NonNullable<Awaited<ReturnType<typeof createGoal>>>;
+export type CreateGoalMutationBody = BodyType<EducationalGoalWrite>;
+export type CreateGoalMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type CreateGoalMutationVariables = {
+  data: BodyType<EducationalGoalWrite>;
+};
+/**
+ * @summary Create Goal
+ */
+export declare const useCreateGoal: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof createGoal>>, TError, CreateGoalMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof createGoal>>, TError, CreateGoalMutationVariables, TContext>;
+export declare const getAmendGoalUrl: (goalId: number) => string;
+/**
+ * @summary Amend Goal
+ */
+export declare const amendGoal: (goalId: number, educationalGoalWrite: EducationalGoalWrite, options?: Parameters<typeof request>[1]) => Promise<EducationalGoalRead>;
+export declare const getAmendGoalMutationKey: () => readonly ['amendGoal'];
+export declare const getAmendGoalMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendGoal>>, TError, AmendGoalMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof amendGoal>>, TError, AmendGoalMutationVariables, TContext>;
+export type AmendGoalMutationResult = NonNullable<Awaited<ReturnType<typeof amendGoal>>>;
+export type AmendGoalMutationBody = BodyType<EducationalGoalWrite>;
+export type AmendGoalMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type AmendGoalMutationVariables = {
+  goalId: number;
+  data: BodyType<EducationalGoalWrite>;
+};
+/**
+ * @summary Amend Goal
+ */
+export declare const useAmendGoal: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendGoal>>, TError, AmendGoalMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof amendGoal>>, TError, AmendGoalMutationVariables, TContext>;
+export declare const getCreateLevelUrl: () => string;
+/**
+ * @summary Create Level
+ */
+export declare const createLevel: (levelWrite: LevelWrite, options?: Parameters<typeof request>[1]) => Promise<LevelRead>;
+export declare const getCreateLevelMutationKey: () => readonly ['createLevel'];
+export declare const getCreateLevelMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof createLevel>>, TError, CreateLevelMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createLevel>>, TError, CreateLevelMutationVariables, TContext>;
+export type CreateLevelMutationResult = NonNullable<Awaited<ReturnType<typeof createLevel>>>;
+export type CreateLevelMutationBody = BodyType<LevelWrite>;
+export type CreateLevelMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type CreateLevelMutationVariables = {
+  data: BodyType<LevelWrite>;
+};
+/**
+ * @summary Create Level
+ */
+export declare const useCreateLevel: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof createLevel>>, TError, CreateLevelMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof createLevel>>, TError, CreateLevelMutationVariables, TContext>;
+export declare const getAmendLevelUrl: (levelId: number) => string;
+/**
+ * @summary Amend Level
+ */
+export declare const amendLevel: (levelId: number, levelWrite: LevelWrite, options?: Parameters<typeof request>[1]) => Promise<LevelRead>;
+export declare const getAmendLevelMutationKey: () => readonly ['amendLevel'];
+export declare const getAmendLevelMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendLevel>>, TError, AmendLevelMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof amendLevel>>, TError, AmendLevelMutationVariables, TContext>;
+export type AmendLevelMutationResult = NonNullable<Awaited<ReturnType<typeof amendLevel>>>;
+export type AmendLevelMutationBody = BodyType<LevelWrite>;
+export type AmendLevelMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type AmendLevelMutationVariables = {
+  levelId: number;
+  data: BodyType<LevelWrite>;
+};
+/**
+ * @summary Amend Level
+ */
+export declare const useAmendLevel: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendLevel>>, TError, AmendLevelMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof amendLevel>>, TError, AmendLevelMutationVariables, TContext>;
+export declare const getListPractitionersUrl: (params?: ListPractitionersParams) => string;
+/**
+ * Who can take work, filtered the way the question is actually asked.
+ *
+ * ``role``, ``capability``, ``subjectId`` and ``levelId`` together answer "who
+ * can take *this* request", which is the only thing anybody wants from this
+ * list. The legacy answers it with a different screen per role — nine of them,
+ * plus two more for pelite.
+ * @summary List Practitioners
+ */
+export declare const listPractitioners: (params?: ListPractitionersParams, options?: Parameters<typeof request>[1]) => Promise<PractitionerPage>;
+export declare const getListPractitionersQueryKey: (params?: ListPractitionersParams) => readonly ["/admin/tutoring/practitioners", ...ListPractitionersParams[]];
+export declare const getListPractitionersQueryOptions: <TData = Awaited<ReturnType<typeof listPractitioners>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListPractitionersParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listPractitioners>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listPractitioners>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListPractitionersQueryResult = NonNullable<Awaited<ReturnType<typeof listPractitioners>>>;
+export type ListPractitionersQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useListPractitioners<TData = Awaited<ReturnType<typeof listPractitioners>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params: undefined | ListPractitionersParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listPractitioners>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listPractitioners>>, TError, Awaited<ReturnType<typeof listPractitioners>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListPractitioners<TData = Awaited<ReturnType<typeof listPractitioners>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListPractitionersParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listPractitioners>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listPractitioners>>, TError, Awaited<ReturnType<typeof listPractitioners>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListPractitioners<TData = Awaited<ReturnType<typeof listPractitioners>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListPractitionersParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listPractitioners>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getAmendPractitionerUrl: (userId: number) => string;
+/**
+ * Availability, capabilities and competencies in one call.
+ *
+ * Competencies are replaced wholesale rather than diffed: the screen shows a
+ * checklist and submits it. Absent means unchanged; an empty list means none,
+ * which is a real instruction and has to be distinguishable from absence —
+ * hence ``exclude_unset``.
+ * @summary Amend Practitioner
+ */
+export declare const amendPractitioner: (userId: number, practitionerWrite: PractitionerWrite, options?: Parameters<typeof request>[1]) => Promise<PractitionerRead>;
+export declare const getAmendPractitionerMutationKey: () => readonly ['amendPractitioner'];
+export declare const getAmendPractitionerMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendPractitioner>>, TError, AmendPractitionerMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof amendPractitioner>>, TError, AmendPractitionerMutationVariables, TContext>;
+export type AmendPractitionerMutationResult = NonNullable<Awaited<ReturnType<typeof amendPractitioner>>>;
+export type AmendPractitionerMutationBody = BodyType<PractitionerWrite>;
+export type AmendPractitionerMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type AmendPractitionerMutationVariables = {
+  userId: number;
+  data: BodyType<PractitionerWrite>;
+};
+/**
+ * @summary Amend Practitioner
+ */
+export declare const useAmendPractitioner: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendPractitioner>>, TError, AmendPractitionerMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof amendPractitioner>>, TError, AmendPractitionerMutationVariables, TContext>;
+export declare const getListPractitionerDocumentsUrl: (userId: number) => string;
+/**
+ * One practitioner's compliance paperwork. Metadata only, never the file.
+ * @summary List Practitioner Documents
+ */
+export declare const listPractitionerDocuments: (userId: number, options?: Parameters<typeof request>[1]) => Promise<PractitionerDocumentListRead>;
+export declare const getListPractitionerDocumentsQueryKey: (userId: number) => readonly [`/admin/tutoring/practitioners/${number}/documents`];
+export declare const getListPractitionerDocumentsQueryOptions: <TData = Awaited<ReturnType<typeof listPractitionerDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(userId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listPractitionerDocuments>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listPractitionerDocuments>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListPractitionerDocumentsQueryResult = NonNullable<Awaited<ReturnType<typeof listPractitionerDocuments>>>;
+export type ListPractitionerDocumentsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useListPractitionerDocuments<TData = Awaited<ReturnType<typeof listPractitionerDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(userId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listPractitionerDocuments>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listPractitionerDocuments>>, TError, Awaited<ReturnType<typeof listPractitionerDocuments>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListPractitionerDocuments<TData = Awaited<ReturnType<typeof listPractitionerDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(userId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listPractitionerDocuments>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listPractitionerDocuments>>, TError, Awaited<ReturnType<typeof listPractitionerDocuments>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListPractitionerDocuments<TData = Awaited<ReturnType<typeof listPractitionerDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(userId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listPractitionerDocuments>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getListAllRequestsUrl: (params?: ListAllRequestsParams) => string;
+/**
+ * Every request in the tenants this operator reaches.
+ *
+ * Returns the queue shape rather than the staff shape on purpose: this is the
+ * list screen, and a list of five hundred requests should not carry five hundred
+ * statements. The staff detail shape is on the single-request route.
+ * @summary List All Requests
+ */
+export declare const listAllRequests: (params?: ListAllRequestsParams, options?: Parameters<typeof request>[1]) => Promise<TutoringQueuePage>;
+export declare const getListAllRequestsQueryKey: (params?: ListAllRequestsParams) => readonly ["/admin/tutoring/requests", ...ListAllRequestsParams[]];
+export declare const getListAllRequestsQueryOptions: <TData = Awaited<ReturnType<typeof listAllRequests>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListAllRequestsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listAllRequests>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listAllRequests>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListAllRequestsQueryResult = NonNullable<Awaited<ReturnType<typeof listAllRequests>>>;
+export type ListAllRequestsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useListAllRequests<TData = Awaited<ReturnType<typeof listAllRequests>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params: undefined | ListAllRequestsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listAllRequests>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listAllRequests>>, TError, Awaited<ReturnType<typeof listAllRequests>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListAllRequests<TData = Awaited<ReturnType<typeof listAllRequests>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListAllRequestsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listAllRequests>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listAllRequests>>, TError, Awaited<ReturnType<typeof listAllRequests>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListAllRequests<TData = Awaited<ReturnType<typeof listAllRequests>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListAllRequestsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listAllRequests>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getReadRequestUrl: (requestId: number) => string;
+/**
+ * One request in full, including provenance and the staff note.
+ * @summary Read Request
+ */
+export declare const readRequest: (requestId: number, options?: Parameters<typeof request>[1]) => Promise<TutoringRequestStaffRead>;
+export declare const getReadRequestQueryKey: (requestId: number) => readonly [`/admin/tutoring/requests/${number}`];
+export declare const getReadRequestQueryOptions: <TData = Awaited<ReturnType<typeof readRequest>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(requestId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readRequest>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readRequest>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadRequestQueryResult = NonNullable<Awaited<ReturnType<typeof readRequest>>>;
+export type ReadRequestQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadRequest<TData = Awaited<ReturnType<typeof readRequest>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(requestId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readRequest>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readRequest>>, TError, Awaited<ReturnType<typeof readRequest>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadRequest<TData = Awaited<ReturnType<typeof readRequest>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(requestId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readRequest>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readRequest>>, TError, Awaited<ReturnType<typeof readRequest>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadRequest<TData = Awaited<ReturnType<typeof readRequest>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(requestId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readRequest>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getAmendRequestUrl: (requestId: number) => string;
+/**
+ * Reassign a stalled request, and say why, in one call.
+ *
+ * Partial: only fields present in the body are applied, so a client that knows
+ * about one of them cannot blank the rest. Reassignment does **not** move the
+ * status — a request routed to somebody else is still dispatched, and pretending
+ * otherwise would corrupt the timestamp ladder every report reads.
+ * @summary Amend Request
+ */
+export declare const amendRequest: (requestId: number, tutoringRequestAdminWrite: TutoringRequestAdminWrite, options?: Parameters<typeof request>[1]) => Promise<TutoringRequestStaffRead>;
+export declare const getAmendRequestMutationKey: () => readonly ['amendRequest'];
+export declare const getAmendRequestMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendRequest>>, TError, AmendRequestMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof amendRequest>>, TError, AmendRequestMutationVariables, TContext>;
+export type AmendRequestMutationResult = NonNullable<Awaited<ReturnType<typeof amendRequest>>>;
+export type AmendRequestMutationBody = BodyType<TutoringRequestAdminWrite>;
+export type AmendRequestMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type AmendRequestMutationVariables = {
+  requestId: number;
+  data: BodyType<TutoringRequestAdminWrite>;
+};
+/**
+ * @summary Amend Request
+ */
+export declare const useAmendRequest: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendRequest>>, TError, AmendRequestMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof amendRequest>>, TError, AmendRequestMutationVariables, TContext>;
+export declare const getAdminCloseRequestUrl: (requestId: number) => string;
+/**
+ * Close a request from the back office. Goes through the state machine.
+ * @summary Admin Close Request
+ */
+export declare const adminCloseRequest: (requestId: number, tutoringRequestAdminCloseWrite: TutoringRequestAdminCloseWrite, options?: Parameters<typeof request>[1]) => Promise<void>;
+export declare const getAdminCloseRequestMutationKey: () => readonly ['adminCloseRequest'];
+export declare const getAdminCloseRequestMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCloseRequest>>, TError, AdminCloseRequestMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof adminCloseRequest>>, TError, AdminCloseRequestMutationVariables, TContext>;
+export type AdminCloseRequestMutationResult = NonNullable<Awaited<ReturnType<typeof adminCloseRequest>>>;
+export type AdminCloseRequestMutationBody = BodyType<TutoringRequestAdminCloseWrite>;
+export type AdminCloseRequestMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type AdminCloseRequestMutationVariables = {
+  requestId: number;
+  data: BodyType<TutoringRequestAdminCloseWrite>;
+};
+/**
+ * @summary Admin Close Request
+ */
+export declare const useAdminCloseRequest: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCloseRequest>>, TError, AdminCloseRequestMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof adminCloseRequest>>, TError, AdminCloseRequestMutationVariables, TContext>;
+export declare const getReadDraftUrl: (requestId: number) => string;
+/**
+ * The latest draft for one request.
+ *
+ * ``404`` when there is none, which is the ordinary case: drafting is off by
+ * default, and even switched on it produces nothing when the provider is
+ * unreachable. A client must treat a missing draft as normal rather than as
+ * an error — the request is answerable by a person either way.
+ *
+ * Only the latest. Re-drafting is not a feature yet, and returning a list
+ * would promise one.
+ * @summary Read Draft
+ */
+export declare const readDraft: (requestId: number, options?: Parameters<typeof request>[1]) => Promise<AiDraftRead>;
+export declare const getReadDraftQueryKey: (requestId: number) => readonly [`/admin/tutoring/requests/${number}/draft`];
+export declare const getReadDraftQueryOptions: <TData = Awaited<ReturnType<typeof readDraft>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(requestId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readDraft>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readDraft>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadDraftQueryResult = NonNullable<Awaited<ReturnType<typeof readDraft>>>;
+export type ReadDraftQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadDraft<TData = Awaited<ReturnType<typeof readDraft>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(requestId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readDraft>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readDraft>>, TError, Awaited<ReturnType<typeof readDraft>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadDraft<TData = Awaited<ReturnType<typeof readDraft>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(requestId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readDraft>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readDraft>>, TError, Awaited<ReturnType<typeof readDraft>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadDraft<TData = Awaited<ReturnType<typeof readDraft>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(requestId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readDraft>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getReviewDraftUrl: (requestId: number) => string;
+/**
+ * Score a draft, and optionally hand the request to a person.
+ *
+ * ``escalate`` stamps ``escalatedAt`` — the legacy's ``ai_to_live``. It is
+ * taken from the body rather than inferred from a low ``vote``: a reviewer may
+ * rate a draft poorly and still keep it as a starting point, or rate it well
+ * and escalate anyway because the pupil needs a conversation.
+ *
+ * Re-reviewing overwrites the score. Escalation does not un-stamp, because
+ * handing a request to a person is not a thing that gets taken back.
+ *
+ * The request's own status is untouched. A draft is not a state of the
+ * request, and moving it here would corrupt the timestamp ladder the reports
+ * read.
+ * @summary Review Draft
+ */
+export declare const reviewDraft: (requestId: number, aiDraftReviewWrite: AiDraftReviewWrite, options?: Parameters<typeof request>[1]) => Promise<AiDraftRead>;
+export declare const getReviewDraftMutationKey: () => readonly ['reviewDraft'];
+export declare const getReviewDraftMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof reviewDraft>>, TError, ReviewDraftMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof reviewDraft>>, TError, ReviewDraftMutationVariables, TContext>;
+export type ReviewDraftMutationResult = NonNullable<Awaited<ReturnType<typeof reviewDraft>>>;
+export type ReviewDraftMutationBody = BodyType<AiDraftReviewWrite>;
+export type ReviewDraftMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type ReviewDraftMutationVariables = {
+  requestId: number;
+  data: BodyType<AiDraftReviewWrite>;
+};
+/**
+ * @summary Review Draft
+ */
+export declare const useReviewDraft: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof reviewDraft>>, TError, ReviewDraftMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof reviewDraft>>, TError, ReviewDraftMutationVariables, TContext>;
+export declare const getCreateSubjectUrl: () => string;
+/**
+ * Add a subject. Reference data, so ADMIN rather than SUPPORT.
+ * @summary Create Subject
+ */
+export declare const createSubject: (subjectWrite: SubjectWrite, options?: Parameters<typeof request>[1]) => Promise<SubjectRead>;
+export declare const getCreateSubjectMutationKey: () => readonly ['createSubject'];
+export declare const getCreateSubjectMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof createSubject>>, TError, CreateSubjectMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createSubject>>, TError, CreateSubjectMutationVariables, TContext>;
+export type CreateSubjectMutationResult = NonNullable<Awaited<ReturnType<typeof createSubject>>>;
+export type CreateSubjectMutationBody = BodyType<SubjectWrite>;
+export type CreateSubjectMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type CreateSubjectMutationVariables = {
+  data: BodyType<SubjectWrite>;
+};
+/**
+ * @summary Create Subject
+ */
+export declare const useCreateSubject: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof createSubject>>, TError, CreateSubjectMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof createSubject>>, TError, CreateSubjectMutationVariables, TContext>;
+export declare const getAmendSubjectUrl: (subjectId: number) => string;
+/**
+ * @summary Amend Subject
+ */
+export declare const amendSubject: (subjectId: number, subjectWrite: SubjectWrite, options?: Parameters<typeof request>[1]) => Promise<SubjectRead>;
+export declare const getAmendSubjectMutationKey: () => readonly ['amendSubject'];
+export declare const getAmendSubjectMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendSubject>>, TError, AmendSubjectMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof amendSubject>>, TError, AmendSubjectMutationVariables, TContext>;
+export type AmendSubjectMutationResult = NonNullable<Awaited<ReturnType<typeof amendSubject>>>;
+export type AmendSubjectMutationBody = BodyType<SubjectWrite>;
+export type AmendSubjectMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type AmendSubjectMutationVariables = {
+  subjectId: number;
+  data: BodyType<SubjectWrite>;
+};
+/**
+ * @summary Amend Subject
+ */
+export declare const useAmendSubject: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof amendSubject>>, TError, AmendSubjectMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof amendSubject>>, TError, AmendSubjectMutationVariables, TContext>;
+//#endregion
+//# sourceMappingURL=admin-tutoring.d.ts.map