Skip to main content

useCache

Datalayer Core

Datalayer Core / useCache

Function: useCache()

useCache(options): object

Defined in: src/hooks/useCache.ts:455

TanStack Query-based cache hook for Datalayer API

This hook provides React Query-based data fetching and mutations for all Datalayer entities. Unlike the original useCache hook, this returns hook factories that components can use directly.

Parameters​

options​

CacheProps = {}

Configuration options

Returns​

Object containing all query and mutation hook factories

documentUploadLoading​

documentUploadLoading: boolean

documentUploadProgress​

documentUploadProgress: number

notebookUploadLoading​

notebookUploadLoading: boolean

notebookUploadProgress​

notebookUploadProgress: number

queryKeys​

queryKeys: object

Centralized query key factories for all entities Following TanStack Query best practices for key structure

See​

https://tanstack.com/query/latest/docs/framework/react/guides/query-keys

queryKeys.assignments​

readonly assignments: object

queryKeys.assignments.all()​

readonly all: () => readonly ["assignments"]

Returns​

readonly ["assignments"]

queryKeys.assignments.bySpace()​

readonly bySpace: (spaceId) => readonly ["assignments", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["assignments", "space", string]

queryKeys.assignments.detail()​

readonly detail: (id) => readonly ["assignments", "detail", string]

Parameters​
id​

string

Returns​

readonly ["assignments", "detail", string]

queryKeys.assignments.details()​

readonly details: () => readonly ["assignments", "detail"]

Returns​

readonly ["assignments", "detail"]

queryKeys.assignments.forStudent()​

readonly forStudent: (assignmentId, courseId, studentId) => readonly ["assignments", "detail", string, "course", string, "student", string]

Parameters​
assignmentId​

string

courseId​

string

studentId​

string

Returns​

readonly ["assignments", "detail", string, "course", string, "student", string]

queryKeys.assignments.studentVersion()​

readonly studentVersion: (assignmentId) => readonly ["assignments", "detail", string, "studentVersion"]

Parameters​
assignmentId​

string

Returns​

readonly ["assignments", "detail", string, "studentVersion"]

queryKeys.auth​

readonly auth: object

queryKeys.auth.me()​

readonly me: () => readonly ["auth", "me"]

Returns​

readonly ["auth", "me"]

queryKeys.auth.whoami()​

readonly whoami: () => readonly ["auth", "whoami"]

Returns​

readonly ["auth", "whoami"]

queryKeys.cells​

readonly cells: object

queryKeys.cells.all()​

readonly all: () => readonly ["cells"]

Returns​

readonly ["cells"]

queryKeys.cells.bySpace()​

readonly bySpace: (spaceId) => readonly ["cells", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["cells", "space", string]

queryKeys.cells.detail()​

readonly detail: (id) => readonly ["cells", "detail", string]

Parameters​
id​

string

Returns​

readonly ["cells", "detail", string]

queryKeys.cells.details()​

readonly details: () => readonly ["cells", "detail"]

Returns​

readonly ["cells", "detail"]

queryKeys.contacts​

readonly contacts: object

queryKeys.contacts.all()​

readonly all: () => readonly ["contacts"]

Returns​

readonly ["contacts"]

queryKeys.contacts.byHandle()​

readonly byHandle: (handle) => readonly ["contacts", "handle", string]

Parameters​
handle​

string

Returns​

readonly ["contacts", "handle", string]

queryKeys.contacts.detail()​

readonly detail: (id) => readonly ["contacts", "detail", string]

Parameters​
id​

string

Returns​

readonly ["contacts", "detail", string]

queryKeys.contacts.details()​

readonly details: () => readonly ["contacts", "detail"]

Returns​

readonly ["contacts", "detail"]

queryKeys.contacts.lists()​

readonly lists: () => readonly ["contacts", "list"]

Returns​

readonly ["contacts", "list"]

queryKeys.contacts.search()​

readonly search: (query) => readonly ["contacts", "search", string]

Parameters​
query​

string

Returns​

readonly ["contacts", "search", string]

queryKeys.courses​

readonly courses: object

queryKeys.courses.all()​

readonly all: () => readonly ["courses"]

Returns​

readonly ["courses"]

queryKeys.courses.detail()​

readonly detail: (id) => readonly ["courses", "detail", string]

Parameters​
id​

string

Returns​

readonly ["courses", "detail", string]

queryKeys.courses.details()​

readonly details: () => readonly ["courses", "detail"]

Returns​

readonly ["courses", "detail"]

queryKeys.courses.enrollments()​

readonly enrollments: () => readonly ["courses", "enrollments", "me"]

Returns​

readonly ["courses", "enrollments", "me"]

queryKeys.courses.instructor()​

readonly instructor: (instructorId) => readonly ["courses", "instructor", string]

Parameters​
instructorId​

string

Returns​

readonly ["courses", "instructor", string]

queryKeys.courses.public()​

readonly public: () => readonly ["courses", "public"]

Returns​

readonly ["courses", "public"]

queryKeys.courses.student()​

readonly student: (courseId, studentId) => readonly ["courses", "detail", string, "student", string]

Parameters​
courseId​

string

studentId​

string

Returns​

readonly ["courses", "detail", string, "student", string]

queryKeys.courses.students()​

readonly students: (courseId) => readonly ["courses", "detail", string, "students"]

Parameters​
courseId​

string

Returns​

readonly ["courses", "detail", string, "students"]

queryKeys.datasets​

readonly datasets: object

queryKeys.datasets.all()​

readonly all: () => readonly ["datasets"]

Returns​

readonly ["datasets"]

queryKeys.datasets.bySpace()​

readonly bySpace: (spaceId) => readonly ["datasets", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["datasets", "space", string]

queryKeys.datasets.detail()​

readonly detail: (id) => readonly ["datasets", "detail", string]

Parameters​
id​

string

Returns​

readonly ["datasets", "detail", string]

queryKeys.datasets.details()​

readonly details: () => readonly ["datasets", "detail"]

Returns​

readonly ["datasets", "detail"]

queryKeys.datasources​

readonly datasources: object

queryKeys.datasources.all()​

readonly all: () => readonly ["datasources"]

Returns​

readonly ["datasources"]

queryKeys.datasources.detail()​

readonly detail: (id) => readonly ["datasources", "detail", string]

Parameters​
id​

string

Returns​

readonly ["datasources", "detail", string]

queryKeys.datasources.details()​

readonly details: () => readonly ["datasources", "detail"]

Returns​

readonly ["datasources", "detail"]

queryKeys.documents​

readonly documents: object

queryKeys.documents.all()​

readonly all: () => readonly ["documents"]

Returns​

readonly ["documents"]

queryKeys.documents.bySpace()​

readonly bySpace: (spaceId) => readonly ["documents", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["documents", "space", string]

queryKeys.documents.detail()​

readonly detail: (id) => readonly ["documents", "detail", string]

Parameters​
id​

string

Returns​

readonly ["documents", "detail", string]

queryKeys.documents.details()​

readonly details: () => readonly ["documents", "detail"]

Returns​

readonly ["documents", "detail"]

queryKeys.documents.model()​

readonly model: (documentId) => readonly ["documents", "detail", string, "model"]

Parameters​
documentId​

string

Returns​

readonly ["documents", "detail", string, "model"]

queryKeys.environments​

readonly environments: object

queryKeys.environments.all()​

readonly all: () => readonly ["environments"]

Returns​

readonly ["environments"]

queryKeys.environments.bySpace()​

readonly bySpace: (spaceId) => readonly ["environments", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["environments", "space", string]

queryKeys.environments.detail()​

readonly detail: (id) => readonly ["environments", "detail", string]

Parameters​
id​

string

Returns​

readonly ["environments", "detail", string]

queryKeys.environments.details()​

readonly details: () => readonly ["environments", "detail"]

Returns​

readonly ["environments", "detail"]

queryKeys.exercises​

readonly exercises: object

queryKeys.exercises.all()​

readonly all: () => readonly ["exercises"]

Returns​

readonly ["exercises"]

queryKeys.exercises.bySpace()​

readonly bySpace: (spaceId) => readonly ["exercises", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["exercises", "space", string]

queryKeys.exercises.detail()​

readonly detail: (id) => readonly ["exercises", "detail", string]

Parameters​
id​

string

Returns​

readonly ["exercises", "detail", string]

queryKeys.exercises.details()​

readonly details: () => readonly ["exercises", "detail"]

Returns​

readonly ["exercises", "detail"]

queryKeys.growth​

readonly growth: object

queryKeys.growth.kpi()​

readonly kpi: () => readonly ["growth", "kpi"]

Returns​

readonly ["growth", "kpi"]

queryKeys.inbounds​

readonly inbounds: object

queryKeys.inbounds.all()​

readonly all: () => readonly ["inbounds"]

Returns​

readonly ["inbounds"]

queryKeys.inbounds.byHandle()​

readonly byHandle: (handle) => readonly ["inbounds", "handle", string]

Parameters​
handle​

string

Returns​

readonly ["inbounds", "handle", string]

queryKeys.inbounds.detail()​

readonly detail: (id) => readonly ["inbounds", string]

Parameters​
id​

string

Returns​

readonly ["inbounds", string]

queryKeys.invites​

readonly invites: object

queryKeys.invites.all()​

readonly all: () => readonly ["invites"]

Returns​

readonly ["invites"]

queryKeys.invites.byAccount()​

readonly byAccount: (accountId) => readonly ["invites", "account", string]

Parameters​
accountId​

string

Returns​

readonly ["invites", "account", string]

queryKeys.invites.byToken()​

readonly byToken: (token) => readonly ["invites", "token", string]

Parameters​
token​

string

Returns​

readonly ["invites", "token", string]

queryKeys.items​

readonly items: object

queryKeys.items.all()​

readonly all: () => readonly ["items"]

Returns​

readonly ["items"]

queryKeys.items.bySpace()​

readonly bySpace: (spaceId) => readonly ["items", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["items", "space", string]

queryKeys.items.public()​

readonly public: () => readonly ["items", "public"]

Returns​

readonly ["items", "public"]

queryKeys.items.search()​

readonly search: (opts) => readonly ["items", "search", ISearchOpts]

Parameters​
opts​

ISearchOpts

Returns​

readonly ["items", "search", ISearchOpts]

queryKeys.layout​

readonly layout: object

queryKeys.layout.byAccount()​

readonly byAccount: (accountHandle, spaceHandle?) => readonly ["layout", string, string] | readonly ["layout", string]

Parameters​
accountHandle​

string

spaceHandle?​

string

Returns​

readonly ["layout", string, string] | readonly ["layout", string]

queryKeys.lessons​

readonly lessons: object

queryKeys.lessons.all()​

readonly all: () => readonly ["lessons"]

Returns​

readonly ["lessons"]

queryKeys.lessons.bySpace()​

readonly bySpace: (spaceId) => readonly ["lessons", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["lessons", "space", string]

queryKeys.lessons.detail()​

readonly detail: (id) => readonly ["lessons", "detail", string]

Parameters​
id​

string

Returns​

readonly ["lessons", "detail", string]

queryKeys.lessons.details()​

readonly details: () => readonly ["lessons", "detail"]

Returns​

readonly ["lessons", "detail"]

queryKeys.notebooks​

readonly notebooks: object

queryKeys.notebooks.all()​

readonly all: () => readonly ["notebooks"]

Returns​

readonly ["notebooks"]

queryKeys.notebooks.bySpace()​

readonly bySpace: (spaceId) => readonly ["notebooks", "space", string]

Parameters​
spaceId​

string

Returns​

readonly ["notebooks", "space", string]

queryKeys.notebooks.detail()​

readonly detail: (id) => readonly ["notebooks", "detail", string]

Parameters​
id​

string

Returns​

readonly ["notebooks", "detail", string]

queryKeys.notebooks.details()​

readonly details: () => readonly ["notebooks", "detail"]

Returns​

readonly ["notebooks", "detail"]

queryKeys.notebooks.model()​

readonly model: (notebookId) => readonly ["notebooks", "detail", string, "model"]

Parameters​
notebookId​

string

Returns​

readonly ["notebooks", "detail", string, "model"]

queryKeys.oauth2​

readonly oauth2: object

queryKeys.oauth2.authorizationLinkUrl()​

readonly authorizationLinkUrl: (queryArgs) => readonly ["oauth2", "authz", "url", "link", Record<string, string>]

Parameters​
queryArgs​

Record<string, string>

Returns​

readonly ["oauth2", "authz", "url", "link", Record<string, string>]

queryKeys.oauth2.authorizationUrl()​

readonly authorizationUrl: (queryArgs) => readonly ["oauth2", "authz", "url", Record<string, string>]

Parameters​
queryArgs​

Record<string, string>

Returns​

readonly ["oauth2", "authz", "url", Record<string, string>]

queryKeys.organizations​

readonly organizations: object

queryKeys.organizations.all()​

readonly all: () => readonly ["organizations"]

Returns​

readonly ["organizations"]

queryKeys.organizations.byHandle()​

readonly byHandle: (handle) => readonly ["organizations", "handle", string]

Parameters​
handle​

string

Returns​

readonly ["organizations", "handle", string]

queryKeys.organizations.detail()​

readonly detail: (id) => readonly ["organizations", "detail", string]

Parameters​
id​

string

Returns​

readonly ["organizations", "detail", string]

queryKeys.organizations.details()​

readonly details: () => readonly ["organizations", "detail"]

Returns​

readonly ["organizations", "detail"]

queryKeys.organizations.lists()​

readonly lists: () => readonly ["organizations", "list"]

Returns​

readonly ["organizations", "list"]

queryKeys.organizations.members()​

readonly members: (orgId) => readonly ["organizations", "detail", string, "members"]

Parameters​
orgId​

string

Returns​

readonly ["organizations", "detail", string, "members"]

queryKeys.organizations.userOrgs()​

readonly userOrgs: () => readonly ["organizations", "user"]

Returns​

readonly ["organizations", "user"]

queryKeys.outbounds​

readonly outbounds: object

queryKeys.outbounds.all()​

readonly all: () => readonly ["outbounds"]

Returns​

readonly ["outbounds"]

queryKeys.outbounds.detail()​

readonly detail: (id) => readonly ["outbounds", string]

Parameters​
id​

string

Returns​

readonly ["outbounds", string]

queryKeys.pages​

readonly pages: object

queryKeys.pages.all()​

readonly all: () => readonly ["pages"]

Returns​

readonly ["pages"]

queryKeys.pages.detail()​

readonly detail: (id) => readonly ["pages", "detail", string]

Parameters​
id​

string

Returns​

readonly ["pages", "detail", string]

queryKeys.pages.details()​

readonly details: () => readonly ["pages", "detail"]

Returns​

readonly ["pages", "detail"]

queryKeys.prices​

readonly prices: object

queryKeys.prices.stripe()​

readonly stripe: () => readonly ["prices", "stripe"]

Returns​

readonly ["prices", "stripe"]

queryKeys.schools​

readonly schools: object

queryKeys.schools.all()​

readonly all: () => readonly ["schools"]

Returns​

readonly ["schools"]

queryKeys.secrets​

readonly secrets: object

queryKeys.secrets.all()​

readonly all: () => readonly ["secrets"]

Returns​

readonly ["secrets"]

queryKeys.secrets.detail()​

readonly detail: (id) => readonly ["secrets", "detail", string]

Parameters​
id​

string

Returns​

readonly ["secrets", "detail", string]

queryKeys.secrets.details()​

readonly details: () => readonly ["secrets", "detail"]

Returns​

readonly ["secrets", "detail"]

queryKeys.spaces​

readonly spaces: object

queryKeys.spaces.all()​

readonly all: () => readonly ["spaces"]

Returns​

readonly ["spaces"]

queryKeys.spaces.byHandle()​

readonly byHandle: (handle) => readonly ["spaces", "handle", string]

Parameters​
handle​

string

Returns​

readonly ["spaces", "handle", string]

queryKeys.spaces.byOrganization()​

readonly byOrganization: (orgId) => readonly ["spaces", "organization", string]

Parameters​
orgId​

string

Returns​

readonly ["spaces", "organization", string]

queryKeys.spaces.byOrganizationAndHandle()​

readonly byOrganizationAndHandle: (orgHandle, spaceHandle) => readonly ["spaces", "organization", string, "space", string]

Parameters​
orgHandle​

string

spaceHandle​

string

Returns​

readonly ["spaces", "organization", string, "space", string]

queryKeys.spaces.detail()​

readonly detail: (id) => readonly ["spaces", "detail", string]

Parameters​
id​

string

Returns​

readonly ["spaces", "detail", string]

queryKeys.spaces.details()​

readonly details: () => readonly ["spaces", "detail"]

Returns​

readonly ["spaces", "detail"]

queryKeys.spaces.items()​

readonly items: (spaceId) => readonly ["spaces", "detail", string, "items"]

Parameters​
spaceId​

string

Returns​

readonly ["spaces", "detail", string, "items"]

queryKeys.spaces.members()​

readonly members: (spaceId) => readonly ["spaces", "detail", string, "members"]

Parameters​
spaceId​

string

Returns​

readonly ["spaces", "detail", string, "members"]

queryKeys.spaces.orgSpaceByHandle()​

readonly orgSpaceByHandle: (orgId, handle) => readonly ["spaces", "organization", string, "handle", string]

Parameters​
orgId​

string

handle​

string

Returns​

readonly ["spaces", "organization", string, "handle", string]

queryKeys.spaces.userSpaces()​

readonly userSpaces: () => readonly ["spaces", "user"]

Returns​

readonly ["spaces", "user"]

queryKeys.teams​

readonly teams: object

queryKeys.teams.all()​

readonly all: () => readonly ["teams"]

Returns​

readonly ["teams"]

queryKeys.teams.byHandle()​

readonly byHandle: (handle) => readonly ["teams", "handle", string]

Parameters​
handle​

string

Returns​

readonly ["teams", "handle", string]

queryKeys.teams.byOrganization()​

readonly byOrganization: (orgId) => readonly ["teams", "organization", string]

Parameters​
orgId​

string

Returns​

readonly ["teams", "organization", string]

queryKeys.teams.detail()​

readonly detail: (id) => readonly ["teams", "detail", string]

Parameters​
id​

string

Returns​

readonly ["teams", "detail", string]

queryKeys.teams.details()​

readonly details: () => readonly ["teams", "detail"]

Returns​

readonly ["teams", "detail"]

queryKeys.teams.members()​

readonly members: (teamId) => readonly ["teams", "detail", string, "members"]

Parameters​
teamId​

string

Returns​

readonly ["teams", "detail", string, "members"]

queryKeys.tokens​

readonly tokens: object

queryKeys.tokens.all()​

readonly all: () => readonly ["tokens"]

Returns​

readonly ["tokens"]

queryKeys.tokens.detail()​

readonly detail: (id) => readonly ["tokens", "detail", string]

Parameters​
id​

string

Returns​

readonly ["tokens", "detail", string]

queryKeys.tokens.details()​

readonly details: () => readonly ["tokens", "detail"]

Returns​

readonly ["tokens", "detail"]

queryKeys.usages​

readonly usages: object

queryKeys.usages.platform()​

readonly platform: () => readonly ["usages", "platform"]

Returns​

readonly ["usages", "platform"]

queryKeys.usages.user()​

readonly user: () => readonly ["usages", "user"]

Returns​

readonly ["usages", "user"]

queryKeys.usages.userById()​

readonly userById: (userId) => readonly ["usages", "user", string]

Parameters​
userId​

string

Returns​

readonly ["usages", "user", string]

queryKeys.users​

readonly users: object

queryKeys.users.all()​

readonly all: () => readonly ["users"]

Returns​

readonly ["users"]

queryKeys.users.byHandle()​

readonly byHandle: (handle) => readonly ["users", "handle", string]

Parameters​
handle​

string

Returns​

readonly ["users", "handle", string]

queryKeys.users.credits()​

readonly credits: (userId) => readonly ["users", "detail", string, "credits"]

Parameters​
userId​

string

Returns​

readonly ["users", "detail", string, "credits"]

queryKeys.users.detail()​

readonly detail: (id) => readonly ["users", "detail", string]

Parameters​
id​

string

Returns​

readonly ["users", "detail", string]

queryKeys.users.details()​

readonly details: () => readonly ["users", "detail"]

Returns​

readonly ["users", "detail"]

queryKeys.users.list()​

readonly list: (filters?) => readonly ["users", "list", { filters: string | undefined; }]

Parameters​
filters?​

string

Returns​

readonly ["users", "list", { filters: string | undefined; }]

queryKeys.users.lists()​

readonly lists: () => readonly ["users", "list"]

Returns​

readonly ["users", "list"]

queryKeys.users.onboarding()​

readonly onboarding: (userId) => readonly ["users", "detail", string, "onboarding"]

Parameters​
userId​

string

Returns​

readonly ["users", "detail", string, "onboarding"]

queryKeys.users.search()​

readonly search: (pattern) => readonly ["users", "search", string]

Parameters​
pattern​

string

Returns​

readonly ["users", "search", string]

queryKeys.users.settings()​

readonly settings: (userId) => readonly ["users", "detail", string, "settings"]

Parameters​
userId​

string

Returns​

readonly ["users", "detail", string, "settings"]

queryKeys.users.surveys()​

readonly surveys: (userId) => readonly ["users", "detail", string, "surveys"]

Parameters​
userId​

string

Returns​

readonly ["users", "detail", string, "surveys"]

resetDocumentUpload()​

resetDocumentUpload: () => void

Returns​

void

resetNotebookUpload()​

resetNotebookUpload: () => void

Returns​

void

useAddMemberToOrganization()​

useAddMemberToOrganization: () => UseMutationResult<any, Error, { organizationId: string; userId: string; }, unknown>

Add member to organization

Returns​

UseMutationResult<any, Error, { organizationId: string; userId: string; }, unknown>

useAddMemberToOrganizationSpace()​

useAddMemberToOrganizationSpace: () => UseMutationResult<any, Error, { accountId: string; organizationId: string; spaceId: string; }, unknown>

Add member to organization space

Returns​

UseMutationResult<any, Error, { accountId: string; organizationId: string; spaceId: string; }, unknown>

useAddMemberToTeam()​

useAddMemberToTeam: () => UseMutationResult<any, Error, { teamId: string; userId: string; }, unknown>

Add member to team

Returns​

UseMutationResult<any, Error, { teamId: string; userId: string; }, unknown>

useAddRoleToOrganizationMember()​

useAddRoleToOrganizationMember: () => UseMutationResult<any, Error, { organizationId: string; roleName: string; userId: string; }, unknown>

Add role to organization member

Returns​

UseMutationResult<any, Error, { organizationId: string; roleName: string; userId: string; }, unknown>

useAddRoleToTeamMember()​

useAddRoleToTeamMember: () => UseMutationResult<any, Error, { roleName: string; teamId: string; userId: string; }, unknown>

Add role to team member

Returns​

UseMutationResult<any, Error, { roleName: string; teamId: string; userId: string; }, unknown>

useAssignment()​

useAssignment: (assignmentId) => UseQueryResult<IAssignment | undefined, Error>

Get assignment by ID

Parameters​

assignmentId​

string

Returns​

UseQueryResult<IAssignment | undefined, Error>

useAssignmentForStudent()​

useAssignmentForStudent: (assignmentId, courseId, userId, options?) => UseQueryResult<unknown, Error>

Fetch assignment from student perspective with enrollment data

Parameters​

assignmentId​

string

courseId​

string

userId​

string

options?​

Omit<UseQueryOptions<unknown, Error, unknown, readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown, Error>

useAssignmentsBySpace()​

useAssignmentsBySpace: (spaceId) => UseQueryResult<any, Error>

Get assignments by space

Parameters​

spaceId​

string

Returns​

UseQueryResult<any, Error>

useAssignmentStudentVersion()​

useAssignmentStudentVersion: (assignmentId, options?) => UseQueryResult<unknown, Error>

Get student version of assignment (submission view)

Parameters​

assignmentId​

string

options?​

Omit<UseQueryOptions<unknown, Error, unknown, readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown, Error>

useAssignRoleToUser()​

useAssignRoleToUser: () => UseMutationResult<any, Error, { roleName: string; userId: string; }, unknown>

Assign role to user

Returns​

UseMutationResult<any, Error, { roleName: string; userId: string; }, unknown>

useAssignTagToContact()​

useAssignTagToContact: () => UseMutationResult<any, Error, { contactId: string; tagName: string; }, unknown>

Assign tag to contact

Returns​

UseMutationResult<any, Error, { contactId: string; tagName: string; }, unknown>

useBurnCredit()​

useBurnCredit: () => UseMutationResult<any, Error, number, unknown>

Burn user credits (deduct from balance)

Returns​

UseMutationResult<any, Error, number, unknown>

useCell()​

useCell: (cellId) => UseQueryResult<ICell | undefined, Error>

Get cell by ID

Parameters​

cellId​

string

Returns​

UseQueryResult<ICell | undefined, Error>

useCellsBySpace()​

useCellsBySpace: (spaceId) => UseQueryResult<any, Error>

Get cells by space

Parameters​

spaceId​

string

Returns​

UseQueryResult<any, Error>

useChangePassword()​

useChangePassword: () => UseMutationResult<any, Error, { handle: string; password: string; passwordConfirm: string; }, unknown>

Change user password

Returns​

UseMutationResult<any, Error, { handle: string; password: string; passwordConfirm: string; }, unknown>

useClearCachedInvites()​

useClearCachedInvites: (options?) => UseMutationResult<void, Error, void, unknown>

Clear cached invites (mutation)

Parameters​

options?​

UseMutationOptions<void, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<void, Error, void, unknown>

useClearCachedItems()​

useClearCachedItems: (options?) => UseMutationResult<void, Error, void, unknown>

Clear cached items (mutation)

Parameters​

options?​

UseMutationOptions<void, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<void, Error, void, unknown>

useClearCachedOrganizations()​

useClearCachedOrganizations: (options?) => UseMutationResult<void, Error, void, unknown>

Clear cached organizations (mutation)

Parameters​

options?​

UseMutationOptions<void, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<void, Error, void, unknown>

useClearCachedPublicItems()​

useClearCachedPublicItems: (options?) => UseMutationResult<void, Error, void, unknown>

Clear cached public items (mutation)

Parameters​

options?​

UseMutationOptions<void, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<void, Error, void, unknown>

useClearCachedTeams()​

useClearCachedTeams: (options?) => UseMutationResult<void, Error, void, unknown>

Clear cached teams (mutation)

Parameters​

options?​

UseMutationOptions<void, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<void, Error, void, unknown>

useCloneAssignment()​

useCloneAssignment: () => UseMutationResult<any, Error, string, unknown>

Clone assignment

Returns​

UseMutationResult<any, Error, string, unknown>

useCloneCell()​

useCloneCell: () => UseMutationResult<any, Error, string, unknown>

Clone cell

Returns​

UseMutationResult<any, Error, string, unknown>

useCloneDocument()​

useCloneDocument: () => UseMutationResult<any, Error, string, unknown>

Clone document

Returns​

UseMutationResult<any, Error, string, unknown>

useCloneExercise()​

useCloneExercise: () => UseMutationResult<any, Error, string, unknown>

Clone exercise

Returns​

UseMutationResult<any, Error, string, unknown>

useCloneLesson()​

useCloneLesson: () => UseMutationResult<any, Error, string, unknown>

Clone lesson

Returns​

UseMutationResult<any, Error, string, unknown>

useCloneNotebook()​

useCloneNotebook: () => UseMutationResult<any, Error, string, unknown>

Clone notebook

Returns​

UseMutationResult<any, Error, string, unknown>

useConfirmCourseItemCompletion()​

useConfirmCourseItemCompletion: () => UseMutationResult<any, Error, { completed: boolean; courseId: string; itemId: string; itemType: string; }, unknown>

Mark a course item as completed

Returns​

UseMutationResult<any, Error, { completed: boolean; courseId: string; itemId: string; itemType: string; }, unknown>

useConfirmEmailUpdate()​

useConfirmEmailUpdate: () => UseMutationResult<any, Error, string, unknown>

Confirm email update with token

Returns​

UseMutationResult<any, Error, string, unknown>

useConfirmJoinWithToken()​

useConfirmJoinWithToken: () => UseMutationResult<any, Error, { token: string; userHandle: string; }, unknown>

Confirm join with token

Returns​

UseMutationResult<any, Error, { token: string; userHandle: string; }, unknown>

useConfirmPasswordWithToken()​

useConfirmPasswordWithToken: () => UseMutationResult<any, Error, { token: string; userHandle: string; }, unknown>

Confirm password change with token

Returns​

UseMutationResult<any, Error, { token: string; userHandle: string; }, unknown>

useContact()​

useContact: (contactId, options?) => UseQueryResult<IContact | undefined, Error>

Get contact by ID

Parameters​

contactId​

string

options?​
enabled?​

boolean

Returns​

UseQueryResult<IContact | undefined, Error>

useContactByHandle()​

useContactByHandle: (handle) => UseQueryResult<IContact | null | undefined, Error>

Get contact by handle

Parameters​

handle​

string

Returns​

UseQueryResult<IContact | null | undefined, Error>

useCourse()​

useCourse: (courseId) => UseQueryResult<ICourse | undefined, Error>

Get course by ID

Parameters​

courseId​

string

Returns​

UseQueryResult<ICourse | undefined, Error>

useCourseEnrollments()​

useCourseEnrollments: () => UseQueryResult<any, Error>

Get course enrollments for current user

Returns​

UseQueryResult<any, Error>

useCreateCheckoutSession()​

useCreateCheckoutSession: () => UseMutationResult<any, Error, { location: Location; product: any; }, unknown>

Create Stripe checkout session

Returns​

UseMutationResult<any, Error, { location: Location; product: any; }, unknown>

useCreateContact()​

useCreateContact: () => UseMutationResult<any, Error, IContact, unknown>

Create contact

Returns​

UseMutationResult<any, Error, IContact, unknown>

useCreateDatasource()​

useCreateDatasource: () => UseMutationResult<any, Error, Omit<IDatasource, "id">, unknown>

Create datasource

Returns​

UseMutationResult<any, Error, Omit<IDatasource, "id">, unknown>

useCreateDocument()​

useCreateDocument: () => UseMutationResult<any, Error, { description?: string; documentType?: string; file?: File; name: string; spaceId: string; }, unknown>

Create document

Returns​

UseMutationResult<any, Error, { description?: string; documentType?: string; file?: File; name: string; spaceId: string; }, unknown>

useCreateNotebook()​

useCreateNotebook: () => UseMutationResult<any, Error, { description?: string; file?: File; name: string; notebookType?: string; spaceId: string; }, unknown>

Create notebook

Returns​

UseMutationResult<any, Error, { description?: string; file?: File; name: string; notebookType?: string; spaceId: string; }, unknown>

useCreateOrganization()​

useCreateOrganization: () => UseMutationResult<any, Error, Partial<IOrganization>, unknown>

Create organization

Returns​

UseMutationResult<any, Error, Partial<IOrganization>, unknown>

useCreatePage()​

useCreatePage: () => UseMutationResult<any, Error, Omit<IPage, "id">, unknown>

Create page

Returns​

UseMutationResult<any, Error, Omit<IPage, "id">, unknown>

useCreateSecret()​

useCreateSecret: () => UseMutationResult<any, Error, Omit<ISecret, "id">, unknown>

Create secret

Returns​

UseMutationResult<any, Error, Omit<ISecret, "id">, unknown>

useCreateSpace()​

useCreateSpace: () => UseMutationResult<any, Error, { organization?: IAnyOrganization; space: Partial<IAnySpace>; }, unknown>

Create space

Returns​

UseMutationResult<any, Error, { organization?: IAnyOrganization; space: Partial<IAnySpace>; }, unknown>

useCreateTeam()​

useCreateTeam: () => UseMutationResult<any, Error, { organization: IAnyOrganization; team: Partial<ITeam>; }, unknown>

Create team

Returns​

UseMutationResult<any, Error, { organization: IAnyOrganization; team: Partial<ITeam>; }, unknown>

useCreateToken()​

useCreateToken: () => UseMutationResult<any, Error, Omit<IIAMToken, "id" | "value">, unknown>

Create token

Returns​

UseMutationResult<any, Error, Omit<IIAMToken, "id" | "value">, unknown>

useCreateTokenForPasswordChange()​

useCreateTokenForPasswordChange: () => UseMutationResult<any, Error, { handle: string; password: string; passwordConfirm: string; }, unknown>

Create token for password change

Returns​

UseMutationResult<any, Error, { handle: string; password: string; passwordConfirm: string; }, unknown>

useDataset()​

useDataset: (datasetId) => UseQueryResult<IDataset | undefined, Error>

Get dataset by ID

Parameters​

datasetId​

string

Returns​

UseQueryResult<IDataset | undefined, Error>

useDatasetsBySpace()​

useDatasetsBySpace: (spaceId) => UseQueryResult<any, Error>

Get datasets by space

Parameters​

spaceId​

string

Returns​

UseQueryResult<any, Error>

useDatasource()​

useDatasource: (datasourceId) => UseQueryResult<IDatasource | null | undefined, Error>

Get single datasource by ID

Parameters​

datasourceId​

string

Returns​

UseQueryResult<IDatasource | null | undefined, Error>

useDatasources()​

useDatasources: () => UseQueryResult<any, Error>

Get all datasources

Returns​

UseQueryResult<any, Error>

useDeleteContact()​

useDeleteContact: () => UseMutationResult<any, Error, string, unknown>

Delete contact

Returns​

UseMutationResult<any, Error, string, unknown>

useDeleteItem()​

useDeleteItem: () => UseMutationResult<any, Error, string, unknown>

Delete any item (notebook, document, cell, etc.)

Returns​

UseMutationResult<any, Error, string, unknown>

useDeleteOutbound()​

useDeleteOutbound: () => UseMutationResult<any, Error, string, unknown>

Delete an outbound campaign

Returns​

UseMutationResult<any, Error, string, unknown>

useDeletePage()​

useDeletePage: () => UseMutationResult<any, Error, string, unknown>

Delete page

Returns​

UseMutationResult<any, Error, string, unknown>

useDeleteSecret()​

useDeleteSecret: () => UseMutationResult<any, Error, string, unknown>

Delete secret

Returns​

UseMutationResult<any, Error, string, unknown>

useDisableUserMFA()​

useDisableUserMFA: () => UseMutationResult<any, Error, void, unknown>

Disable MFA for current user

Returns​

UseMutationResult<any, Error, void, unknown>

useDocument()​

useDocument: (documentId) => UseQueryResult<IDocument, Error>

Get document by ID

Parameters​

documentId​

string

Returns​

UseQueryResult<IDocument, Error>

useDocumentsBySpace()​

useDocumentsBySpace: (spaceId) => UseQueryResult<any, Error>

Get documents by space

Parameters​

spaceId​

string

Returns​

UseQueryResult<any, Error>

useDraftBulkEmailsOutbounds()​

useDraftBulkEmailsOutbounds: () => UseMutationResult<any, Error, unknown, unknown>

Draft bulk emails for outbound campaign

Returns​

UseMutationResult<any, Error, unknown, unknown>

useEnableUserMFA()​

useEnableUserMFA: () => UseMutationResult<any, Error, void, unknown>

Enable MFA for current user

Returns​

UseMutationResult<any, Error, void, unknown>

useEnrichContactEmail()​

useEnrichContactEmail: () => UseMutationResult<any, Error, { contactId: string; useDomain: boolean; }, unknown>

Enrich contact with email data

Returns​

UseMutationResult<any, Error, { contactId: string; useDomain: boolean; }, unknown>

useEnrichContactLinkedin()​

useEnrichContactLinkedin: () => UseMutationResult<any, Error, string, unknown>

Enrich contact with LinkedIn data

Returns​

UseMutationResult<any, Error, string, unknown>

useEnrollStudentToCourse()​

useEnrollStudentToCourse: () => UseMutationResult<any, Error, { courseId: string; studentId: string; }, unknown>

Enroll student to course

Returns​

UseMutationResult<any, Error, { courseId: string; studentId: string; }, unknown>

useEnvironment()​

useEnvironment: (environmentId) => UseQueryResult<IEnvironment | undefined, Error>

Get environment by ID

Parameters​

environmentId​

string

Returns​

UseQueryResult<IEnvironment | undefined, Error>

useEnvironmentsBySpace()​

useEnvironmentsBySpace: (spaceId) => UseQueryResult<any, Error>

Get environments by space

Parameters​

spaceId​

string

Returns​

UseQueryResult<any, Error>

useExercise()​

useExercise: (exerciseId) => UseQueryResult<IExercise | undefined, Error>

Get exercise by ID

Parameters​

exerciseId​

string

Returns​

UseQueryResult<IExercise | undefined, Error>

useExercisesBySpace()​

useExercisesBySpace: (spaceId) => UseQueryResult<any, Error>

Get exercises by space

Parameters​

spaceId​

string

Returns​

UseQueryResult<any, Error>

useExportSpace()​

useExportSpace: () => UseMutationResult<any, Error, string, unknown>

Export space

Returns​

UseMutationResult<any, Error, string, unknown>

useGetGitHubProfile()​

useGetGitHubProfile: () => UseMutationResult<any, Error, string, unknown>

Get GitHub profile from access token

Returns​

UseMutationResult<any, Error, string, unknown>

useGetLinkedinProfile()​

useGetLinkedinProfile: () => UseMutationResult<any, Error, string, unknown>

Get LinkedIn profile via proxy

Returns​

UseMutationResult<any, Error, string, unknown>

useGradeAssignmentForStudent()​

useGradeAssignmentForStudent: () => UseMutationResult<any, Error, { assignmentId: string; courseId: string; model: unknown; userId: string; }, unknown>

Grade an assignment for a student

Returns​

UseMutationResult<any, Error, { assignmentId: string; courseId: string; model: unknown; userId: string; }, unknown>

useGrowthKPI()​

useGrowthKPI: (options?) => UseQueryResult<unknown, Error>

Get growth KPIs

Parameters​

options?​

Omit<UseQueryOptions<unknown, Error, unknown, readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown, Error>

useInbound()​

useInbound: (id, options?) => UseQueryResult<unknown, Error>

Get inbound by ID (query hook)

Parameters​

id​

string

Inbound ID

options?​

UseQueryOptions<unknown, Error, unknown, readonly unknown[]>

Query options

Returns​

UseQueryResult<unknown, Error>

useInboundByHandle()​

useInboundByHandle: (handle, options?) => UseQueryResult<unknown, Error>

Get inbound by handle (query hook)

Parameters​

handle​

string

Inbound handle

options?​

UseQueryOptions<unknown, Error, unknown, readonly unknown[]>

Query options

Returns​

UseQueryResult<unknown, Error>

useInbounds()​

useInbounds: (options?) => UseQueryResult<unknown[], Error>

Get all inbound leads

Parameters​

options?​

Omit<UseQueryOptions<unknown[], Error, unknown[], readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown[], Error>

useInstructorCourses()​

useInstructorCourses: (userId?) => UseQueryResult<any, Error>

Get instructor courses

Parameters​

userId?​

string

Returns​

UseQueryResult<any, Error>

useInvite()​

useInvite: (token) => UseQueryResult<IInvite | undefined, Error>

Get invite by token

Parameters​

token​

string

Returns​

UseQueryResult<IInvite | undefined, Error>

useInvitesByUser()​

useInvitesByUser: (accountId) => UseQueryResult<any, Error>

Get invites for user

Parameters​

accountId​

string

Returns​

UseQueryResult<any, Error>

useJoinWithInvite()​

useJoinWithInvite: () => UseMutationResult<any, Error, { formValues: any; token: string; }, unknown>

Join platform with invite token

Returns​

UseMutationResult<any, Error, { formValues: any; token: string; }, unknown>

useLaunchBulkEmailsOutbounds()​

useLaunchBulkEmailsOutbounds: () => UseMutationResult<any, Error, string, unknown>

Launch bulk emails for outbound campaign (production mode)

Returns​

UseMutationResult<any, Error, string, unknown>

useLesson()​

useLesson: (lessonId) => UseQueryResult<ILesson | undefined, Error>

Get lesson by ID

Parameters​

lessonId​

string

Returns​

UseQueryResult<ILesson | undefined, Error>

useLessonsBySpace()​

useLessonsBySpace: (spaceId) => UseQueryResult<any, Error>

Get lessons by space

Parameters​

spaceId​

string

Returns​

UseQueryResult<any, Error>

useLinkUserWithContact()​

useLinkUserWithContact: () => UseMutationResult<any, Error, { contactId: string; userId: string; }, unknown>

Link user with contact

Returns​

UseMutationResult<any, Error, { contactId: string; userId: string; }, unknown>

useLogin()​

useLogin: () => UseMutationResult<any, Error, { handle: string; password: string; }, unknown>

Login mutation

Returns​

UseMutationResult<any, Error, { handle: string; password: string; }, unknown>

Example​

const login = useLogin();
login.mutate({ handle: 'user', password: 'pass' });

useLogout()​

useLogout: () => UseMutationResult<any, Error, void, unknown>

Logout mutation

Returns​

UseMutationResult<any, Error, void, unknown>

Example​

const logout = useLogout();
logout.mutate();

useMakeItemPrivate()​

useMakeItemPrivate: () => UseMutationResult<any, Error, string, unknown>

Make item private

Returns​

UseMutationResult<any, Error, string, unknown>

useMakeItemPublic()​

useMakeItemPublic: () => UseMutationResult<any, Error, string, unknown>

Make item public

Returns​

UseMutationResult<any, Error, string, unknown>

useMakeSpacePrivate()​

useMakeSpacePrivate: () => UseMutationResult<any, Error, string, unknown>

Make space private

Returns​

UseMutationResult<any, Error, string, unknown>

useMakeSpacePublic()​

useMakeSpacePublic: () => UseMutationResult<any, Error, string, unknown>

Make space public

Returns​

UseMutationResult<any, Error, string, unknown>

useMe()​

useMe: (token?) => UseQueryResult<IUser | null | undefined, Error>

Get current user profile

Parameters​

token?​

string

Returns​

UseQueryResult<IUser | null | undefined, Error>

Example​

const { data: user, isPending } = useMe();

useNotebook()​

useNotebook: (notebookId) => UseQueryResult<INotebook, Error>

Get notebook by ID

Parameters​

notebookId​

string

Returns​

UseQueryResult<INotebook, Error>

useNotebooksBySpace()​

useNotebooksBySpace: (spaceId) => UseQueryResult<any, Error>

Get notebooks by space

Parameters​

spaceId​

string

Returns​

UseQueryResult<any, Error>

useOAuth2AuthorizationLinkURL()​

useOAuth2AuthorizationLinkURL: () => UseMutationResult<string, Error, Record<string, string>, unknown>

Get OAuth2 authorization link URL

Returns​

UseMutationResult<string, Error, Record<string, string>, unknown>

useOAuth2AuthorizationURL()​

useOAuth2AuthorizationURL: () => UseMutationResult<string, Error, Record<string, string>, unknown>

Get OAuth2 authorization URL

Returns​

UseMutationResult<string, Error, Record<string, string>, unknown>

useOrganization()​

useOrganization: (organizationId) => UseQueryResult<IOrganization, Error>

Get organization by ID

Parameters​

organizationId​

string

Returns​

UseQueryResult<IOrganization, Error>

useOrganizationByHandle()​

useOrganizationByHandle: (handle) => UseQueryResult<IOrganization | null, Error>

Get organization by handle

Parameters​

handle​

string

Returns​

UseQueryResult<IOrganization | null, Error>

useOrganizationSpace()​

useOrganizationSpace: (organizationId, spaceId) => UseQueryResult<IAnySpace, Error>

Get organization space

Parameters​

organizationId​

string

spaceId​

string

Returns​

UseQueryResult<IAnySpace, Error>

useOrganizationSpaceByHandle()​

useOrganizationSpaceByHandle: (organizationId, handle) => UseQueryResult<IAnySpace | null, Error>

Get organization space by handle

Parameters​

organizationId​

string

handle​

string

Returns​

UseQueryResult<IAnySpace | null, Error>

useOrganizationSpaces()​

useOrganizationSpaces: (organizationId) => UseQueryResult<any, Error>

Get spaces by organization

Parameters​

organizationId​

string

Returns​

UseQueryResult<any, Error>

useOutbound()​

useOutbound: (outboundId, options?) => UseQueryResult<unknown, Error>

Get a specific outbound by ID

Parameters​

outboundId​

string

options?​

Omit<UseQueryOptions<unknown, Error, unknown, readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown, Error>

useOutbounds()​

useOutbounds: (options?) => UseQueryResult<unknown[], Error>

Get all outbound campaigns

Parameters​

options?​

Omit<UseQueryOptions<unknown[], Error, unknown[], readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown[], Error>

usePage()​

usePage: (pageId) => UseQueryResult<IPage | undefined, Error>

Get page by ID

Parameters​

pageId​

string

Returns​

UseQueryResult<IPage | undefined, Error>

usePages()​

usePages: () => UseQueryResult<any, Error>

Get all pages

Returns​

UseQueryResult<any, Error>

usePlatformUsages()​

usePlatformUsages: (options?) => UseQueryResult<unknown[], Error>

Get platform-wide usage statistics

Parameters​

options?​

Omit<UseQueryOptions<unknown[], Error, unknown[], readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown[], Error>

usePostLinkedinShare()​

usePostLinkedinShare: () => UseMutationResult<any, Error, { accessToken: string; linkedinUserUrn: string; postText: string; }, unknown>

Post LinkedIn share

Returns​

UseMutationResult<any, Error, { accessToken: string; linkedinUserUrn: string; postText: string; }, unknown>

usePostLinkedinShareWithUpload()​

usePostLinkedinShareWithUpload: () => UseMutationResult<any, Error, { accessToken: string; linkedinUserUrn: string; postText: string; uploadObject: string; }, unknown>

Post LinkedIn share with image upload

Returns​

UseMutationResult<any, Error, { accessToken: string; linkedinUserUrn: string; postText: string; uploadObject: string; }, unknown>

useProxyGET()​

useProxyGET: () => UseMutationResult<any, Error, { token: string; url: string; }, unknown>

Proxy GET request

Returns​

UseMutationResult<any, Error, { token: string; url: string; }, unknown>

useProxyPOST()​

useProxyPOST: () => UseMutationResult<any, Error, { body: object; token: string; url: string; }, unknown>

Proxy POST request

Returns​

UseMutationResult<any, Error, { body: object; token: string; url: string; }, unknown>

useProxyPUT()​

useProxyPUT: () => UseMutationResult<any, Error, { body: object; token: string; url: string; }, unknown>

Proxy PUT request

Returns​

UseMutationResult<any, Error, { body: object; token: string; url: string; }, unknown>

usePublicCourses()​

usePublicCourses: () => UseQueryResult<any, Error>

Get public courses

Returns​

UseQueryResult<any, Error>

usePublicItems()​

usePublicItems: (options?) => UseQueryResult<unknown, Error>

Get public items (query hook)

Parameters​

options?​

UseQueryOptions<unknown, Error, unknown, readonly unknown[]>

Query options

Returns​

UseQueryResult<unknown, Error>

usePutInvite()​

usePutInvite: () => UseMutationResult<any, Error, string, unknown>

Accept/put invite

Returns​

UseMutationResult<any, Error, string, unknown>

useRefreshAssignment()​

useRefreshAssignment: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific assignment

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshAssignmentForStudent()​

useRefreshAssignmentForStudent: (options?) => UseMutationResult<unknown, Error, { assignmentId: string; courseId: string; userId: string; }, unknown>

Refresh assignment for a specific student

Parameters​

options?​

UseMutationOptions<unknown, Error, { assignmentId: string; courseId: string; userId: string; }, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, { assignmentId: string; courseId: string; userId: string; }, unknown>

useRefreshCell()​

useRefreshCell: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific cell

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshContact()​

useRefreshContact: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific contact

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshCourse()​

useRefreshCourse: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific course

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshCoursesEnrollments()​

useRefreshCoursesEnrollments: (options?) => UseMutationResult<unknown, Error, void, unknown>

Refresh course enrollments

Parameters​

options?​

UseMutationOptions<unknown, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, void, unknown>

useRefreshDataset()​

useRefreshDataset: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific dataset

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshDocument()​

useRefreshDocument: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific document

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshEnvironment()​

useRefreshEnvironment: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific environment

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshExercise()​

useRefreshExercise: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific exercise

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshInbound()​

useRefreshInbound: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh inbound data

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshInstructorCourses()​

useRefreshInstructorCourses: (options?) => UseMutationResult<unknown, Error, void, unknown>

Refresh instructor courses list

Parameters​

options?​

UseMutationOptions<unknown, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, void, unknown>

useRefreshInvite()​

useRefreshInvite: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific invite by token

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshInvites()​

useRefreshInvites: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh invites for a user

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshLayout()​

useRefreshLayout: () => UseMutationResult<any, Error, { accountHandle: string; spaceHandle?: string; }, unknown>

Refresh layout (loads user, organization, and space data)

Returns​

UseMutationResult<any, Error, { accountHandle: string; spaceHandle?: string; }, unknown>

useRefreshLesson()​

useRefreshLesson: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific lesson

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshNotebook()​

useRefreshNotebook: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh a specific notebook

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshOrganization()​

useRefreshOrganization: () => UseMutationResult<any, Error, string, unknown>

Refresh organization data

Returns​

UseMutationResult<any, Error, string, unknown>

useRefreshOrganizationSpace()​

useRefreshOrganizationSpace: () => UseMutationResult<any, Error, { organizationId: string; spaceId: string; }, unknown>

Refresh organization space

Returns​

UseMutationResult<any, Error, { organizationId: string; spaceId: string; }, unknown>

useRefreshOrganizationSpaces()​

useRefreshOrganizationSpaces: () => UseMutationResult<any, Error, string, unknown>

Refresh organization spaces

Returns​

UseMutationResult<any, Error, string, unknown>

useRefreshOutbound()​

useRefreshOutbound: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh outbound data

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshPublicCourses()​

useRefreshPublicCourses: (options?) => UseMutationResult<unknown, Error, void, unknown>

Refresh public courses list

Parameters​

options?​

UseMutationOptions<unknown, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, void, unknown>

useRefreshPublicItems()​

useRefreshPublicItems: (options?) => UseMutationResult<unknown, Error, void, unknown>

Refresh public items

Parameters​

options?​

UseMutationOptions<unknown, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, void, unknown>

useRefreshSchools()​

useRefreshSchools: (options?) => UseMutationResult<unknown, Error, void, unknown>

Refresh schools list

Parameters​

options?​

UseMutationOptions<unknown, Error, void, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, void, unknown>

useRefreshSpaceAssignments()​

useRefreshSpaceAssignments: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space assignments

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshSpaceCells()​

useRefreshSpaceCells: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space cells

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshSpaceDatasets()​

useRefreshSpaceDatasets: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space datasets

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshSpaceDocuments()​

useRefreshSpaceDocuments: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space documents

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshSpaceEnvironments()​

useRefreshSpaceEnvironments: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space environments

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshSpaceExercises()​

useRefreshSpaceExercises: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space exercises

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshSpaceItems()​

useRefreshSpaceItems: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space items

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshSpaceLessons()​

useRefreshSpaceLessons: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space lessons

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshSpaceNotebooks()​

useRefreshSpaceNotebooks: (options?) => UseMutationResult<unknown, Error, string, unknown>

Refresh space notebooks

Parameters​

options?​

UseMutationOptions<unknown, Error, string, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, string, unknown>

useRefreshStudent()​

useRefreshStudent: (options?) => UseMutationResult<unknown, Error, { courseId: string; studentHandle: string; }, unknown>

Refresh student data

Parameters​

options?​

UseMutationOptions<unknown, Error, { courseId: string; studentHandle: string; }, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, { courseId: string; studentHandle: string; }, unknown>

useRefreshTeam()​

useRefreshTeam: () => UseMutationResult<any, Error, { organizationId: string; teamId: string; }, unknown>

Refresh team data

Returns​

UseMutationResult<any, Error, { organizationId: string; teamId: string; }, unknown>

useRefreshTeams()​

useRefreshTeams: () => UseMutationResult<any, Error, string, unknown>

Refresh teams for organization

Returns​

UseMutationResult<any, Error, string, unknown>

useRefreshUser()​

useRefreshUser: () => UseMutationResult<any, Error, string, unknown>

Refresh user data by ID (re-fetch from API)

Returns​

UseMutationResult<any, Error, string, unknown>

useRefreshUserOrganizations()​

useRefreshUserOrganizations: () => UseMutationResult<any, Error, void, unknown>

Refresh user organizations

Returns​

UseMutationResult<any, Error, void, unknown>

useRefreshUserSpace()​

useRefreshUserSpace: (options?) => UseMutationResult<unknown, Error, { spaceId: string; userId: string; }, unknown>

Refresh a specific user space

Parameters​

options?​

UseMutationOptions<unknown, Error, { spaceId: string; userId: string; }, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, { spaceId: string; userId: string; }, unknown>

useRefreshUserSpaces()​

useRefreshUserSpaces: () => UseMutationResult<any, Error, void, unknown>

Refresh user spaces

Returns​

UseMutationResult<any, Error, void, unknown>

useRegisterToWaitingList()​

useRegisterToWaitingList: () => UseMutationResult<any, Error, { affiliation?: string; email: string; firstName: string; lastName: string; }, unknown>

Register to waiting list

Returns​

UseMutationResult<any, Error, { affiliation?: string; email: string; firstName: string; lastName: string; }, unknown>

useRemoveMemberFromOrganization()​

useRemoveMemberFromOrganization: () => UseMutationResult<any, Error, { organizationId: string; userId: string; }, unknown>

Remove member from organization

Returns​

UseMutationResult<any, Error, { organizationId: string; userId: string; }, unknown>

useRemoveMemberFromOrganizationSpace()​

useRemoveMemberFromOrganizationSpace: () => UseMutationResult<any, Error, { accountId: string; organizationId: string; spaceId: string; }, unknown>

Remove member from organization space

Returns​

UseMutationResult<any, Error, { accountId: string; organizationId: string; spaceId: string; }, unknown>

useRemoveMemberFromTeam()​

useRemoveMemberFromTeam: () => UseMutationResult<any, Error, { teamId: string; userId: string; }, unknown>

Remove member from team

Returns​

UseMutationResult<any, Error, { teamId: string; userId: string; }, unknown>

useRemoveRoleFromOrganizationMember()​

useRemoveRoleFromOrganizationMember: () => UseMutationResult<any, Error, { organizationId: string; roleName: string; userId: string; }, unknown>

Remove role from organization member

Returns​

UseMutationResult<any, Error, { organizationId: string; roleName: string; userId: string; }, unknown>

useRemoveRoleFromTeamMember()​

useRemoveRoleFromTeamMember: () => UseMutationResult<any, Error, { roleName: string; teamId: string; userId: string; }, unknown>

Remove role from team member

Returns​

UseMutationResult<any, Error, { roleName: string; teamId: string; userId: string; }, unknown>

useRemoveStudentFromCourse()​

useRemoveStudentFromCourse: () => UseMutationResult<any, Error, { courseId: string; studentId: string; }, unknown>

Remove student from course

Returns​

UseMutationResult<any, Error, { courseId: string; studentId: string; }, unknown>

useRequestEmailUpdate()​

useRequestEmailUpdate: () => UseMutationResult<any, Error, string, unknown>

Request email update

Returns​

UseMutationResult<any, Error, string, unknown>

useRequestInvite()​

useRequestInvite: (options?) => UseMutationResult<unknown, Error, { email: string; firstName: string; lastName: string; socialUrl: string; }, unknown>

Request an invite (mutation)

Parameters​

options?​

UseMutationOptions<unknown, Error, { email: string; firstName: string; lastName: string; socialUrl: string; }, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, { email: string; firstName: string; lastName: string; socialUrl: string; }, unknown>

useRequestJoin()​

useRequestJoin: () => UseMutationResult<any, Error, { email: string; firstName: string; handle: string; lastName: string; password: string; passwordConfirm: string; }, unknown>

Request to join platform (standard registration)

Returns​

UseMutationResult<any, Error, { email: string; firstName: string; handle: string; lastName: string; password: string; passwordConfirm: string; }, unknown>

useRequestJoinToken()​

useRequestJoinToken: () => UseMutationResult<any, Error, { email: string; firstName: string; handle: string; lastName: string; password: string; passwordConfirm: string; }, unknown>

Request to join with token (token-based registration)

Returns​

UseMutationResult<any, Error, { email: string; firstName: string; handle: string; lastName: string; password: string; passwordConfirm: string; }, unknown>

useRequestPlatformSupport()​

useRequestPlatformSupport: () => UseMutationResult<any, Error, { brand: string; email: string; message: string; subject: string; }, unknown>

Request platform support (first form)

Returns​

UseMutationResult<any, Error, { brand: string; email: string; message: string; subject: string; }, unknown>

useRequestPlatformSupport2()​

useRequestPlatformSupport2: () => UseMutationResult<any, Error, { accountHandle: string; email: string; firstName: string; lastName: string; message: string; }, unknown>

Request platform support (second form with more details)

Returns​

UseMutationResult<any, Error, { accountHandle: string; email: string; firstName: string; lastName: string; message: string; }, unknown>

useResetAssignmentForStudent()​

useResetAssignmentForStudent: () => UseMutationResult<any, Error, { assignmentId: string; courseId: string; userId: string; }, unknown>

Reset assignment for a student (clear their progress)

Returns​

UseMutationResult<any, Error, { assignmentId: string; courseId: string; userId: string; }, unknown>

useSchools()​

useSchools: () => UseQueryResult<ISchool[], Error>

Get all schools

Returns​

UseQueryResult<ISchool[], Error>

useSearchContacts()​

useSearchContacts: (query) => UseQueryResult<any, Error>

Search contacts

Parameters​

query​

string

Returns​

UseQueryResult<any, Error>

useSearchPublicItems()​

useSearchPublicItems: () => UseMutationResult<any, Error, { max?: number; q?: string; types?: string[]; }, unknown>

Search public items (notebooks, documents, etc.)

Returns​

UseMutationResult<any, Error, { max?: number; q?: string; types?: string[]; }, unknown>

useSearchUsers()​

useSearchUsers: (namingPattern) => UseQueryResult<IUser[], Error>

Search users by naming pattern

Parameters​

namingPattern​

string

Returns​

UseQueryResult<IUser[], Error>

useSecret()​

useSecret: (secretId, options?) => UseQueryResult<ISecret | null | undefined, Error>

Get single secret by ID

Parameters​

secretId​

string

options?​
enabled?​

boolean

refetchOnMount?​

boolean

Returns​

UseQueryResult<ISecret | null | undefined, Error>

useSecrets()​

useSecrets: () => UseQueryResult<any, Error>

Get all secrets

Returns​

UseQueryResult<any, Error>

useSendInvite()​

useSendInvite: (options?) => UseMutationResult<unknown, Error, { brand: string; email: string; firstName: string; lastName: string; message: string; }, unknown>

Send an invite (mutation)

Parameters​

options?​

UseMutationOptions<unknown, Error, { brand: string; email: string; firstName: string; lastName: string; message: string; }, unknown>

Mutation options

Returns​

UseMutationResult<unknown, Error, { brand: string; email: string; firstName: string; lastName: string; message: string; }, unknown>

useSendInviteToContact()​

useSendInviteToContact: () => UseMutationResult<any, Error, { contactId: string; message: string; }, unknown>

Send invite to contact

Returns​

UseMutationResult<any, Error, { contactId: string; message: string; }, unknown>

useSendLinkedinConnectionRequest()​

useSendLinkedinConnectionRequest: () => UseMutationResult<any, Error, { contactId: string; message: string; }, unknown>

Send LinkedIn connection request to contact

Returns​

UseMutationResult<any, Error, { contactId: string; message: string; }, unknown>

useSendOutboundEmailToUser()​

useSendOutboundEmailToUser: () => UseMutationResult<any, Error, { content: string; recipient: string; subject: string; userId: string; }, unknown>

Send individual outbound email to a user

Returns​

UseMutationResult<any, Error, { content: string; recipient: string; subject: string; userId: string; }, unknown>

useSetCourseItems()​

useSetCourseItems: () => UseMutationResult<any, Error, { courseId: string; itemIds: string[]; }, unknown>

Set the curriculum items for a course

Returns​

UseMutationResult<any, Error, { courseId: string; itemIds: string[]; }, unknown>

useSpace()​

useSpace: (spaceId) => UseQueryResult<IAnySpace, Error>

Get space by ID

Parameters​

spaceId​

string

Returns​

UseQueryResult<IAnySpace, Error>

useSpaceItems()​

useSpaceItems: (spaceId) => UseQueryResult<any[], Error>

Get space items

Parameters​

spaceId​

string

Returns​

UseQueryResult<any[], Error>

useStripePrices()​

useStripePrices: (options?) => UseQueryResult<unknown[], Error>

Get Stripe pricing information

Parameters​

options?​

Omit<UseQueryOptions<unknown[], Error, unknown[], readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown[], Error>

useStudent()​

useStudent: (courseId, studentId, options?) => UseQueryResult<unknown, Error>

Get a student in a course

Parameters​

courseId​

string

studentId​

string

options?​

Omit<UseQueryOptions<unknown, Error, unknown, readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown, Error>

useSubscribeUserToOutbounds()​

useSubscribeUserToOutbounds: () => UseMutationResult<any, Error, string, unknown>

Subscribe a user to outbound communications

Returns​

UseMutationResult<any, Error, string, unknown>

useTeam()​

useTeam: (teamId, organizationId) => UseQueryResult<ITeam, Error>

Get team by ID

Parameters​

teamId​

string

organizationId​

string

Returns​

UseQueryResult<ITeam, Error>

useTeamByHandle()​

useTeamByHandle: (handle) => UseQueryResult<ITeam | null, Error>

Get team by handle

Parameters​

handle​

string

Returns​

UseQueryResult<ITeam | null, Error>

useTeamsByOrganization()​

useTeamsByOrganization: (organizationId) => UseQueryResult<any, Error>

Get teams by organization

Parameters​

organizationId​

string

Returns​

UseQueryResult<any, Error>

useToken()​

useToken: (tokenId) => UseQueryResult<IIAMToken | null | undefined, Error>

Get single token by ID

Parameters​

tokenId​

string

Returns​

UseQueryResult<IIAMToken | null | undefined, Error>

useTokens()​

useTokens: () => UseQueryResult<any, Error>

Get all tokens

Returns​

UseQueryResult<any, Error>

useTryBulkEmailsOutbounds()​

useTryBulkEmailsOutbounds: () => UseMutationResult<any, Error, string, unknown>

Try bulk emails (test mode) for outbound campaign

Returns​

UseMutationResult<any, Error, string, unknown>

useUnassignRoleFromUser()​

useUnassignRoleFromUser: () => UseMutationResult<any, Error, { roleName: string; userId: string; }, unknown>

Unassign role from user

Returns​

UseMutationResult<any, Error, { roleName: string; userId: string; }, unknown>

useUnassignTagFromContact()​

useUnassignTagFromContact: () => UseMutationResult<any, Error, { contactId: string; tagName: string; }, unknown>

Remove tag from contact

Returns​

UseMutationResult<any, Error, { contactId: string; tagName: string; }, unknown>

useUnlinkUserFromContact()​

useUnlinkUserFromContact: () => UseMutationResult<any, Error, { contactId: string; userId: string; }, unknown>

Unlink user from contact

Returns​

UseMutationResult<any, Error, { contactId: string; userId: string; }, unknown>

useUnsubscribeContactFromOutbounds()​

useUnsubscribeContactFromOutbounds: () => UseMutationResult<any, Error, string, unknown>

Unsubscribe a contact from outbound communications

Returns​

UseMutationResult<any, Error, string, unknown>

useUnsubscribeInviteeFromOutbounds()​

useUnsubscribeInviteeFromOutbounds: () => UseMutationResult<any, Error, string, unknown>

Unsubscribe an invitee from outbound communications

Returns​

UseMutationResult<any, Error, string, unknown>

useUnsubscribeUserFromOutbounds()​

useUnsubscribeUserFromOutbounds: () => UseMutationResult<any, Error, string, unknown>

Unsubscribe a user from outbound communications

Returns​

UseMutationResult<any, Error, string, unknown>

useUpdateCell()​

useUpdateCell: () => UseMutationResult<any, Error, { description: string; id: string; name: string; outputshotData?: string; outputshotUrl?: string; source: string; spaceId: string; }, unknown>

Update cell

Returns​

UseMutationResult<any, Error, { description: string; id: string; name: string; outputshotData?: string; outputshotUrl?: string; source: string; spaceId: string; }, unknown>

useUpdateContact()​

useUpdateContact: () => UseMutationResult<any, Error, { contact: IContact; contactId: string; }, unknown>

Update contact

Returns​

UseMutationResult<any, Error, { contact: IContact; contactId: string; }, unknown>

useUpdateCourse()​

useUpdateCourse: () => UseMutationResult<any, Error, { courseId: string; description: string; name: string; }, unknown>

Update course

Returns​

UseMutationResult<any, Error, { courseId: string; description: string; name: string; }, unknown>

useUpdateDataset()​

useUpdateDataset: () => UseMutationResult<any, Error, { description: string; id: string; name: string; spaceId?: string; }, unknown>

Update dataset

Returns​

UseMutationResult<any, Error, { description: string; id: string; name: string; spaceId?: string; }, unknown>

useUpdateDatasource()​

useUpdateDatasource: () => UseMutationResult<any, Error, IDatasource, unknown>

Update datasource

Returns​

UseMutationResult<any, Error, IDatasource, unknown>

useUpdateDocument()​

useUpdateDocument: () => UseMutationResult<any, Error, { description: string; id: string; name: string; }, unknown>

Update document

Returns​

UseMutationResult<any, Error, { description: string; id: string; name: string; }, unknown>

useUpdateDocumentModel()​

useUpdateDocumentModel: () => UseMutationResult<any, Error, { id: string; model: unknown; }, unknown>

Update document model

Returns​

UseMutationResult<any, Error, { id: string; model: unknown; }, unknown>

useUpdateExercise()​

useUpdateExercise: () => UseMutationResult<any, Error, { codePre?: string; codeQuestion?: string; codeSolution?: string; codeTest?: string; description: string; help?: string; id: string; name: string; }, unknown>

Update exercise

Returns​

UseMutationResult<any, Error, { codePre?: string; codeQuestion?: string; codeSolution?: string; codeTest?: string; description: string; help?: string; id: string; name: string; }, unknown>

useUpdateExercisePoints()​

useUpdateExercisePoints: () => UseMutationResult<any, Error, { codeStudent: string; exerciseId: string; points: number; }, unknown>

Grade an exercise by assigning points to student code

Returns​

UseMutationResult<any, Error, { codeStudent: string; exerciseId: string; points: number; }, unknown>

useUpdateMe()​

useUpdateMe: () => UseMutationResult<any, Error, { email: string; firstName: string; lastName: string; }, unknown>

Update current user profile

Returns​

UseMutationResult<any, Error, { email: string; firstName: string; lastName: string; }, unknown>

useUpdateNotebook()​

useUpdateNotebook: () => UseMutationResult<any, Error, { description: string; id: string; name: string; }, unknown>

Update notebook with optimistic update

Returns​

UseMutationResult<any, Error, { description: string; id: string; name: string; }, unknown>

useUpdateNotebookModel()​

useUpdateNotebookModel: () => UseMutationResult<any, Error, { nbformat: unknown; notebookId: string; }, unknown>

Update notebook model

Returns​

UseMutationResult<any, Error, { nbformat: unknown; notebookId: string; }, unknown>

useUpdateOrganization()​

useUpdateOrganization: () => UseMutationResult<any, Error, Partial<IAnyOrganization>, unknown>

Update organization with optimistic update

Returns​

UseMutationResult<any, Error, Partial<IAnyOrganization>, unknown>

useUpdateOrganizationSpace()​

useUpdateOrganizationSpace: () => UseMutationResult<any, Error, { organizationId: string; spaceId: string; updates: Partial<IAnySpace>; }, unknown>

Update organization space

Returns​

UseMutationResult<any, Error, { organizationId: string; spaceId: string; updates: Partial<IAnySpace>; }, unknown>

useUpdatePage()​

useUpdatePage: () => UseMutationResult<any, Error, Pick<IPage, "id" | "name" | "tags" | "description">, unknown>

Update page

Returns​

UseMutationResult<any, Error, Pick<IPage, "id" | "name" | "tags" | "description">, unknown>

useUpdateSecret()​

useUpdateSecret: () => UseMutationResult<any, Error, ISecret, unknown>

Update secret

Returns​

UseMutationResult<any, Error, ISecret, unknown>

useUpdateSpace()​

useUpdateSpace: () => UseMutationResult<any, Error, Partial<IAnySpace>, unknown>

Update space with optimistic update

Returns​

UseMutationResult<any, Error, Partial<IAnySpace>, unknown>

useUpdateTeam()​

useUpdateTeam: () => UseMutationResult<any, Error, Partial<ITeam>, unknown>

Update team

Returns​

UseMutationResult<any, Error, Partial<ITeam>, unknown>

useUpdateToken()​

useUpdateToken: () => UseMutationResult<any, Error, IIAMToken, unknown>

Update token

Returns​

UseMutationResult<any, Error, IIAMToken, unknown>

useUpdateUserCredits()​

useUpdateUserCredits: () => UseMutationResult<any, Error, { brand?: string; credits: number; userId: string; }, unknown>

Update user credits

Returns​

UseMutationResult<any, Error, { brand?: string; credits: number; userId: string; }, unknown>

useUpdateUserCreditsQuota()​

useUpdateUserCreditsQuota: () => UseMutationResult<any, Error, { quota?: number; userId: string; }, unknown>

Update user credits quota

Returns​

UseMutationResult<any, Error, { quota?: number; userId: string; }, unknown>

useUpdateUserOnboarding()​

useUpdateUserOnboarding: () => UseMutationResult<any, Error, IUserOnboarding, unknown>

Update user onboarding

Returns​

UseMutationResult<any, Error, IUserOnboarding, unknown>

useUpdateUserSettings()​

useUpdateUserSettings: () => UseMutationResult<any, Error, { settings: IUserSettings; userId: string; }, unknown>

Update user settings

Returns​

UseMutationResult<any, Error, { settings: IUserSettings; userId: string; }, unknown>

useUsages()​

useUsages: (options?) => UseQueryResult<unknown[], Error>

Get current user's usage data

Parameters​

options?​

Omit<UseQueryOptions<unknown[], Error, unknown[], readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown[], Error>

useUsagesForUser()​

useUsagesForUser: (userId, options?) => UseQueryResult<unknown[], Error>

Get usage data for specific user

Parameters​

userId​

string

options?​

Omit<UseQueryOptions<unknown[], Error, unknown[], readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown[], Error>

useUser()​

useUser: (userId) => UseQueryResult<IUser | undefined, Error>

Get user by ID

Parameters​

userId​

string

User ID

Returns​

UseQueryResult<IUser | undefined, Error>

Example​

const { data: user, isPending, isError } = useUser('user-123');

useUserByHandle()​

useUserByHandle: (handle) => UseQueryResult<any, Error>

Get user by handle

Parameters​

handle​

string

User handle

Returns​

UseQueryResult<any, Error>

useUserCredits()​

useUserCredits: (userId) => UseQueryResult<any, Error>

Get user credits

Parameters​

userId​

string

Returns​

UseQueryResult<any, Error>

useUserOrganizationById()​

useUserOrganizationById: (organizationId) => any

Get user organization by ID (helper method)

Parameters​

organizationId​

string

Returns​

any

useUserOrganizations()​

useUserOrganizations: () => UseQueryResult<any, Error>

Get user's organizations

Returns​

UseQueryResult<any, Error>

useUserSpace()​

useUserSpace: (spaceId) => UseQueryResult<IAnySpace | null, Error>

Get user space (personal space)

Parameters​

spaceId​

string

Returns​

UseQueryResult<IAnySpace | null, Error>

useUserSpaceByHandle()​

useUserSpaceByHandle: (handle) => UseQueryResult<{ } | null, Error>

Get user space by handle (personal space) This reads from the cache populated by useUserSpaces()

Parameters​

handle​

string

Returns​

UseQueryResult<{ } | null, Error>

useUserSpaces()​

useUserSpaces: () => UseQueryResult<any, Error>

Get user spaces

Returns​

UseQueryResult<any, Error>

useUserSurveys()​

useUserSurveys: (userId, options?) => UseQueryResult<unknown, Error>

Get user surveys

Parameters​

userId​

string

options?​

Omit<UseQueryOptions<unknown, Error, unknown, readonly unknown[]>, "queryKey" | "queryFn">

Returns​

UseQueryResult<unknown, Error>

useValidateUserMFACode()​

useValidateUserMFACode: () => UseMutationResult<any, Error, { code: string; userUid: string; }, unknown>

Validate MFA code for a user

Returns​

UseMutationResult<any, Error, { code: string; userUid: string; }, unknown>

useWhoami()​

useWhoami: () => UseQueryResult<any, Error>

Whoami query

Returns​

UseQueryResult<any, Error>