Hooks Public

Name: Hooks Public
Author: constructive-io

constructive-io/constructive

1 installs
52 repo stars
Updated August 5, 2026
constructive-io/constructive

React Query hooks for the public API providing typed query and mutation hooks for 129 tables and 71 custom operations.

About

hookspublic React Query hooks for the public API provide typed query and mutation hooks for 129 tables and 71 custom operations.. Comprehensive frontend access to public endpoints.

Typed hooks for public entities
Full React Query integration for public API

Hooks Public by the numbers

1 all-time installs (skills.sh)
Ranked #1,912 of 2,245 Frontend Development skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

npx skills add https://github.com/constructive-io/constructive --skill hooks-public

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/constructive-io/constructive/hooks-public.svg)](https://skillselion.com/skills/constructive-io/constructive/hooks-public)

Installs	1
repo stars	★ 52
Last updated	August 5, 2026
Repository	constructive-io/constructive ↗

What it does

React Query hooks for the public API providing typed query and mutation hooks for 129 tables and 71 custom operations.

Files

references/

SKILL.mdMarkdownGitHub ↗

hooks-public

React Query hooks for the public API — provides typed query and mutation hooks for 129 tables and 71 custom operations

Usage

// Import hooks
import { useOrgGetManagersQuery } from './hooks';

// Query hooks: use<Model>Query, use<Model>sQuery
// Mutation hooks: useCreate<Model>Mutation, useUpdate<Model>Mutation, useDelete<Model>Mutation

const { data, isLoading } = useOrgGetManagersQuery({
  selection: { fields: { id: true } },
});

Examples

Query records

const { data, isLoading } = useOrgGetManagersQuery({
  selection: { fields: { id: true } },
});

References

See the references/ directory for detailed per-entity API documentation:

org-get-managers-record
org-get-subordinates-record
get-all-record
app-permission
org-permission
object
app-level-requirement
database
schema
table
check-constraint
field
spatial-relation
foreign-key-constraint
full-text-search
index
policy
primary-key-constraint
table-grant
trigger
unique-constraint
view
view-table
view-grant
view-rule
embedding-chunk
secure-table-provision
relation-provision
session-secrets-module
identity-providers-module
schema-grant
default-privilege
enum
api-schema
api-module
domain
site-metadatum
site-module
site-theme
trigger-function
database-transfer
api
site
app
connected-accounts-module
crypto-addresses-module
crypto-auth-module
default-ids-module
denormalized-table-field
emails-module
encrypted-secrets-module
invites-module
levels-module
limits-module
membership-types-module
memberships-module
permissions-module
phone-numbers-module
profiles-module
secrets-module
sessions-module
user-auth-module
users-module
blueprint
blueprint-template
blueprint-construction
storage-module
entity-type-provision
webauthn-credentials-module
webauthn-auth-module
notifications-module
database-provision-module
app-admin-grant
app-owner-grant
app-grant
org-membership
org-member
org-admin-grant
org-owner-grant
org-member-profile
org-grant
org-chart-edge
org-chart-edge-grant
org-permission-default
app-limit
org-limit
org-limit-aggregate
app-step
app-achievement
app-level
email
phone-number
crypto-address
webauthn-credential
app-invite
app-claimed-invite
org-invite
org-claimed-invite
audit-log
agent-thread
agent-message
agent-task
role-type
identity-provider
ref
store
app-permission-default
membership-type
migrate-file
devices-module
node-type-registry
app-limit-default
org-limit-default
user-connected-account
commit
rate-limits-module
app-membership-default
org-membership-default
app-limit-event
org-limit-event
plans-module
rls-module
sql-action
billing-module
ast-migration
user
org-membership-setting
app-membership
hierarchy-module
current-user-id
current-user-agent
current-ip-address
require-step-up
app-permissions-get-padded-mask
org-permissions-get-padded-mask
steps-achieved
rev-parse
resolve-blueprint-field
org-is-manager-of
app-permissions-get-mask
org-permissions-get-mask
resolve-blueprint-table
app-permissions-get-mask-by-names
org-permissions-get-mask-by-names
app-permissions-get-by-mask
org-permissions-get-by-mask
get-all-objects-from-root
get-path-objects-from-root
get-object-at-path
steps-required
current-user
send-account-deletion-email
sign-out
accept-database-transfer
cancel-database-transfer
reject-database-transfer
disconnect-account
revoke-api-key
revoke-session
verify-password
verify-totp
submit-app-invite-code
submit-org-invite-code
check-password
confirm-delete-account
set-password
verify-email
freeze-objects
init-empty-repo
construct-blueprint
provision-new-user
reset-password
remove-node-at-path
copy-template-to-blueprint
provision-spatial-relation
bootstrap-user
set-field-order
provision-unique-constraint
provision-full-text-search
provision-index
set-data-at-path
set-props-and-commit
provision-database-with-user
insert-node-at-path
update-node-at-path
set-and-commit
provision-relation
apply-rls
sign-in-cross-origin
create-user-database
extend-token-expires
create-api-key
send-verification-email
forgot-password
sign-up
request-cross-origin-token
sign-in
provision-table
request-upload-url
provision-bucket

acceptDatabaseTransfer

React Query mutation hook for acceptDatabaseTransfer

Usage

const { mutate } = useAcceptDatabaseTransferMutation(); mutate({ input: { transferId: '<UUID>' } });

Examples

Use useAcceptDatabaseTransferMutation

const { mutate, isLoading } = useAcceptDatabaseTransferMutation();
mutate({ input: { transferId: '<UUID>' } });

agentMessage

A single message in an agent_thread. The full client-rendered content (TextPart and ToolPart, including the ToolPart state machine and inline approval object) lives in the parts jsonb column — there is no separate agent_tool_call or agent_tool_approval table in v1. Cascade-deleted with the parent thread; RLS is owner-only.

Usage

useAgentMessagesQuery({ selection: { fields: { threadId: true, entityId: true, authorRole: true, id: true, createdAt: true, updatedAt: true, ownerId: true, parts: true } } })
useAgentMessageQuery({ id: '<UUID>', selection: { fields: { threadId: true, entityId: true, authorRole: true, id: true, createdAt: true, updatedAt: true, ownerId: true, parts: true } } })
useCreateAgentMessageMutation({ selection: { fields: { id: true } } })
useUpdateAgentMessageMutation({ selection: { fields: { id: true } } })
useDeleteAgentMessageMutation({})

Examples

List all agentMessages

const { data, isLoading } = useAgentMessagesQuery({
  selection: { fields: { threadId: true, entityId: true, authorRole: true, id: true, createdAt: true, updatedAt: true, ownerId: true, parts: true } },
});

Create a agentMessage

const { mutate } = useCreateAgentMessageMutation({
  selection: { fields: { id: true } },
});
mutate({ threadId: '<UUID>', entityId: '<UUID>', authorRole: '<String>', ownerId: '<UUID>', parts: '<JSON>' });

agentTask

An agent- or user-authored todo item attached to an agent_thread. Captures the planning surface for agent-mode conversations: each row is a single discrete unit of work with a status lifecycle (pending → in-progress → done|failed). Cascade-deleted with the parent thread; RLS is owner-only.

Usage

useAgentTasksQuery({ selection: { fields: { threadId: true, entityId: true, description: true, source: true, error: true, id: true, createdAt: true, updatedAt: true, ownerId: true, status: true } } })
useAgentTaskQuery({ id: '<UUID>', selection: { fields: { threadId: true, entityId: true, description: true, source: true, error: true, id: true, createdAt: true, updatedAt: true, ownerId: true, status: true } } })
useCreateAgentTaskMutation({ selection: { fields: { id: true } } })
useUpdateAgentTaskMutation({ selection: { fields: { id: true } } })
useDeleteAgentTaskMutation({})

Examples

List all agentTasks

const { data, isLoading } = useAgentTasksQuery({
  selection: { fields: { threadId: true, entityId: true, description: true, source: true, error: true, id: true, createdAt: true, updatedAt: true, ownerId: true, status: true } },
});

Create a agentTask

const { mutate } = useCreateAgentTaskMutation({
  selection: { fields: { id: true } },
});
mutate({ threadId: '<UUID>', entityId: '<UUID>', description: '<String>', source: '<String>', error: '<String>', ownerId: '<UUID>', status: '<String>' });

agentThread

Top-level AI/LLM conversation. Owns the chat-mode + model + system-prompt snapshot for the lifetime of the conversation, and is the entity-scoping anchor — descendants (agent_message, agent_task) inherit entity_id from this row via DataInheritFromParent. RLS is owner-only (AuthzDirectOwner); entity_id is a grouping dimension, not a security dimension.

Usage

useAgentThreadsQuery({ selection: { fields: { title: true, mode: true, model: true, systemPrompt: true, id: true, createdAt: true, updatedAt: true, ownerId: true, entityId: true, status: true } } })
useAgentThreadQuery({ id: '<UUID>', selection: { fields: { title: true, mode: true, model: true, systemPrompt: true, id: true, createdAt: true, updatedAt: true, ownerId: true, entityId: true, status: true } } })
useCreateAgentThreadMutation({ selection: { fields: { id: true } } })
useUpdateAgentThreadMutation({ selection: { fields: { id: true } } })
useDeleteAgentThreadMutation({})

Examples

List all agentThreads

const { data, isLoading } = useAgentThreadsQuery({
  selection: { fields: { title: true, mode: true, model: true, systemPrompt: true, id: true, createdAt: true, updatedAt: true, ownerId: true, entityId: true, status: true } },
});

Create a agentThread

const { mutate } = useCreateAgentThreadMutation({
  selection: { fields: { id: true } },
});
mutate({ title: '<String>', mode: '<String>', model: '<String>', systemPrompt: '<String>', ownerId: '<UUID>', entityId: '<UUID>', status: '<String>' });

apiModule

Server-side module configuration for an API endpoint; stores module name and JSON settings used by the application server

Usage

useApiModulesQuery({ selection: { fields: { id: true, databaseId: true, apiId: true, name: true, data: true } } })
useApiModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, apiId: true, name: true, data: true } } })
useCreateApiModuleMutation({ selection: { fields: { id: true } } })
useUpdateApiModuleMutation({ selection: { fields: { id: true } } })
useDeleteApiModuleMutation({})

Examples

List all apiModules

const { data, isLoading } = useApiModulesQuery({
  selection: { fields: { id: true, databaseId: true, apiId: true, name: true, data: true } },
});

Create a apiModule

const { mutate } = useCreateApiModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', apiId: '<UUID>', name: '<String>', data: '<JSON>' });

apiSchema

Join table linking APIs to the database schemas they expose; controls which schemas are accessible through each API

Usage

useApiSchemasQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, apiId: true } } })
useApiSchemaQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, apiId: true } } })
useCreateApiSchemaMutation({ selection: { fields: { id: true } } })
useUpdateApiSchemaMutation({ selection: { fields: { id: true } } })
useDeleteApiSchemaMutation({})

Examples

List all apiSchemas

const { data, isLoading } = useApiSchemasQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, apiId: true } },
});

Create a apiSchema

const { mutate } = useCreateApiSchemaMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', apiId: '<UUID>' });

api

API endpoint configurations: each record defines a PostGraphile/PostgREST API with its database role and public access settings

Usage

useApisQuery({ selection: { fields: { id: true, databaseId: true, name: true, dbname: true, roleName: true, anonRole: true, isPublic: true } } })
useApiQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, name: true, dbname: true, roleName: true, anonRole: true, isPublic: true } } })
useCreateApiMutation({ selection: { fields: { id: true } } })
useUpdateApiMutation({ selection: { fields: { id: true } } })
useDeleteApiMutation({})

Examples

List all apis

const { data, isLoading } = useApisQuery({
  selection: { fields: { id: true, databaseId: true, name: true, dbname: true, roleName: true, anonRole: true, isPublic: true } },
});

Create a api

const { mutate } = useCreateApiMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', name: '<String>', dbname: '<String>', roleName: '<String>', anonRole: '<String>', isPublic: '<Boolean>' });

appAchievement

Aggregated user progress for level requirements, tallying the total count; updated via triggers and should not be modified manually

Usage

useAppAchievementsQuery({ selection: { fields: { id: true, actorId: true, name: true, count: true, createdAt: true, updatedAt: true } } })
useAppAchievementQuery({ id: '<UUID>', selection: { fields: { id: true, actorId: true, name: true, count: true, createdAt: true, updatedAt: true } } })
useCreateAppAchievementMutation({ selection: { fields: { id: true } } })
useUpdateAppAchievementMutation({ selection: { fields: { id: true } } })
useDeleteAppAchievementMutation({})

Examples

List all appAchievements

const { data, isLoading } = useAppAchievementsQuery({
  selection: { fields: { id: true, actorId: true, name: true, count: true, createdAt: true, updatedAt: true } },
});

Create a appAchievement

const { mutate } = useCreateAppAchievementMutation({
  selection: { fields: { id: true } },
});
mutate({ actorId: '<UUID>', name: '<String>', count: '<Int>' });

appAdminGrant

Records of admin role grants and revocations between members

Usage

useAppAdminGrantsQuery({ selection: { fields: { id: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } } })
useAppAdminGrantQuery({ id: '<UUID>', selection: { fields: { id: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } } })
useCreateAppAdminGrantMutation({ selection: { fields: { id: true } } })
useUpdateAppAdminGrantMutation({ selection: { fields: { id: true } } })
useDeleteAppAdminGrantMutation({})

Examples

List all appAdminGrants

const { data, isLoading } = useAppAdminGrantsQuery({
  selection: { fields: { id: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } },
});

Create a appAdminGrant

const { mutate } = useCreateAppAdminGrantMutation({
  selection: { fields: { id: true } },
});
mutate({ isGrant: '<Boolean>', actorId: '<UUID>', grantorId: '<UUID>' });

appClaimedInvite

Records of successfully claimed invitations, linking senders to receivers

Usage

useAppClaimedInvitesQuery({ selection: { fields: { id: true, data: true, senderId: true, receiverId: true, createdAt: true, updatedAt: true } } })
useAppClaimedInviteQuery({ id: '<UUID>', selection: { fields: { id: true, data: true, senderId: true, receiverId: true, createdAt: true, updatedAt: true } } })
useCreateAppClaimedInviteMutation({ selection: { fields: { id: true } } })
useUpdateAppClaimedInviteMutation({ selection: { fields: { id: true } } })
useDeleteAppClaimedInviteMutation({})

Examples

List all appClaimedInvites

const { data, isLoading } = useAppClaimedInvitesQuery({
  selection: { fields: { id: true, data: true, senderId: true, receiverId: true, createdAt: true, updatedAt: true } },
});

Create a appClaimedInvite

const { mutate } = useCreateAppClaimedInviteMutation({
  selection: { fields: { id: true } },
});
mutate({ data: '<JSON>', senderId: '<UUID>', receiverId: '<UUID>' });

appGrant

Records of individual permission grants and revocations for members via bitmask

Usage

useAppGrantsQuery({ selection: { fields: { id: true, permissions: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } } })
useAppGrantQuery({ id: '<UUID>', selection: { fields: { id: true, permissions: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } } })
useCreateAppGrantMutation({ selection: { fields: { id: true } } })
useUpdateAppGrantMutation({ selection: { fields: { id: true } } })
useDeleteAppGrantMutation({})

Examples

List all appGrants

const { data, isLoading } = useAppGrantsQuery({
  selection: { fields: { id: true, permissions: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } },
});

Create a appGrant

const { mutate } = useCreateAppGrantMutation({
  selection: { fields: { id: true } },
});
mutate({ permissions: '<BitString>', isGrant: '<Boolean>', actorId: '<UUID>', grantorId: '<UUID>' });

appInvite

Invitation records sent to prospective members via email, with token-based redemption and expiration

Usage

useAppInvitesQuery({ selection: { fields: { id: true, email: true, senderId: true, inviteToken: true, inviteValid: true, inviteLimit: true, inviteCount: true, multiple: true, data: true, profileId: true, expiresAt: true, createdAt: true, updatedAt: true } } })
useAppInviteQuery({ id: '<UUID>', selection: { fields: { id: true, email: true, senderId: true, inviteToken: true, inviteValid: true, inviteLimit: true, inviteCount: true, multiple: true, data: true, profileId: true, expiresAt: true, createdAt: true, updatedAt: true } } })
useCreateAppInviteMutation({ selection: { fields: { id: true } } })
useUpdateAppInviteMutation({ selection: { fields: { id: true } } })
useDeleteAppInviteMutation({})

Examples

List all appInvites

const { data, isLoading } = useAppInvitesQuery({
  selection: { fields: { id: true, email: true, senderId: true, inviteToken: true, inviteValid: true, inviteLimit: true, inviteCount: true, multiple: true, data: true, profileId: true, expiresAt: true, createdAt: true, updatedAt: true } },
});

Create a appInvite

const { mutate } = useCreateAppInviteMutation({
  selection: { fields: { id: true } },
});
mutate({ email: '<Email>', senderId: '<UUID>', inviteToken: '<String>', inviteValid: '<Boolean>', inviteLimit: '<Int>', inviteCount: '<Int>', multiple: '<Boolean>', data: '<JSON>', profileId: '<UUID>', expiresAt: '<Datetime>' });

appLevelRequirement

Defines the specific requirements that must be met to achieve a level

Usage

useAppLevelRequirementsQuery({ selection: { fields: { id: true, name: true, level: true, description: true, requiredCount: true, priority: true, createdAt: true, updatedAt: true } } })
useAppLevelRequirementQuery({ id: '<UUID>', selection: { fields: { id: true, name: true, level: true, description: true, requiredCount: true, priority: true, createdAt: true, updatedAt: true } } })
useCreateAppLevelRequirementMutation({ selection: { fields: { id: true } } })
useUpdateAppLevelRequirementMutation({ selection: { fields: { id: true } } })
useDeleteAppLevelRequirementMutation({})

Examples

List all appLevelRequirements

const { data, isLoading } = useAppLevelRequirementsQuery({
  selection: { fields: { id: true, name: true, level: true, description: true, requiredCount: true, priority: true, createdAt: true, updatedAt: true } },
});

Create a appLevelRequirement

const { mutate } = useCreateAppLevelRequirementMutation({
  selection: { fields: { id: true } },
});
mutate({ name: '<String>', level: '<String>', description: '<String>', requiredCount: '<Int>', priority: '<Int>' });

appLevel

Defines available levels that users can achieve by completing requirements

Usage

useAppLevelsQuery({ selection: { fields: { id: true, name: true, description: true, image: true, ownerId: true, createdAt: true, updatedAt: true } } })
useAppLevelQuery({ id: '<UUID>', selection: { fields: { id: true, name: true, description: true, image: true, ownerId: true, createdAt: true, updatedAt: true } } })
useCreateAppLevelMutation({ selection: { fields: { id: true } } })
useUpdateAppLevelMutation({ selection: { fields: { id: true } } })
useDeleteAppLevelMutation({})

Examples

List all appLevels

const { data, isLoading } = useAppLevelsQuery({
  selection: { fields: { id: true, name: true, description: true, image: true, ownerId: true, createdAt: true, updatedAt: true } },
});

Create a appLevel

const { mutate } = useCreateAppLevelMutation({
  selection: { fields: { id: true } },
});
mutate({ name: '<String>', description: '<String>', image: '<Image>', ownerId: '<UUID>' });

appLimitDefault

Default maximum values for each named limit, applied when no per-actor override exists

Usage

useAppLimitDefaultsQuery({ selection: { fields: { id: true, name: true, max: true, softMax: true } } })
useAppLimitDefaultQuery({ id: '<UUID>', selection: { fields: { id: true, name: true, max: true, softMax: true } } })
useCreateAppLimitDefaultMutation({ selection: { fields: { id: true } } })
useUpdateAppLimitDefaultMutation({ selection: { fields: { id: true } } })
useDeleteAppLimitDefaultMutation({})

Examples

List all appLimitDefaults

const { data, isLoading } = useAppLimitDefaultsQuery({
  selection: { fields: { id: true, name: true, max: true, softMax: true } },
});

Create a appLimitDefault

const { mutate } = useCreateAppLimitDefaultMutation({
  selection: { fields: { id: true } },
});
mutate({ name: '<String>', max: '<BigInt>', softMax: '<BigInt>' });

appLimitEvent

Append-only log of limit events for historical reporting and audit

Usage

useAppLimitEventsQuery({ selection: { fields: { name: true, actorId: true, entityId: true, eventType: true, delta: true, numBefore: true, numAfter: true, maxAtEvent: true, reason: true } } })
useCreateAppLimitEventMutation({ selection: { fields: { id: true } } })

Examples

List all appLimitEvents

const { data, isLoading } = useAppLimitEventsQuery({
  selection: { fields: { name: true, actorId: true, entityId: true, eventType: true, delta: true, numBefore: true, numAfter: true, maxAtEvent: true, reason: true } },
});

Create a appLimitEvent

const { mutate } = useCreateAppLimitEventMutation({
  selection: { fields: { id: true } },
});
mutate({ name: '<String>', actorId: '<UUID>', entityId: '<UUID>', eventType: '<String>', delta: '<BigInt>', numBefore: '<BigInt>', numAfter: '<BigInt>', maxAtEvent: '<BigInt>', reason: '<String>' });

appLimit

Tracks per-actor usage counts against configurable maximum limits

Usage

useAppLimitsQuery({ selection: { fields: { id: true, name: true, actorId: true, num: true, max: true, softMax: true, windowStart: true, windowDuration: true } } })
useAppLimitQuery({ id: '<UUID>', selection: { fields: { id: true, name: true, actorId: true, num: true, max: true, softMax: true, windowStart: true, windowDuration: true } } })
useCreateAppLimitMutation({ selection: { fields: { id: true } } })
useUpdateAppLimitMutation({ selection: { fields: { id: true } } })
useDeleteAppLimitMutation({})

Examples

List all appLimits

const { data, isLoading } = useAppLimitsQuery({
  selection: { fields: { id: true, name: true, actorId: true, num: true, max: true, softMax: true, windowStart: true, windowDuration: true } },
});

Create a appLimit

const { mutate } = useCreateAppLimitMutation({
  selection: { fields: { id: true } },
});
mutate({ name: '<String>', actorId: '<UUID>', num: '<BigInt>', max: '<BigInt>', softMax: '<BigInt>', windowStart: '<Datetime>', windowDuration: '<Interval>' });

appMembershipDefault

Default membership settings per entity, controlling initial approval and verification state for new members

Usage

useAppMembershipDefaultsQuery({ selection: { fields: { id: true, createdAt: true, updatedAt: true, createdBy: true, updatedBy: true, isApproved: true, isVerified: true } } })
useAppMembershipDefaultQuery({ id: '<UUID>', selection: { fields: { id: true, createdAt: true, updatedAt: true, createdBy: true, updatedBy: true, isApproved: true, isVerified: true } } })
useCreateAppMembershipDefaultMutation({ selection: { fields: { id: true } } })
useUpdateAppMembershipDefaultMutation({ selection: { fields: { id: true } } })
useDeleteAppMembershipDefaultMutation({})

Examples

List all appMembershipDefaults

const { data, isLoading } = useAppMembershipDefaultsQuery({
  selection: { fields: { id: true, createdAt: true, updatedAt: true, createdBy: true, updatedBy: true, isApproved: true, isVerified: true } },
});

Create a appMembershipDefault

const { mutate } = useCreateAppMembershipDefaultMutation({
  selection: { fields: { id: true } },
});
mutate({ createdBy: '<UUID>', updatedBy: '<UUID>', isApproved: '<Boolean>', isVerified: '<Boolean>' });

appMembership

Tracks membership records linking actors to entities with permission bitmasks, ownership, and admin status

Usage

useAppMembershipsQuery({ selection: { fields: { id: true, createdAt: true, updatedAt: true, createdBy: true, updatedBy: true, isApproved: true, isBanned: true, isDisabled: true, isVerified: true, isActive: true, isOwner: true, isAdmin: true, permissions: true, granted: true, actorId: true, profileId: true } } })
useAppMembershipQuery({ id: '<UUID>', selection: { fields: { id: true, createdAt: true, updatedAt: true, createdBy: true, updatedBy: true, isApproved: true, isBanned: true, isDisabled: true, isVerified: true, isActive: true, isOwner: true, isAdmin: true, permissions: true, granted: true, actorId: true, profileId: true } } })
useCreateAppMembershipMutation({ selection: { fields: { id: true } } })
useUpdateAppMembershipMutation({ selection: { fields: { id: true } } })
useDeleteAppMembershipMutation({})

Examples

List all appMemberships

const { data, isLoading } = useAppMembershipsQuery({
  selection: { fields: { id: true, createdAt: true, updatedAt: true, createdBy: true, updatedBy: true, isApproved: true, isBanned: true, isDisabled: true, isVerified: true, isActive: true, isOwner: true, isAdmin: true, permissions: true, granted: true, actorId: true, profileId: true } },
});

Create a appMembership

const { mutate } = useCreateAppMembershipMutation({
  selection: { fields: { id: true } },
});
mutate({ createdBy: '<UUID>', updatedBy: '<UUID>', isApproved: '<Boolean>', isBanned: '<Boolean>', isDisabled: '<Boolean>', isVerified: '<Boolean>', isActive: '<Boolean>', isOwner: '<Boolean>', isAdmin: '<Boolean>', permissions: '<BitString>', granted: '<BitString>', actorId: '<UUID>', profileId: '<UUID>' });

appOwnerGrant

Records of ownership transfers and grants between members

Usage

useAppOwnerGrantsQuery({ selection: { fields: { id: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } } })
useAppOwnerGrantQuery({ id: '<UUID>', selection: { fields: { id: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } } })
useCreateAppOwnerGrantMutation({ selection: { fields: { id: true } } })
useUpdateAppOwnerGrantMutation({ selection: { fields: { id: true } } })
useDeleteAppOwnerGrantMutation({})

Examples

List all appOwnerGrants

const { data, isLoading } = useAppOwnerGrantsQuery({
  selection: { fields: { id: true, isGrant: true, actorId: true, grantorId: true, createdAt: true, updatedAt: true } },
});

Create a appOwnerGrant

const { mutate } = useCreateAppOwnerGrantMutation({
  selection: { fields: { id: true } },
});
mutate({ isGrant: '<Boolean>', actorId: '<UUID>', grantorId: '<UUID>' });

appPermissionDefault

Stores the default permission bitmask assigned to new members upon joining

Usage

useAppPermissionDefaultsQuery({ selection: { fields: { id: true, permissions: true } } })
useAppPermissionDefaultQuery({ id: '<UUID>', selection: { fields: { id: true, permissions: true } } })
useCreateAppPermissionDefaultMutation({ selection: { fields: { id: true } } })
useUpdateAppPermissionDefaultMutation({ selection: { fields: { id: true } } })
useDeleteAppPermissionDefaultMutation({})

Examples

List all appPermissionDefaults

const { data, isLoading } = useAppPermissionDefaultsQuery({
  selection: { fields: { id: true, permissions: true } },
});

Create a appPermissionDefault

const { mutate } = useCreateAppPermissionDefaultMutation({
  selection: { fields: { id: true } },
});
mutate({ permissions: '<BitString>' });

appPermission

Defines available permissions as named bits within a bitmask, used by the RBAC system for access control

Usage

useAppPermissionsQuery({ selection: { fields: { id: true, name: true, bitnum: true, bitstr: true, description: true } } })
useAppPermissionQuery({ id: '<UUID>', selection: { fields: { id: true, name: true, bitnum: true, bitstr: true, description: true } } })
useCreateAppPermissionMutation({ selection: { fields: { id: true } } })
useUpdateAppPermissionMutation({ selection: { fields: { id: true } } })
useDeleteAppPermissionMutation({})

Examples

List all appPermissions

const { data, isLoading } = useAppPermissionsQuery({
  selection: { fields: { id: true, name: true, bitnum: true, bitstr: true, description: true } },
});

Create a appPermission

const { mutate } = useCreateAppPermissionMutation({
  selection: { fields: { id: true } },
});
mutate({ name: '<String>', bitnum: '<Int>', bitstr: '<BitString>', description: '<String>' });

appPermissionsGetByMask

Reads and enables pagination through a set of AppPermission.

Usage

useAppPermissionsGetByMaskQuery({ mask: '<BitString>', first: '<Int>', offset: '<Int>', after: '<Cursor>' })

Examples

Use useAppPermissionsGetByMaskQuery

const { data, isLoading } = useAppPermissionsGetByMaskQuery({ mask: '<BitString>', first: '<Int>', offset: '<Int>', after: '<Cursor>' });

appPermissionsGetMaskByNames

React Query query hook for appPermissionsGetMaskByNames

Usage

useAppPermissionsGetMaskByNamesQuery({ names: '<String>' })

Examples

Use useAppPermissionsGetMaskByNamesQuery

const { data, isLoading } = useAppPermissionsGetMaskByNamesQuery({ names: '<String>' });

appPermissionsGetMask

React Query query hook for appPermissionsGetMask

Usage

useAppPermissionsGetMaskQuery({ ids: '<UUID>' })

Examples

Use useAppPermissionsGetMaskQuery

const { data, isLoading } = useAppPermissionsGetMaskQuery({ ids: '<UUID>' });

appPermissionsGetPaddedMask

React Query query hook for appPermissionsGetPaddedMask

Usage

useAppPermissionsGetPaddedMaskQuery({ mask: '<BitString>' })

Examples

Use useAppPermissionsGetPaddedMaskQuery

const { data, isLoading } = useAppPermissionsGetPaddedMaskQuery({ mask: '<BitString>' });

appStep

Log of individual user actions toward level requirements; every single step ever taken is recorded here

Usage

useAppStepsQuery({ selection: { fields: { id: true, actorId: true, name: true, count: true, createdAt: true, updatedAt: true } } })
useAppStepQuery({ id: '<UUID>', selection: { fields: { id: true, actorId: true, name: true, count: true, createdAt: true, updatedAt: true } } })
useCreateAppStepMutation({ selection: { fields: { id: true } } })
useUpdateAppStepMutation({ selection: { fields: { id: true } } })
useDeleteAppStepMutation({})

Examples

List all appSteps

const { data, isLoading } = useAppStepsQuery({
  selection: { fields: { id: true, actorId: true, name: true, count: true, createdAt: true, updatedAt: true } },
});

Create a appStep

const { mutate } = useCreateAppStepMutation({
  selection: { fields: { id: true } },
});
mutate({ actorId: '<UUID>', name: '<String>', count: '<Int>' });

app

Mobile and native app configuration linked to a site, including store links and identifiers

Usage

useAppsQuery({ selection: { fields: { id: true, databaseId: true, siteId: true, name: true, appImage: true, appStoreLink: true, appStoreId: true, appIdPrefix: true, playStoreLink: true } } })
useAppQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, siteId: true, name: true, appImage: true, appStoreLink: true, appStoreId: true, appIdPrefix: true, playStoreLink: true } } })
useCreateAppMutation({ selection: { fields: { id: true } } })
useUpdateAppMutation({ selection: { fields: { id: true } } })
useDeleteAppMutation({})

Examples

List all apps

const { data, isLoading } = useAppsQuery({
  selection: { fields: { id: true, databaseId: true, siteId: true, name: true, appImage: true, appStoreLink: true, appStoreId: true, appIdPrefix: true, playStoreLink: true } },
});

Create a app

const { mutate } = useCreateAppMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', siteId: '<UUID>', name: '<String>', appImage: '<Image>', appStoreLink: '<Url>', appStoreId: '<String>', appIdPrefix: '<String>', playStoreLink: '<Url>' });

applyRls

React Query mutation hook for applyRls

Usage

const { mutate } = useApplyRlsMutation(); mutate({ input: '<ApplyRlsInput>' });

Examples

Use useApplyRlsMutation

const { mutate, isLoading } = useApplyRlsMutation();
mutate({ input: '<ApplyRlsInput>' });

astMigration

React Query hooks for AstMigration data operations

Usage

useAstMigrationsQuery({ selection: { fields: { id: true, databaseId: true, name: true, requires: true, payload: true, deploys: true, deploy: true, revert: true, verify: true, createdAt: true, action: true, actionId: true, actorId: true } } })
useAstMigrationQuery({ id: '<Int>', selection: { fields: { id: true, databaseId: true, name: true, requires: true, payload: true, deploys: true, deploy: true, revert: true, verify: true, createdAt: true, action: true, actionId: true, actorId: true } } })
useCreateAstMigrationMutation({ selection: { fields: { id: true } } })
useUpdateAstMigrationMutation({ selection: { fields: { id: true } } })
useDeleteAstMigrationMutation({})

Examples

List all astMigrations

const { data, isLoading } = useAstMigrationsQuery({
  selection: { fields: { id: true, databaseId: true, name: true, requires: true, payload: true, deploys: true, deploy: true, revert: true, verify: true, createdAt: true, action: true, actionId: true, actorId: true } },
});

Create a astMigration

const { mutate } = useCreateAstMigrationMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', name: '<String>', requires: '<String>', payload: '<JSON>', deploys: '<String>', deploy: '<JSON>', revert: '<JSON>', verify: '<JSON>', action: '<String>', actionId: '<UUID>', actorId: '<UUID>' });

auditLog

Append-only audit log of authentication events (sign-in, sign-up, password changes, etc.)

Usage

useAuditLogsQuery({ selection: { fields: { id: true, event: true, actorId: true, origin: true, userAgent: true, ipAddress: true, success: true, createdAt: true } } })
useAuditLogQuery({ id: '<UUID>', selection: { fields: { id: true, event: true, actorId: true, origin: true, userAgent: true, ipAddress: true, success: true, createdAt: true } } })
useCreateAuditLogMutation({ selection: { fields: { id: true } } })
useUpdateAuditLogMutation({ selection: { fields: { id: true } } })
useDeleteAuditLogMutation({})

Examples

List all auditLogs

const { data, isLoading } = useAuditLogsQuery({
  selection: { fields: { id: true, event: true, actorId: true, origin: true, userAgent: true, ipAddress: true, success: true, createdAt: true } },
});

Create a auditLog

const { mutate } = useCreateAuditLogMutation({
  selection: { fields: { id: true } },
});
mutate({ event: '<String>', actorId: '<UUID>', origin: '<Origin>', userAgent: '<String>', ipAddress: '<InternetAddress>', success: '<Boolean>' });

billingModule

React Query hooks for BillingModule data operations

Usage

useBillingModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, metersTableId: true, metersTableName: true, planSubscriptionsTableId: true, planSubscriptionsTableName: true, ledgerTableId: true, ledgerTableName: true, balancesTableId: true, balancesTableName: true, recordUsageFunction: true, prefix: true } } })
useBillingModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, metersTableId: true, metersTableName: true, planSubscriptionsTableId: true, planSubscriptionsTableName: true, ledgerTableId: true, ledgerTableName: true, balancesTableId: true, balancesTableName: true, recordUsageFunction: true, prefix: true } } })
useCreateBillingModuleMutation({ selection: { fields: { id: true } } })
useUpdateBillingModuleMutation({ selection: { fields: { id: true } } })
useDeleteBillingModuleMutation({})

Examples

List all billingModules

const { data, isLoading } = useBillingModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, metersTableId: true, metersTableName: true, planSubscriptionsTableId: true, planSubscriptionsTableName: true, ledgerTableId: true, ledgerTableName: true, balancesTableId: true, balancesTableName: true, recordUsageFunction: true, prefix: true } },
});

Create a billingModule

const { mutate } = useCreateBillingModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', metersTableId: '<UUID>', metersTableName: '<String>', planSubscriptionsTableId: '<UUID>', planSubscriptionsTableName: '<String>', ledgerTableId: '<UUID>', ledgerTableName: '<String>', balancesTableId: '<UUID>', balancesTableName: '<String>', recordUsageFunction: '<String>', prefix: '<String>' });

blueprintConstruction

Tracks individual construction attempts of a blueprint. Each time construct_blueprint() is called, a new record is created here. This separates the editable blueprint definition from its build history, allowing blueprints to be re-executed, constructed into multiple databases, and maintain an audit trail of all construction attempts.

Usage

useBlueprintConstructionsQuery({ selection: { fields: { id: true, blueprintId: true, databaseId: true, schemaId: true, status: true, errorDetails: true, tableMap: true, constructedDefinition: true, constructedAt: true, createdAt: true, updatedAt: true } } })
useBlueprintConstructionQuery({ id: '<UUID>', selection: { fields: { id: true, blueprintId: true, databaseId: true, schemaId: true, status: true, errorDetails: true, tableMap: true, constructedDefinition: true, constructedAt: true, createdAt: true, updatedAt: true } } })
useCreateBlueprintConstructionMutation({ selection: { fields: { id: true } } })
useUpdateBlueprintConstructionMutation({ selection: { fields: { id: true } } })
useDeleteBlueprintConstructionMutation({})

Examples

List all blueprintConstructions

const { data, isLoading } = useBlueprintConstructionsQuery({
  selection: { fields: { id: true, blueprintId: true, databaseId: true, schemaId: true, status: true, errorDetails: true, tableMap: true, constructedDefinition: true, constructedAt: true, createdAt: true, updatedAt: true } },
});

Create a blueprintConstruction

const { mutate } = useCreateBlueprintConstructionMutation({
  selection: { fields: { id: true } },
});
mutate({ blueprintId: '<UUID>', databaseId: '<UUID>', schemaId: '<UUID>', status: '<String>', errorDetails: '<String>', tableMap: '<JSON>', constructedDefinition: '<JSON>', constructedAt: '<Datetime>' });

blueprintTemplate

A shareable, versioned schema recipe for the blueprint marketplace. Templates define arrays of secure_table_provision + relation_provision inputs that together describe a complete domain schema (e.g. e-commerce, telemedicine, habit tracker). Templates are never executed directly — they are copied into a blueprint first via copy_template_to_blueprint(). Can be private (owner-only) or public (marketplace-visible).

Usage

useBlueprintTemplatesQuery({ selection: { fields: { id: true, name: true, version: true, displayName: true, description: true, ownerId: true, visibility: true, categories: true, tags: true, definition: true, definitionSchemaVersion: true, source: true, complexity: true, copyCount: true, forkCount: true, forkedFromId: true, definitionHash: true, tableHashes: true, createdAt: true, updatedAt: true } } })
useBlueprintTemplateQuery({ id: '<UUID>', selection: { fields: { id: true, name: true, version: true, displayName: true, description: true, ownerId: true, visibility: true, categories: true, tags: true, definition: true, definitionSchemaVersion: true, source: true, complexity: true, copyCount: true, forkCount: true, forkedFromId: true, definitionHash: true, tableHashes: true, createdAt: true, updatedAt: true } } })
useCreateBlueprintTemplateMutation({ selection: { fields: { id: true } } })
useUpdateBlueprintTemplateMutation({ selection: { fields: { id: true } } })
useDeleteBlueprintTemplateMutation({})

Examples

List all blueprintTemplates

const { data, isLoading } = useBlueprintTemplatesQuery({
  selection: { fields: { id: true, name: true, version: true, displayName: true, description: true, ownerId: true, visibility: true, categories: true, tags: true, definition: true, definitionSchemaVersion: true, source: true, complexity: true, copyCount: true, forkCount: true, forkedFromId: true, definitionHash: true, tableHashes: true, createdAt: true, updatedAt: true } },
});

Create a blueprintTemplate

const { mutate } = useCreateBlueprintTemplateMutation({
  selection: { fields: { id: true } },
});
mutate({ name: '<String>', version: '<String>', displayName: '<String>', description: '<String>', ownerId: '<UUID>', visibility: '<String>', categories: '<String>', tags: '<String>', definition: '<JSON>', definitionSchemaVersion: '<String>', source: '<String>', complexity: '<String>', copyCount: '<Int>', forkCount: '<Int>', forkedFromId: '<UUID>', definitionHash: '<UUID>', tableHashes: '<JSON>' });

blueprint

An owned, editable blueprint scoped to a specific database. Created by copying from a blueprint_template via copy_template_to_blueprint() or built from scratch. The owner can customize the definition at any time. Execute it with construct_blueprint() which creates a separate blueprint_construction record to track the build.

Usage

useBlueprintsQuery({ selection: { fields: { id: true, ownerId: true, databaseId: true, name: true, displayName: true, description: true, definition: true, templateId: true, definitionHash: true, tableHashes: true, createdAt: true, updatedAt: true } } })
useBlueprintQuery({ id: '<UUID>', selection: { fields: { id: true, ownerId: true, databaseId: true, name: true, displayName: true, description: true, definition: true, templateId: true, definitionHash: true, tableHashes: true, createdAt: true, updatedAt: true } } })
useCreateBlueprintMutation({ selection: { fields: { id: true } } })
useUpdateBlueprintMutation({ selection: { fields: { id: true } } })
useDeleteBlueprintMutation({})

Examples

List all blueprints

const { data, isLoading } = useBlueprintsQuery({
  selection: { fields: { id: true, ownerId: true, databaseId: true, name: true, displayName: true, description: true, definition: true, templateId: true, definitionHash: true, tableHashes: true, createdAt: true, updatedAt: true } },
});

Create a blueprint

const { mutate } = useCreateBlueprintMutation({
  selection: { fields: { id: true } },
});
mutate({ ownerId: '<UUID>', databaseId: '<UUID>', name: '<String>', displayName: '<String>', description: '<String>', definition: '<JSON>', templateId: '<UUID>', definitionHash: '<UUID>', tableHashes: '<JSON>' });

bootstrapUser

React Query mutation hook for bootstrapUser

Usage

const { mutate } = useBootstrapUserMutation(); mutate({ input: '<BootstrapUserInput>' });

Examples

Use useBootstrapUserMutation

const { mutate, isLoading } = useBootstrapUserMutation();
mutate({ input: '<BootstrapUserInput>' });

cancelDatabaseTransfer

React Query mutation hook for cancelDatabaseTransfer

Usage

const { mutate } = useCancelDatabaseTransferMutation(); mutate({ input: { transferId: '<UUID>' } });

Examples

Use useCancelDatabaseTransferMutation

const { mutate, isLoading } = useCancelDatabaseTransferMutation();
mutate({ input: { transferId: '<UUID>' } });

checkConstraint

React Query hooks for CheckConstraint data operations

Usage

useCheckConstraintsQuery({ selection: { fields: { id: true, databaseId: true, tableId: true, name: true, type: true, fieldIds: true, expr: true, smartTags: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } } })
useCheckConstraintQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, tableId: true, name: true, type: true, fieldIds: true, expr: true, smartTags: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } } })
useCreateCheckConstraintMutation({ selection: { fields: { id: true } } })
useUpdateCheckConstraintMutation({ selection: { fields: { id: true } } })
useDeleteCheckConstraintMutation({})

Examples

List all checkConstraints

const { data, isLoading } = useCheckConstraintsQuery({
  selection: { fields: { id: true, databaseId: true, tableId: true, name: true, type: true, fieldIds: true, expr: true, smartTags: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } },
});

Create a checkConstraint

const { mutate } = useCreateCheckConstraintMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', tableId: '<UUID>', name: '<String>', type: '<String>', fieldIds: '<UUID>', expr: '<JSON>', smartTags: '<JSON>', category: '<ObjectCategory>', module: '<String>', scope: '<Int>', tags: '<String>' });

checkPassword

React Query mutation hook for checkPassword

Usage

const { mutate } = useCheckPasswordMutation(); mutate({ input: { password: '<String>' } });

Examples

Use useCheckPasswordMutation

const { mutate, isLoading } = useCheckPasswordMutation();
mutate({ input: { password: '<String>' } });

claimedInvite

Records of successfully claimed invitations, linking senders to receivers

Usage

useClaimedInvitesQuery({ selection: { fields: { id: true, data: true, senderId: true, receiverId: true, createdAt: true, updatedAt: true } } })
useClaimedInviteQuery({ id: '<UUID>', selection: { fields: { id: true, data: true, senderId: true, receiverId: true, createdAt: true, updatedAt: true } } })
useCreateClaimedInviteMutation({ selection: { fields: { id: true } } })
useUpdateClaimedInviteMutation({ selection: { fields: { id: true } } })
useDeleteClaimedInviteMutation({})

Examples

List all claimedInvites

const { data, isLoading } = useClaimedInvitesQuery({
  selection: { fields: { id: true, data: true, senderId: true, receiverId: true, createdAt: true, updatedAt: true } },
});

Create a claimedInvite

const { mutate } = useCreateClaimedInviteMutation({
  selection: { fields: { id: true } },
});
mutate({ data: '<JSON>', senderId: '<UUID>', receiverId: '<UUID>' });

commit

A commit records changes to the repository.

Usage

useCommitsQuery({ selection: { fields: { id: true, message: true, databaseId: true, storeId: true, parentIds: true, authorId: true, committerId: true, treeId: true, date: true } } })
useCommitQuery({ id: '<UUID>', selection: { fields: { id: true, message: true, databaseId: true, storeId: true, parentIds: true, authorId: true, committerId: true, treeId: true, date: true } } })
useCreateCommitMutation({ selection: { fields: { id: true } } })
useUpdateCommitMutation({ selection: { fields: { id: true } } })
useDeleteCommitMutation({})

Examples

List all commits

const { data, isLoading } = useCommitsQuery({
  selection: { fields: { id: true, message: true, databaseId: true, storeId: true, parentIds: true, authorId: true, committerId: true, treeId: true, date: true } },
});

Create a commit

const { mutate } = useCreateCommitMutation({
  selection: { fields: { id: true } },
});
mutate({ message: '<String>', databaseId: '<UUID>', storeId: '<UUID>', parentIds: '<UUID>', authorId: '<UUID>', committerId: '<UUID>', treeId: '<UUID>', date: '<Datetime>' });

confirmDeleteAccount

React Query mutation hook for confirmDeleteAccount

Usage

const { mutate } = useConfirmDeleteAccountMutation(); mutate({ input: { userId: '<UUID>', token: '<String>' } });

Examples

Use useConfirmDeleteAccountMutation

const { mutate, isLoading } = useConfirmDeleteAccountMutation();
mutate({ input: { userId: '<UUID>', token: '<String>' } });

confirmUpload

Confirm that a file has been uploaded to S3. Verifies the object exists in S3, checks content-type, and transitions the file status from 'pending' to 'ready'.

Usage

const { mutate } = useConfirmUploadMutation(); mutate({ input: { fileId: '<UUID>' } });

Examples

Use useConfirmUploadMutation

const { mutate, isLoading } = useConfirmUploadMutation();
mutate({ input: { fileId: '<UUID>' } });

connectedAccount

OAuth and social login connections linking external service accounts to users

Usage

useConnectedAccountsQuery({ selection: { fields: { id: true, ownerId: true, service: true, identifier: true, details: true, isVerified: true, createdAt: true, updatedAt: true } } })
useConnectedAccountQuery({ id: '<UUID>', selection: { fields: { id: true, ownerId: true, service: true, identifier: true, details: true, isVerified: true, createdAt: true, updatedAt: true } } })
useCreateConnectedAccountMutation({ selection: { fields: { id: true } } })
useUpdateConnectedAccountMutation({ selection: { fields: { id: true } } })
useDeleteConnectedAccountMutation({})

Examples

List all connectedAccounts

const { data, isLoading } = useConnectedAccountsQuery({
  selection: { fields: { id: true, ownerId: true, service: true, identifier: true, details: true, isVerified: true, createdAt: true, updatedAt: true } },
});

Create a connectedAccount

const { mutate } = useCreateConnectedAccountMutation({
  selection: { fields: { id: true } },
});
mutate({ ownerId: '<UUID>', service: '<String>', identifier: '<String>', details: '<JSON>', isVerified: '<Boolean>' });

connectedAccountsModule

React Query hooks for ConnectedAccountsModule data operations

Usage

useConnectedAccountsModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true } } })
useConnectedAccountsModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true } } })
useCreateConnectedAccountsModuleMutation({ selection: { fields: { id: true } } })
useUpdateConnectedAccountsModuleMutation({ selection: { fields: { id: true } } })
useDeleteConnectedAccountsModuleMutation({})

Examples

List all connectedAccountsModules

const { data, isLoading } = useConnectedAccountsModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true } },
});

Create a connectedAccountsModule

const { mutate } = useCreateConnectedAccountsModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', tableId: '<UUID>', ownerTableId: '<UUID>', tableName: '<String>' });

constructBlueprint

Executes a blueprint definition by delegating to provision_* procedures. Creates a blueprint_construction record to track the attempt. Six phases: (0) entity_type_provision for each membership_type entry — provisions entity tables, membership modules, and security, (1) provision_table() for each table with nodes[], fields[], policies[], and grants (table-level indexes/fts/unique_constraints are deferred), (2) provision_relation() for each relation, (3) provision_index() for top-level + deferred indexes, (4) provision_full_text_search() for top-level + deferred FTS, (5) provision_unique_constraint() for top-level + deferred unique constraints. Phase 0 entity tables are added to the table_map so subsequent phases can reference them by name. Table-level indexes/fts/unique_constraints are deferred to phases 3-5 so they can reference columns created by relations in phase 2. Returns the construction record ID on success, NULL on failure.

Usage

const { mutate } = useConstructBlueprintMutation(); mutate({ input: { blueprintId: '<UUID>', schemaId: '<UUID>' } });

Examples

Use useConstructBlueprintMutation

const { mutate, isLoading } = useConstructBlueprintMutation();
mutate({ input: { blueprintId: '<UUID>', schemaId: '<UUID>' } });

copyTemplateToBlueprint

Creates a new blueprint by copying a template definition. Checks visibility: owners can always copy their own templates, others require public visibility. Increments the template copy_count. Returns the new blueprint ID.

Usage

const { mutate } = useCopyTemplateToBlueprintMutation(); mutate({ input: { templateId: '<UUID>', databaseId: '<UUID>', ownerId: '<UUID>', nameOverride: '<String>', displayNameOverride: '<String>' } });

Examples

Use useCopyTemplateToBlueprintMutation

const { mutate, isLoading } = useCopyTemplateToBlueprintMutation();
mutate({ input: { templateId: '<UUID>', databaseId: '<UUID>', ownerId: '<UUID>', nameOverride: '<String>', displayNameOverride: '<String>' } });

createApiKey

React Query mutation hook for createApiKey

Usage

const { mutate } = useCreateApiKeyMutation(); mutate({ input: { keyName: '<String>', accessLevel: '<String>', mfaLevel: '<String>', expiresIn: '<IntervalInput>' } });

Examples

Use useCreateApiKeyMutation

const { mutate, isLoading } = useCreateApiKeyMutation();
mutate({ input: { keyName: '<String>', accessLevel: '<String>', mfaLevel: '<String>', expiresIn: '<IntervalInput>' } });

createUserDatabase

Creates a new user database with all required modules, permissions, and RLS policies.

Parameters:

database_name: Name for the new database (required)
owner_id: UUID of the owner user (required)
include_invites: Include invite system (default: true)
include_groups: Include group-level memberships (default: false)
include_levels: Include levels/achievements (default: false)
bitlen: Bit length for permission masks (default: 64)
tokens_expiration: Token expiration interval (default: 30 days)

Returns the database_id UUID of the newly created database.

Example usage: SELECT metaschema_public.create_user_database('my_app', 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'::uuid); SELECT metaschema_public.create_user_database('my_app', 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'::uuid, true, true); -- with invites and groups

Usage

const { mutate } = useCreateUserDatabaseMutation(); mutate({ input: '<CreateUserDatabaseInput>' });

Examples

Use useCreateUserDatabaseMutation

const { mutate, isLoading } = useCreateUserDatabaseMutation();
mutate({ input: '<CreateUserDatabaseInput>' });

cryptoAddress

Cryptocurrency wallet addresses owned by users, with network-specific validation and verification

Usage

useCryptoAddressesQuery({ selection: { fields: { id: true, ownerId: true, address: true, isVerified: true, isPrimary: true, name: true, createdAt: true, updatedAt: true } } })
useCryptoAddressQuery({ id: '<UUID>', selection: { fields: { id: true, ownerId: true, address: true, isVerified: true, isPrimary: true, name: true, createdAt: true, updatedAt: true } } })
useCreateCryptoAddressMutation({ selection: { fields: { id: true } } })
useUpdateCryptoAddressMutation({ selection: { fields: { id: true } } })
useDeleteCryptoAddressMutation({})

Examples

List all cryptoAddresses

const { data, isLoading } = useCryptoAddressesQuery({
  selection: { fields: { id: true, ownerId: true, address: true, isVerified: true, isPrimary: true, name: true, createdAt: true, updatedAt: true } },
});

Create a cryptoAddress

const { mutate } = useCreateCryptoAddressMutation({
  selection: { fields: { id: true } },
});
mutate({ ownerId: '<UUID>', address: '<String>', isVerified: '<Boolean>', isPrimary: '<Boolean>', name: '<String>' });

cryptoAddressesModule

React Query hooks for CryptoAddressesModule data operations

Usage

useCryptoAddressesModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true, cryptoNetwork: true } } })
useCryptoAddressesModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true, cryptoNetwork: true } } })
useCreateCryptoAddressesModuleMutation({ selection: { fields: { id: true } } })
useUpdateCryptoAddressesModuleMutation({ selection: { fields: { id: true } } })
useDeleteCryptoAddressesModuleMutation({})

Examples

List all cryptoAddressesModules

const { data, isLoading } = useCryptoAddressesModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true, cryptoNetwork: true } },
});

Create a cryptoAddressesModule

const { mutate } = useCreateCryptoAddressesModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', tableId: '<UUID>', ownerTableId: '<UUID>', tableName: '<String>', cryptoNetwork: '<String>' });

cryptoAuthModule

React Query hooks for CryptoAuthModule data operations

Usage

useCryptoAuthModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, usersTableId: true, secretsTableId: true, sessionsTableId: true, sessionCredentialsTableId: true, addressesTableId: true, userField: true, cryptoNetwork: true, signInRequestChallenge: true, signInRecordFailure: true, signUpWithKey: true, signInWithChallenge: true } } })
useCryptoAuthModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, usersTableId: true, secretsTableId: true, sessionsTableId: true, sessionCredentialsTableId: true, addressesTableId: true, userField: true, cryptoNetwork: true, signInRequestChallenge: true, signInRecordFailure: true, signUpWithKey: true, signInWithChallenge: true } } })
useCreateCryptoAuthModuleMutation({ selection: { fields: { id: true } } })
useUpdateCryptoAuthModuleMutation({ selection: { fields: { id: true } } })
useDeleteCryptoAuthModuleMutation({})

Examples

List all cryptoAuthModules

const { data, isLoading } = useCryptoAuthModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, usersTableId: true, secretsTableId: true, sessionsTableId: true, sessionCredentialsTableId: true, addressesTableId: true, userField: true, cryptoNetwork: true, signInRequestChallenge: true, signInRecordFailure: true, signUpWithKey: true, signInWithChallenge: true } },
});

Create a cryptoAuthModule

const { mutate } = useCreateCryptoAuthModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', usersTableId: '<UUID>', secretsTableId: '<UUID>', sessionsTableId: '<UUID>', sessionCredentialsTableId: '<UUID>', addressesTableId: '<UUID>', userField: '<String>', cryptoNetwork: '<String>', signInRequestChallenge: '<String>', signInRecordFailure: '<String>', signUpWithKey: '<String>', signInWithChallenge: '<String>' });

currentIpAddress

React Query query hook for currentIpAddress

Usage

useCurrentIpAddressQuery()

Examples

Use useCurrentIpAddressQuery

const { data, isLoading } = useCurrentIpAddressQuery();

currentUserAgent

React Query query hook for currentUserAgent

Usage

useCurrentUserAgentQuery()

Examples

Use useCurrentUserAgentQuery

const { data, isLoading } = useCurrentUserAgentQuery();

currentUserId

React Query query hook for currentUserId

Usage

useCurrentUserIdQuery()

Examples

Use useCurrentUserIdQuery

const { data, isLoading } = useCurrentUserIdQuery();

currentUser

React Query query hook for currentUser

Usage

useCurrentUserQuery()

Examples

Use useCurrentUserQuery

const { data, isLoading } = useCurrentUserQuery();

databaseProvisionModule

Tracks database provisioning requests and their status. The BEFORE INSERT trigger creates the database and sets database_id before RLS policies are evaluated.

Usage

useDatabaseProvisionModulesQuery({ selection: { fields: { id: true, databaseName: true, ownerId: true, subdomain: true, domain: true, modules: true, options: true, bootstrapUser: true, status: true, errorMessage: true, databaseId: true, createdAt: true, updatedAt: true, completedAt: true } } })
useDatabaseProvisionModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseName: true, ownerId: true, subdomain: true, domain: true, modules: true, options: true, bootstrapUser: true, status: true, errorMessage: true, databaseId: true, createdAt: true, updatedAt: true, completedAt: true } } })
useCreateDatabaseProvisionModuleMutation({ selection: { fields: { id: true } } })
useUpdateDatabaseProvisionModuleMutation({ selection: { fields: { id: true } } })
useDeleteDatabaseProvisionModuleMutation({})

Examples

List all databaseProvisionModules

const { data, isLoading } = useDatabaseProvisionModulesQuery({
  selection: { fields: { id: true, databaseName: true, ownerId: true, subdomain: true, domain: true, modules: true, options: true, bootstrapUser: true, status: true, errorMessage: true, databaseId: true, createdAt: true, updatedAt: true, completedAt: true } },
});

Create a databaseProvisionModule

const { mutate } = useCreateDatabaseProvisionModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseName: '<String>', ownerId: '<UUID>', subdomain: '<String>', domain: '<String>', modules: '<String>', options: '<JSON>', bootstrapUser: '<Boolean>', status: '<String>', errorMessage: '<String>', databaseId: '<UUID>', completedAt: '<Datetime>' });

databaseTransfer

React Query hooks for DatabaseTransfer data operations

Usage

useDatabaseTransfersQuery({ selection: { fields: { id: true, databaseId: true, targetOwnerId: true, sourceApproved: true, targetApproved: true, sourceApprovedAt: true, targetApprovedAt: true, status: true, initiatedBy: true, notes: true, expiresAt: true, createdAt: true, updatedAt: true, completedAt: true } } })
useDatabaseTransferQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, targetOwnerId: true, sourceApproved: true, targetApproved: true, sourceApprovedAt: true, targetApprovedAt: true, status: true, initiatedBy: true, notes: true, expiresAt: true, createdAt: true, updatedAt: true, completedAt: true } } })
useCreateDatabaseTransferMutation({ selection: { fields: { id: true } } })
useUpdateDatabaseTransferMutation({ selection: { fields: { id: true } } })
useDeleteDatabaseTransferMutation({})

Examples

List all databaseTransfers

const { data, isLoading } = useDatabaseTransfersQuery({
  selection: { fields: { id: true, databaseId: true, targetOwnerId: true, sourceApproved: true, targetApproved: true, sourceApprovedAt: true, targetApprovedAt: true, status: true, initiatedBy: true, notes: true, expiresAt: true, createdAt: true, updatedAt: true, completedAt: true } },
});

Create a databaseTransfer

const { mutate } = useCreateDatabaseTransferMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', targetOwnerId: '<UUID>', sourceApproved: '<Boolean>', targetApproved: '<Boolean>', sourceApprovedAt: '<Datetime>', targetApprovedAt: '<Datetime>', status: '<String>', initiatedBy: '<UUID>', notes: '<String>', expiresAt: '<Datetime>', completedAt: '<Datetime>' });

database

React Query hooks for Database data operations

Usage

useDatabasesQuery({ selection: { fields: { id: true, ownerId: true, schemaHash: true, name: true, label: true, hash: true, createdAt: true, updatedAt: true } } })
useDatabaseQuery({ id: '<UUID>', selection: { fields: { id: true, ownerId: true, schemaHash: true, name: true, label: true, hash: true, createdAt: true, updatedAt: true } } })
useCreateDatabaseMutation({ selection: { fields: { id: true } } })
useUpdateDatabaseMutation({ selection: { fields: { id: true } } })
useDeleteDatabaseMutation({})

Examples

List all databases

const { data, isLoading } = useDatabasesQuery({
  selection: { fields: { id: true, ownerId: true, schemaHash: true, name: true, label: true, hash: true, createdAt: true, updatedAt: true } },
});

Create a database

const { mutate } = useCreateDatabaseMutation({
  selection: { fields: { id: true } },
});
mutate({ ownerId: '<UUID>', schemaHash: '<String>', name: '<String>', label: '<String>', hash: '<UUID>' });

defaultIdsModule

React Query hooks for DefaultIdsModule data operations

Usage

useDefaultIdsModulesQuery({ selection: { fields: { id: true, databaseId: true } } })
useDefaultIdsModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true } } })
useCreateDefaultIdsModuleMutation({ selection: { fields: { id: true } } })
useUpdateDefaultIdsModuleMutation({ selection: { fields: { id: true } } })
useDeleteDefaultIdsModuleMutation({})

Examples

List all defaultIdsModules

const { data, isLoading } = useDefaultIdsModulesQuery({
  selection: { fields: { id: true, databaseId: true } },
});

Create a defaultIdsModule

const { mutate } = useCreateDefaultIdsModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>' });

defaultPrivilege

React Query hooks for DefaultPrivilege data operations

Usage

useDefaultPrivilegesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, objectType: true, privilege: true, granteeName: true, isGrant: true } } })
useDefaultPrivilegeQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, objectType: true, privilege: true, granteeName: true, isGrant: true } } })
useCreateDefaultPrivilegeMutation({ selection: { fields: { id: true } } })
useUpdateDefaultPrivilegeMutation({ selection: { fields: { id: true } } })
useDeleteDefaultPrivilegeMutation({})

Examples

List all defaultPrivileges

const { data, isLoading } = useDefaultPrivilegesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, objectType: true, privilege: true, granteeName: true, isGrant: true } },
});

Create a defaultPrivilege

const { mutate } = useCreateDefaultPrivilegeMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', objectType: '<String>', privilege: '<String>', granteeName: '<String>', isGrant: '<Boolean>' });

denormalizedTableField

React Query hooks for DenormalizedTableField data operations

Usage

useDenormalizedTableFieldsQuery({ selection: { fields: { id: true, databaseId: true, tableId: true, fieldId: true, setIds: true, refTableId: true, refFieldId: true, refIds: true, useUpdates: true, updateDefaults: true, funcName: true, funcOrder: true } } })
useDenormalizedTableFieldQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, tableId: true, fieldId: true, setIds: true, refTableId: true, refFieldId: true, refIds: true, useUpdates: true, updateDefaults: true, funcName: true, funcOrder: true } } })
useCreateDenormalizedTableFieldMutation({ selection: { fields: { id: true } } })
useUpdateDenormalizedTableFieldMutation({ selection: { fields: { id: true } } })
useDeleteDenormalizedTableFieldMutation({})

Examples

List all denormalizedTableFields

const { data, isLoading } = useDenormalizedTableFieldsQuery({
  selection: { fields: { id: true, databaseId: true, tableId: true, fieldId: true, setIds: true, refTableId: true, refFieldId: true, refIds: true, useUpdates: true, updateDefaults: true, funcName: true, funcOrder: true } },
});

Create a denormalizedTableField

const { mutate } = useCreateDenormalizedTableFieldMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', tableId: '<UUID>', fieldId: '<UUID>', setIds: '<UUID>', refTableId: '<UUID>', refFieldId: '<UUID>', refIds: '<UUID>', useUpdates: '<Boolean>', updateDefaults: '<Boolean>', funcName: '<String>', funcOrder: '<Int>' });

devicesModule

React Query hooks for DevicesModule data operations

Usage

useDevicesModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, userDevicesTableId: true, deviceSettingsTableId: true, userDevicesTable: true, deviceSettingsTable: true } } })
useDevicesModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, userDevicesTableId: true, deviceSettingsTableId: true, userDevicesTable: true, deviceSettingsTable: true } } })
useCreateDevicesModuleMutation({ selection: { fields: { id: true } } })
useUpdateDevicesModuleMutation({ selection: { fields: { id: true } } })
useDeleteDevicesModuleMutation({})

Examples

List all devicesModules

const { data, isLoading } = useDevicesModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, userDevicesTableId: true, deviceSettingsTableId: true, userDevicesTable: true, deviceSettingsTable: true } },
});

Create a devicesModule

const { mutate } = useCreateDevicesModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', userDevicesTableId: '<UUID>', deviceSettingsTableId: '<UUID>', userDevicesTable: '<String>', deviceSettingsTable: '<String>' });

disconnectAccount

React Query mutation hook for disconnectAccount

Usage

const { mutate } = useDisconnectAccountMutation(); mutate({ input: { accountId: '<UUID>' } });

Examples

Use useDisconnectAccountMutation

const { mutate, isLoading } = useDisconnectAccountMutation();
mutate({ input: { accountId: '<UUID>' } });

domain

DNS domain and subdomain routing: maps hostnames to either an API endpoint or a site

Usage

useDomainsQuery({ selection: { fields: { id: true, databaseId: true, apiId: true, siteId: true, subdomain: true, domain: true } } })
useDomainQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, apiId: true, siteId: true, subdomain: true, domain: true } } })
useCreateDomainMutation({ selection: { fields: { id: true } } })
useUpdateDomainMutation({ selection: { fields: { id: true } } })
useDeleteDomainMutation({})

Examples

List all domains

const { data, isLoading } = useDomainsQuery({
  selection: { fields: { id: true, databaseId: true, apiId: true, siteId: true, subdomain: true, domain: true } },
});

Create a domain

const { mutate } = useCreateDomainMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', apiId: '<UUID>', siteId: '<UUID>', subdomain: '<Hostname>', domain: '<Hostname>' });

email

User email addresses with verification and primary-email management

Usage

useEmailsQuery({ selection: { fields: { id: true, ownerId: true, email: true, isVerified: true, isPrimary: true, name: true, createdAt: true, updatedAt: true } } })
useEmailQuery({ id: '<UUID>', selection: { fields: { id: true, ownerId: true, email: true, isVerified: true, isPrimary: true, name: true, createdAt: true, updatedAt: true } } })
useCreateEmailMutation({ selection: { fields: { id: true } } })
useUpdateEmailMutation({ selection: { fields: { id: true } } })
useDeleteEmailMutation({})

Examples

List all emails

const { data, isLoading } = useEmailsQuery({
  selection: { fields: { id: true, ownerId: true, email: true, isVerified: true, isPrimary: true, name: true, createdAt: true, updatedAt: true } },
});

Create a email

const { mutate } = useCreateEmailMutation({
  selection: { fields: { id: true } },
});
mutate({ ownerId: '<UUID>', email: '<Email>', isVerified: '<Boolean>', isPrimary: '<Boolean>', name: '<String>' });

emailsModule

React Query hooks for EmailsModule data operations

Usage

useEmailsModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true } } })
useEmailsModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true } } })
useCreateEmailsModuleMutation({ selection: { fields: { id: true } } })
useUpdateEmailsModuleMutation({ selection: { fields: { id: true } } })
useDeleteEmailsModuleMutation({})

Examples

List all emailsModules

const { data, isLoading } = useEmailsModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, ownerTableId: true, tableName: true } },
});

Create a emailsModule

const { mutate } = useCreateEmailsModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', tableId: '<UUID>', ownerTableId: '<UUID>', tableName: '<String>' });

embeddingChunk

React Query hooks for EmbeddingChunk data operations

Usage

useEmbeddingChunksQuery({ selection: { fields: { id: true, databaseId: true, tableId: true, embeddingFieldId: true, chunksTableId: true, chunksTableName: true, contentFieldName: true, dimensions: true, metric: true, chunkSize: true, chunkOverlap: true, chunkStrategy: true, metadataFields: true, enqueueChunkingJob: true, chunkingTaskName: true, parentFkFieldId: true, createdAt: true, updatedAt: true } } })
useEmbeddingChunkQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, tableId: true, embeddingFieldId: true, chunksTableId: true, chunksTableName: true, contentFieldName: true, dimensions: true, metric: true, chunkSize: true, chunkOverlap: true, chunkStrategy: true, metadataFields: true, enqueueChunkingJob: true, chunkingTaskName: true, parentFkFieldId: true, createdAt: true, updatedAt: true } } })
useCreateEmbeddingChunkMutation({ selection: { fields: { id: true } } })
useUpdateEmbeddingChunkMutation({ selection: { fields: { id: true } } })
useDeleteEmbeddingChunkMutation({})

Examples

List all embeddingChunks

const { data, isLoading } = useEmbeddingChunksQuery({
  selection: { fields: { id: true, databaseId: true, tableId: true, embeddingFieldId: true, chunksTableId: true, chunksTableName: true, contentFieldName: true, dimensions: true, metric: true, chunkSize: true, chunkOverlap: true, chunkStrategy: true, metadataFields: true, enqueueChunkingJob: true, chunkingTaskName: true, parentFkFieldId: true, createdAt: true, updatedAt: true } },
});

Create a embeddingChunk

const { mutate } = useCreateEmbeddingChunkMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', tableId: '<UUID>', embeddingFieldId: '<UUID>', chunksTableId: '<UUID>', chunksTableName: '<String>', contentFieldName: '<String>', dimensions: '<Int>', metric: '<String>', chunkSize: '<Int>', chunkOverlap: '<Int>', chunkStrategy: '<String>', metadataFields: '<JSON>', enqueueChunkingJob: '<Boolean>', chunkingTaskName: '<String>', parentFkFieldId: '<UUID>' });

encryptedSecretsModule

React Query hooks for EncryptedSecretsModule data operations

Usage

useEncryptedSecretsModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, tableId: true, tableName: true } } })
useEncryptedSecretsModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, tableId: true, tableName: true } } })
useCreateEncryptedSecretsModuleMutation({ selection: { fields: { id: true } } })
useUpdateEncryptedSecretsModuleMutation({ selection: { fields: { id: true } } })
useDeleteEncryptedSecretsModuleMutation({})

Examples

List all encryptedSecretsModules

const { data, isLoading } = useEncryptedSecretsModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, tableId: true, tableName: true } },
});

Create a encryptedSecretsModule

const { mutate } = useCreateEncryptedSecretsModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', tableId: '<UUID>', tableName: '<String>' });

entityTypeProvision

Provisions a new membership entity type. Each INSERT creates an entity table, registers a membership type, and installs the required modules (permissions, memberships, limits) plus optional modules (profiles, levels, invites). Uses provision_membership_table() internally. Graceful: duplicate (database_id, prefix) pairs are silently skipped via the unique constraint (use INSERT ... ON CONFLICT DO NOTHING). Policy behavior: by default the five entity-table RLS policies are applied (gated by is_visible). Set table_provision to a single jsonb object (using the same shape as provision_table() / blueprint tables[] entries) to replace the defaults with your own; set skip_entity_policies=true as an escape hatch to apply zero policies.

Usage

useEntityTypeProvisionsQuery({ selection: { fields: { id: true, databaseId: true, name: true, prefix: true, description: true, parentEntity: true, tableName: true, isVisible: true, hasLimits: true, hasProfiles: true, hasLevels: true, hasStorage: true, hasInvites: true, storageConfig: true, skipEntityPolicies: true, tableProvision: true, outMembershipType: true, outEntityTableId: true, outEntityTableName: true, outInstalledModules: true, outStorageModuleId: true, outBucketsTableId: true, outFilesTableId: true, outInvitesModuleId: true } } })
useEntityTypeProvisionQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, name: true, prefix: true, description: true, parentEntity: true, tableName: true, isVisible: true, hasLimits: true, hasProfiles: true, hasLevels: true, hasStorage: true, hasInvites: true, storageConfig: true, skipEntityPolicies: true, tableProvision: true, outMembershipType: true, outEntityTableId: true, outEntityTableName: true, outInstalledModules: true, outStorageModuleId: true, outBucketsTableId: true, outFilesTableId: true, outInvitesModuleId: true } } })
useCreateEntityTypeProvisionMutation({ selection: { fields: { id: true } } })
useUpdateEntityTypeProvisionMutation({ selection: { fields: { id: true } } })
useDeleteEntityTypeProvisionMutation({})

Examples

List all entityTypeProvisions

const { data, isLoading } = useEntityTypeProvisionsQuery({
  selection: { fields: { id: true, databaseId: true, name: true, prefix: true, description: true, parentEntity: true, tableName: true, isVisible: true, hasLimits: true, hasProfiles: true, hasLevels: true, hasStorage: true, hasInvites: true, storageConfig: true, skipEntityPolicies: true, tableProvision: true, outMembershipType: true, outEntityTableId: true, outEntityTableName: true, outInstalledModules: true, outStorageModuleId: true, outBucketsTableId: true, outFilesTableId: true, outInvitesModuleId: true } },
});

Create a entityTypeProvision

const { mutate } = useCreateEntityTypeProvisionMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', name: '<String>', prefix: '<String>', description: '<String>', parentEntity: '<String>', tableName: '<String>', isVisible: '<Boolean>', hasLimits: '<Boolean>', hasProfiles: '<Boolean>', hasLevels: '<Boolean>', hasStorage: '<Boolean>', hasInvites: '<Boolean>', storageConfig: '<JSON>', skipEntityPolicies: '<Boolean>', tableProvision: '<JSON>', outMembershipType: '<Int>', outEntityTableId: '<UUID>', outEntityTableName: '<String>', outInstalledModules: '<String>', outStorageModuleId: '<UUID>', outBucketsTableId: '<UUID>', outFilesTableId: '<UUID>', outInvitesModuleId: '<UUID>' });

enum

React Query hooks for Enum data operations

Usage

useEnumsQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, name: true, label: true, description: true, values: true, smartTags: true, category: true, module: true, scope: true, tags: true } } })
useEnumQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, name: true, label: true, description: true, values: true, smartTags: true, category: true, module: true, scope: true, tags: true } } })
useCreateEnumMutation({ selection: { fields: { id: true } } })
useUpdateEnumMutation({ selection: { fields: { id: true } } })
useDeleteEnumMutation({})

Examples

List all enums

const { data, isLoading } = useEnumsQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, name: true, label: true, description: true, values: true, smartTags: true, category: true, module: true, scope: true, tags: true } },
});

Create a enum

const { mutate } = useCreateEnumMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', name: '<String>', label: '<String>', description: '<String>', values: '<String>', smartTags: '<JSON>', category: '<ObjectCategory>', module: '<String>', scope: '<Int>', tags: '<String>' });

extendTokenExpires

React Query mutation hook for extendTokenExpires

Usage

const { mutate } = useExtendTokenExpiresMutation(); mutate({ input: { amount: '<IntervalInput>' } });

Examples

Use useExtendTokenExpiresMutation

const { mutate, isLoading } = useExtendTokenExpiresMutation();
mutate({ input: { amount: '<IntervalInput>' } });

fieldModule

React Query hooks for FieldModule data operations

Usage

useFieldModulesQuery({ selection: { fields: { id: true, databaseId: true, privateSchemaId: true, tableId: true, fieldId: true, nodeType: true, data: true, triggers: true, functions: true } } })
useFieldModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, privateSchemaId: true, tableId: true, fieldId: true, nodeType: true, data: true, triggers: true, functions: true } } })
useCreateFieldModuleMutation({ selection: { fields: { id: true } } })
useUpdateFieldModuleMutation({ selection: { fields: { id: true } } })
useDeleteFieldModuleMutation({})

Examples

List all fieldModules

const { data, isLoading } = useFieldModulesQuery({
  selection: { fields: { id: true, databaseId: true, privateSchemaId: true, tableId: true, fieldId: true, nodeType: true, data: true, triggers: true, functions: true } },
});

Create a fieldModule

const { mutate } = useCreateFieldModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', privateSchemaId: '<UUID>', tableId: '<UUID>', fieldId: '<UUID>', nodeType: '<String>', data: '<JSON>', triggers: '<String>', functions: '<String>' });

field

React Query hooks for Field data operations

Usage

useFieldsQuery({ selection: { fields: { id: true, databaseId: true, tableId: true, name: true, label: true, description: true, smartTags: true, isRequired: true, apiRequired: true, defaultValue: true, defaultValueAst: true, type: true, fieldOrder: true, regexp: true, chk: true, chkExpr: true, min: true, max: true, tags: true, category: true, module: true, scope: true, createdAt: true, updatedAt: true } } })
useFieldQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, tableId: true, name: true, label: true, description: true, smartTags: true, isRequired: true, apiRequired: true, defaultValue: true, defaultValueAst: true, type: true, fieldOrder: true, regexp: true, chk: true, chkExpr: true, min: true, max: true, tags: true, category: true, module: true, scope: true, createdAt: true, updatedAt: true } } })
useCreateFieldMutation({ selection: { fields: { id: true } } })
useUpdateFieldMutation({ selection: { fields: { id: true } } })
useDeleteFieldMutation({})

Examples

List all fields

const { data, isLoading } = useFieldsQuery({
  selection: { fields: { id: true, databaseId: true, tableId: true, name: true, label: true, description: true, smartTags: true, isRequired: true, apiRequired: true, defaultValue: true, defaultValueAst: true, type: true, fieldOrder: true, regexp: true, chk: true, chkExpr: true, min: true, max: true, tags: true, category: true, module: true, scope: true, createdAt: true, updatedAt: true } },
});

Create a field

const { mutate } = useCreateFieldMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', tableId: '<UUID>', name: '<String>', label: '<String>', description: '<String>', smartTags: '<JSON>', isRequired: '<Boolean>', apiRequired: '<Boolean>', defaultValue: '<String>', defaultValueAst: '<JSON>', type: '<String>', fieldOrder: '<Int>', regexp: '<String>', chk: '<JSON>', chkExpr: '<JSON>', min: '<Float>', max: '<Float>', tags: '<String>', category: '<ObjectCategory>', module: '<String>', scope: '<Int>' });

foreignKeyConstraint

React Query hooks for ForeignKeyConstraint data operations

Usage

useForeignKeyConstraintsQuery({ selection: { fields: { id: true, databaseId: true, tableId: true, name: true, description: true, smartTags: true, type: true, fieldIds: true, refTableId: true, refFieldIds: true, deleteAction: true, updateAction: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } } })
useForeignKeyConstraintQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, tableId: true, name: true, description: true, smartTags: true, type: true, fieldIds: true, refTableId: true, refFieldIds: true, deleteAction: true, updateAction: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } } })
useCreateForeignKeyConstraintMutation({ selection: { fields: { id: true } } })
useUpdateForeignKeyConstraintMutation({ selection: { fields: { id: true } } })
useDeleteForeignKeyConstraintMutation({})

Examples

List all foreignKeyConstraints

const { data, isLoading } = useForeignKeyConstraintsQuery({
  selection: { fields: { id: true, databaseId: true, tableId: true, name: true, description: true, smartTags: true, type: true, fieldIds: true, refTableId: true, refFieldIds: true, deleteAction: true, updateAction: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } },
});

Create a foreignKeyConstraint

const { mutate } = useCreateForeignKeyConstraintMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', tableId: '<UUID>', name: '<String>', description: '<String>', smartTags: '<JSON>', type: '<String>', fieldIds: '<UUID>', refTableId: '<UUID>', refFieldIds: '<UUID>', deleteAction: '<String>', updateAction: '<String>', category: '<ObjectCategory>', module: '<String>', scope: '<Int>', tags: '<String>' });

forgotPassword

React Query mutation hook for forgotPassword

Usage

const { mutate } = useForgotPasswordMutation(); mutate({ input: { email: '<Email>' } });

Examples

Use useForgotPasswordMutation

const { mutate, isLoading } = useForgotPasswordMutation();
mutate({ input: { email: '<Email>' } });

freezeObjects

React Query mutation hook for freezeObjects

Usage

const { mutate } = useFreezeObjectsMutation(); mutate({ input: { databaseId: '<UUID>', id: '<UUID>' } });

Examples

Use useFreezeObjectsMutation

const { mutate, isLoading } = useFreezeObjectsMutation();
mutate({ input: { databaseId: '<UUID>', id: '<UUID>' } });

fullTextSearch

React Query hooks for FullTextSearch data operations

Usage

useFullTextSearchesQuery({ selection: { fields: { id: true, databaseId: true, tableId: true, fieldId: true, fieldIds: true, weights: true, langs: true, createdAt: true, updatedAt: true } } })
useFullTextSearchQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, tableId: true, fieldId: true, fieldIds: true, weights: true, langs: true, createdAt: true, updatedAt: true } } })
useCreateFullTextSearchMutation({ selection: { fields: { id: true } } })
useUpdateFullTextSearchMutation({ selection: { fields: { id: true } } })
useDeleteFullTextSearchMutation({})

Examples

List all fullTextSearches

const { data, isLoading } = useFullTextSearchesQuery({
  selection: { fields: { id: true, databaseId: true, tableId: true, fieldId: true, fieldIds: true, weights: true, langs: true, createdAt: true, updatedAt: true } },
});

Create a fullTextSearch

const { mutate } = useCreateFullTextSearchMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', tableId: '<UUID>', fieldId: '<UUID>', fieldIds: '<UUID>', weights: '<String>', langs: '<String>' });

getAllObjectsFromRoot

Reads and enables pagination through a set of Object.

Usage

useGetAllObjectsFromRootQuery({ databaseId: '<UUID>', id: '<UUID>', first: '<Int>', offset: '<Int>', after: '<Cursor>' })

Examples

Use useGetAllObjectsFromRootQuery

const { data, isLoading } = useGetAllObjectsFromRootQuery({ databaseId: '<UUID>', id: '<UUID>', first: '<Int>', offset: '<Int>', after: '<Cursor>' });

getAllRecord

React Query hooks for GetAllRecord data operations

Usage

useGetAllQuery({ selection: { fields: { path: true, data: true } } })
useCreateGetAllRecordMutation({ selection: { fields: { id: true } } })

Examples

List all getAll

const { data, isLoading } = useGetAllQuery({
  selection: { fields: { path: true, data: true } },
});

Create a getAllRecord

const { mutate } = useCreateGetAllRecordMutation({
  selection: { fields: { id: true } },
});
mutate({ path: '<String>', data: '<JSON>' });

getObjectAtPath

React Query query hook for getObjectAtPath

Usage

useGetObjectAtPathQuery({ dbId: '<UUID>', storeId: '<UUID>', path: '<String>', refname: '<String>' })

Examples

Use useGetObjectAtPathQuery

const { data, isLoading } = useGetObjectAtPathQuery({ dbId: '<UUID>', storeId: '<UUID>', path: '<String>', refname: '<String>' });

getPathObjectsFromRoot

Reads and enables pagination through a set of Object.

Usage

useGetPathObjectsFromRootQuery({ databaseId: '<UUID>', id: '<UUID>', path: '<String>', first: '<Int>', offset: '<Int>', after: '<Cursor>' })

Examples

Use useGetPathObjectsFromRootQuery

const { data, isLoading } = useGetPathObjectsFromRootQuery({ databaseId: '<UUID>', id: '<UUID>', path: '<String>', first: '<Int>', offset: '<Int>', after: '<Cursor>' });

hierarchyModule

React Query hooks for HierarchyModule data operations

Usage

useHierarchyModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, chartEdgesTableId: true, chartEdgesTableName: true, hierarchySprtTableId: true, hierarchySprtTableName: true, chartEdgeGrantsTableId: true, chartEdgeGrantsTableName: true, entityTableId: true, usersTableId: true, prefix: true, privateSchemaName: true, sprtTableName: true, rebuildHierarchyFunction: true, getSubordinatesFunction: true, getManagersFunction: true, isManagerOfFunction: true, createdAt: true } } })
useHierarchyModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, chartEdgesTableId: true, chartEdgesTableName: true, hierarchySprtTableId: true, hierarchySprtTableName: true, chartEdgeGrantsTableId: true, chartEdgeGrantsTableName: true, entityTableId: true, usersTableId: true, prefix: true, privateSchemaName: true, sprtTableName: true, rebuildHierarchyFunction: true, getSubordinatesFunction: true, getManagersFunction: true, isManagerOfFunction: true, createdAt: true } } })
useCreateHierarchyModuleMutation({ selection: { fields: { id: true } } })
useUpdateHierarchyModuleMutation({ selection: { fields: { id: true } } })
useDeleteHierarchyModuleMutation({})

Examples

List all hierarchyModules

const { data, isLoading } = useHierarchyModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, chartEdgesTableId: true, chartEdgesTableName: true, hierarchySprtTableId: true, hierarchySprtTableName: true, chartEdgeGrantsTableId: true, chartEdgeGrantsTableName: true, entityTableId: true, usersTableId: true, prefix: true, privateSchemaName: true, sprtTableName: true, rebuildHierarchyFunction: true, getSubordinatesFunction: true, getManagersFunction: true, isManagerOfFunction: true, createdAt: true } },
});

Create a hierarchyModule

const { mutate } = useCreateHierarchyModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', chartEdgesTableId: '<UUID>', chartEdgesTableName: '<String>', hierarchySprtTableId: '<UUID>', hierarchySprtTableName: '<String>', chartEdgeGrantsTableId: '<UUID>', chartEdgeGrantsTableName: '<String>', entityTableId: '<UUID>', usersTableId: '<UUID>', prefix: '<String>', privateSchemaName: '<String>', sprtTableName: '<String>', rebuildHierarchyFunction: '<String>', getSubordinatesFunction: '<String>', getManagersFunction: '<String>', isManagerOfFunction: '<String>' });

identityProvider

React Query hooks for IdentityProvider data operations

Usage

useIdentityProvidersQuery({ selection: { fields: { slug: true, kind: true, displayName: true, enabled: true, isBuiltIn: true } } })
useCreateIdentityProviderMutation({ selection: { fields: { id: true } } })

Examples

List all identityProviders

const { data, isLoading } = useIdentityProvidersQuery({
  selection: { fields: { slug: true, kind: true, displayName: true, enabled: true, isBuiltIn: true } },
});

Create a identityProvider

const { mutate } = useCreateIdentityProviderMutation({
  selection: { fields: { id: true } },
});
mutate({ slug: '<String>', kind: '<String>', displayName: '<String>', enabled: '<Boolean>', isBuiltIn: '<Boolean>' });

identityProvidersModule

Config row for the identity_providers_module, which provisions a per-database identity_providers config table holding OAuth2 / OIDC (and future SAML) provider definitions: protocol kind, endpoint URLs, encrypted client secret, scopes, audience validation, PKCE, and email-handling flags. Built-in providers (google, github, apple, ...) are seeded as is_built_in=true rows; custom providers use slugs of the form custom:<slug>.

Usage

useIdentityProvidersModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, tableName: true } } })
useIdentityProvidersModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, tableName: true } } })
useCreateIdentityProvidersModuleMutation({ selection: { fields: { id: true } } })
useUpdateIdentityProvidersModuleMutation({ selection: { fields: { id: true } } })
useDeleteIdentityProvidersModuleMutation({})

Examples

List all identityProvidersModules

const { data, isLoading } = useIdentityProvidersModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, tableName: true } },
});

Create a identityProvidersModule

const { mutate } = useCreateIdentityProvidersModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', tableId: '<UUID>', tableName: '<String>' });

index

React Query hooks for Index data operations

Usage

useIndicesQuery({ selection: { fields: { id: true, databaseId: true, tableId: true, name: true, fieldIds: true, includeFieldIds: true, accessMethod: true, indexParams: true, whereClause: true, isUnique: true, options: true, opClasses: true, smartTags: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } } })
useIndexQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, tableId: true, name: true, fieldIds: true, includeFieldIds: true, accessMethod: true, indexParams: true, whereClause: true, isUnique: true, options: true, opClasses: true, smartTags: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } } })
useCreateIndexMutation({ selection: { fields: { id: true } } })
useUpdateIndexMutation({ selection: { fields: { id: true } } })
useDeleteIndexMutation({})

Examples

List all indices

const { data, isLoading } = useIndicesQuery({
  selection: { fields: { id: true, databaseId: true, tableId: true, name: true, fieldIds: true, includeFieldIds: true, accessMethod: true, indexParams: true, whereClause: true, isUnique: true, options: true, opClasses: true, smartTags: true, category: true, module: true, scope: true, tags: true, createdAt: true, updatedAt: true } },
});

Create a index

const { mutate } = useCreateIndexMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', tableId: '<UUID>', name: '<String>', fieldIds: '<UUID>', includeFieldIds: '<UUID>', accessMethod: '<String>', indexParams: '<JSON>', whereClause: '<JSON>', isUnique: '<Boolean>', options: '<JSON>', opClasses: '<String>', smartTags: '<JSON>', category: '<ObjectCategory>', module: '<String>', scope: '<Int>', tags: '<String>' });

initEmptyRepo

React Query mutation hook for initEmptyRepo

Usage

const { mutate } = useInitEmptyRepoMutation(); mutate({ input: { dbId: '<UUID>', storeId: '<UUID>' } });

Examples

Use useInitEmptyRepoMutation

const { mutate, isLoading } = useInitEmptyRepoMutation();
mutate({ input: { dbId: '<UUID>', storeId: '<UUID>' } });

insertNodeAtPath

React Query mutation hook for insertNodeAtPath

Usage

const { mutate } = useInsertNodeAtPathMutation(); mutate({ input: '<InsertNodeAtPathInput>' });

Examples

Use useInsertNodeAtPathMutation

const { mutate, isLoading } = useInsertNodeAtPathMutation();
mutate({ input: '<InsertNodeAtPathInput>' });

invite

Invitation records sent to prospective members via email, with token-based redemption and expiration

Usage

useInvitesQuery({ selection: { fields: { id: true, email: true, senderId: true, inviteToken: true, inviteValid: true, inviteLimit: true, inviteCount: true, multiple: true, data: true, expiresAt: true, createdAt: true, updatedAt: true } } })
useInviteQuery({ id: '<UUID>', selection: { fields: { id: true, email: true, senderId: true, inviteToken: true, inviteValid: true, inviteLimit: true, inviteCount: true, multiple: true, data: true, expiresAt: true, createdAt: true, updatedAt: true } } })
useCreateInviteMutation({ selection: { fields: { id: true } } })
useUpdateInviteMutation({ selection: { fields: { id: true } } })
useDeleteInviteMutation({})

Examples

List all invites

const { data, isLoading } = useInvitesQuery({
  selection: { fields: { id: true, email: true, senderId: true, inviteToken: true, inviteValid: true, inviteLimit: true, inviteCount: true, multiple: true, data: true, expiresAt: true, createdAt: true, updatedAt: true } },
});

Create a invite

const { mutate } = useCreateInviteMutation({
  selection: { fields: { id: true } },
});
mutate({ email: '<Email>', senderId: '<UUID>', inviteToken: '<String>', inviteValid: '<Boolean>', inviteLimit: '<Int>', inviteCount: '<Int>', multiple: '<Boolean>', data: '<JSON>', expiresAt: '<Datetime>' });

invitesModule

React Query hooks for InvitesModule data operations

Usage

useInvitesModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, emailsTableId: true, usersTableId: true, invitesTableId: true, claimedInvitesTableId: true, invitesTableName: true, claimedInvitesTableName: true, submitInviteCodeFunction: true, prefix: true, membershipType: true, entityTableId: true } } })
useInvitesModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, emailsTableId: true, usersTableId: true, invitesTableId: true, claimedInvitesTableId: true, invitesTableName: true, claimedInvitesTableName: true, submitInviteCodeFunction: true, prefix: true, membershipType: true, entityTableId: true } } })
useCreateInvitesModuleMutation({ selection: { fields: { id: true } } })
useUpdateInvitesModuleMutation({ selection: { fields: { id: true } } })
useDeleteInvitesModuleMutation({})

Examples

List all invitesModules

const { data, isLoading } = useInvitesModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, emailsTableId: true, usersTableId: true, invitesTableId: true, claimedInvitesTableId: true, invitesTableName: true, claimedInvitesTableName: true, submitInviteCodeFunction: true, prefix: true, membershipType: true, entityTableId: true } },
});

Create a invitesModule

const { mutate } = useCreateInvitesModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', emailsTableId: '<UUID>', usersTableId: '<UUID>', invitesTableId: '<UUID>', claimedInvitesTableId: '<UUID>', invitesTableName: '<String>', claimedInvitesTableName: '<String>', submitInviteCodeFunction: '<String>', prefix: '<String>', membershipType: '<Int>', entityTableId: '<UUID>' });

levelsModule

React Query hooks for LevelsModule data operations

Usage

useLevelsModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, stepsTableId: true, stepsTableName: true, achievementsTableId: true, achievementsTableName: true, levelsTableId: true, levelsTableName: true, levelRequirementsTableId: true, levelRequirementsTableName: true, completedStep: true, incompletedStep: true, tgAchievement: true, tgAchievementToggle: true, tgAchievementToggleBoolean: true, tgAchievementBoolean: true, upsertAchievement: true, tgUpdateAchievements: true, stepsRequired: true, levelAchieved: true, prefix: true, membershipType: true, entityTableId: true, actorTableId: true } } })
useLevelsModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, stepsTableId: true, stepsTableName: true, achievementsTableId: true, achievementsTableName: true, levelsTableId: true, levelsTableName: true, levelRequirementsTableId: true, levelRequirementsTableName: true, completedStep: true, incompletedStep: true, tgAchievement: true, tgAchievementToggle: true, tgAchievementToggleBoolean: true, tgAchievementBoolean: true, upsertAchievement: true, tgUpdateAchievements: true, stepsRequired: true, levelAchieved: true, prefix: true, membershipType: true, entityTableId: true, actorTableId: true } } })
useCreateLevelsModuleMutation({ selection: { fields: { id: true } } })
useUpdateLevelsModuleMutation({ selection: { fields: { id: true } } })
useDeleteLevelsModuleMutation({})

Examples

List all levelsModules

const { data, isLoading } = useLevelsModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, stepsTableId: true, stepsTableName: true, achievementsTableId: true, achievementsTableName: true, levelsTableId: true, levelsTableName: true, levelRequirementsTableId: true, levelRequirementsTableName: true, completedStep: true, incompletedStep: true, tgAchievement: true, tgAchievementToggle: true, tgAchievementToggleBoolean: true, tgAchievementBoolean: true, upsertAchievement: true, tgUpdateAchievements: true, stepsRequired: true, levelAchieved: true, prefix: true, membershipType: true, entityTableId: true, actorTableId: true } },
});

Create a levelsModule

const { mutate } = useCreateLevelsModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', stepsTableId: '<UUID>', stepsTableName: '<String>', achievementsTableId: '<UUID>', achievementsTableName: '<String>', levelsTableId: '<UUID>', levelsTableName: '<String>', levelRequirementsTableId: '<UUID>', levelRequirementsTableName: '<String>', completedStep: '<String>', incompletedStep: '<String>', tgAchievement: '<String>', tgAchievementToggle: '<String>', tgAchievementToggleBoolean: '<String>', tgAchievementBoolean: '<String>', upsertAchievement: '<String>', tgUpdateAchievements: '<String>', stepsRequired: '<String>', levelAchieved: '<String>', prefix: '<String>', membershipType: '<Int>', entityTableId: '<UUID>', actorTableId: '<UUID>' });

limitsModule

React Query hooks for LimitsModule data operations

Usage

useLimitsModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, tableName: true, defaultTableId: true, defaultTableName: true, limitIncrementFunction: true, limitDecrementFunction: true, limitIncrementTrigger: true, limitDecrementTrigger: true, limitUpdateTrigger: true, limitCheckFunction: true, aggregateTableId: true, prefix: true, membershipType: true, entityTableId: true, actorTableId: true } } })
useLimitsModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, tableName: true, defaultTableId: true, defaultTableName: true, limitIncrementFunction: true, limitDecrementFunction: true, limitIncrementTrigger: true, limitDecrementTrigger: true, limitUpdateTrigger: true, limitCheckFunction: true, aggregateTableId: true, prefix: true, membershipType: true, entityTableId: true, actorTableId: true } } })
useCreateLimitsModuleMutation({ selection: { fields: { id: true } } })
useUpdateLimitsModuleMutation({ selection: { fields: { id: true } } })
useDeleteLimitsModuleMutation({})

Examples

List all limitsModules

const { data, isLoading } = useLimitsModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, tableId: true, tableName: true, defaultTableId: true, defaultTableName: true, limitIncrementFunction: true, limitDecrementFunction: true, limitIncrementTrigger: true, limitDecrementTrigger: true, limitUpdateTrigger: true, limitCheckFunction: true, aggregateTableId: true, prefix: true, membershipType: true, entityTableId: true, actorTableId: true } },
});

Create a limitsModule

const { mutate } = useCreateLimitsModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', tableId: '<UUID>', tableName: '<String>', defaultTableId: '<UUID>', defaultTableName: '<String>', limitIncrementFunction: '<String>', limitDecrementFunction: '<String>', limitIncrementTrigger: '<String>', limitDecrementTrigger: '<String>', limitUpdateTrigger: '<String>', limitCheckFunction: '<String>', aggregateTableId: '<UUID>', prefix: '<String>', membershipType: '<Int>', entityTableId: '<UUID>', actorTableId: '<UUID>' });

membershipType

Defines the different scopes of membership (e.g. App Member, Organization Member, Group Member)

Usage

useMembershipTypesQuery({ selection: { fields: { id: true, name: true, description: true, prefix: true, parentMembershipType: true, hasUsersTableEntry: true } } })
useMembershipTypeQuery({ id: '<Int>', selection: { fields: { id: true, name: true, description: true, prefix: true, parentMembershipType: true, hasUsersTableEntry: true } } })
useCreateMembershipTypeMutation({ selection: { fields: { id: true } } })
useUpdateMembershipTypeMutation({ selection: { fields: { id: true } } })
useDeleteMembershipTypeMutation({})

Examples

List all membershipTypes

const { data, isLoading } = useMembershipTypesQuery({
  selection: { fields: { id: true, name: true, description: true, prefix: true, parentMembershipType: true, hasUsersTableEntry: true } },
});

Create a membershipType

const { mutate } = useCreateMembershipTypeMutation({
  selection: { fields: { id: true } },
});
mutate({ name: '<String>', description: '<String>', prefix: '<String>', parentMembershipType: '<Int>', hasUsersTableEntry: '<Boolean>' });

membershipTypesModule

React Query hooks for MembershipTypesModule data operations

Usage

useMembershipTypesModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, tableId: true, tableName: true } } })
useMembershipTypesModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, tableId: true, tableName: true } } })
useCreateMembershipTypesModuleMutation({ selection: { fields: { id: true } } })
useUpdateMembershipTypesModuleMutation({ selection: { fields: { id: true } } })
useDeleteMembershipTypesModuleMutation({})

Examples

List all membershipTypesModules

const { data, isLoading } = useMembershipTypesModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, tableId: true, tableName: true } },
});

Create a membershipTypesModule

const { mutate } = useCreateMembershipTypesModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', tableId: '<UUID>', tableName: '<String>' });

membershipsModule

React Query hooks for MembershipsModule data operations

Usage

useMembershipsModulesQuery({ selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, membershipsTableId: true, membershipsTableName: true, membersTableId: true, membersTableName: true, membershipDefaultsTableId: true, membershipDefaultsTableName: true, membershipSettingsTableId: true, membershipSettingsTableName: true, grantsTableId: true, grantsTableName: true, actorTableId: true, limitsTableId: true, defaultLimitsTableId: true, permissionsTableId: true, defaultPermissionsTableId: true, sprtTableId: true, adminGrantsTableId: true, adminGrantsTableName: true, ownerGrantsTableId: true, ownerGrantsTableName: true, membershipType: true, entityTableId: true, entityTableOwnerId: true, prefix: true, actorMaskCheck: true, actorPermCheck: true, entityIdsByMask: true, entityIdsByPerm: true, entityIdsFunction: true, memberProfilesTableId: true } } })
useMembershipsModuleQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, membershipsTableId: true, membershipsTableName: true, membersTableId: true, membersTableName: true, membershipDefaultsTableId: true, membershipDefaultsTableName: true, membershipSettingsTableId: true, membershipSettingsTableName: true, grantsTableId: true, grantsTableName: true, actorTableId: true, limitsTableId: true, defaultLimitsTableId: true, permissionsTableId: true, defaultPermissionsTableId: true, sprtTableId: true, adminGrantsTableId: true, adminGrantsTableName: true, ownerGrantsTableId: true, ownerGrantsTableName: true, membershipType: true, entityTableId: true, entityTableOwnerId: true, prefix: true, actorMaskCheck: true, actorPermCheck: true, entityIdsByMask: true, entityIdsByPerm: true, entityIdsFunction: true, memberProfilesTableId: true } } })
useCreateMembershipsModuleMutation({ selection: { fields: { id: true } } })
useUpdateMembershipsModuleMutation({ selection: { fields: { id: true } } })
useDeleteMembershipsModuleMutation({})

Examples

List all membershipsModules

const { data, isLoading } = useMembershipsModulesQuery({
  selection: { fields: { id: true, databaseId: true, schemaId: true, privateSchemaId: true, membershipsTableId: true, membershipsTableName: true, membersTableId: true, membersTableName: true, membershipDefaultsTableId: true, membershipDefaultsTableName: true, membershipSettingsTableId: true, membershipSettingsTableName: true, grantsTableId: true, grantsTableName: true, actorTableId: true, limitsTableId: true, defaultLimitsTableId: true, permissionsTableId: true, defaultPermissionsTableId: true, sprtTableId: true, adminGrantsTableId: true, adminGrantsTableName: true, ownerGrantsTableId: true, ownerGrantsTableName: true, membershipType: true, entityTableId: true, entityTableOwnerId: true, prefix: true, actorMaskCheck: true, actorPermCheck: true, entityIdsByMask: true, entityIdsByPerm: true, entityIdsFunction: true, memberProfilesTableId: true } },
});

Create a membershipsModule

const { mutate } = useCreateMembershipsModuleMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', schemaId: '<UUID>', privateSchemaId: '<UUID>', membershipsTableId: '<UUID>', membershipsTableName: '<String>', membersTableId: '<UUID>', membersTableName: '<String>', membershipDefaultsTableId: '<UUID>', membershipDefaultsTableName: '<String>', membershipSettingsTableId: '<UUID>', membershipSettingsTableName: '<String>', grantsTableId: '<UUID>', grantsTableName: '<String>', actorTableId: '<UUID>', limitsTableId: '<UUID>', defaultLimitsTableId: '<UUID>', permissionsTableId: '<UUID>', defaultPermissionsTableId: '<UUID>', sprtTableId: '<UUID>', adminGrantsTableId: '<UUID>', adminGrantsTableName: '<String>', ownerGrantsTableId: '<UUID>', ownerGrantsTableName: '<String>', membershipType: '<Int>', entityTableId: '<UUID>', entityTableOwnerId: '<UUID>', prefix: '<String>', actorMaskCheck: '<String>', actorPermCheck: '<String>', entityIdsByMask: '<String>', entityIdsByPerm: '<String>', entityIdsFunction: '<String>', memberProfilesTableId: '<UUID>' });

migrateFile

React Query hooks for MigrateFile data operations

Usage

useMigrateFilesQuery({ selection: { fields: { id: true, databaseId: true, upload: true } } })
useMigrateFileQuery({ id: '<UUID>', selection: { fields: { id: true, databaseId: true, upload: true } } })
useCreateMigrateFileMutation({ selection: { fields: { id: true } } })
useUpdateMigrateFileMutation({ selection: { fields: { id: true } } })
useDeleteMigrateFileMutation({})

Examples

List all migrateFiles

const { data, isLoading } = useMigrateFilesQuery({
  selection: { fields: { id: true, databaseId: true, upload: true } },
});

Create a migrateFile

const { mutate } = useCreateMigrateFileMutation({
  selection: { fields: { id: true } },
});
mutate({ databaseId: '<UUID>', upload: '<Upload>' });

Related skills

Vercel React Best PracticesAutomatically apply Vercel’s official React and Next.js performance rules during code generation and review.587k29.6k

Vercel Composition PatternsGenerate and refactor React components that stay maintainable as complexity grows without boolean prop explosion.267k29.6k

ShadcnAdd, compose, search, fix, and style production-grade React components directly from source without leaving their editor.257k120k

Develop UserscriptsCorrectly write, debug, and package userscripts for Tampermonkey and ScriptCat with proper metadata, GM APIs, and runtime decisions.224k72

Minimalist UiGenerate clean, editorial-style web interfaces with warm monochrome palettes, typographic hierarchy, bento grids and flat components that feel premium and utilita212k69.4k

Image To CodeConvert high-fidelity design images into production-ready, visually accurate frontend code that avoids generic AI design pitfalls.177k69.4k

Frontend Developmentaudit