@sublay/js 7.9.0 → 7.9.2

package/dist/index.d.ts

@@ -1,27 +1,4367 @@
-import { SublayHttpClient, ClientConfig, AuthTokens } from "./core/client";
-import * as Auth from "./modules/auth";
-import * as Users from "./modules/users";
-import * as Entities from "./modules/entities";
-import * as Events from "./modules/events";
-import * as Comments from "./modules/comments";
-import * as Spaces from "./modules/spaces";
-import * as Collections from "./modules/collections";
-import * as Follows from "./modules/follows";
-import * as Connections from "./modules/connections";
-import * as AppNotifications from "./modules/app-notifications";
-import * as Reports from "./modules/reports";
-import * as Reputation from "./modules/reputation";
-import * as Search from "./modules/search";
-import * as Storage from "./modules/storage";
-import * as OAuth from "./modules/oauth";
-import * as Chat from "./modules/chat";
-import * as Push from "./modules/push";
-import * as Workspaces from "./modules/workspaces";
-import { TableAccessor, TableRow } from "./interfaces/Table";
+import { AxiosInstance } from 'axios';
+
+interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+}
+interface ClientConfig {
+    projectId: string;
+    /**
+     * Optional tokens to hydrate the SDK on init (SDK-managed mode) — e.g. tokens
+     * the host app persisted from a previous session.
+     */
+    initialTokens?: AuthTokens;
+    /**
+     * Optional async hook returning the current access token. **Providing it puts
+     * the SDK in "host-managed" mode**: the host owns the token and its refresh,
+     * and the SDK never stores or refreshes tokens itself.
+     */
+    getToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    /**
+     * Called whenever the SDK sets, rotates, or clears tokens (SDK-managed mode
+     * only). Receives `null` on sign-out. Use it to persist tokens so a session
+     * survives a reload.
+     */
+    onAuthChange?: (tokens: AuthTokens | null) => void;
+}
+declare class SublayHttpClient {
+    projectInstance: AxiosInstance;
+    private readonly baseURL;
+    private readonly hostManaged;
+    private readonly getToken?;
+    private readonly onAuthChange?;
+    private accessToken;
+    private refreshToken;
+    /** Shared so concurrent 403s trigger a single refresh (mutex). */
+    private refreshPromise;
+    constructor({ projectId, initialTokens, getToken, onAuthChange, }: ClientConfig);
+    /**
+     * The SDK's own in-memory access token (SDK-managed mode). Distinct from the
+     * `init({ getToken })` host hook, which supplies a token in host-managed mode.
+     */
+    getAccessToken(): string | null;
+    getRefreshToken(): string | null;
+    /**
+     * The `Authorization` header value (`Bearer <token>`) for the active auth
+     * mode, or `undefined` if there is no token. Host-managed mode reads the
+     * `getToken` hook; SDK-managed mode reads the in-memory access token. Use this
+     * for requests that bypass `projectInstance` (e.g. the SSE `askContent`
+     * stream, which needs `fetch` rather than axios).
+     */
+    getAuthHeader(): Promise<string | undefined>;
+    /** Store a full token pair (SDK-managed mode only; no-op when host-managed). */
+    setTokens(tokens: AuthTokens): void;
+    /** Update just the access token, e.g. after a refresh (no-op when host-managed). */
+    setAccessToken(accessToken: string): void;
+    /** Clear tokens and notify with null (SDK-managed mode only). */
+    clearTokens(): void;
+    /**
+     * Refresh the access token using the in-memory refresh token. A single shared
+     * promise (mutex) means concurrent 403s trigger only one network refresh. The
+     * call goes through a bare axios (not `projectInstance`) so it never re-enters
+     * the response interceptor. Returns the new access token, or null on failure.
+     */
+    private refreshAccessToken;
+}
+
+interface FileImageVariant {
+    path: string;
+    publicPath: string;
+    width: number;
+    height: number;
+    size: number;
+    format: string;
+}
+interface FileImage {
+    fileId: string;
+    originalWidth: number;
+    originalHeight: number;
+    variants: Record<string, FileImageVariant>;
+    processingStatus: "completed" | "failed";
+    processingError: string | null;
+    format: string;
+    quality: number;
+    exifStripped: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface File$1 {
+    id: string;
+    projectId: string;
+    userId: string | null;
+    entityId: string | null;
+    commentId: string | null;
+    chatMessageId: string | null;
+    spaceId: string | null;
+    type: "image" | "video" | "document" | "other";
+    originalPath: string;
+    originalSize: number;
+    originalMimeType: string;
+    position: number;
+    metadata: Record<string, any>;
+    image?: FileImage;
+    createdAt: string;
+    updatedAt: string;
+}
+
+type UserRole = "admin" | "moderator" | "visitor";
+type UserFull = {
+    id: string;
+    projectId: string;
+    foreignId: string | null;
+    role: UserRole;
+    email: string | null;
+    name: string | null;
+    username: string | null;
+    avatar: string | null;
+    avatarFileId: string | null;
+    bannerFileId: string | null;
+    avatarFile?: File$1 | null;
+    bannerFile?: File$1 | null;
+    bio: string | null;
+    birthdate: string | null;
+    location: {
+        type: "Point";
+        coordinates: [number, number];
+    } | null;
+    metadata: Record<string, any>;
+    secureMetadata: Record<string, any>;
+    reputation: number;
+    /**
+     * Space-scoped reputation, present only when the request opted in via
+     * `spaceReputationId` (and the project has the reputation bundle). It is the
+     * user's reputation within the requested space context — see
+     * {@link SpaceReputationContextParams} / {@link SpaceReputationUserParams}.
+     */
+    spaceReputation?: number;
+    isVerified: boolean;
+    isActive: boolean;
+    lastActive: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type AuthUser = Omit<UserFull, "secureMetadata"> & {
+    suspensions: {
+        reason: string | null;
+        startDate: string;
+        endDate: string | null;
+    }[];
+    authMethods: string[];
+};
+type User = Omit<UserFull, "email" | "secureMetadata" | "isVerified" | "isActive" | "lastActive" | "updatedAt">;
+
+interface SignUpProps {
+    email: string;
+    password: string;
+    name?: string;
+    username?: string;
+    avatar?: string;
+    bio?: string;
+    location?: {
+        latitude: number;
+        longitude: number;
+    };
+    /** ISO 8601 datetime string. */
+    birthdate?: string;
+    metadata?: Record<string, any>;
+    secureMetadata?: Record<string, any>;
+}
+interface SignUpResponse {
+    user: AuthUser;
+    accessToken: string;
+    refreshToken: string;
+}
+declare function signUp(client: SublayHttpClient, data: SignUpProps): Promise<SignUpResponse>;
+
+interface SignInProps {
+    email: string;
+    password: string;
+}
+interface SignInResponse {
+    user: AuthUser;
+    accessToken: string;
+    refreshToken: string;
+}
+declare function signIn(client: SublayHttpClient, data: SignInProps): Promise<SignInResponse>;
+
+/**
+ * Every push event type — the full app-notification type set plus the chat
+ * `message` event (push-only). Mirrors the server's `PUSH_EVENT_TYPES` exactly
+ * (server `src/constants/push/pushEvents.ts`); these are the only names a
+ * `disabledTypes` set may contain.
+ */
+declare const PUSH_EVENT_TYPES: readonly ["entity-comment", "comment-reply", "entity-mention", "comment-mention", "entity-reaction", "comment-reaction", "entity-reaction-milestone-specific", "entity-reaction-milestone-total", "comment-reaction-milestone-specific", "comment-reaction-milestone-total", "new-follow", "connection-request", "connection-accepted", "space-membership-approved", "event-invite", "event-updated", "event-cancelled", "reputation-grant", "message"];
+type PushEventType = (typeof PUSH_EVENT_TYPES)[number];
+/**
+ * The four conversation-mute duration choices. Send the CHOICE, never a raw
+ * timestamp — the server resolves it and represents "forever" via the explicit
+ * `mutedForever` signal on the returned member. Mirrors the server's
+ * `MUTE_DURATIONS` (server `src/helpers/push/muteDuration.ts`).
+ */
+declare const MUTE_DURATIONS: readonly ["8h", "24h", "1w", "forever"];
+type MuteDuration = (typeof MUTE_DURATIONS)[number];
+/** Response of read/update notification preferences. */
+interface NotificationPreferences {
+    disabledTypes: PushEventType[];
+}
+/**
+ * A Web Push subscription in its SERIALIZED form — the JSON the server reads,
+ * not the live browser object.
+ *
+ * A `PushSubscription` straight from `PushManager.subscribe()` does NOT satisfy
+ * this type. It exposes its keys only through `getKey(name)`; there is no `keys`
+ * property to read, so it is not assignable here under strict TypeScript, and
+ * passing one through a cast sends a body the server rejects.
+ *
+ * To produce a value of this type:
+ *
+ * 1. **Serialize** the subscription with `subscription.toJSON()`.
+ * 2. **Confirm** `endpoint`, `keys.p256dh` and `keys.auth` are all present —
+ *    `PushSubscriptionJSON` types every one of them as optional, while the
+ *    server requires all three as non-empty strings and 400s otherwise.
+ *
+ * ```ts
+ * const json = subscription.toJSON();
+ * if (!json.endpoint || !json.keys?.p256dh || !json.keys?.auth) {
+ *   throw new Error("Incomplete Web Push subscription");
+ * }
+ * const webPushSubscription: WebPushSubscription = {
+ *   endpoint: json.endpoint,
+ *   keys: { p256dh: json.keys.p256dh, auth: json.keys.auth },
+ * };
+ * ```
+ *
+ * Mirrors the server's `webPushSubscriptionSchema`
+ * (server `src/v7/validation/push-notifications/push-notifications.schema.ts`).
+ */
+interface WebPushSubscription {
+    endpoint: string;
+    keys: {
+        p256dh: string;
+        auth: string;
+    };
+}
+/**
+ * Identifies one physical device. Mirrors the server's device-identifier body
+ * exactly (server `src/v7/validation/push-notifications/push-notifications.schema.ts`):
+ * a provider token for `ios`/`android`, a Web Push subscription for `web`. The
+ * union encodes the server's own cross-check — it rejects the same
+ * combinations the server's `superRefine` rejects.
+ *
+ * Passed to `auth.signOut` to unbind that device's push binding in the same
+ * transaction as the sign-out.
+ */
+type PushDeviceIdentifier = {
+    platform: "ios" | "android";
+    token: string;
+} | {
+    platform: "web";
+    subscription: WebPushSubscription;
+};
+
+interface SignOutProps {
+    /**
+     * Defaults to the SDK's stored refresh token (SDK-managed mode). Pass it
+     * explicitly in host-managed mode, where the SDK holds no refresh token.
+     */
+    refreshToken?: string;
+    /**
+     * Optional. When supplied — and the project has the `push` bundle — the
+     * server deletes this user's push binding for that device in the SAME
+     * transaction as the token-family destroy: signing out unbinds the device's
+     * push, or nothing happens at all.
+     *
+     * **Needs a refresh token to have any effect.** The unbind is scoped to the
+     * `sub` of the refresh token, which is what stops one account removing
+     * another account's binding on a shared device — so with no token there is no
+     * user to scope it to and the server answers `204` before it ever looks at
+     * `pushDevice`. When none can be resolved the field is DROPPED from the
+     * request rather than sent into that silent no-op, the sign-out proceeds
+     * normally, and the returned `pushUnbindSkipped` says so. Watch for it in
+     * **host-managed mode**: such a client is built with `getToken` and no
+     * `initialTokens`, and its `setTokens` is inert, so it starts with no refresh
+     * token and can never acquire one. Pass `refreshToken` explicitly alongside
+     * `pushDevice` there.
+     *
+     * If the unbind fails the request fails (HTTP 500, code
+     * `auth/device-deregistration-failed` or `auth/sign-out-failed`) and NOTHING
+     * is committed — the session survives so the caller can retry, and this call
+     * rethrows WITHOUT clearing the SDK's local tokens, so the credential that
+     * retry needs is still there.
+     *
+     * That is the ONLY failure that leaves you signed in. Every other one — a
+     * `429` from the rate limiter or a quota gate, a `423`, a `503`, a `400` on
+     * the body, a dropped connection — never touched a push binding, so it
+     * clears the local tokens and RESOLVES: a user must always be able to sign
+     * out. See `UNBIND_FAILURE_CODES`.
+     *
+     * Omit it and the request is byte-identical to before this field existed.
+     */
+    pushDevice?: PushDeviceIdentifier;
+}
+/**
+ * Why the unbind did not happen. Present only when `pushUnbindSkipped` is
+ * `true`, and it exists because THE TWO SKIPS ARE RECOVERED DIFFERENTLY — a
+ * caller that cannot tell them apart can only ever pick the wrong remedy for
+ * one of them:
+ *
+ * - `no-refresh-token` — this SDK never asked. Nothing was destroyed either:
+ *   with no token the server has no session to end, so the account, its
+ *   credential and its binding are all still there. **Retryable**: re-issue
+ *   the sign-out with an explicit `refreshToken` and the unbind happens.
+ * - `push-unbind-status-unknown` — the server was asked and could not answer.
+ *   The sign-out itself DID commit, so the credential that would have driven a
+ *   retry is gone; re-issuing achieves nothing. The binding clears when that
+ *   account next registers on this device, or when the server prunes the token
+ *   as undeliverable.
+ */
+type PushUnbindSkipReason = "no-refresh-token" | "push-unbind-status-unknown";
+interface SignOutResult {
+    /**
+     * `true` whenever a `pushDevice` was supplied and the unbind did NOT happen,
+     * so this device's push binding for that account may still be live. Either
+     * the SDK declined to ask (no refresh token to scope the unbind to) or the
+     * server could not answer whether a binding exists; `pushUnbindSkipReason`
+     * says which, and the two are recovered differently.
+     *
+     * `false` means NO SKIP WAS REPORTED — by this SDK or by the server. It is
+     * not a promise that no skip happened, and the difference is not academic:
+     * the server declines the unbind for several reasons it answers with a plain
+     * `204`, and every one of them reads `false` here.
+     *
+     *   - The refresh token is authentic but expired beyond the server's unbind
+     *     window (90 days past `exp`), so there is no subject to scope the unbind
+     *     to. Reachable from this SDK by passing an old `refreshToken` explicitly
+     *     alongside `pushDevice`.
+     *   - The refresh token is malformed or fails signature verification.
+     *   - The project has no `push` bundle, so no binding can exist.
+     *   - The unbind ran and matched zero rows — the binding was already gone, or
+     *     was never registered under this device key.
+     *
+     * The server logs each of those under its own reason; only the case where it
+     * could not determine whether a binding exists is reported in the response,
+     * because that is the one where the binding may still be LIVE and nobody
+     * looked. The rest either prove there was nothing to remove or leave a device
+     * key the server cannot attribute to a user, and neither gives the caller
+     * anything to act on beyond what it already knows.
+     *
+     * A request that failed short of an unbind attempt reads `false` too — a
+     * gate's `429` or `423`, a `503`, a `400`, a dropped connection. Those clear
+     * the local tokens and resolve rather than reject (see `UNBIND_FAILURE_CODES`
+     * for why), and none of them is a REPORTED skip; they are logged with a
+     * warning instead.
+     *
+     * The sign-out itself is unaffected by the flag in both directions: a user
+     * must always be able to sign out, so a skipped unbind never fails the call
+     * and never leaves the local tokens in place.
+     */
+    pushUnbindSkipped: boolean;
+    /** Set only when `pushUnbindSkipped` is `true`. See `PushUnbindSkipReason`. */
+    pushUnbindSkipReason?: PushUnbindSkipReason;
+}
+declare function signOut(client: SublayHttpClient, data?: SignOutProps): Promise<SignOutResult>;
+
+interface RequestNewAccessTokenProps {
+    /** Defaults to the SDK's stored refresh token (SDK-managed mode). */
+    refreshToken?: string;
+}
+interface RequestNewAccessTokenResponse {
+    accessToken: string;
+    /** The server rotates the refresh token on every refresh and returns the new one. */
+    refreshToken?: string;
+}
+/**
+ * Manually rotate the access token. The SDK auto-refreshes on 403 in
+ * SDK-managed mode, so this is rarely needed directly; it's exposed for parity
+ * and for host-managed callers that own their own refresh flow.
+ */
+declare function requestNewAccessToken(client: SublayHttpClient, data?: RequestNewAccessTokenProps): Promise<RequestNewAccessTokenResponse>;
+
+interface VerifyExternalUserProps {
+    userJwt: string;
+}
+interface VerifyExternalUserResponse {
+    user: AuthUser;
+    accessToken: string;
+    refreshToken: string;
+}
+declare function verifyExternalUser(client: SublayHttpClient, data: VerifyExternalUserProps): Promise<VerifyExternalUserResponse>;
+
+interface RequestPasswordResetProps {
+    email: string;
+}
+declare function requestPasswordReset(client: SublayHttpClient, data: RequestPasswordResetProps): Promise<void>;
+
+interface ResetPasswordProps {
+    token: string;
+    newPassword: string;
+}
+declare function resetPassword(client: SublayHttpClient, data: ResetPasswordProps): Promise<void>;
+
+interface ChangePasswordProps {
+    /** The user's current password (verified before the change). */
+    password: string;
+    newPassword: string;
+    /**
+     * Optional. The physical device making this call.
+     *
+     * A password change also deletes every push binding the user holds, so an
+     * intruder's device stops receiving notification content. Naming this device
+     * keeps ITS binding — nothing re-binds a device from its live session, so
+     * without this the handset the user just changed their password on goes
+     * quiet until the app cold-starts or switches accounts.
+     *
+     * Same value passed to `push.register` / `auth.signOut`. Omit it and every
+     * binding for the user goes, this device included.
+     */
+    pushDevice?: PushDeviceIdentifier;
+}
+interface ChangePasswordResponse {
+    success: boolean;
+    message: string;
+}
+/**
+ * Change the signed-in user's password.
+ *
+ * Ends every OTHER session for that user — every other device must sign in
+ * again with the new password — while the session making this call survives.
+ * The server identifies that session from the access token this request is
+ * already authenticated with, so nothing about the caller's session has to be
+ * sent.
+ */
+declare function changePassword(client: SublayHttpClient, data: ChangePasswordProps): Promise<ChangePasswordResponse>;
+
+interface SetPasswordProps {
+    newPassword: string;
+}
+interface SetPasswordResponse {
+    success: boolean;
+    message: string;
+}
+declare function setPassword(client: SublayHttpClient, data: SetPasswordProps): Promise<SetPasswordResponse>;
+
+interface VerifyEmailProps {
+    token: string;
+}
+declare function verifyEmail(client: SublayHttpClient, data: VerifyEmailProps): Promise<void>;
+
+interface SendCodeVerificationEmailHexProps {
+    mode: "code";
+    tokenFormat: "hex";
+    tokenLength?: never;
+}
+interface SendCodeVerificationEmailShortProps {
+    mode: "code";
+    tokenFormat: "numeric" | "alpha" | "alphanumeric";
+    tokenLength: number;
+}
+interface SendLinkVerificationEmailProps {
+    mode: "link";
+    tokenFormat?: "hex" | "numeric" | "alpha" | "alphanumeric";
+    tokenLength?: number;
+    /** Where to send the user after the link is verified. */
+    redirectUrl?: string;
+}
+/**
+ * `mode` is required so every caller explicitly decides code vs link, and the
+ * `tokenFormat`/`tokenLength` pair for "code" is a discriminated union rather
+ * than two independent optionals — pairing `mode: "code"` with the default
+ * `tokenFormat: "hex"` used to compile fine and silently email a 64-character
+ * string no one could type.
+ */
+type SendVerificationEmailProps = SendCodeVerificationEmailHexProps | SendCodeVerificationEmailShortProps | SendLinkVerificationEmailProps;
+interface SendVerificationEmailResponse {
+    success: boolean;
+}
+declare function sendVerificationEmail(client: SublayHttpClient, data: SendVerificationEmailProps): Promise<SendVerificationEmailResponse>;
+
+interface RequestAccountDeletionResponse {
+    success: boolean;
+}
+/**
+ * Step 1 of self-service account deletion. Emails the signed-in user a one-time
+ * confirmation code. Pass that code to {@link confirmAccountDeletion} to
+ * permanently delete the account.
+ *
+ * Requires the account to have an email on file — accounts without one (e.g.
+ * anonymous or foreign-id users) must be deleted server-side with a service key
+ * via the node SDK (`client.users.deleteUser`).
+ */
+declare function requestAccountDeletion(client: SublayHttpClient): Promise<RequestAccountDeletionResponse>;
+
+interface ConfirmAccountDeletionProps {
+    /** The one-time code emailed by {@link requestAccountDeletion}. */
+    code: string;
+}
+/**
+ * Step 2 of self-service account deletion. Verifies the emailed code and then
+ * permanently deletes the signed-in user's account (same cascade as the
+ * admin/service delete). This is immediate and cannot be undone.
+ */
+declare function confirmAccountDeletion(client: SublayHttpClient, data: ConfirmAccountDeletionProps): Promise<void>;
+
+declare const Auth_changePassword: typeof changePassword;
+declare const Auth_confirmAccountDeletion: typeof confirmAccountDeletion;
+declare const Auth_requestAccountDeletion: typeof requestAccountDeletion;
+declare const Auth_requestNewAccessToken: typeof requestNewAccessToken;
+declare const Auth_requestPasswordReset: typeof requestPasswordReset;
+declare const Auth_resetPassword: typeof resetPassword;
+declare const Auth_sendVerificationEmail: typeof sendVerificationEmail;
+declare const Auth_setPassword: typeof setPassword;
+declare const Auth_signIn: typeof signIn;
+declare const Auth_signOut: typeof signOut;
+declare const Auth_signUp: typeof signUp;
+declare const Auth_verifyEmail: typeof verifyEmail;
+declare const Auth_verifyExternalUser: typeof verifyExternalUser;
+declare namespace Auth {
+  export { Auth_changePassword as changePassword, Auth_confirmAccountDeletion as confirmAccountDeletion, Auth_requestAccountDeletion as requestAccountDeletion, Auth_requestNewAccessToken as requestNewAccessToken, Auth_requestPasswordReset as requestPasswordReset, Auth_resetPassword as resetPassword, Auth_sendVerificationEmail as sendVerificationEmail, Auth_setPassword as setPassword, Auth_signIn as signIn, Auth_signOut as signOut, Auth_signUp as signUp, Auth_verifyEmail as verifyEmail, Auth_verifyExternalUser as verifyExternalUser };
+}
+
+/**
+ * Shared optional params for opting a request into space-scoped reputation
+ * enrichment. When set, users embedded in the response carry a
+ * `spaceReputation` field (see {@link import("./User").UserFull}).
+ *
+ * Two variants exist because the server accepts a different value set per
+ * endpoint class:
+ * - {@link SpaceReputationContextParams} — context endpoints (entities,
+ *   comments, chat, spaces, search, reports). Accept `<uuid> | "none" |
+ *   "context"`.
+ * - {@link SpaceReputationUserParams} — user-direct endpoints (the `users`
+ *   module). Accept `<uuid> | "none"` only; `"context"` is rejected by the
+ *   server (400).
+ *
+ * Both classes share the same param names and types — only the accepted
+ * `spaceReputationId` value set (documented in JSDoc) differs.
+ */
+/**
+ * Space-reputation params for **context** endpoints.
+ */
+interface SpaceReputationContextParams {
+    /**
+     * Opt into space-scoped reputation enrichment. The primary form: an object
+     * describing the space and whether to include descendants.
+     *
+     * - `spaceId` — a space `<uuid>` (reputation within that specific space),
+     *   `"none"` (no space context — global reputation only), or `"context"`
+     *   (derive the space from each record's own context, e.g. a feed enriches
+     *   each row's author with reputation in that row's space).
+     * - `includeDescendants` — whether to include descendant spaces when
+     *   computing space-scoped reputation. Only honored with an explicit space
+     *   `<uuid>` (ignored for `"none"` / `"context"`).
+     */
+    spaceReputation?: {
+        spaceId: string | "none" | "context";
+        includeDescendants?: boolean;
+    };
+    /**
+     * @deprecated Pass the `spaceReputation` object instead. Retained for
+     * back-compat; removal is a later major version.
+     *
+     * Opt into space-scoped reputation enrichment. Accepted forms:
+     * - a space `<uuid>` — reputation within that specific space;
+     * - `"none"` — no space context (global reputation only);
+     * - `"context"` — derive the space from each record's own context
+     *   (e.g. a feed enriches each row's author with reputation in that row's
+     *   space).
+     */
+    spaceReputationId?: string;
+    /**
+     * @deprecated Pass the `spaceReputation` object (`includeDescendants`)
+     * instead. Retained for back-compat; removal is a later major version.
+     *
+     * Whether to include descendant spaces when computing space-scoped
+     * reputation. Only honored with an explicit space `<uuid>` (ignored for
+     * `"none"` / `"context"`).
+     */
+    spaceReputationDescendants?: boolean;
+}
+/**
+ * Space-reputation params for **user-direct** endpoints (the `users` module).
+ */
+interface SpaceReputationUserParams {
+    /**
+     * Opt into space-scoped reputation enrichment. The primary form: an object
+     * describing the space and whether to include descendants.
+     *
+     * - `spaceId` — a space `<uuid>` (reputation within that specific space) or
+     *   `"none"` (no space context — global reputation only). `"context"` is
+     *   **rejected by the server (400)** on user-direct endpoints — there is no
+     *   per-record context to derive a space from.
+     * - `includeDescendants` — whether to include descendant spaces when
+     *   computing space-scoped reputation. Only honored with an explicit space
+     *   `<uuid>`.
+     */
+    spaceReputation?: {
+        spaceId: string | "none";
+        includeDescendants?: boolean;
+    };
+    /**
+     * @deprecated Pass the `spaceReputation` object instead. Retained for
+     * back-compat; removal is a later major version.
+     *
+     * Opt into space-scoped reputation enrichment. Accepted forms:
+     * - a space `<uuid>` — reputation within that specific space;
+     * - `"none"` — no space context (global reputation only).
+     *
+     * `"context"` is **rejected by the server (400)** on user-direct endpoints —
+     * there is no per-record context to derive a space from.
+     */
+    spaceReputationId?: string;
+    /**
+     * @deprecated Pass the `spaceReputation` object (`includeDescendants`)
+     * instead. Retained for back-compat; removal is a later major version.
+     *
+     * Whether to include descendant spaces when computing space-scoped
+     * reputation. Only honored with an explicit space `<uuid>`.
+     */
+    spaceReputationDescendants?: boolean;
+}
+
+interface FetchUserByIdProps extends SpaceReputationUserParams {
+    userId: string;
+    include?: string;
+}
+declare function fetchUserById(client: SublayHttpClient, data: FetchUserByIdProps): Promise<User>;
+
+interface FetchUserByForeignIdProps extends SpaceReputationUserParams {
+    foreignId: string;
+    include?: string;
+}
+declare function fetchUserByForeignId(client: SublayHttpClient, data: FetchUserByForeignIdProps): Promise<User>;
+
+interface FetchUserByUsernameProps extends SpaceReputationUserParams {
+    username: string;
+    include?: string;
+}
+declare function fetchUserByUsername(client: SublayHttpClient, data: FetchUserByUsernameProps): Promise<User>;
+
+interface FetchUserSuggestionsProps extends SpaceReputationUserParams {
+    query: string;
+}
+declare function fetchUserSuggestions(client: SublayHttpClient, data: FetchUserSuggestionsProps): Promise<User[]>;
+
+interface CheckUsernameAvailabilityProps {
+    username: string;
+}
+interface CheckUsernameAvailabilityResponse {
+    available: boolean;
+}
+declare function checkUsernameAvailability(client: SublayHttpClient, data: CheckUsernameAvailabilityProps): Promise<CheckUsernameAvailabilityResponse>;
+
+type ImageFit = "cover" | "contain" | "inside" | "outside";
+type ImageFormat = "webp" | "jpeg" | "png" | "original";
+interface BaseImageOptions {
+    /** 1–100. Output quality. */
+    quality?: number;
+    format?: ImageFormat;
+    stripExif?: boolean;
+}
+/** Mode 1 — explicit width/height per named variant. */
+interface ExactDimensionsOptions extends BaseImageOptions {
+    mode: "exact-dimensions";
+    /** Keyed by variant name, e.g. `{ thumbnail: { width, height } }`. 50–10000. */
+    dimensions: Record<string, {
+        width: number;
+        height: number;
+    }>;
+    fit?: ImageFit;
+}
+/** Mode 2a — fixed aspect ratio, sized by width per variant. */
+interface AspectRatioWidthOptions extends BaseImageOptions {
+    mode: "aspect-ratio-width-based";
+    aspectRatio: {
+        width: number;
+        height: number;
+    };
+    /** Keyed by variant name → target width (50–10000). */
+    widths: Record<string, number>;
+    fit?: ImageFit;
+}
+/** Mode 2b — fixed aspect ratio, sized by height per variant. */
+interface AspectRatioHeightOptions extends BaseImageOptions {
+    mode: "aspect-ratio-height-based";
+    aspectRatio: {
+        width: number;
+        height: number;
+    };
+    /** Keyed by variant name → target height (50–10000). */
+    heights: Record<string, number>;
+    fit?: ImageFit;
+}
+/** Mode 3 — preserve the source aspect ratio, bounded per variant. */
+interface OriginalAspectOptions extends BaseImageOptions {
+    mode: "original-aspect";
+    /** Keyed by variant name → bounding size (50–10000). */
+    sizes: Record<string, number>;
+    /** Server restricts this mode to `inside` | `outside`. */
+    fit?: "inside" | "outside";
+}
+/** Mode 4 — multiple aspect ratios, sized per variant. */
+interface MultiAspectRatioOptions extends BaseImageOptions {
+    mode: "multi-aspect-ratio";
+    /** 1–10 aspect ratios. */
+    aspectRatios: {
+        width: number;
+        height: number;
+    }[];
+    /** Keyed by variant name → target size (50–10000). */
+    sizes: Record<string, number>;
+    fit?: ImageFit;
+}
+type ImageOptions = ExactDimensionsOptions | AspectRatioWidthOptions | AspectRatioHeightOptions | OriginalAspectOptions | MultiAspectRatioOptions;
+
+/** A file plus the image-processing options the server requires alongside it. */
+interface UserImageUpload {
+    file: Blob | File;
+    /** Image-processing config (must include `mode`) — see {@link ImageOptions}. */
+    options: ImageOptions;
+}
+interface UpdateUserProps {
+    /** The user to update (the target). A user token may only update itself. */
+    userId: string;
+    name?: string;
+    username?: string;
+    avatar?: string;
+    bio?: string;
+    birthdate?: string;
+    location?: {
+        latitude: number;
+        longitude: number;
+    } | null;
+    metadata?: Record<string, any>;
+    secureMetadata?: Record<string, any>;
+    /**
+     * New avatar image. When present the request is sent as `multipart/form-data`.
+     * The server processes the image per `options` and replaces the old avatar.
+     */
+    avatarFile?: UserImageUpload;
+    /** New banner image; same contract as {@link UpdateUserProps.avatarFile}. */
+    bannerFile?: UserImageUpload;
+}
+declare function updateUser(client: SublayHttpClient, data: UpdateUserProps): Promise<AuthUser>;
+
+interface Follow {
+    id: string;
+    projectId: string;
+    followerId: string;
+    followedId: string;
+    createdAt: string;
+}
+/**
+ * An entry in a follower/following list. The list endpoints
+ * (`/follows/(followers|following)` and `/users/:userId/(followers|following)`)
+ * return the follow id, the populated other user, and when the follow happened
+ * — NOT the raw {@link Follow} row.
+ */
+interface FollowListItem {
+    followId: string;
+    user: User;
+    followedAt: string;
+}
+
+interface PaginationMetadata {
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    totalItems: number;
+    hasMore: boolean;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: PaginationMetadata;
+}
+
+/**
+ * Shared optional params for text-searching a list of users
+ * (followers / following / connections).
+ *
+ * - `query` — free-text search term. When omitted, no filtering is applied.
+ * - `searchFields` — narrows which user field the term matches against. When
+ *   omitted, the term matches either `username` OR `name` (case-insensitive
+ *   substring). `"username"` / `"name"` restrict the match to that one field.
+ */
+interface UserSearchParams {
+    query?: string;
+    searchFields?: "username" | "name";
+}
+
+interface FetchFollowersByUserIdProps extends SpaceReputationUserParams, UserSearchParams {
+    userId: string;
+    page?: number;
+    limit?: number;
+}
+declare function fetchFollowersByUserId(client: SublayHttpClient, data: FetchFollowersByUserIdProps): Promise<PaginatedResponse<FollowListItem>>;
+
+interface FetchFollowersCountByUserIdProps {
+    userId: string;
+}
+interface FollowersCountResponse$1 {
+    count: number;
+}
+declare function fetchFollowersCountByUserId(client: SublayHttpClient, data: FetchFollowersCountByUserIdProps): Promise<FollowersCountResponse$1>;
+
+interface FetchFollowingByUserIdProps extends SpaceReputationUserParams, UserSearchParams {
+    userId: string;
+    page?: number;
+    limit?: number;
+}
+declare function fetchFollowingByUserId(client: SublayHttpClient, data: FetchFollowingByUserIdProps): Promise<PaginatedResponse<FollowListItem>>;
+
+interface FetchFollowingCountByUserIdProps {
+    userId: string;
+}
+interface FollowingCountResponse$1 {
+    count: number;
+}
+declare function fetchFollowingCountByUserId(client: SublayHttpClient, data: FetchFollowingCountByUserIdProps): Promise<FollowingCountResponse$1>;
+
+interface Connection {
+    id: string;
+    message?: string;
+    createdAt: string;
+}
+/** Returned by `POST /users/:userId/connection` (requestConnection). */
+interface ConnectionRequestResponse {
+    id: string;
+    status: string;
+    createdAt: string;
+}
+interface EstablishedConnection {
+    id: string;
+    connectedUser: User;
+    connectedAt: string;
+}
+interface PendingConnection extends Connection {
+    user: User;
+    type: "received" | "sent";
+}
+interface ConnectionActionResponse {
+    id: string;
+    status: string;
+    createdAt?: string;
+    respondedAt?: string;
+}
+interface ConnectionCountResponse {
+    count: number;
+}
+interface RemoveConnectionByUserIdResponse {
+    id?: string;
+    status?: string;
+    respondedAt?: string;
+    message?: string;
+    action?: "withdraw" | "disconnect" | "decline";
+}
+interface ConnectionStatusNone {
+    status: "none";
+}
+interface ConnectionStatusPending {
+    status: "pending";
+    type: "sent" | "received";
+    connectionId: string;
+    createdAt: string;
+}
+interface ConnectionStatusConnected {
+    status: "connected";
+    connectionId: string;
+    connectedAt: string;
+    requestedAt: string;
+}
+interface ConnectionStatusDeclined {
+    status: "declined";
+    type: "sent" | "received";
+    connectionId: string;
+    respondedAt: string;
+}
+type ConnectionStatusResponse = ConnectionStatusNone | ConnectionStatusPending | ConnectionStatusConnected | ConnectionStatusDeclined;
+
+interface FetchConnectionsByUserIdProps extends SpaceReputationUserParams, UserSearchParams {
+    userId: string;
+    page?: number;
+    limit?: number;
+}
+declare function fetchConnectionsByUserId(client: SublayHttpClient, data: FetchConnectionsByUserIdProps): Promise<PaginatedResponse<EstablishedConnection>>;
+
+interface FetchConnectionsCountByUserIdProps {
+    userId: string;
+}
+declare function fetchConnectionsCountByUserId(client: SublayHttpClient, data: FetchConnectionsCountByUserIdProps): Promise<ConnectionCountResponse>;
+
+interface CreateFollowProps {
+    /** The user being followed (the target). The follower is the token holder. */
+    userId: string;
+}
+declare function createFollow(client: SublayHttpClient, data: CreateFollowProps): Promise<Follow>;
+
+interface DeleteFollowProps {
+    /** The user being unfollowed (the target). The follower is the token holder. */
+    userId: string;
+}
+declare function deleteFollow$1(client: SublayHttpClient, data: DeleteFollowProps): Promise<void>;
+
+interface FetchFollowStatusProps {
+    /**
+     * The user whose follow relationship is being checked (the target). The
+     * status is from the perspective of the token holder.
+     */
+    userId: string;
+}
+interface FollowStatusResponse {
+    isFollowing: boolean;
+    followId?: string;
+    followedAt?: string;
+}
+declare function fetchFollowStatus(client: SublayHttpClient, data: FetchFollowStatusProps): Promise<FollowStatusResponse>;
+
+interface RequestConnectionProps {
+    /**
+     * The user the connection is requested with (the target). The requester is
+     * the token holder.
+     */
+    userId: string;
+    message?: string;
+}
+declare function requestConnection(client: SublayHttpClient, data: RequestConnectionProps): Promise<ConnectionRequestResponse>;
+
+interface FetchConnectionStatusProps {
+    /**
+     * The other user in the connection (the target). The status is from the
+     * perspective of the token holder.
+     */
+    userId: string;
+}
+declare function fetchConnectionStatus(client: SublayHttpClient, data: FetchConnectionStatusProps): Promise<ConnectionStatusResponse>;
+
+interface RemoveConnectionByUserIdProps {
+    /**
+     * The other user in the connection (the target). The token holder is the
+     * user withdrawing/declining/disconnecting.
+     */
+    userId: string;
+}
+declare function removeConnectionByUserId(client: SublayHttpClient, data: RemoveConnectionByUserIdProps): Promise<RemoveConnectionByUserIdResponse>;
+
+interface CreateBlockProps {
+    /** The user being blocked (the target). The blocker is the token holder. */
+    userId: string;
+}
+interface BlockResponse {
+    id: string;
+    blockerId: string;
+    blockedId: string;
+    createdAt: string;
+}
+/**
+ * POST /users/:userId/block — block `:userId`.
+ *
+ * The blocker is derived from the token (Rule A — no `actingUserId`). Idempotent:
+ * re-blocking an already-blocked user succeeds. Self-block is rejected server-side.
+ * On a new block the server tears down existing follows/connections both ways.
+ */
+declare function createBlock(client: SublayHttpClient, data: CreateBlockProps): Promise<BlockResponse>;
+
+interface DeleteBlockProps {
+    /** The user being unblocked (the target). The blocker is the token holder. */
+    userId: string;
+}
+/**
+ * DELETE /users/:userId/block — unblock `:userId`.
+ *
+ * The blocker is derived from the token (Rule A — no `actingUserId`). Idempotent:
+ * unblocking a user who isn't blocked succeeds. Restores nothing (torn-down
+ * follows/connections are gone for good).
+ */
+declare function deleteBlock(client: SublayHttpClient, data: DeleteBlockProps): Promise<void>;
+
+interface FetchBlockStatusProps {
+    /**
+     * The user whose block status is being checked (the target). The status is the
+     * token holder's OUTBOUND state only: do *I* block `:userId`?
+     */
+    userId: string;
+}
+/**
+ * The block-status response is outbound-only by design: it reports whether the
+ * token holder blocks the target, and NEVER whether the target blocked the
+ * caller (the inbound direction is deliberately not disclosed).
+ */
+interface BlockStatusResponse {
+    blocked: boolean;
+    blockId?: string;
+    createdAt?: string;
+}
+/**
+ * GET /users/:userId/block — the token holder's outbound block status toward
+ * `:userId` (Rule A — no `actingUserId`).
+ */
+declare function fetchBlockStatus(client: SublayHttpClient, data: FetchBlockStatusProps): Promise<BlockStatusResponse>;
+
+interface FetchBlockedUsersProps {
+    page?: number;
+    limit?: number;
+}
+/** An entry in the token holder's own block list (their outbound blocks). */
+interface BlockedUserListItem {
+    id: string;
+    blockedUser: User | null;
+    createdAt: string;
+}
+/**
+ * GET /blocks — the token holder's own block list (their outbound blocks),
+ * paginated. This is the private "manage / way back to unblock" surface (Rule A
+ * — the subject is derived from the token, no `actingUserId`).
+ */
+declare function fetchBlockedUsers(client: SublayHttpClient, data?: FetchBlockedUsersProps): Promise<PaginatedResponse<BlockedUserListItem>>;
+
+declare const Users_checkUsernameAvailability: typeof checkUsernameAvailability;
+declare const Users_createBlock: typeof createBlock;
+declare const Users_createFollow: typeof createFollow;
+declare const Users_deleteBlock: typeof deleteBlock;
+declare const Users_fetchBlockStatus: typeof fetchBlockStatus;
+declare const Users_fetchBlockedUsers: typeof fetchBlockedUsers;
+declare const Users_fetchConnectionStatus: typeof fetchConnectionStatus;
+declare const Users_fetchConnectionsByUserId: typeof fetchConnectionsByUserId;
+declare const Users_fetchConnectionsCountByUserId: typeof fetchConnectionsCountByUserId;
+declare const Users_fetchFollowStatus: typeof fetchFollowStatus;
+declare const Users_fetchFollowersByUserId: typeof fetchFollowersByUserId;
+declare const Users_fetchFollowersCountByUserId: typeof fetchFollowersCountByUserId;
+declare const Users_fetchFollowingByUserId: typeof fetchFollowingByUserId;
+declare const Users_fetchFollowingCountByUserId: typeof fetchFollowingCountByUserId;
+declare const Users_fetchUserByForeignId: typeof fetchUserByForeignId;
+declare const Users_fetchUserById: typeof fetchUserById;
+declare const Users_fetchUserByUsername: typeof fetchUserByUsername;
+declare const Users_fetchUserSuggestions: typeof fetchUserSuggestions;
+declare const Users_removeConnectionByUserId: typeof removeConnectionByUserId;
+declare const Users_requestConnection: typeof requestConnection;
+declare const Users_updateUser: typeof updateUser;
+declare namespace Users {
+  export { Users_checkUsernameAvailability as checkUsernameAvailability, Users_createBlock as createBlock, Users_createFollow as createFollow, Users_deleteBlock as deleteBlock, deleteFollow$1 as deleteFollow, Users_fetchBlockStatus as fetchBlockStatus, Users_fetchBlockedUsers as fetchBlockedUsers, Users_fetchConnectionStatus as fetchConnectionStatus, Users_fetchConnectionsByUserId as fetchConnectionsByUserId, Users_fetchConnectionsCountByUserId as fetchConnectionsCountByUserId, Users_fetchFollowStatus as fetchFollowStatus, Users_fetchFollowersByUserId as fetchFollowersByUserId, Users_fetchFollowersCountByUserId as fetchFollowersCountByUserId, Users_fetchFollowingByUserId as fetchFollowingByUserId, Users_fetchFollowingCountByUserId as fetchFollowingCountByUserId, Users_fetchUserByForeignId as fetchUserByForeignId, Users_fetchUserById as fetchUserById, Users_fetchUserByUsername as fetchUserByUsername, Users_fetchUserSuggestions as fetchUserSuggestions, Users_removeConnectionByUserId as removeConnectionByUserId, Users_requestConnection as requestConnection, Users_updateUser as updateUser };
+}
+
+/** The three grantable target kinds. Polymorphic — `targetId` carries no FK. */
+type ReputationGrantTargetType = "entity" | "comment" | "chat-message";
+/**
+ * Who created the grant. `"user"` is a debited transfer (reputation moved out
+ * of `senderId`'s bucket); `"app"` is a mint issued by the project itself with
+ * a null `senderId`. Persisted rather than inferred from `senderId`, which is
+ * also null for a transfer whose sender was later deleted.
+ */
+type ReputationGrantSourceType = "user" | "app";
+/**
+ * The "which item was rewarded" pair, as a both-or-neither union.
+ *
+ * Modelled as a two-branch union rather than two independent optional fields so
+ * a half-filled target — `{ targetType }` with no `targetId`, or the reverse —
+ * does not compile. The server answers that shape with
+ * `400 reputation-grant/invalid-body` on the write (a shared
+ * `bothOrNeitherTarget` refinement) and
+ * `400 reputation-grant/invalid-filter` on the list, so the union turns a
+ * guaranteed round trip into a red squiggle.
+ *
+ * The empty branch is `?: undefined`, NOT `?: null` — deliberately, and for the
+ * same reason `metadata` is not nullable: `grantBodyFields.targetType` is
+ * `.optional()` with no `.nullable()`, so an explicit `targetType: null` is
+ * rejected. Omit both keys to mean "no target".
+ *
+ * Building the pair conditionally needs one accommodation: an inline
+ * conditional spread of just these two keys widens both to `T | undefined` and
+ * then matches neither branch. Either branch the whole argument, or name this
+ * type on a helper and spread that:
+ *
+ * ```ts
+ * const target: ReputationGrantTargetFilter = item
+ *   ? { targetType: "entity", targetId: item.id }
+ *   : {};
+ * await listGrants(client, { ...base, ...target });
+ * ```
+ */
+type ReputationGrantTargetFilter = {
+    /** The kind of item rewarded. Requires `targetId` alongside it. */
+    targetType: ReputationGrantTargetType;
+    /** The rewarded item's id. Requires `targetType` alongside it. */
+    targetId: string;
+} | {
+    targetType?: undefined;
+    targetId?: undefined;
+};
+/**
+ * Per-item reputation-grant summary. Covers positive grants only — negative
+ * grants (app deductions) are invisible on every public read surface.
+ */
+interface GrantSummary {
+    /** Sum of positive grant amounts on the item. */
+    total: number;
+    /** Number of positive grants on the item. */
+    count: number;
+    /** The calling user's own summed positive grants on the item. */
+    viewerTotal: number;
+}
+/**
+ * A single reputation movement. Rows are append-only — nothing updates or
+ * soft-deletes them — so the table is the audit log behind every balance.
+ */
+interface ReputationGrant {
+    id: string;
+    sourceType: ReputationGrantSourceType;
+    /** Null for an app mint, and for a transfer whose sender was deleted. */
+    senderId: string | null;
+    /** Populated when the list is called with `include: "user"`. */
+    sender?: User | null;
+    recipientId: string;
+    /** Populated when the list is called with `include: "user"`. */
+    recipient?: User | null;
+    /** Non-zero. Negative only when `sourceType` is `"app"`. */
+    amount: number;
+    /** The bucket both legs moved in; null = the project-general bucket. */
+    spaceId: string | null;
+    /** Both null or both non-null. */
+    targetType: ReputationGrantTargetType | null;
+    targetId: string | null;
+    note: string | null;
+    metadata: Record<string, any> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+
+type Mention = UserMention | SpaceMention;
+interface UserMention {
+    type: "user";
+    id: string;
+    foreignId?: string | null;
+    username: string;
+}
+interface SpaceMention {
+    type: "space";
+    id: string;
+    slug: string;
+}
+
+type ReadingPermission = "anyone" | "members";
+type PostingPermission = "anyone" | "members" | "admins";
+type SpaceVisibility = "public" | "unlisted" | "private";
+type SpaceMemberRole = "admin" | "moderator" | "member";
+type SpaceMemberStatus = "pending" | "active" | "banned" | "rejected";
+interface SpaceMemberPermissions {
+    isAdmin: boolean;
+    isModerator: boolean;
+    isMember: boolean;
+    status: "pending" | "active" | "banned" | null;
+    canPost: boolean;
+    canModerate: boolean;
+    canRead: boolean;
+}
+interface SpacePreview {
+    id: string;
+    shortId: string;
+    name: string;
+    slug: string | null;
+    avatarFileId: string | null;
+    readingPermission?: ReadingPermission;
+    visibility?: SpaceVisibility;
+    parentSpaceId?: string | null;
+    depth?: number;
+    avatarFile?: File$1;
+}
+interface Space {
+    id: string;
+    projectId: string;
+    shortId: string;
+    slug: string | null;
+    name: string;
+    description: string | null;
+    avatarFileId: string | null;
+    bannerFileId: string | null;
+    userId: string;
+    readingPermission: ReadingPermission;
+    postingPermission: PostingPermission;
+    visibility: SpaceVisibility;
+    requireJoinApproval: boolean;
+    nsfw: boolean;
+    nsfwEffective: boolean;
+    parentSpaceId: string | null;
+    depth: number;
+    metadata: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+    membersCount: number;
+    childSpacesCount: number;
+    isMember?: boolean;
+    avatarFile?: File$1;
+    bannerFile?: File$1;
+}
+interface SpaceDetailed extends Space {
+    memberPermissions: SpaceMemberPermissions | null;
+    parentSpace: SpacePreview | null;
+    childSpaces: SpacePreview[];
+}
+interface UserSpaceItem {
+    space: Space;
+    membership: {
+        membershipId: string;
+        role: SpaceMemberRole;
+        status: SpaceMemberStatus;
+        joinedAt: string;
+    };
+}
+type UserSpacesResponse = PaginatedResponse<UserSpaceItem>;
+interface JoinSpaceResponse {
+    message: string;
+    membership: {
+        id: string;
+        spaceId: string;
+        userId: string;
+        role: "member";
+        status: "pending" | "active";
+        joinedAt: string;
+    };
+}
+interface LeaveSpaceResponse {
+    message: string;
+}
+interface UpdateMemberRoleResponse {
+    message: string;
+    membership: {
+        id: string;
+        role: SpaceMemberRole;
+        status: string;
+        joinedAt: string;
+        userId: string;
+    };
+}
+interface ApproveMemberResponse {
+    message: string;
+    membership: {
+        id: string;
+        status: "active";
+        joinedAt: string;
+    };
+}
+interface DeclineMemberResponse {
+    message: string;
+    membership: {
+        id: string;
+        status: "rejected";
+    };
+}
+interface CheckMyMembershipResponse {
+    isMember: boolean;
+    role: "admin" | "moderator" | "member" | null;
+    status: "pending" | "active" | "banned" | "rejected" | null;
+    joinedAt: string | null;
+    permissions: {
+        canPost: boolean;
+        canModerate: boolean;
+        canRead: boolean;
+        isAdmin: boolean;
+        isModerator: boolean;
+    };
+}
+interface DeleteSpaceResponse {
+    message: string;
+}
+interface SpaceBreadcrumb {
+    breadcrumb: SpacePreview[];
+    depth: number;
+}
+
+type ReactionType = "upvote" | "downvote" | "like" | "love" | "wow" | "sad" | "angry" | "funny";
+interface ReactionCounts {
+    upvote: number;
+    downvote: number;
+    like: number;
+    love: number;
+    wow: number;
+    sad: number;
+    angry: number;
+    funny: number;
+}
+interface Reaction {
+    id: string;
+    projectId: string;
+    targetType: "entity" | "comment";
+    targetId: string;
+    userId: string;
+    reactionType: ReactionType;
+    createdAt: string;
+    updatedAt: string;
+    user?: User;
+}
+
+interface TopComment {
+    id: string;
+    user: User;
+    upvotesCount: number;
+    content: string;
+    createdAt: string;
+}
+interface Entity {
+    id: string;
+    foreignId: string | null;
+    shortId: string;
+    projectId: string;
+    sourceId: string | null;
+    spaceId: string | null;
+    space?: Space | null;
+    userId: string | null;
+    user?: User | null;
+    title: string | null;
+    content: string | null;
+    mentions: Mention[];
+    attachments: Record<string, any>[];
+    files?: File$1[];
+    keywords: string[];
+    upvotes: string[];
+    downvotes: string[];
+    reactionCounts: ReactionCounts;
+    userReaction?: ReactionType | null;
+    repliesCount: number;
+    views: number;
+    score: number;
+    scoreUpdatedAt: string;
+    location: {
+        type: "Point";
+        coordinates: [number, number];
+    } | null;
+    metadata: Record<string, any>;
+    nsfw: boolean;
+    nsfwEffective: boolean;
+    topComment: TopComment | null;
+    isSaved?: boolean;
+    /**
+     * Reputation-grant summary. Opt-in — present exactly when the read requested
+     * `include=grants`. Once requested the server always returns the object,
+     * zero-filled rather than omitted, on projects with no grants and on projects
+     * without the reputation bundle alike.
+     */
+    grants?: GrantSummary;
+    isDraft: boolean | null;
+    moderationStatus: "approved" | "removed" | null;
+    moderatedAt: string | null;
+    moderatedById: string | null;
+    moderatedByType: "client" | "user" | null;
+    moderationReason: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+}
+
+interface CreateEntityProps {
+    foreignId?: string;
+    sourceId?: string;
+    spaceId?: string;
+    title?: string;
+    content?: string;
+    attachments?: Record<string, any>[];
+    keywords?: string[];
+    mentions?: Mention[];
+    location?: {
+        latitude: number;
+        longitude: number;
+    };
+    metadata?: Record<string, any>;
+    nsfw?: boolean;
+    isDraft?: boolean;
+    /** Create the entity without attributing it to the logged-in user (authorless). */
+    excludeUserId?: boolean;
+}
+declare function createEntity(client: SublayHttpClient, data: CreateEntityProps): Promise<Entity>;
+
+interface FetchEntityProps extends SpaceReputationContextParams {
+    entityId: string;
+    include?: string;
+}
+declare function fetchEntity(client: SublayHttpClient, data: FetchEntityProps): Promise<Entity>;
+
+interface FetchEntityByForeignIdProps {
+    foreignId: string;
+    createIfNotFound?: boolean;
+    include?: string;
+}
+declare function fetchEntityByForeignId(client: SublayHttpClient, data: FetchEntityByForeignIdProps): Promise<Entity>;
+
+interface FetchEntityByShortIdProps {
+    shortId: string;
+    include?: string;
+}
+declare function fetchEntityByShortId(client: SublayHttpClient, data: FetchEntityByShortIdProps): Promise<Entity>;
+
+interface KeywordsFilters {
+    includes?: string[];
+    doesNotInclude?: string[];
+}
+interface MetadataFilters {
+    includes?: {
+        [key: string]: any;
+    };
+    includesAny?: {
+        [key: string]: any;
+    }[];
+    doesNotInclude?: {
+        [key: string]: any;
+    };
+    exists?: string[];
+    doesNotExist?: string[];
+}
+interface TextFilters {
+    hasTitle?: "true" | "false";
+    includes?: string | string[];
+    doesNotInclude?: string | string[];
+}
+interface AttachmentsFilters {
+    hasAttachments?: "true" | "false";
+}
+interface LocationFilters {
+    latitude: string;
+    longitude: string;
+    radius: string;
+}
+interface FetchManyEntitiesProps extends SpaceReputationContextParams {
+    sourceId?: string;
+    spaceId?: string;
+    sortBy?: "createdAt" | "hot" | "top" | "controversial"
+    /** @deprecated Use "createdAt" instead. "new" is a directional alias removed
+     * in v8; the server still accepts it (identical behavior) but responds with
+     * deprecation headers. */
+     | "new" | (string & {});
+    sortDir?: "asc" | "desc";
+    sortType?: "auto" | "numeric" | "text" | "boolean" | "timestamp";
+    sortByReaction?: "upvote" | "downvote" | "like" | "love" | "wow" | "sad" | "angry" | "funny";
+    page?: number;
+    limit?: number;
+    include?: string;
+    timeFrame?: "hour" | "day" | "week" | "month" | "year";
+    userId?: string;
+    followedOnly?: "true" | "false";
+    keywordsFilters?: KeywordsFilters;
+    metadataFilters?: MetadataFilters;
+    titleFilters?: TextFilters;
+    contentFilters?: {
+        hasContent?: "true" | "false";
+        includes?: string | string[];
+        doesNotInclude?: string | string[];
+    };
+    attachmentsFilters?: AttachmentsFilters;
+    locationFilters?: LocationFilters;
+    nsfwFilter?: "include-all" | "exclude" | "only";
+    blockedFilter?: "exclude" | "include-outbound-blocked";
+}
+declare function fetchManyEntities(client: SublayHttpClient, data: FetchManyEntitiesProps): Promise<PaginatedResponse<Entity>>;
+
+interface UpdateEntityProps {
+    entityId: string;
+    title?: string;
+    content?: string;
+    attachments?: Record<string, any>[];
+    keywords?: string[];
+    mentions?: Mention[];
+    location?: {
+        latitude: number;
+        longitude: number;
+    };
+    metadata?: Record<string, any>;
+    nsfw?: boolean;
+}
+declare function updateEntity(client: SublayHttpClient, data: UpdateEntityProps): Promise<Entity>;
+
+interface DeleteEntityProps {
+    entityId: string;
+}
+declare function deleteEntity(client: SublayHttpClient, data: DeleteEntityProps): Promise<void>;
+
+interface FetchDraftsProps {
+    page?: number;
+    limit?: number;
+    sourceId?: string;
+    spaceId?: string;
+    include?: string;
+}
+declare function fetchDrafts(client: SublayHttpClient, data: FetchDraftsProps): Promise<PaginatedResponse<Entity>>;
+
+interface PublishDraftProps {
+    entityId: string;
+}
+declare function publishDraft(client: SublayHttpClient, data: PublishDraftProps): Promise<Entity>;
+
+interface FetchTopCommentProps {
+    entityId: string;
+}
+declare function fetchTopComment(client: SublayHttpClient, data: FetchTopCommentProps): Promise<TopComment | null>;
+
+interface AddEntityReactionProps {
+    entityId: string;
+    reactionType: ReactionType;
+}
+declare function addReaction$1(client: SublayHttpClient, data: AddEntityReactionProps): Promise<Entity>;
+
+interface RemoveEntityReactionProps {
+    entityId: string;
+}
+declare function removeReaction$1(client: SublayHttpClient, data: RemoveEntityReactionProps): Promise<Entity>;
+
+interface FetchEntityReactionsProps extends SpaceReputationContextParams {
+    entityId: string;
+    reactionType?: ReactionType;
+    page?: number;
+    limit?: number;
+    sortDir?: "asc" | "desc";
+}
+interface FetchEntityReactionsResponse {
+    data: Reaction[];
+    pagination: PaginationMetadata;
+}
+declare function fetchReactions$1(client: SublayHttpClient, data: FetchEntityReactionsProps): Promise<FetchEntityReactionsResponse>;
+
+interface GetUserEntityReactionProps {
+    entityId: string;
+}
+interface UserReactionResponse {
+    reactionType: ReactionType | null;
+}
+declare function getUserReaction$1(client: SublayHttpClient, data: GetUserEntityReactionProps): Promise<UserReactionResponse>;
+
+interface IsEntitySavedProps {
+    entityId: string;
+}
+interface IsEntitySavedResponse {
+    saved: boolean;
+    collections: {
+        id: string;
+        name: string;
+    }[];
+}
+declare function isEntitySaved(client: SublayHttpClient, data: IsEntitySavedProps): Promise<IsEntitySavedResponse>;
+
+declare const Entities_createEntity: typeof createEntity;
+declare const Entities_deleteEntity: typeof deleteEntity;
+declare const Entities_fetchDrafts: typeof fetchDrafts;
+declare const Entities_fetchEntity: typeof fetchEntity;
+declare const Entities_fetchEntityByForeignId: typeof fetchEntityByForeignId;
+declare const Entities_fetchEntityByShortId: typeof fetchEntityByShortId;
+declare const Entities_fetchManyEntities: typeof fetchManyEntities;
+declare const Entities_fetchTopComment: typeof fetchTopComment;
+declare const Entities_isEntitySaved: typeof isEntitySaved;
+declare const Entities_publishDraft: typeof publishDraft;
+declare const Entities_updateEntity: typeof updateEntity;
+declare namespace Entities {
+  export { addReaction$1 as addReaction, Entities_createEntity as createEntity, Entities_deleteEntity as deleteEntity, Entities_fetchDrafts as fetchDrafts, Entities_fetchEntity as fetchEntity, Entities_fetchEntityByForeignId as fetchEntityByForeignId, Entities_fetchEntityByShortId as fetchEntityByShortId, Entities_fetchManyEntities as fetchManyEntities, fetchReactions$1 as fetchReactions, Entities_fetchTopComment as fetchTopComment, getUserReaction$1 as getUserReaction, Entities_isEntitySaved as isEntitySaved, Entities_publishDraft as publishDraft, removeReaction$1 as removeReaction, Entities_updateEntity as updateEntity };
+}
+
+type EventType = "online" | "physical" | "hybrid";
+type EventVisibility = "public" | "members" | "invite";
+type EventStatus = "active" | "cancelled";
+type RsvpStatus = "going" | "maybe" | "not_going";
+interface RsvpCounts {
+    going: number;
+    maybe: number;
+    not_going: number;
+}
+interface Event {
+    id: string;
+    shortId: string;
+    projectId: string;
+    userId: string | null;
+    user?: User | null;
+    title: string;
+    description: string | null;
+    startTime: string;
+    endTime: string | null;
+    timezone: string | null;
+    type: EventType;
+    url: string | null;
+    venueName: string | null;
+    address: string | null;
+    location: {
+        type: "Point";
+        coordinates: [number, number];
+    } | null;
+    spaceId: string | null;
+    space?: Space | null;
+    visibility: EventVisibility;
+    status: EventStatus;
+    allowMaybe: boolean;
+    guestListVisible: boolean;
+    capacity: number | null;
+    hostIds: string[];
+    coverImageId: string | null;
+    files?: File$1[];
+    rsvpCounts: RsvpCounts;
+    userRsvp?: RsvpStatus | null;
+    metadata: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+}
+interface EventRsvp {
+    id: string;
+    eventId: string;
+    userId: string;
+    user?: User | null;
+    status: RsvpStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface EventInvite {
+    id: string;
+    eventId: string;
+    userId: string;
+    user?: User | null;
+    invitedAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+/** A single cover image plus its processing options (stored as Event.coverImageId). */
+interface EventCoverUpload {
+    file: Blob | File;
+    /** Image-processing config (must include `mode`) — see {@link ImageOptions}. */
+    options: ImageOptions;
+}
+/** A gallery image set plus shared processing options (Files with eventId + position). */
+interface EventGalleryUpload {
+    files: (Blob | File)[];
+    /** Image-processing config applied to every gallery image — see {@link ImageOptions}. */
+    options: ImageOptions;
+}
+interface CreateEventProps {
+    title: string;
+    description?: string;
+    startTime: string;
+    endTime?: string;
+    timezone?: string;
+    type: EventType;
+    url?: string;
+    venueName?: string;
+    address?: string;
+    location?: {
+        latitude: number;
+        longitude: number;
+    };
+    spaceId?: string;
+    visibility?: EventVisibility;
+    capacity?: number;
+    allowMaybe?: boolean;
+    guestListVisible?: boolean;
+    /** Additional host user IDs (the logged-in user is auto-added as a host). */
+    hostIds?: string[];
+    metadata?: Record<string, any>;
+    /**
+     * Inline cover image (single). When present the request is sent as
+     * `multipart/form-data`. Requires the `files-images` bundle.
+     */
+    cover?: EventCoverUpload;
+    /**
+     * Inline gallery images (multi). When present the request is sent as
+     * `multipart/form-data`. Requires the `files-images` bundle.
+     */
+    gallery?: EventGalleryUpload;
+}
+declare function createEvent(client: SublayHttpClient, data: CreateEventProps): Promise<Event>;
+
+interface FetchEventProps {
+    eventId: string;
+    /** Comma-separated associations to expand, e.g. "user,space,files,userRsvp". */
+    include?: string;
+}
+declare function fetchEvent(client: SublayHttpClient, data: FetchEventProps): Promise<Event>;
+
+interface EventTextFilters {
+    hasTitle?: "true" | "false";
+    includes?: string | string[];
+    doesNotInclude?: string | string[];
+}
+interface EventDescriptionFilters {
+    hasDescription?: "true" | "false";
+    includes?: string | string[];
+    doesNotInclude?: string | string[];
+}
+interface EventLocationFilters {
+    latitude: string;
+    longitude: string;
+    radius: string;
+}
+interface FetchManyEventsProps {
+    page?: number;
+    limit?: number;
+    sortBy?: "startTime" | "going";
+    sortDir?: "asc" | "desc";
+    timeWindow?: "upcoming" | "ongoing" | "past";
+    startsAfter?: string;
+    startsBefore?: string;
+    spaceId?: string;
+    hostId?: string;
+    type?: EventType;
+    status?: EventStatus;
+    /**
+     * Comma-separated RSVP statuses the logged-in user RSVP'd with, e.g.
+     * "going,maybe". Filters to events the caller has that RSVP on.
+     */
+    myRsvp?: string;
+    locationFilters?: EventLocationFilters;
+    titleFilters?: EventTextFilters;
+    descriptionFilters?: EventDescriptionFilters;
+    /** Comma-separated associations to expand, e.g. "user,space,files,userRsvp". */
+    include?: string;
+}
+declare function fetchManyEvents(client: SublayHttpClient, data?: FetchManyEventsProps): Promise<PaginatedResponse<Event>>;
+
+interface UpdateEventProps {
+    eventId: string;
+    title?: string;
+    description?: string;
+    startTime?: string;
+    endTime?: string;
+    timezone?: string;
+    type?: EventType;
+    url?: string;
+    venueName?: string;
+    address?: string;
+    location?: {
+        latitude: number;
+        longitude: number;
+    };
+    visibility?: EventVisibility;
+    capacity?: number;
+    allowMaybe?: boolean;
+    guestListVisible?: boolean;
+    metadata?: Record<string, any>;
+    /**
+     * File IDs of existing event images to REMOVE (gallery photos and/or the
+     * current cover). Combine with `gallery` (append) + `cover` (replace) to fully
+     * curate the image set in one update. Sent in the JSON body, or — when an
+     * image file is also attached — as a JSON-string field the server parses.
+     */
+    removeImageIds?: string[];
+    /**
+     * New cover image (single) — REPLACES the existing cover. When present the
+     * request is sent as `multipart/form-data`. Requires the `files-images` bundle.
+     */
+    cover?: EventCoverUpload;
+    /**
+     * Gallery images (multi) — APPENDED to the event's existing images. When
+     * present the request is sent as `multipart/form-data`. Requires the
+     * `files-images` bundle.
+     */
+    gallery?: EventGalleryUpload;
+}
+declare function updateEvent(client: SublayHttpClient, data: UpdateEventProps): Promise<Event>;
+
+interface CancelEventProps {
+    eventId: string;
+}
+declare function cancelEvent(client: SublayHttpClient, data: CancelEventProps): Promise<Event>;
+
+interface DeleteEventProps {
+    eventId: string;
+}
+declare function deleteEvent(client: SublayHttpClient, data: DeleteEventProps): Promise<void>;
+
+interface SetRsvpProps {
+    eventId: string;
+    status: RsvpStatus;
+}
+declare function setRsvp(client: SublayHttpClient, data: SetRsvpProps): Promise<Event>;
+
+interface WithdrawRsvpProps {
+    eventId: string;
+}
+declare function withdrawRsvp(client: SublayHttpClient, data: WithdrawRsvpProps): Promise<Event>;
+
+interface AddHostProps {
+    eventId: string;
+    /** The user to grant host on the event. */
+    userId: string;
+}
+declare function addHost(client: SublayHttpClient, data: AddHostProps): Promise<Event>;
+
+interface RemoveHostProps {
+    eventId: string;
+    /** The host to remove. Rejected if it would leave the event with no hosts. */
+    userId: string;
+}
+declare function removeHost(client: SublayHttpClient, data: RemoveHostProps): Promise<Event>;
+
+interface AddInviteProps {
+    eventId: string;
+    /** The user to invite (userId only — never a foreignId). Idempotent. */
+    userId: string;
+}
+declare function addInvite(client: SublayHttpClient, data: AddInviteProps): Promise<Event>;
+
+interface RemoveInviteProps {
+    eventId: string;
+    /** The invitee to remove. Also drops their RSVP and revokes access. */
+    userId: string;
+}
+declare function removeInvite(client: SublayHttpClient, data: RemoveInviteProps): Promise<Event>;
+
+interface FetchInviteesProps {
+    eventId: string;
+    page?: number;
+    limit?: number;
+}
+/**
+ * Host-only invitee (guest) list. Non-hosts get 403.
+ */
+declare function fetchInvitees(client: SublayHttpClient, data: FetchInviteesProps): Promise<PaginatedResponse<EventInvite>>;
+
+interface FetchEventRsvpsProps {
+    eventId: string;
+    page?: number;
+    limit?: number;
+    /**
+     * Comma-separated RSVP statuses to filter by, e.g. "going,maybe". When
+     * omitted, all statuses are returned.
+     */
+    status?: string;
+}
+/**
+ * Named RSVP (guest) list. Visible to hosts always, or to any viewer when the
+ * event's `guestListVisible` is true; otherwise 403. RSVP counts themselves are
+ * public via the event's `rsvpCounts`.
+ */
+declare function fetchEventRsvps(client: SublayHttpClient, data: FetchEventRsvpsProps): Promise<PaginatedResponse<EventRsvp>>;
+
+declare const Events_addHost: typeof addHost;
+declare const Events_addInvite: typeof addInvite;
+declare const Events_cancelEvent: typeof cancelEvent;
+declare const Events_createEvent: typeof createEvent;
+declare const Events_deleteEvent: typeof deleteEvent;
+declare const Events_fetchEvent: typeof fetchEvent;
+declare const Events_fetchEventRsvps: typeof fetchEventRsvps;
+declare const Events_fetchInvitees: typeof fetchInvitees;
+declare const Events_fetchManyEvents: typeof fetchManyEvents;
+declare const Events_removeHost: typeof removeHost;
+declare const Events_removeInvite: typeof removeInvite;
+declare const Events_setRsvp: typeof setRsvp;
+declare const Events_updateEvent: typeof updateEvent;
+declare const Events_withdrawRsvp: typeof withdrawRsvp;
+declare namespace Events {
+  export { Events_addHost as addHost, Events_addInvite as addInvite, Events_cancelEvent as cancelEvent, Events_createEvent as createEvent, Events_deleteEvent as deleteEvent, Events_fetchEvent as fetchEvent, Events_fetchEventRsvps as fetchEventRsvps, Events_fetchInvitees as fetchInvitees, Events_fetchManyEvents as fetchManyEvents, Events_removeHost as removeHost, Events_removeInvite as removeInvite, Events_setRsvp as setRsvp, Events_updateEvent as updateEvent, Events_withdrawRsvp as withdrawRsvp };
+}
+
+interface GifData {
+    id: string;
+    url: string;
+    gifUrl: string;
+    gifPreviewUrl: string;
+    altText: string;
+    aspectRatio: string;
+}
+interface Comment {
+    id: string;
+    projectId: string;
+    foreignId: string | null;
+    entityId: string;
+    entity?: Entity;
+    userId: string;
+    user?: User;
+    parentId: string | null;
+    parentComment?: Comment;
+    content: string | null;
+    gif: GifData | null;
+    mentions: Mention[];
+    upvotes: string[];
+    downvotes: string[];
+    reactionCounts: ReactionCounts;
+    userReaction?: ReactionType | null;
+    repliesCount: number;
+    /**
+     * Reputation-grant summary. Opt-in — present exactly when the read requested
+     * `include=grants`. Once requested the server always returns the object,
+     * zero-filled rather than omitted, on projects with no grants and on projects
+     * without the reputation bundle alike.
+     */
+    grants?: GrantSummary;
+    metadata: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+    parentDeletedAt: string | null;
+    userDeletedAt: string | null;
+    moderationStatus: "approved" | "removed" | null;
+    moderatedAt: string | null;
+    moderatedById: string | null;
+    moderatedByType: "client" | "user" | null;
+    moderationReason: string | null;
+}
+
+interface CreateCommentProps {
+    entityId: string;
+    foreignId?: string;
+    content?: string;
+    gif?: GifData | null;
+    mentions?: Mention[];
+    parentId?: string | null;
+    referencedCommentId?: string;
+    attachments?: Record<string, any>[];
+    metadata?: Record<string, any>;
+}
+declare function createComment(client: SublayHttpClient, data: CreateCommentProps): Promise<Comment>;
+
+interface FetchCommentProps extends SpaceReputationContextParams {
+    commentId: string;
+    include?: string;
+}
+declare function fetchComment(client: SublayHttpClient, data: FetchCommentProps): Promise<Comment>;
+
+interface FetchCommentByForeignIdProps {
+    foreignId: string;
+    include?: string;
+}
+declare function fetchCommentByForeignId(client: SublayHttpClient, data: FetchCommentByForeignIdProps): Promise<Comment>;
+
+interface UpdateCommentProps {
+    commentId: string;
+    /** New text content. Cannot be empty. Omit to leave the content untouched. */
+    content?: string;
+    /** Replaces the comment's metadata wholesale (not merged). */
+    metadata?: Record<string, any>;
+}
+declare function updateComment(client: SublayHttpClient, data: UpdateCommentProps): Promise<Comment>;
+
+interface DeleteCommentProps {
+    commentId: string;
+}
+declare function deleteComment(client: SublayHttpClient, data: DeleteCommentProps): Promise<void>;
+
+interface FetchManyCommentsProps extends SpaceReputationContextParams {
+    entityId?: string;
+    userId?: string;
+    parentId?: string;
+    page?: number;
+    limit?: number;
+    sortBy?: "createdAt" | "top" | "controversial"
+    /** @deprecated Use "createdAt" instead. "new" is a directional alias for
+     * createdAt DESC, removed in v8; the server still accepts it (identical
+     * behavior) but responds with deprecation headers. */
+     | "new"
+    /** @deprecated Use "createdAt" with sortDir:"asc" instead. "old" is a
+     * directional alias for createdAt ASC, removed in v8; the server still
+     * accepts it (identical behavior) but responds with deprecation headers. */
+     | "old";
+    /** Sort direction for `sortBy: "createdAt"`. Defaults to "desc". */
+    sortDir?: "asc" | "desc";
+    include?: string;
+    sourceId?: string;
+    blockedFilter?: "exclude" | "include-outbound-blocked";
+}
+declare function fetchManyComments(client: SublayHttpClient, data: FetchManyCommentsProps): Promise<PaginatedResponse<Comment>>;
+
+interface AddCommentReactionProps {
+    commentId: string;
+    reactionType: ReactionType;
+}
+declare function addReaction(client: SublayHttpClient, data: AddCommentReactionProps): Promise<Comment>;
+
+interface RemoveCommentReactionProps {
+    commentId: string;
+}
+declare function removeReaction(client: SublayHttpClient, data: RemoveCommentReactionProps): Promise<Comment>;
+
+interface FetchCommentReactionsProps extends SpaceReputationContextParams {
+    commentId: string;
+    reactionType?: ReactionType;
+    page?: number;
+    limit?: number;
+    sortDir?: "asc" | "desc";
+}
+interface FetchCommentReactionsResponse {
+    data: Reaction[];
+    pagination: PaginationMetadata;
+}
+declare function fetchReactions(client: SublayHttpClient, data: FetchCommentReactionsProps): Promise<FetchCommentReactionsResponse>;
+
+interface GetUserCommentReactionProps {
+    commentId: string;
+}
+interface UserCommentReactionResponse {
+    reactionType: ReactionType | null;
+}
+declare function getUserReaction(client: SublayHttpClient, data: GetUserCommentReactionProps): Promise<UserCommentReactionResponse>;
+
+declare const Comments_addReaction: typeof addReaction;
+declare const Comments_createComment: typeof createComment;
+declare const Comments_deleteComment: typeof deleteComment;
+declare const Comments_fetchComment: typeof fetchComment;
+declare const Comments_fetchCommentByForeignId: typeof fetchCommentByForeignId;
+declare const Comments_fetchManyComments: typeof fetchManyComments;
+declare const Comments_fetchReactions: typeof fetchReactions;
+declare const Comments_getUserReaction: typeof getUserReaction;
+declare const Comments_removeReaction: typeof removeReaction;
+declare const Comments_updateComment: typeof updateComment;
+declare namespace Comments {
+  export { Comments_addReaction as addReaction, Comments_createComment as createComment, Comments_deleteComment as deleteComment, Comments_fetchComment as fetchComment, Comments_fetchCommentByForeignId as fetchCommentByForeignId, Comments_fetchManyComments as fetchManyComments, Comments_fetchReactions as fetchReactions, Comments_getUserReaction as getUserReaction, Comments_removeReaction as removeReaction, Comments_updateComment as updateComment };
+}
+
+/** A file plus the image-processing options the server requires alongside it. */
+interface SpaceImageUpload {
+    file: Blob | File;
+    /** Image-processing config (must include `mode`) — see {@link ImageOptions}. */
+    options: ImageOptions;
+}
+interface CreateSpaceProps {
+    name: string;
+    slug?: string;
+    description?: string;
+    readingPermission?: ReadingPermission;
+    postingPermission?: PostingPermission;
+    visibility?: SpaceVisibility;
+    requireJoinApproval?: boolean;
+    parentSpaceId?: string;
+    metadata?: Record<string, any>;
+    nsfw?: boolean;
+    /**
+     * Avatar image. When present the request is sent as `multipart/form-data` and
+     * the server processes the image per `options`.
+     */
+    avatarFile?: SpaceImageUpload;
+    /** Banner image; same contract as {@link CreateSpaceProps.avatarFile}. */
+    bannerFile?: SpaceImageUpload;
+}
+declare function createSpace(client: SublayHttpClient, data: CreateSpaceProps): Promise<Space>;
+
+interface FetchManySpacesProps {
+    page?: number;
+    limit?: number;
+    sortBy?: "alphabetical" | "newest" | "members";
+    searchSlug?: string;
+    searchName?: string;
+    searchDescription?: string;
+    searchAny?: string;
+    memberOf?: "true";
+    parentSpaceId?: string | "null";
+    nsfwFilter?: "include-all" | "exclude" | "only";
+    include?: string;
+}
+declare function fetchManySpaces(client: SublayHttpClient, data: FetchManySpacesProps): Promise<PaginatedResponse<Space>>;
+
+interface FetchSpaceProps {
+    spaceId: string;
+}
+declare function fetchSpace(client: SublayHttpClient, data: FetchSpaceProps): Promise<SpaceDetailed>;
+
+interface FetchSpaceByShortIdProps {
+    shortId: string;
+}
+declare function fetchSpaceByShortId(client: SublayHttpClient, data: FetchSpaceByShortIdProps): Promise<SpaceDetailed>;
+
+interface FetchSpaceBySlugProps {
+    slug: string;
+}
+declare function fetchSpaceBySlug(client: SublayHttpClient, data: FetchSpaceBySlugProps): Promise<SpaceDetailed>;
+
+interface FetchUserSpacesProps {
+    page?: number;
+    limit?: number;
+    sortBy?: "alphabetical" | "newest" | "members";
+    include?: string;
+    role?: string;
+    all?: "true" | "false";
+    /**
+     * Membership status to list. Defaults to `"active"` (spaces the user is in);
+     * `"pending"` returns join requests awaiting approval, `"banned"` the spaces
+     * they were removed from.
+     */
+    status?: "active" | "pending" | "banned";
+}
+declare function fetchUserSpaces(client: SublayHttpClient, data: FetchUserSpacesProps): Promise<UserSpacesResponse>;
+
+interface FetchMutualSpacesProps {
+    /** The OTHER user — spaces shared with this user are returned. */
+    userId: string;
+    page?: number;
+    limit?: number;
+    include?: string;
+}
+declare function fetchMutualSpaces(client: SublayHttpClient, { userId, ...params }: FetchMutualSpacesProps): Promise<PaginatedResponse<Space>>;
+
+interface CheckSlugAvailabilityProps {
+    slug: string;
+}
+interface CheckSlugAvailabilityResponse {
+    available: boolean;
+}
+declare function checkSlugAvailability(client: SublayHttpClient, data: CheckSlugAvailabilityProps): Promise<CheckSlugAvailabilityResponse>;
+
+interface UpdateSpaceProps {
+    spaceId: string;
+    name?: string;
+    slug?: string;
+    description?: string;
+    readingPermission?: ReadingPermission;
+    postingPermission?: PostingPermission;
+    visibility?: SpaceVisibility;
+    metadata?: Record<string, any>;
+    nsfw?: boolean;
+    /**
+     * New avatar image. When present the request is sent as `multipart/form-data`
+     * and the server processes the image per `options`, replacing the old avatar.
+     */
+    avatarFile?: SpaceImageUpload;
+    /** New banner image; same contract as {@link UpdateSpaceProps.avatarFile}. */
+    bannerFile?: SpaceImageUpload;
+}
+declare function updateSpace(client: SublayHttpClient, data: UpdateSpaceProps): Promise<Space>;
+
+interface DeleteSpaceProps {
+    spaceId: string;
+}
+declare function deleteSpace(client: SublayHttpClient, data: DeleteSpaceProps): Promise<DeleteSpaceResponse>;
+
+interface FetchChildSpacesProps {
+    spaceId: string;
+    page?: number;
+    limit?: number;
+    sortBy?: "alphabetical" | "newest" | "members";
+    include?: string;
+}
+declare function fetchChildSpaces(client: SublayHttpClient, data: FetchChildSpacesProps): Promise<PaginatedResponse<Space>>;
+
+interface FetchSpaceBreadcrumbProps {
+    spaceId: string;
+}
+declare function fetchSpaceBreadcrumb(client: SublayHttpClient, data: FetchSpaceBreadcrumbProps): Promise<SpaceBreadcrumb>;
+
+interface JoinSpaceProps {
+    spaceId: string;
+}
+declare function joinSpace(client: SublayHttpClient, data: JoinSpaceProps): Promise<JoinSpaceResponse>;
+
+interface LeaveSpaceProps {
+    spaceId: string;
+}
+declare function leaveSpace(client: SublayHttpClient, data: LeaveSpaceProps): Promise<LeaveSpaceResponse>;
+
+interface CheckMyMembershipProps {
+    spaceId: string;
+}
+declare function checkMyMembership(client: SublayHttpClient, data: CheckMyMembershipProps): Promise<CheckMyMembershipResponse>;
+
+interface SpaceMemberWithUser {
+    membershipId: string;
+    role: SpaceMemberRole;
+    status: SpaceMemberStatus;
+    joinedAt: string;
+    user: {
+        id: string;
+        username: string;
+        displayName: string;
+        avatar: string;
+        metadata: object;
+    };
+}
+type SpaceMembersResponse = PaginatedResponse<SpaceMemberWithUser>;
+interface SpaceTeamResponse {
+    data: SpaceMemberWithUser[];
+}
+
+interface FetchSpaceMembersProps extends SpaceReputationContextParams {
+    spaceId: string;
+    page?: number;
+    limit?: number;
+    role?: "admin" | "moderator" | "member";
+    status?: "pending" | "active" | "banned" | "rejected";
+}
+declare function fetchSpaceMembers(client: SublayHttpClient, data: FetchSpaceMembersProps): Promise<SpaceMembersResponse>;
+
+interface FetchSpaceTeamProps extends SpaceReputationContextParams {
+    spaceId: string;
+}
+declare function fetchSpaceTeam(client: SublayHttpClient, data: FetchSpaceTeamProps): Promise<SpaceTeamResponse>;
+
+interface UpdateMemberRoleProps {
+    spaceId: string;
+    memberId: string;
+    role: SpaceMemberRole;
+}
+declare function updateMemberRole(client: SublayHttpClient, data: UpdateMemberRoleProps): Promise<UpdateMemberRoleResponse>;
+
+interface ApproveMembershipProps {
+    spaceId: string;
+    memberId: string;
+}
+declare function approveMembership(client: SublayHttpClient, data: ApproveMembershipProps): Promise<ApproveMemberResponse>;
+
+interface DeclineMembershipProps {
+    spaceId: string;
+    memberId: string;
+}
+declare function declineMembership(client: SublayHttpClient, data: DeclineMembershipProps): Promise<DeclineMemberResponse>;
+
+interface BanMemberProps {
+    spaceId: string;
+    memberId: string;
+}
+interface BanMemberResponse {
+    message: string;
+    membership: {
+        id: string;
+        status: "banned";
+    };
+}
+declare function banMember(client: SublayHttpClient, data: BanMemberProps): Promise<BanMemberResponse>;
+
+interface UnbanMemberProps {
+    spaceId: string;
+    memberId: string;
+}
+interface UnbanMemberResponse {
+    message: string;
+    membership: {
+        id: string;
+        status: "active";
+    };
+}
+declare function unbanMember(client: SublayHttpClient, data: UnbanMemberProps): Promise<UnbanMemberResponse>;
+
+interface Rule {
+    id: string;
+    projectId: string;
+    spaceId: string;
+    title: string;
+    description: string | null;
+    order: number;
+    lastApprovedBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface FetchManyRulesResponse {
+    data: Rule[];
+    count: number;
+}
+interface DeleteRuleResponse {
+    message: string;
+    deletedRule: {
+        id: string;
+        title: string;
+    };
+}
+
+interface FetchManyRulesProps {
+    spaceId: string;
+}
+declare function fetchManyRules(client: SublayHttpClient, data: FetchManyRulesProps): Promise<FetchManyRulesResponse>;
+
+interface FetchRuleProps {
+    spaceId: string;
+    ruleId: string;
+}
+declare function fetchRule(client: SublayHttpClient, data: FetchRuleProps): Promise<Rule>;
+
+interface CreateRuleProps {
+    spaceId: string;
+    title: string;
+    description?: string;
+}
+declare function createRule(client: SublayHttpClient, data: CreateRuleProps): Promise<Rule>;
+
+interface UpdateRuleProps {
+    spaceId: string;
+    ruleId: string;
+    title?: string;
+    description?: string;
+}
+declare function updateRule(client: SublayHttpClient, data: UpdateRuleProps): Promise<Rule>;
+
+interface DeleteRuleProps {
+    spaceId: string;
+    ruleId: string;
+}
+declare function deleteRule(client: SublayHttpClient, data: DeleteRuleProps): Promise<DeleteRuleResponse>;
+
+interface ReorderRulesProps {
+    spaceId: string;
+    ruleIds: string[];
+}
+declare function reorderRules(client: SublayHttpClient, data: ReorderRulesProps): Promise<Rule[]>;
+
+type EntityReportAction = "remove-entity" | "ban-user" | "dismiss";
+interface HandleEntityReportProps {
+    spaceId: string;
+    reportId: string;
+    entityId: string;
+    actions: EntityReportAction[];
+    summary?: string;
+    reason?: string;
+    /** The user to ban (target), required when actions include "ban-user". */
+    userId?: string;
+}
+interface HandleReportResponse {
+    message: string;
+    code: string;
+}
+declare function handleEntityReport(client: SublayHttpClient, data: HandleEntityReportProps): Promise<HandleReportResponse>;
+
+type CommentReportAction = "remove-comment" | "ban-user" | "dismiss";
+interface HandleCommentReportProps {
+    spaceId: string;
+    reportId: string;
+    commentId: string;
+    actions: CommentReportAction[];
+    summary?: string;
+    reason?: string;
+    /** The user to ban (target), required when actions include "ban-user". */
+    userId?: string;
+}
+declare function handleCommentReport(client: SublayHttpClient, data: HandleCommentReportProps): Promise<HandleReportResponse>;
+
+interface ModerateSpaceEntityProps {
+    spaceId: string;
+    entityId: string;
+    action: "approve" | "remove";
+    reason?: string;
+}
+interface ModerationResponse {
+    message: string;
+    moderationStatus: "approved" | "removed";
+}
+declare function moderateSpaceEntity(client: SublayHttpClient, data: ModerateSpaceEntityProps): Promise<ModerationResponse>;
+
+interface SetSpaceEntityNsfwProps {
+    spaceId: string;
+    entityId: string;
+    nsfw: boolean;
+}
+interface SetSpaceEntityNsfwResponse {
+    message: string;
+    nsfw: boolean;
+}
+/**
+ * Space-moderator endpoint to set the NSFW flag on an entity within their space
+ * (including other users' entities). Near-copy of `moderateSpaceEntity`, but it
+ * writes the entity's own `nsfw` (the NSFW axis), not `moderationStatus`.
+ */
+declare function setSpaceEntityNsfw(client: SublayHttpClient, data: SetSpaceEntityNsfwProps): Promise<SetSpaceEntityNsfwResponse>;
+
+interface ModerateSpaceCommentProps {
+    spaceId: string;
+    commentId: string;
+    action: "approve" | "remove";
+    reason?: string;
+}
+declare function moderateSpaceComment(client: SublayHttpClient, data: ModerateSpaceCommentProps): Promise<ModerationResponse>;
+
+interface ChatMessage {
+    id: string;
+    projectId: string;
+    conversationId: string;
+    userId: string | null;
+    content: string | null;
+    gif: GifData | null;
+    mentions: Mention[];
+    files?: File$1[];
+    metadata: Record<string, any>;
+    parentMessageId: string | null;
+    quotedMessageId: string | null;
+    threadReplyCount: number;
+    reactionCounts: Record<string, number>;
+    userReactions: string[];
+    /**
+     * Reputation-grant summary. Opt-in — present exactly when the read requested
+     * `include=grants`. Once requested the server always returns the object,
+     * zero-filled rather than omitted, on projects with no grants and on projects
+     * without the reputation bundle alike.
+     */
+    grants?: GrantSummary;
+    editedAt: string | null;
+    userDeletedAt: string | null;
+    moderationStatus: "approved" | "removed" | null;
+    moderatedAt: string | null;
+    moderatedById: string | null;
+    moderatedByType: "client" | "user" | null;
+    moderationReason: string | null;
+    createdAt: string;
+    updatedAt: string;
+    user: User | null;
+    quotedMessage?: ChatMessage | null;
+    parentMessage?: ChatMessage | null;
+}
+
+type ConversationMemberRole = "admin" | "member";
+interface ConversationMember {
+    id: string;
+    projectId: string;
+    conversationId: string;
+    userId: string;
+    role: ConversationMemberRole | null;
+    lastReadAt: string | null;
+    mutedUntil?: string | null;
+    mutedForever?: boolean;
+    isActive: boolean;
+    leftAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    user?: User;
+}
+
+interface Conversation {
+    id: string;
+    projectId: string;
+    type: "direct" | "group" | "space";
+    name: string | null;
+    description: string | null;
+    spaceId: string | null;
+    createdById: string | null;
+    avatarFileId: string | null;
+    lastMessageAt: string | null;
+    postingPermission: "members" | "admins" | null;
+    metadata: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+    memberCount?: number;
+    currentMember?: ConversationMember;
+    avatarFile?: File$1;
+}
+interface ConversationPreview extends Conversation {
+    unreadCount: number;
+    lastMessage: ChatMessage | null;
+    otherMembers?: Pick<User, "id" | "name" | "username" | "avatar">[];
+}
+
+interface GetSpaceConversationProps {
+    spaceId: string;
+}
+declare function getSpaceConversation(client: SublayHttpClient, data: GetSpaceConversationProps): Promise<Conversation>;
+
+interface ModerateSpaceChatMessageProps {
+    spaceId: string;
+    messageId: string;
+    moderationStatus: "removed";
+    moderationReason?: string;
+}
+interface ModerateSpaceChatMessageResponse {
+    message: string;
+    moderationStatus: string;
+}
+declare function moderateSpaceChatMessage(client: SublayHttpClient, data: ModerateSpaceChatMessageProps): Promise<ModerateSpaceChatMessageResponse>;
+
+type SpaceChatReportAction = "remove-message" | "ban-user" | "dismiss";
+interface HandleSpaceChatReportProps {
+    spaceId: string;
+    reportId: string;
+    actions: SpaceChatReportAction[];
+    summary?: string;
+    /** The user to ban (target), required when actions include "ban-user". */
+    userId?: string;
+    reason?: string;
+    /** The message to remove, required when actions include "remove-message". */
+    messageId?: string;
+}
+interface HandleSpaceChatReportResponse {
+    message: string;
+    code: string;
+}
+declare function handleSpaceChatReport(client: SublayHttpClient, data: HandleSpaceChatReportProps): Promise<HandleSpaceChatReportResponse>;
+
+declare const Spaces_approveMembership: typeof approveMembership;
+declare const Spaces_banMember: typeof banMember;
+declare const Spaces_checkMyMembership: typeof checkMyMembership;
+declare const Spaces_checkSlugAvailability: typeof checkSlugAvailability;
+declare const Spaces_createRule: typeof createRule;
+declare const Spaces_createSpace: typeof createSpace;
+declare const Spaces_declineMembership: typeof declineMembership;
+declare const Spaces_deleteRule: typeof deleteRule;
+declare const Spaces_deleteSpace: typeof deleteSpace;
+declare const Spaces_fetchChildSpaces: typeof fetchChildSpaces;
+declare const Spaces_fetchManyRules: typeof fetchManyRules;
+declare const Spaces_fetchManySpaces: typeof fetchManySpaces;
+declare const Spaces_fetchMutualSpaces: typeof fetchMutualSpaces;
+declare const Spaces_fetchRule: typeof fetchRule;
+declare const Spaces_fetchSpace: typeof fetchSpace;
+declare const Spaces_fetchSpaceBreadcrumb: typeof fetchSpaceBreadcrumb;
+declare const Spaces_fetchSpaceByShortId: typeof fetchSpaceByShortId;
+declare const Spaces_fetchSpaceBySlug: typeof fetchSpaceBySlug;
+declare const Spaces_fetchSpaceMembers: typeof fetchSpaceMembers;
+declare const Spaces_fetchSpaceTeam: typeof fetchSpaceTeam;
+declare const Spaces_fetchUserSpaces: typeof fetchUserSpaces;
+declare const Spaces_getSpaceConversation: typeof getSpaceConversation;
+declare const Spaces_handleCommentReport: typeof handleCommentReport;
+declare const Spaces_handleEntityReport: typeof handleEntityReport;
+declare const Spaces_handleSpaceChatReport: typeof handleSpaceChatReport;
+declare const Spaces_joinSpace: typeof joinSpace;
+declare const Spaces_leaveSpace: typeof leaveSpace;
+declare const Spaces_moderateSpaceChatMessage: typeof moderateSpaceChatMessage;
+declare const Spaces_moderateSpaceComment: typeof moderateSpaceComment;
+declare const Spaces_moderateSpaceEntity: typeof moderateSpaceEntity;
+declare const Spaces_reorderRules: typeof reorderRules;
+declare const Spaces_setSpaceEntityNsfw: typeof setSpaceEntityNsfw;
+declare const Spaces_unbanMember: typeof unbanMember;
+declare const Spaces_updateMemberRole: typeof updateMemberRole;
+declare const Spaces_updateRule: typeof updateRule;
+declare const Spaces_updateSpace: typeof updateSpace;
+declare namespace Spaces {
+  export { Spaces_approveMembership as approveMembership, Spaces_banMember as banMember, Spaces_checkMyMembership as checkMyMembership, Spaces_checkSlugAvailability as checkSlugAvailability, Spaces_createRule as createRule, Spaces_createSpace as createSpace, Spaces_declineMembership as declineMembership, Spaces_deleteRule as deleteRule, Spaces_deleteSpace as deleteSpace, Spaces_fetchChildSpaces as fetchChildSpaces, Spaces_fetchManyRules as fetchManyRules, Spaces_fetchManySpaces as fetchManySpaces, Spaces_fetchMutualSpaces as fetchMutualSpaces, Spaces_fetchRule as fetchRule, Spaces_fetchSpace as fetchSpace, Spaces_fetchSpaceBreadcrumb as fetchSpaceBreadcrumb, Spaces_fetchSpaceByShortId as fetchSpaceByShortId, Spaces_fetchSpaceBySlug as fetchSpaceBySlug, Spaces_fetchSpaceMembers as fetchSpaceMembers, Spaces_fetchSpaceTeam as fetchSpaceTeam, Spaces_fetchUserSpaces as fetchUserSpaces, Spaces_getSpaceConversation as getSpaceConversation, Spaces_handleCommentReport as handleCommentReport, Spaces_handleEntityReport as handleEntityReport, Spaces_handleSpaceChatReport as handleSpaceChatReport, Spaces_joinSpace as joinSpace, Spaces_leaveSpace as leaveSpace, Spaces_moderateSpaceChatMessage as moderateSpaceChatMessage, Spaces_moderateSpaceComment as moderateSpaceComment, Spaces_moderateSpaceEntity as moderateSpaceEntity, Spaces_reorderRules as reorderRules, Spaces_setSpaceEntityNsfw as setSpaceEntityNsfw, Spaces_unbanMember as unbanMember, Spaces_updateMemberRole as updateMemberRole, Spaces_updateRule as updateRule, Spaces_updateSpace as updateSpace };
+}
+
+interface Collection {
+    id: string;
+    projectId: string;
+    userId: string;
+    parentId: string | null;
+    name: string;
+    entityCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+
+declare function fetchRootCollection(client: SublayHttpClient): Promise<Collection>;
+
+interface FetchSubCollectionsProps {
+    collectionId: string;
+}
+declare function fetchSubCollections(client: SublayHttpClient, data: FetchSubCollectionsProps): Promise<Collection[]>;
+
+interface CreateNewCollectionProps {
+    /** The parent collection under which to create the sub-collection. */
+    collectionId: string;
+    collectionName: string;
+}
+declare function createNewCollection(client: SublayHttpClient, data: CreateNewCollectionProps): Promise<Collection>;
+
+interface FetchCollectionEntitiesProps {
+    collectionId: string;
+    page?: number;
+    limit?: number;
+    sortBy?: "new" | "added" | "top" | "hot";
+    sortDir?: "asc" | "desc";
+    /** Comma-separated list of associations to populate, e.g. "user". */
+    include?: string;
+}
+declare function fetchCollectionEntities(client: SublayHttpClient, data: FetchCollectionEntitiesProps): Promise<PaginatedResponse<Entity>>;
+
+interface AddEntityToCollectionProps {
+    collectionId: string;
+    entityId: string;
+}
+interface CollectionEntityMutationResponse {
+    success: boolean;
+    collection: {
+        id: string;
+        entityCount: number;
+    };
+}
+declare function addEntityToCollection(client: SublayHttpClient, data: AddEntityToCollectionProps): Promise<CollectionEntityMutationResponse>;
+
+interface RemoveEntityFromCollectionProps {
+    collectionId: string;
+    entityId: string;
+}
+declare function removeEntityFromCollection(client: SublayHttpClient, data: RemoveEntityFromCollectionProps): Promise<CollectionEntityMutationResponse>;
+
+interface UpdateCollectionProps {
+    collectionId: string;
+    name: string;
+}
+declare function updateCollection(client: SublayHttpClient, data: UpdateCollectionProps): Promise<Collection>;
+
+interface DeleteCollectionProps {
+    collectionId: string;
+}
+declare function deleteCollection(client: SublayHttpClient, data: DeleteCollectionProps): Promise<void>;
+
+declare const Collections_addEntityToCollection: typeof addEntityToCollection;
+declare const Collections_createNewCollection: typeof createNewCollection;
+declare const Collections_deleteCollection: typeof deleteCollection;
+declare const Collections_fetchCollectionEntities: typeof fetchCollectionEntities;
+declare const Collections_fetchRootCollection: typeof fetchRootCollection;
+declare const Collections_fetchSubCollections: typeof fetchSubCollections;
+declare const Collections_removeEntityFromCollection: typeof removeEntityFromCollection;
+declare const Collections_updateCollection: typeof updateCollection;
+declare namespace Collections {
+  export { Collections_addEntityToCollection as addEntityToCollection, Collections_createNewCollection as createNewCollection, Collections_deleteCollection as deleteCollection, Collections_fetchCollectionEntities as fetchCollectionEntities, Collections_fetchRootCollection as fetchRootCollection, Collections_fetchSubCollections as fetchSubCollections, Collections_removeEntityFromCollection as removeEntityFromCollection, Collections_updateCollection as updateCollection };
+}
+
+interface FetchFollowingProps extends UserSearchParams {
+    page?: number;
+    limit?: number;
+}
+declare function fetchFollowing(client: SublayHttpClient, data: FetchFollowingProps): Promise<PaginatedResponse<FollowListItem>>;
+
+interface FetchFollowersProps extends UserSearchParams {
+    page?: number;
+    limit?: number;
+}
+declare function fetchFollowers(client: SublayHttpClient, data: FetchFollowersProps): Promise<PaginatedResponse<FollowListItem>>;
+
+interface FollowingCountResponse {
+    count: number;
+}
+declare function fetchFollowingCount(client: SublayHttpClient): Promise<FollowingCountResponse>;
+
+interface FollowersCountResponse {
+    count: number;
+}
+declare function fetchFollowersCount(client: SublayHttpClient): Promise<FollowersCountResponse>;
+
+interface DeleteFollowByIdProps {
+    followId: string;
+}
+declare function deleteFollow(client: SublayHttpClient, data: DeleteFollowByIdProps): Promise<void>;
+
+declare const Follows_deleteFollow: typeof deleteFollow;
+declare const Follows_fetchFollowers: typeof fetchFollowers;
+declare const Follows_fetchFollowersCount: typeof fetchFollowersCount;
+declare const Follows_fetchFollowing: typeof fetchFollowing;
+declare const Follows_fetchFollowingCount: typeof fetchFollowingCount;
+declare namespace Follows {
+  export { Follows_deleteFollow as deleteFollow, Follows_fetchFollowers as fetchFollowers, Follows_fetchFollowersCount as fetchFollowersCount, Follows_fetchFollowing as fetchFollowing, Follows_fetchFollowingCount as fetchFollowingCount };
+}
+
+interface FetchConnectionsProps extends UserSearchParams {
+    page?: number;
+    limit?: number;
+}
+declare function fetchConnections(client: SublayHttpClient, data: FetchConnectionsProps): Promise<PaginatedResponse<EstablishedConnection>>;
+
+declare function fetchConnectionsCount(client: SublayHttpClient): Promise<ConnectionCountResponse>;
+
+interface FetchSentPendingConnectionsProps {
+    page?: number;
+    limit?: number;
+}
+declare function fetchSentPendingConnections(client: SublayHttpClient, data: FetchSentPendingConnectionsProps): Promise<PaginatedResponse<PendingConnection>>;
+
+interface FetchReceivedPendingConnectionsProps {
+    page?: number;
+    limit?: number;
+}
+declare function fetchReceivedPendingConnections(client: SublayHttpClient, data: FetchReceivedPendingConnectionsProps): Promise<PaginatedResponse<PendingConnection>>;
+
+interface AcceptConnectionProps {
+    connectionId: string;
+}
+declare function acceptConnection(client: SublayHttpClient, data: AcceptConnectionProps): Promise<ConnectionActionResponse>;
+
+interface DeclineConnectionProps {
+    connectionId: string;
+}
+declare function declineConnection(client: SublayHttpClient, data: DeclineConnectionProps): Promise<ConnectionActionResponse>;
+
+interface RemoveConnectionProps {
+    connectionId: string;
+}
+declare function removeConnection(client: SublayHttpClient, data: RemoveConnectionProps): Promise<void>;
+
+declare const Connections_acceptConnection: typeof acceptConnection;
+declare const Connections_declineConnection: typeof declineConnection;
+declare const Connections_fetchConnections: typeof fetchConnections;
+declare const Connections_fetchConnectionsCount: typeof fetchConnectionsCount;
+declare const Connections_fetchReceivedPendingConnections: typeof fetchReceivedPendingConnections;
+declare const Connections_fetchSentPendingConnections: typeof fetchSentPendingConnections;
+declare const Connections_removeConnection: typeof removeConnection;
+declare namespace Connections {
+  export { Connections_acceptConnection as acceptConnection, Connections_declineConnection as declineConnection, Connections_fetchConnections as fetchConnections, Connections_fetchConnectionsCount as fetchConnectionsCount, Connections_fetchReceivedPendingConnections as fetchReceivedPendingConnections, Connections_fetchSentPendingConnections as fetchSentPendingConnections, Connections_removeConnection as removeConnection };
+}
+
+type AppNotificationType = "system" | "entity-comment" | "comment-reply" | "entity-mention" | "comment-mention" | "entity-upvote" | "comment-upvote" | "entity-reaction" | "comment-reaction" | "entity-reaction-milestone-specific" | "entity-reaction-milestone-total" | "comment-reaction-milestone-specific" | "comment-reaction-milestone-total" | "new-follow" | "connection-request" | "connection-accepted" | "space-membership-approved";
+interface BaseAppNotification {
+    id: string;
+    userId: string;
+    type: AppNotificationType;
+    isRead: boolean;
+    metadata: Record<string, any>;
+    createdAt: string;
+}
+interface SystemNotification extends BaseAppNotification {
+    type: "system";
+    action: string;
+    metadata: {
+        title?: string;
+        content?: string;
+        buttonData: {
+            text: string;
+            url: string;
+        } | null;
+    };
+}
+interface EntityCommentNotification extends BaseAppNotification {
+    type: "entity-comment";
+    action: "open-comment";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        commentId: string;
+        commentContent: string | null | undefined;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface CommentReplyNotification extends BaseAppNotification {
+    type: "comment-reply";
+    action: "open-comment";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        commentId: string;
+        commentContent: string | null | undefined;
+        replyId: string;
+        replyContent: string | null | undefined;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface EntityMentionNotification extends BaseAppNotification {
+    type: "entity-mention";
+    action: "open-entity";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface CommentMentionNotification extends BaseAppNotification {
+    type: "comment-mention";
+    action: "open-comment";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        commentId: string;
+        commentContent: string | null | undefined;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface EntityUpvoteNotification extends BaseAppNotification {
+    type: "entity-upvote";
+    action: "open-entity";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface CommentUpvoteNotification extends BaseAppNotification {
+    type: "comment-upvote";
+    action: "open-comment";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        commentId: string;
+        commentContent: string | null | undefined;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface EntityReactionNotification extends BaseAppNotification {
+    type: "entity-reaction";
+    action: "open-entity";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        reactionType: string;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface CommentReactionNotification extends BaseAppNotification {
+    type: "comment-reaction";
+    action: "open-comment";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        commentId: string;
+        commentContent: string | null | undefined;
+        reactionType: string;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface MilestoneUser {
+    id: string;
+    name: string | null | undefined;
+    username: string | null | undefined;
+    avatar: string | null | undefined;
+}
+interface EntityReactionMilestoneSpecificNotification extends BaseAppNotification {
+    type: "entity-reaction-milestone-specific";
+    action: "open-entity";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        reactionType: string;
+        milestoneCount: number;
+        lastThreeUsers: MilestoneUser[];
+    };
+}
+interface EntityReactionMilestoneTotalNotification extends BaseAppNotification {
+    type: "entity-reaction-milestone-total";
+    action: "open-entity";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        milestoneCount: number;
+        reactionCounts: Record<string, number>;
+        lastThreeUsers: MilestoneUser[];
+    };
+}
+interface CommentReactionMilestoneSpecificNotification extends BaseAppNotification {
+    type: "comment-reaction-milestone-specific";
+    action: "open-comment";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        commentId: string;
+        commentContent: string | null | undefined;
+        reactionType: string;
+        milestoneCount: number;
+        lastThreeUsers: MilestoneUser[];
+    };
+}
+interface CommentReactionMilestoneTotalNotification extends BaseAppNotification {
+    type: "comment-reaction-milestone-total";
+    action: "open-comment";
+    metadata: {
+        entityId: string;
+        entityShortId: string;
+        entityTitle: string | null | undefined;
+        entityContent: string | null | undefined;
+        commentId: string;
+        commentContent: string | null | undefined;
+        milestoneCount: number;
+        reactionCounts: Record<string, number>;
+        lastThreeUsers: MilestoneUser[];
+    };
+}
+interface SpaceMembershipApprovedNotification extends BaseAppNotification {
+    type: "space-membership-approved";
+    action: "open-space";
+    metadata: {
+        spaceId: string;
+        spaceName: string;
+        spaceShortId: string;
+        spaceSlug: string | null | undefined;
+        spaceAvatar: string | null | undefined;
+    };
+}
+interface NewFollowNotification extends BaseAppNotification {
+    type: "new-follow";
+    action: "open-profile";
+    metadata: {
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface ConnectionRequestNotification extends BaseAppNotification {
+    type: "connection-request";
+    action: "open-profile";
+    metadata: {
+        connectionId: string;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+interface ConnectionAcceptedNotification extends BaseAppNotification {
+    type: "connection-accepted";
+    action: "open-profile";
+    metadata: {
+        connectionId: string;
+        initiatorId: string;
+        initiatorName: string | null | undefined;
+        initiatorUsername: string | null | undefined;
+        initiatorAvatar: string | null | undefined;
+    };
+}
+type UnifiedAppNotification = SystemNotification | EntityCommentNotification | CommentReplyNotification | EntityMentionNotification | CommentMentionNotification | EntityUpvoteNotification | CommentUpvoteNotification | EntityReactionNotification | CommentReactionNotification | EntityReactionMilestoneSpecificNotification | EntityReactionMilestoneTotalNotification | CommentReactionMilestoneSpecificNotification | CommentReactionMilestoneTotalNotification | NewFollowNotification | ConnectionRequestNotification | ConnectionAcceptedNotification | SpaceMembershipApprovedNotification;
+
+interface FetchNotificationsProps {
+    page?: number;
+    limit?: number;
+}
+declare function fetchNotifications(client: SublayHttpClient, data?: FetchNotificationsProps): Promise<PaginatedResponse<UnifiedAppNotification>>;
+
+declare function countUnreadNotifications(client: SublayHttpClient): Promise<number>;
+
+interface MarkNotificationAsReadProps {
+    notificationId: string;
+}
+declare function markNotificationAsRead(client: SublayHttpClient, data: MarkNotificationAsReadProps): Promise<void>;
+
+interface MarkAllNotificationsAsReadResponse {
+    markedAsRead: number;
+}
+declare function markAllNotificationsAsRead(client: SublayHttpClient): Promise<MarkAllNotificationsAsReadResponse>;
+
+declare const AppNotifications_countUnreadNotifications: typeof countUnreadNotifications;
+declare const AppNotifications_fetchNotifications: typeof fetchNotifications;
+declare const AppNotifications_markAllNotificationsAsRead: typeof markAllNotificationsAsRead;
+declare const AppNotifications_markNotificationAsRead: typeof markNotificationAsRead;
+declare namespace AppNotifications {
+  export { AppNotifications_countUnreadNotifications as countUnreadNotifications, AppNotifications_fetchNotifications as fetchNotifications, AppNotifications_markAllNotificationsAsRead as markAllNotificationsAsRead, AppNotifications_markNotificationAsRead as markNotificationAsRead };
+}
+
+type ReportTargetType = "entity" | "comment" | "message";
+/**
+ * The reasons the API accepts on a report. Server-enforced — anything outside
+ * this set is rejected with `report/invalid-body`. Use `other` plus `details`
+ * for anything the taxonomy doesn't cover.
+ */
+type ReportReason = "spam" | "inappropriateContent" | "harassment" | "misinformation" | "hateSpeech" | "violence" | "illegalActivity" | "selfHarm" | "other";
+type ReportStatus = "pending" | "on-hold" | "escalated" | "dismissed" | "actioned";
+interface UserReport {
+    id: string;
+    projectId: string;
+    reportId: string;
+    userId: string;
+    reason: string;
+    details: string | null;
+    createdAt: string;
+}
+interface Report {
+    id: string;
+    projectId: string;
+    spaceId: string | null;
+    targetId: string;
+    targetType: ReportTargetType;
+    status: ReportStatus;
+    reporterCount: number;
+    createdAt: string;
+    updatedAt: string;
+    userReports?: UserReport[];
+    target?: Entity | Comment | null;
+    space?: Space | null;
+}
+interface CreateReportResponse {
+    message: string;
+    code: "report/created" | "report/updated" | "report/already-reported";
+}
+
+interface CreateReportProps {
+    targetType: ReportTargetType;
+    targetId: string;
+    reason: ReportReason;
+    details?: string;
+}
+declare function createReport(client: SublayHttpClient, data: CreateReportProps): Promise<CreateReportResponse>;
+
+interface FetchModeratedReportsProps extends SpaceReputationContextParams {
+    spaceId?: string;
+    targetType?: ReportTargetType;
+    status?: ReportStatus;
+    sortBy?: "new" | "old";
+    page?: number;
+    limit?: number;
+}
+declare function fetchModeratedReports(client: SublayHttpClient, data: FetchModeratedReportsProps): Promise<PaginatedResponse<Report>>;
+
+declare const Reports_createReport: typeof createReport;
+declare const Reports_fetchModeratedReports: typeof fetchModeratedReports;
+declare namespace Reports {
+  export { Reports_createReport as createReport, Reports_fetchModeratedReports as fetchModeratedReports };
+}
+
+interface CreateGrantBaseProps {
+    /** The user receiving the reputation. Cannot be the logged-in user. */
+    recipientId: string;
+    /**
+     * Positive integer. A user transfer can never mint (negatives) nor be a
+     * no-op (zero) — minting is service-key-only and lives in `@sublay/node`.
+     */
+    amount: number;
+    /** The bucket both legs move in. Omitted/null = the project-general bucket. */
+    spaceId?: string | null;
+    /**
+     * Free-text reason. Trimmed and capped at 2000 characters server-side.
+     * Genuinely nullable — an explicit `null` is accepted and means "no note".
+     */
+    note?: string | null;
+    /**
+     * Arbitrary JSON, capped at 1 MB server-side.
+     *
+     * NOT nullable — deliberately asymmetric with `note` directly above, not a
+     * typo. The server's shared `metadataSchema` is `z.record(...).optional()`
+     * with no `.nullable()`, so an explicit `metadata: null` is rejected with
+     * `400 reputation-grant/invalid-body`. Omit the key to mean "no metadata".
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * `targetType` and `targetId` are supplied together or not at all — the
+ * both-or-neither pair is carried by {@link ReputationGrantTargetFilter}, which
+ * makes the half-filled shape a compile error instead of a
+ * `400 reputation-grant/invalid-body`.
+ */
+type CreateGrantProps = CreateGrantBaseProps & ReputationGrantTargetFilter;
+/**
+ * Transfers reputation from the logged-in user to another user — a **debited
+ * transfer**: the amount leaves the sender's bucket and lands in the
+ * recipient's bucket in the same space. Nothing is created.
+ *
+ * There is no actor field: the sender is always the user the token belongs to.
+ * Naming somebody else as the sender requires a service key, which this SDK
+ * never holds.
+ */
+declare function createGrant(client: SublayHttpClient, data: CreateGrantProps): Promise<ReputationGrant>;
+
+interface ListGrantsBaseProps extends SpaceReputationContextParams {
+    page?: number;
+    limit?: number;
+    /** What this user received. */
+    recipientId?: string;
+    /** What this user sent. */
+    senderId?: string;
+    /** Associations to expand. Only `"user"` is supported (hydrates both parties). */
+    include?: string;
+}
+/**
+ * The third filter shape — "who rewarded this item" — is the
+ * {@link ReputationGrantTargetFilter} pair, so a half-filled target is a
+ * compile error rather than a `400 reputation-grant/invalid-filter`.
+ *
+ * Mutual exclusivity between the three shapes is NOT expressed in the type: a
+ * three-way exclusive union would multiply out across every pagination and
+ * space-reputation field and make the props unreadable, for a rule the server
+ * reports clearly. Only the both-or-neither pairing is typed.
+ */
+type ListGrantsProps = ListGrantsBaseProps & ReputationGrantTargetFilter;
+/**
+ * The `summary` block rides alongside the page envelope, and only on the
+ * target filter shape.
+ */
+interface ListGrantsResponse extends PaginatedResponse<ReputationGrant> {
+    summary?: GrantSummary;
+}
+/**
+ * Lists reputation grants.
+ *
+ * Exactly one filter shape per request — `recipientId`, `senderId`, or
+ * `targetType` + `targetId`. Supplying none or combining two is a `400`; the
+ * shapes are not AND-ed, which is what keeps the `summary` block reconcilable
+ * with the rows beneath it.
+ *
+ * Only positive grants are ever returned. Negative grants are app moderation
+ * deductions and are unreadable from every public surface.
+ */
+declare function listGrants(client: SublayHttpClient, data: ListGrantsProps): Promise<ListGrantsResponse>;
+
+declare const Reputation_createGrant: typeof createGrant;
+declare const Reputation_listGrants: typeof listGrants;
+declare namespace Reputation {
+  export { Reputation_createGrant as createGrant, Reputation_listGrants as listGrants };
+}
+
+interface SearchContentProps extends SpaceReputationContextParams {
+    query: string;
+    sourceTypes?: ("entity" | "comment" | "message")[];
+    spaceId?: string;
+    /**
+     * With a `spaceId`, also search every space nested under it (children,
+     * grandchildren — the whole subtree, any depth). Ignored without a `spaceId`.
+     * Defaults to false (exact-space search).
+     */
+    includeChildSpaces?: boolean;
+    conversationId?: string;
+    limit?: number;
+}
+interface ContentSearchResult {
+    sourceType: "entity" | "comment" | "message";
+    similarity: number;
+    record: Entity | Comment | ChatMessage;
+}
+declare function searchContent(client: SublayHttpClient, data: SearchContentProps): Promise<ContentSearchResult[]>;
+
+interface SearchUsersProps {
+    query: string;
+    limit?: number;
+}
+interface UserSearchResult {
+    similarity: number;
+    record: User;
+}
+declare function searchUsers(client: SublayHttpClient, data: SearchUsersProps): Promise<UserSearchResult[]>;
+
+interface SearchSpacesProps {
+    query: string;
+    limit?: number;
+}
+interface SpaceSearchResult {
+    similarity: number;
+    record: Space;
+}
+declare function searchSpaces(client: SublayHttpClient, data: SearchSpacesProps): Promise<SpaceSearchResult[]>;
+
+interface AskContentProps extends SpaceReputationContextParams {
+    query: string;
+    sourceTypes?: ("entity" | "comment" | "message")[];
+    spaceId?: string;
+    /**
+     * With a `spaceId`, also search every space nested under it (children,
+     * grandchildren — the whole subtree, any depth). Ignored without a `spaceId`.
+     * Defaults to false (exact-space search).
+     */
+    includeChildSpaces?: boolean;
+    conversationId?: string;
+    limit?: number;
+    /** Abort the in-flight stream (e.g. when the user navigates away). */
+    signal?: AbortSignal;
+}
+/**
+ * A single Server-Sent Event from the `askContent` stream.
+ * - `token`   — an incremental chunk of the answer text.
+ * - `sources` — the hydrated source records, emitted once after the answer.
+ * - `done`    — the stream finished successfully.
+ * - `error`   — the server reported an error (the stream ends after this).
+ */
+type AskContentEvent = {
+    type: "token";
+    content: string;
+} | {
+    type: "sources";
+    sources: ContentSearchResult[];
+} | {
+    type: "done";
+} | {
+    type: "error";
+    error: string;
+};
+/**
+ * Ask a question over your project's content (semantic RAG). The server answers
+ * by streaming Server-Sent Events, so this is an **async generator**: iterate it
+ * to consume the answer as it arrives.
+ *
+ * ```ts
+ * let answer = "";
+ * for await (const ev of client.search.askContent({ query: "How do refunds work?" })) {
+ *   if (ev.type === "token") answer += ev.content;
+ *   else if (ev.type === "sources") console.log("sources:", ev.sources);
+ *   else if (ev.type === "error") throw new Error(ev.error);
+ * }
+ * ```
+ *
+ * Cancel by passing an `AbortSignal`, or by `break`ing out of the loop.
+ *
+ * Note: this request uses `fetch` (not the axios instance), so it does not get
+ * the automatic 403→refresh retry. The token is read fresh at call time via the
+ * client's active auth mode.
+ */
+declare function askContent(client: SublayHttpClient, data: AskContentProps): AsyncGenerator<AskContentEvent, void, unknown>;
+
+interface MatchUsersProps {
+    mode: "passive" | "directed";
+    query?: string;
+    limit?: number;
+    spaceId?: string;
+    includeChildSpaces?: boolean;
+    includeSampleContent?: boolean;
+    excludeSelf?: boolean;
+}
+interface MatchFacetRef {
+    id: string;
+    hotness: number;
+}
+interface SampleContent {
+    sourceType: "entity" | "comment" | "message";
+    recordId: string;
+    content: string;
+    similarity: number;
+}
+interface MatchedFacet {
+    similarity: number;
+    askerFacet?: MatchFacetRef;
+    candidateFacet: MatchFacetRef;
+    sampleContent?: SampleContent[];
+}
+interface UserMatchResult {
+    user: User;
+    score: number;
+    matchedFacets: MatchedFacet[];
+}
+interface MatchUsersResponse {
+    results: UserMatchResult[];
+}
+declare function matchUsers(client: SublayHttpClient, data: MatchUsersProps): Promise<MatchUsersResponse>;
+
+declare const Search_askContent: typeof askContent;
+declare const Search_matchUsers: typeof matchUsers;
+declare const Search_searchContent: typeof searchContent;
+declare const Search_searchSpaces: typeof searchSpaces;
+declare const Search_searchUsers: typeof searchUsers;
+declare namespace Search {
+  export { Search_askContent as askContent, Search_matchUsers as matchUsers, Search_searchContent as searchContent, Search_searchSpaces as searchSpaces, Search_searchUsers as searchUsers };
+}
+
+interface UploadedImageVariant {
+    path: string;
+    width: number;
+    height: number;
+    size: number;
+    format: string;
+    publicPath: string;
+}
+interface UploadImageResponse {
+    fileId: string;
+    type: "image";
+    originalPath: string;
+    originalSize: number;
+    originalWidth: number;
+    originalHeight: number;
+    variants: Record<string, UploadedImageVariant>;
+    format: string;
+    quality: number;
+    /** ISO-8601 timestamp. */
+    createdAt: string;
+}
+interface UploadImageProps {
+    /** The image to upload, as a browser `File` or `Blob`. */
+    file: Blob | File;
+    /** Optional filename for the multipart part (defaults to the `File.name` or `"upload"`). */
+    filename?: string;
+    /**
+     * Image-processing configuration. A discriminated union on `mode` mirroring
+     * the server's `uploadImageBodySchema` — see {@link ImageOptions}.
+     */
+    imageOptions: ImageOptions;
+    /** Storage path segments, e.g. ["spaces", spaceId, "banner"]. */
+    pathParts?: string[];
+    /** Only one of entityId/commentId/spaceId/eventId may be set. */
+    entityId?: string;
+    commentId?: string;
+    spaceId?: string;
+    eventId?: string;
+}
+declare function uploadImage(client: SublayHttpClient, data: UploadImageProps): Promise<UploadImageResponse>;
+
+interface UploadFileResponse {
+    fileId: string;
+    type: string;
+    relativePath: string;
+    publicPath: string;
+    size: number;
+    mimeType: string;
+    /** ISO-8601 timestamp. */
+    createdAt: string;
+}
+interface UploadFileProps {
+    /** The file to upload, as a browser `File` or `Blob`. */
+    file: Blob | File;
+    /** Optional filename for the multipart part (defaults to the `File.name` or `"upload"`). */
+    filename?: string;
+    /**
+     * Storage path segments for the file, e.g. ["avatars", userId]. Required by
+     * the server (`uploadFileBodySchema.pathParts`).
+     */
+    pathParts: string[];
+    /** Ordering within the associated entity/comment/space. */
+    position?: number;
+    metadata?: Record<string, any>;
+    /** Only one of entityId/commentId/spaceId may be set. */
+    entityId?: string;
+    commentId?: string;
+    spaceId?: string;
+}
+declare function uploadFile(client: SublayHttpClient, data: UploadFileProps): Promise<UploadFileResponse>;
+
+interface GetFileImage {
+    originalWidth: number;
+    originalHeight: number;
+    variants: Record<string, UploadedImageVariant>;
+    processingStatus: "completed" | "failed";
+    format: string;
+    quality: number;
+    exifStripped: boolean;
+}
+/** Shape returned by `GET /storage/:fileId` (a flat projection, not the populated `File` model). */
+interface GetFileResponse {
+    fileId: string;
+    type: string;
+    originalPath: string;
+    originalSize: number;
+    originalMimeType: string;
+    position: number | null;
+    metadata: Record<string, any> | null;
+    /** ISO-8601 timestamp. */
+    createdAt: string;
+    /** ISO-8601 timestamp. */
+    updatedAt: string;
+    userId?: string;
+    entityId?: string;
+    commentId?: string;
+    spaceId?: string;
+    image?: GetFileImage;
+}
+interface GetFileProps {
+    fileId: string;
+}
+declare function getFile(client: SublayHttpClient, data: GetFileProps): Promise<GetFileResponse>;
+
+interface DeleteFileProps {
+    fileId: string;
+}
+declare function deleteFile(client: SublayHttpClient, data: DeleteFileProps): Promise<void>;
+
+declare const Storage_deleteFile: typeof deleteFile;
+declare const Storage_getFile: typeof getFile;
+declare const Storage_uploadFile: typeof uploadFile;
+declare const Storage_uploadImage: typeof uploadImage;
+declare namespace Storage {
+  export { Storage_deleteFile as deleteFile, Storage_getFile as getFile, Storage_uploadFile as uploadFile, Storage_uploadImage as uploadImage };
+}
+
+/** Providers the server supports (mirrors the server's `oauthProviderSchema`). */
+type OAuthProvider = "google" | "github" | "apple" | "facebook";
+interface AuthorizeProps {
+    provider: OAuthProvider;
+    /**
+     * Where the server should send the browser back to once auth completes. Must
+     * be one of the project's allowed redirect URIs (configured in the dashboard).
+     */
+    redirectAfterAuth: string;
+}
+interface AuthorizeResponse {
+    /**
+     * The provider's authorization URL. The host app redirects the browser here;
+     * the provider then bounces to the server's `/oauth/callback`, which finishes
+     * auth and redirects back to `redirectAfterAuth` with the session.
+     */
+    authorizationUrl: string;
+}
+/**
+ * Begin an OAuth sign-in / sign-up flow (unauthenticated). Returns the
+ * `authorizationUrl` for the host to redirect to — it does NOT return tokens;
+ * the server's callback establishes the session.
+ */
+declare function authorize(client: SublayHttpClient, data: AuthorizeProps): Promise<AuthorizeResponse>;
+
+interface LinkIdentityProps {
+    provider: OAuthProvider;
+    /** Allowed redirect URI to return the browser to after linking completes. */
+    redirectAfterAuth: string;
+}
+/**
+ * Link a new OAuth provider to the **current** user (authenticated). Same
+ * redirect contract as {@link authorize}: returns the `authorizationUrl` for the
+ * host to redirect to. The current user is taken from the auth token, never the
+ * body.
+ */
+declare function linkIdentity(client: SublayHttpClient, data: LinkIdentityProps): Promise<AuthorizeResponse>;
+
+interface OAuthIdentity {
+    id: string;
+    provider: string;
+    providerAccountId: string;
+    email: string | null;
+    name: string | null;
+    avatar: string | null;
+    isVerified: boolean;
+    createdAt: string;
+}
+interface ListIdentitiesResponse {
+    identities: OAuthIdentity[];
+    hasPassword: boolean;
+}
+
+/** List the current user's linked OAuth identities (authenticated). */
+declare function listIdentities(client: SublayHttpClient): Promise<ListIdentitiesResponse>;
+
+interface UnlinkIdentityProps {
+    identityId: string;
+}
+interface UnlinkIdentityResponse {
+    success: boolean;
+}
+/**
+ * Unlink one of the current user's OAuth identities (authenticated). The server
+ * refuses to remove the last identity if the user has no password set.
+ */
+declare function unlinkIdentity(client: SublayHttpClient, data: UnlinkIdentityProps): Promise<UnlinkIdentityResponse>;
+
+declare const OAuth_authorize: typeof authorize;
+declare const OAuth_linkIdentity: typeof linkIdentity;
+declare const OAuth_listIdentities: typeof listIdentities;
+declare const OAuth_unlinkIdentity: typeof unlinkIdentity;
+declare namespace OAuth {
+  export { OAuth_authorize as authorize, OAuth_linkIdentity as linkIdentity, OAuth_listIdentities as listIdentities, OAuth_unlinkIdentity as unlinkIdentity };
+}
+
+interface ListConversationsProps {
+    /** Comma-separated conversation types, e.g. "direct,group,space". */
+    types?: string;
+    /** Cursor for keyset pagination: the `lastMessageAt` of the last item from the previous page (ISO datetime). */
+    cursor?: string;
+    /** Tie-breaker cursor: the `createdAt` of the last item from the previous page (ISO datetime). */
+    cursorCreatedAt?: string;
+    /** Default 20, max 50. */
+    limit?: number;
+}
+interface ListConversationsResponse {
+    conversations: ConversationPreview[];
+    hasMore: boolean;
+}
+declare function listConversations(client: SublayHttpClient, data?: ListConversationsProps): Promise<ListConversationsResponse>;
+
+interface CreateGroupConversationProps {
+    name?: string;
+    description?: string;
+    /** Member user IDs to add to the group. Defaults to []. */
+    memberIds?: string[];
+    metadata?: Record<string, any>;
+}
+declare function createGroupConversation(client: SublayHttpClient, data: CreateGroupConversationProps): Promise<Conversation>;
+
+interface CreateDirectConversationProps {
+    /** The other participant (the target). */
+    userId: string;
+}
+declare function createDirectConversation(client: SublayHttpClient, data: CreateDirectConversationProps): Promise<Conversation>;
+
+interface GetConversationProps {
+    conversationId: string;
+}
+declare function getConversation(client: SublayHttpClient, data: GetConversationProps): Promise<Conversation>;
+
+interface UpdateConversationProps {
+    conversationId: string;
+    name?: string;
+    description?: string;
+    /** File id for the conversation avatar, or null to clear it. */
+    avatarFileId?: string | null;
+    /** Space conversations only: who may post. */
+    postingPermission?: "members" | "admins";
+}
+declare function updateConversation(client: SublayHttpClient, data: UpdateConversationProps): Promise<Conversation>;
+
+interface DeleteConversationProps {
+    conversationId: string;
+}
+interface DeleteConversationResponse {
+    message: string;
+}
+declare function deleteConversation(client: SublayHttpClient, data: DeleteConversationProps): Promise<DeleteConversationResponse>;
+
+interface UnreadCountResponse {
+    totalUnread: number;
+    unreadConversationCount: number;
+}
+declare function getUnreadCount(client: SublayHttpClient): Promise<UnreadCountResponse>;
+
+interface ListMembersProps extends SpaceReputationContextParams {
+    conversationId: string;
+    page?: number;
+    limit?: number;
+    role?: "admin" | "member";
+}
+declare function listMembers(client: SublayHttpClient, data: ListMembersProps): Promise<PaginatedResponse<ConversationMember>>;
+
+interface AddMemberProps {
+    conversationId: string;
+    /** The member to add (the target). */
+    userId: string;
+}
+declare function addMember(client: SublayHttpClient, data: AddMemberProps): Promise<ConversationMember>;
+
+interface RemoveMemberProps {
+    conversationId: string;
+    /** The member to remove (the target). */
+    userId: string;
+}
+declare function removeMember(client: SublayHttpClient, data: RemoveMemberProps): Promise<{
+    message: string;
+}>;
+
+interface LeaveConversationProps {
+    conversationId: string;
+}
+declare function leaveConversation(client: SublayHttpClient, data: LeaveConversationProps): Promise<{
+    message: string;
+}>;
+
+interface ChangeMemberRoleProps {
+    conversationId: string;
+    /** The member whose role changes (the target). */
+    userId: string;
+    role: ConversationMemberRole;
+}
+declare function changeMemberRole(client: SublayHttpClient, data: ChangeMemberRoleProps): Promise<ConversationMember>;
+
+interface MessageFilters {
+    /**
+     * Filter to messages that have thread replies (not quotings). `true` returns
+     * only messages with at least one thread reply; `false` returns only messages
+     * with none. Omit for no reply-count filtering.
+     */
+    hasReplies?: boolean;
+}
+interface ListMessagesProps extends SpaceReputationContextParams {
+    conversationId: string;
+    /** Restrict to replies of this message (thread view). */
+    parentId?: string;
+    /** Keyset pagination: ISO timestamp; return messages created before this. Mutually exclusive with `after`. */
+    before?: string;
+    /** Keyset pagination: ISO timestamp; return messages created after this. Mutually exclusive with `before`. */
+    after?: string;
+    /** Page size (default 50, max 100). */
+    limit?: number;
+    sort?: "asc" | "desc";
+    /**
+     * Comma-separated associations to populate: `"files"` (message
+     * attachments) and `"grants"` (the reputation-grant summary). Combine
+     * them as `"files,grants"` — the server splits and trims this itself.
+     */
+    include?: string;
+    /** Optional filters, e.g. `{ hasReplies: true }`. */
+    filters?: MessageFilters;
+}
+interface ListMessagesResponse {
+    messages: ChatMessage[];
+    hasMore: boolean;
+    oldestCreatedAt: string | null;
+    newestCreatedAt: string | null;
+    /**
+     * Present only when a filter combination can't return results — e.g.
+     * `hasReplies: true` together with `parentId` (thread replies are one level
+     * deep and never have their own replies).
+     */
+    notice?: string;
+}
+declare function listMessages(client: SublayHttpClient, data: ListMessagesProps): Promise<ListMessagesResponse>;
+
+interface SendMessageProps extends SpaceReputationContextParams {
+    conversationId: string;
+    content?: string;
+    gif?: GifData | null;
+    mentions?: Mention[];
+    parentMessageId?: string;
+    quotedMessageId?: string;
+    metadata?: Record<string, any>;
+    /** Client-generated id echoed back on the created message (not stored). */
+    localId?: string;
+    /**
+     * Optional file attachments (browser `File`/`Blob`), up to 10. When present
+     * the request is sent as `multipart/form-data`; otherwise it's a JSON body.
+     */
+    files?: (Blob | File)[];
+}
+declare function sendMessage(client: SublayHttpClient, data: SendMessageProps): Promise<ChatMessage>;
+
+interface GetMessageProps extends SpaceReputationContextParams {
+    conversationId: string;
+    messageId: string;
+    /**
+     * Comma-separated associations to populate. Only `"grants"` is supported
+     * here — it attaches the message's reputation-grant summary.
+     */
+    include?: string;
+}
+declare function getMessage(client: SublayHttpClient, data: GetMessageProps): Promise<ChatMessage>;
+
+interface EditMessageProps {
+    conversationId: string;
+    messageId: string;
+    content?: string;
+    /** A GIF attachment, or null to clear it. */
+    gif?: GifData | null;
+    mentions?: Mention[];
+    metadata?: Record<string, any> | null;
+}
+declare function editMessage(client: SublayHttpClient, data: EditMessageProps): Promise<ChatMessage>;
+
+interface DeleteMessageProps {
+    conversationId: string;
+    messageId: string;
+}
+interface DeleteMessageResponse {
+    message: string;
+    /** Present when the author soft-deletes their own message. */
+    userDeletedAt?: string;
+}
+declare function deleteMessage(client: SublayHttpClient, data: DeleteMessageProps): Promise<DeleteMessageResponse>;
+
+interface ToggleReactionProps {
+    conversationId: string;
+    messageId: string;
+    /** The reaction emoji (required, 1–10 chars). */
+    emoji: string;
+}
+interface ToggleReactionResponse {
+    /** Updated emoji → count map for the message. */
+    reactionCounts: Record<string, number>;
+    /** Emojis the acting user has reacted with after the toggle. */
+    userReactions: string[];
+    /** +1 if the reaction was added, -1 if it was removed. */
+    delta: 1 | -1;
+}
+declare function toggleReaction(client: SublayHttpClient, data: ToggleReactionProps): Promise<ToggleReactionResponse>;
+
+interface ListReactionsProps extends SpaceReputationContextParams {
+    conversationId: string;
+    messageId: string;
+    /** The reaction emoji to list reactors for (required). */
+    emoji: string;
+    /** Page number (default 1). */
+    page?: number;
+    /** Page size (default 50, max 100). */
+    limit?: number;
+}
+interface MessageReaction {
+    user: User;
+    emoji: string;
+    createdAt: Date;
+}
+interface ListReactionsResponse {
+    data: MessageReaction[];
+    pagination: PaginationMetadata;
+}
+declare function listReactions(client: SublayHttpClient, data: ListReactionsProps): Promise<ListReactionsResponse>;
+
+interface MarkAsReadProps {
+    conversationId: string;
+    /** The message up to which the conversation is marked read (uuid, required). */
+    messageId: string;
+}
+declare function markAsRead(client: SublayHttpClient, data: MarkAsReadProps): Promise<{
+    message: string;
+}>;
+
+interface MuteConversationProps {
+    conversationId: string;
+    /**
+     * The duration CHOICE (`8h` / `24h` / `1w` / `forever`), or `null` to clear
+     * the mute. Never a raw timestamp — the server resolves it and represents
+     * "forever" via the returned member's explicit `mutedForever` signal.
+     */
+    duration: MuteDuration | null;
+}
+interface MuteConversationResponse {
+    currentMember: ConversationMember;
+}
+/**
+ * Set / clear the logged-in user's conversation mute.
+ *
+ * Mirrors `POST /:projectId/chat/conversations/:conversationId/mute`. The actor
+ * is derived from the user token (Rule A) — a user only mutes their own
+ * membership, so there is no `userId` param.
+ */
+declare function muteConversation(client: SublayHttpClient, data: MuteConversationProps): Promise<MuteConversationResponse>;
+
+declare const Chat_addMember: typeof addMember;
+declare const Chat_changeMemberRole: typeof changeMemberRole;
+declare const Chat_createDirectConversation: typeof createDirectConversation;
+declare const Chat_createGroupConversation: typeof createGroupConversation;
+declare const Chat_deleteConversation: typeof deleteConversation;
+declare const Chat_deleteMessage: typeof deleteMessage;
+declare const Chat_editMessage: typeof editMessage;
+declare const Chat_getConversation: typeof getConversation;
+declare const Chat_getMessage: typeof getMessage;
+declare const Chat_getUnreadCount: typeof getUnreadCount;
+declare const Chat_leaveConversation: typeof leaveConversation;
+declare const Chat_listConversations: typeof listConversations;
+declare const Chat_listMembers: typeof listMembers;
+declare const Chat_listMessages: typeof listMessages;
+declare const Chat_listReactions: typeof listReactions;
+declare const Chat_markAsRead: typeof markAsRead;
+declare const Chat_muteConversation: typeof muteConversation;
+declare const Chat_removeMember: typeof removeMember;
+declare const Chat_sendMessage: typeof sendMessage;
+declare const Chat_toggleReaction: typeof toggleReaction;
+declare const Chat_updateConversation: typeof updateConversation;
+declare namespace Chat {
+  export { Chat_addMember as addMember, Chat_changeMemberRole as changeMemberRole, Chat_createDirectConversation as createDirectConversation, Chat_createGroupConversation as createGroupConversation, Chat_deleteConversation as deleteConversation, Chat_deleteMessage as deleteMessage, Chat_editMessage as editMessage, Chat_getConversation as getConversation, Chat_getMessage as getMessage, Chat_getUnreadCount as getUnreadCount, Chat_leaveConversation as leaveConversation, Chat_listConversations as listConversations, Chat_listMembers as listMembers, Chat_listMessages as listMessages, Chat_listReactions as listReactions, Chat_markAsRead as markAsRead, Chat_muteConversation as muteConversation, Chat_removeMember as removeMember, Chat_sendMessage as sendMessage, Chat_toggleReaction as toggleReaction, Chat_updateConversation as updateConversation };
+}
+
+/**
+ * Read the logged-in user's push notification preferences (the set of event
+ * types disabled for push). Returns an empty `disabledTypes` (all-on) when no
+ * preference row exists.
+ *
+ * Mirrors `GET /:projectId/push-notifications/preferences`. The actor is derived
+ * from the user token (Rule A) — no `userId` param.
+ */
+declare function getNotificationPreferences(client: SublayHttpClient): Promise<NotificationPreferences>;
+
+interface UpdateNotificationPreferencesProps {
+    /**
+     * The set of push event types the user has opted OUT of. Server-exact type
+     * names only (unknown names are rejected server-side); duplicates collapse.
+     */
+    disabledTypes: PushEventType[];
+}
+/**
+ * Upsert the logged-in user's push notification preferences.
+ *
+ * Mirrors `PUT /:projectId/push-notifications/preferences`. The actor is derived
+ * from the user token (Rule A) — no `userId` param.
+ */
+declare function updateNotificationPreferences(client: SublayHttpClient, data: UpdateNotificationPreferencesProps): Promise<NotificationPreferences>;
+
+declare const Push_getNotificationPreferences: typeof getNotificationPreferences;
+declare const Push_updateNotificationPreferences: typeof updateNotificationPreferences;
+declare namespace Push {
+  export { Push_getNotificationPreferences as getNotificationPreferences, Push_updateNotificationPreferences as updateNotificationPreferences };
+}
+
+/**
+ * Workspaces bundle interfaces (client subset). Mirrors the server's
+ * `IWorkspace` / `IWorkspaceMember` / `IWorkspaceInvitation` shapes and the
+ * workspace controller responses.
+ *
+ * `capabilities` is a CLOSED, Sublay-enforced vocabulary (cascades via reach);
+ * `permissions` is opaque free-form developer strings Sublay never consumes
+ * (per-node only, does NOT cascade).
+ */
+type WorkspaceCapability = "view" | "invite" | "remove-member" | "edit-member-access" | "edit-member-profile" | "create-sub-workspace" | "edit-workspace";
+type WorkspaceInvitationStatus = "pending" | "accepted" | "declined" | "revoked";
+type WorkspaceAuthorityReason = "owner" | "ancestor-owner" | "member" | "reach-holder";
+type WorkspaceAuthorityReasonDetail = {
+    type: "owner" | "member";
+    viaWorkspaceId?: never;
+} | {
+    type: "ancestor-owner" | "reach-holder";
+    viaWorkspaceId: string;
+};
+interface Workspace {
+    id: string;
+    name: string;
+    metadata: Record<string, any>;
+    ownerId: string;
+    parentWorkspaceId: string | null;
+    depth: number;
+    inheritsFromParent: boolean;
+    createdAt: string;
+    updatedAt: string;
+    memberCount?: number;
+}
+interface WorkspaceMember {
+    id: string;
+    workspaceId: string;
+    userId: string;
+    capabilities: WorkspaceCapability[];
+    permissions: string[];
+    rank: number;
+    title: string | null;
+    metadata: Record<string, any>;
+    joinedAt: string;
+    createdAt: string;
+}
+interface WorkspaceInvitation {
+    id: string;
+    workspaceId: string;
+    invitedBy: string;
+    userId: string | null;
+    email: string | null;
+    capabilities: WorkspaceCapability[];
+    permissions: string[];
+    rank: number;
+    title: string | null;
+    status: WorkspaceInvitationStatus;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface WorkspaceInvitationInviter {
+    id: string;
+    name: string | null;
+    username: string | null;
+    avatar: string | null;
+    reputation: number;
+}
+interface MyWorkspaceInvitation extends Omit<WorkspaceInvitation, "invitedBy"> {
+    workspace: {
+        id: string;
+        name: string;
+    };
+    invitedBy: WorkspaceInvitationInviter;
+}
+interface WorkspaceRosterReason {
+    type: "owner" | "member" | "ancestor-owner" | "reach-holder" | "descendant-member";
+    rank?: number;
+    /**
+     * The SAME ladder position, expressed as an offset from the CALLER: `1` = one
+     * rung below you, `0` = your peer, `-3` = three rungs above you. The caller's
+     * own anchor is their member row on this workspace if they hold one, and apex
+     * (one step above rank 0) if they do not — so a rank-0 member reads back as
+     * `relativeRank: 1` for an owner.
+     *
+     * Authority-bearing and fenced WITH `rank`, never beside it: it is `rank`
+     * minus a number the caller already knows, so leaking it leaks `rank` exactly.
+     *
+     * Present on same-node `member` reasons only. `descendant-member` entries
+     * carry `rank` but NEVER `relativeRank` — rank is per-workspace, so an offset
+     * measured against your standing on THIS node would be arithmetic across two
+     * different ladders. Use their absolute `rank` there.
+     *
+     * Note the deliberate asymmetry with the fence described above: the FENCE is
+     * per node (a descendant row may or may not carry `rank` depending on your
+     * standing there), but PRESENCE of `relativeRank` is not — it is absent on
+     * every `descendant-member` row, unconditionally, however much authority you
+     * hold. A field that appears and disappears by who is asking is worse to
+     * consume than one that is uniformly absent.
+     */
+    relativeRank?: number;
+    capabilities?: WorkspaceCapability[];
+    permissions?: string[];
+    title?: string | null;
+    metadata?: Record<string, any>;
+    viaWorkspaceId?: string;
+    workspaceId?: string;
+}
+interface WorkspaceRosterEntry {
+    user: User;
+    reasons: WorkspaceRosterReason[];
+}
+interface WorkspaceRosterResponse {
+    data: WorkspaceRosterEntry[];
+    total: number;
+}
+interface WorkspaceRosterCountsResponse {
+    counts: {
+        owner: number;
+        member: number;
+        ancestorOwner: number;
+        reachHolder: number;
+        descendantMember: number;
+    };
+    total: number;
+    distinctUsers: number;
+}
+/**
+ * The `user` carried by a standing read. Normally the full user record, but the
+ * server falls back to `{ id }` alone when the user row is gone (a deleted user
+ * with a lingering membership row is a reachable case), so every field except
+ * `id` may be absent.
+ */
+type WorkspaceStandingUser = Pick<User, "id"> & Partial<Omit<User, "id">>;
+interface WorkspaceMemberStanding {
+    user: WorkspaceStandingUser;
+    reasons: WorkspaceAuthorityReasonDetail[];
+    capabilities?: WorkspaceCapability[];
+    permissions?: string[];
+    rank?: number | null;
+    /**
+     * `rank` expressed as an offset from the CALLER (negative = senior to you).
+     * `null` exactly when `rank` is `null` — a target with no direct member row
+     * here sits outside the ladder and has no position to measure. Fenced with
+     * `rank`: absent (not null) for a caller who may not see it.
+     */
+    relativeRank?: number | null;
+    title: string | null;
+    metadata: Record<string, any>;
+}
+interface WorkspaceAuthority {
+    reasons: WorkspaceAuthorityReasonDetail[];
+    capabilities: WorkspaceCapability[];
+    permissions: string[];
+    rank: number | null;
+}
+/**
+ * One descendant the subtree sweep did NOT clear, where the target user still
+ * holds a direct membership.
+ *
+ * `id` / `name` are masked TOGETHER: an entry the acting user may see carries
+ * both, and one they may not carries `null` for both — the sweep reports THAT a
+ * membership survived without disclosing the existence or name of a sealed
+ * sub-workspace the actor has no authority over (the same sealing fence the
+ * descendant roster read applies). Modelled as a discriminated union so a
+ * `null` check on `id` narrows `name` too.
+ */
+type SkippedWorkspace = {
+    id: string;
+    name: string;
+    /** Why it was skipped. `out-of-reach`: the actor's authority does not extend there. */
+    reason: "out-of-reach";
+} | {
+    id: null;
+    name: null;
+    /** Why it was skipped. `out-of-reach`: the actor's authority does not extend there. */
+    reason: "out-of-reach";
+};
+interface RemoveWorkspaceMemberFromSubtreeResponse {
+    removedCount: number;
+    removed: {
+        workspaceId: string;
+        userId: string;
+    }[];
+    /**
+     * How many descendant memberships the target RETAINED because the sweep could
+     * not reach them. Always `0` for an owner / ancestor-owner / privileged key.
+     * A non-zero value means the offboarding is PARTIAL — never conclude a user is
+     * fully removed from `removedCount` alone.
+     */
+    skippedCount: number;
+    /** One entry per retained membership; `skippedCount === skipped.length`. */
+    skipped: SkippedWorkspace[];
+}
+
+interface CreateWorkspaceProps {
+    name: string;
+    metadata?: Record<string, any>;
+    parentWorkspaceId?: string | null;
+}
+/**
+ * Create a root or child workspace. The creator (the bearer-token user) becomes
+ * the owner. Root creation requires a verified email.
+ */
+declare function createWorkspace(client: SublayHttpClient, data: CreateWorkspaceProps): Promise<Workspace>;
+
+interface FetchWorkspaceProps {
+    workspaceId: string;
+    include?: string;
+}
+declare function fetchWorkspace(client: SublayHttpClient, data: FetchWorkspaceProps): Promise<Workspace>;
+
+interface FetchManyWorkspacesProps {
+    page?: number;
+    limit?: number;
+    include?: string;
+}
+/**
+ * List the bearer-token user's direct-membership + owned workspaces. The actor
+ * is derived from the token — no actor field is sent.
+ *
+ * ⚠️ Only the fields declared above are accepted. The workspaces endpoints
+ * refuse any undeclared top-level field with a 400 rather than ignoring it, so
+ * do not spread an unrelated object into `data`.
+ */
+declare function fetchManyWorkspaces(client: SublayHttpClient, data?: FetchManyWorkspacesProps): Promise<PaginatedResponse<Workspace>>;
+
+interface UpdateWorkspaceProps {
+    workspaceId: string;
+    name?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Edit a workspace's name / metadata. Requires the `edit-workspace` capability
+ * (or ownership). The actor is the bearer-token user — no actor field is sent.
+ */
+declare function updateWorkspace(client: SublayHttpClient, data: UpdateWorkspaceProps): Promise<Workspace>;
+
+interface UpdateWorkspaceInheritFlagProps {
+    workspaceId: string;
+    inheritsFromParent: boolean;
+}
+/**
+ * Flip whether capabilities held on an ancestor "reach" into this workspace.
+ * Owner-only in both directions (own owner or an ancestor owner), and blocked
+ * (403 `workspace/inherit-enforced`) when the project enforces its default.
+ * The actor is the bearer-token user — no actor field is sent.
+ */
+declare function updateWorkspaceInheritFlag(client: SublayHttpClient, data: UpdateWorkspaceInheritFlagProps): Promise<Workspace>;
+
+interface DeleteWorkspaceProps {
+    workspaceId: string;
+}
+interface DeleteWorkspaceResponse {
+    message: string;
+}
+/**
+ * Owner-only delete (own owner or an ancestor owner). Cascades the whole
+ * subtree transactionally. The actor is the bearer-token user — no actor
+ * field is sent.
+ */
+declare function deleteWorkspace(client: SublayHttpClient, data: DeleteWorkspaceProps): Promise<DeleteWorkspaceResponse>;
+
+interface TransferWorkspaceOwnershipProps {
+    workspaceId: string;
+    newOwnerId: string;
+    previousOwnerDisposition?: "demote" | "remove";
+    previousOwnerRank?: number;
+    previousOwnerCapabilities?: WorkspaceCapability[];
+}
+/**
+ * Hand the workspace to a new owner. Owner-only (own owner or an ancestor
+ * owner). The actor is the bearer-token user — no actor field is sent;
+ * `newOwnerId` addresses the TARGET, not the actor.
+ */
+declare function transferWorkspaceOwnership(client: SublayHttpClient, data: TransferWorkspaceOwnershipProps): Promise<Workspace>;
+
+interface FetchWorkspaceMembersProps {
+    workspaceId: string;
+    include?: string;
+    countOnly?: boolean;
+}
+/**
+ * Unified roster read — one entry per distinct user, each with a `reasons`
+ * array. Always returned in full (never paginated). With `countOnly=true` the
+ * shape is `WorkspaceRosterCountsResponse` instead. Actor from the token.
+ *
+ * Same-node `member` reasons carry both rank coordinates: absolute `rank` and
+ * `relativeRank`, the offset from you (`1` = one rung below you, `-3` = three
+ * above). Both are fenced together and both are absent for a caller who does
+ * not operate people here. `descendant-member` reasons carry `rank` only.
+ */
+declare function fetchWorkspaceMembers(client: SublayHttpClient, data: FetchWorkspaceMembersProps): Promise<WorkspaceRosterResponse | WorkspaceRosterCountsResponse>;
+
+interface FetchWorkspaceMemberStandingProps {
+    workspaceId: string;
+    targetUserId: string;
+}
+/**
+ * Read one user's resolved standing on a workspace (`reasons`, `capabilities`,
+ * `permissions`, `rank`, `relativeRank`, `title`, `metadata`).
+ *
+ * `relativeRank` is the target's `rank` as an offset from YOU (negative =
+ * senior to you), and is fenced with `rank`: both are absent, not null, for a
+ * caller who may not see the target's authority.
+ */
+declare function fetchWorkspaceMemberStanding(client: SublayHttpClient, data: FetchWorkspaceMemberStandingProps): Promise<WorkspaceMemberStanding>;
+
+interface UpdateWorkspaceMemberProps {
+    workspaceId: string;
+    targetUserId: string;
+    capabilities?: WorkspaceCapability[];
+    permissions?: string[];
+    rank?: number;
+    /**
+     * `rank`'s relative twin: an offset from the ACTOR (`1` = one rung below me),
+     * resolved to an absolute rank at write time and stored absolute. Must be
+     * `>= 1`; mutually exclusive with `rank` (sending both is a 400). Both rank fields are also capped at `2147483647` (int4), and the RESOLVED sum is bounded too — an in-range anchor plus an in-range offset can still overflow, which is a 400 rather than a 500.
+     *
+     * The anchor is the actor's own rank if they hold a member row on this
+     * workspace, apex otherwise. A SNAPSHOT — frozen at write time, it does not
+     * follow the actor's own rank afterwards.
+     *
+     * Unlike invite, edit has NO default: omitting BOTH still means "rank
+     * unchanged", so editing someone's capabilities never moves them on the
+     * ladder.
+     */
+    relativeRank?: number;
+    title?: string | null;
+    metadata?: Record<string, any>;
+}
+/**
+ * Edit a member's grant / profile. Powerful fields need `edit-member-access`
+ * plus rank + no-escalation rules; cosmetic fields need only
+ * `edit-member-profile`. No actor field is sent — the actor comes from the token.
+ *
+ * Rank moves in either coordinate — `rank` (absolute) or `relativeRank` (an
+ * offset from the actor) — never both. Omitting both leaves rank UNCHANGED;
+ * unlike invite, edit has no value default.
+ */
+declare function updateWorkspaceMember(client: SublayHttpClient, data: UpdateWorkspaceMemberProps): Promise<WorkspaceMember>;
+
+interface RemoveWorkspaceMemberProps {
+    workspaceId: string;
+    targetUserId: string;
+}
+/**
+ * Remove a member from this workspace. Requires the `remove-member` capability
+ * and is rank-bounded. The workspace owner cannot be removed (409
+ * `workspace/sole-owner`) — transfer ownership first. No actor field is sent;
+ * the actor comes from the token.
+ */
+declare function removeWorkspaceMember(client: SublayHttpClient, data: RemoveWorkspaceMemberProps): Promise<void>;
+
+interface LeaveWorkspaceProps {
+    workspaceId: string;
+}
+/**
+ * The bearer-token user leaves this workspace — removes THEIR OWN direct
+ * membership on THIS node only (owning a child is unaffected). An owner cannot
+ * leave (409 `workspace/sole-owner`) — transfer ownership or remove the
+ * workspace first. No actor field is sent; the server derives the leaver from
+ * the token.
+ */
+declare function leaveWorkspace(client: SublayHttpClient, data: LeaveWorkspaceProps): Promise<void>;
+
+interface RemoveWorkspaceMemberFromSubtreeProps {
+    workspaceId: string;
+    targetUserId: string;
+}
+/**
+ * Removes the target user's direct memberships on this workspace and every
+ * descendant. Requires `remove-member` (rank-bounded per node). Blocks (409
+ * `workspace/owns-descendants`) with a report if the user OWNS any descendant
+ * workspace — transfer or delete those first. The actor comes from the token.
+ *
+ * A NON-owner's sweep can be PARTIAL: it stops at sealed sub-workspaces. Check
+ * `skippedCount` / `skipped` before treating the user as fully offboarded.
+ */
+declare function removeWorkspaceMemberFromSubtree(client: SublayHttpClient, data: RemoveWorkspaceMemberFromSubtreeProps): Promise<RemoveWorkspaceMemberFromSubtreeResponse>;
+
+interface CreateWorkspaceInviteProps {
+    workspaceId: string;
+    email?: string;
+    userId?: string;
+    username?: string;
+    capabilities?: WorkspaceCapability[];
+    permissions?: string[];
+    /**
+     * The invited rank, ABSOLUTE — a position on this workspace's ladder (smaller
+     * = more senior). The escape hatch, and what tier-constant apps want, since
+     * they compute the number anyway.
+     *
+     * Optional, and mutually exclusive with `relativeRank` — sending both is a
+     * 400. Sending NEITHER defaults to `relativeRank: 1`, one rung below the
+     * inviter, which is well defined for every actor and can never fail the rank
+     * floor.
+     *
+     * ⚠️ That default is for a NEW invitation. Re-inviting a target who already
+     * has a live pending invite updates it in place, and there omitting both rank
+     * fields PRESERVES the stored rank instead of re-defaulting it. See the
+     * function doc below.
+     */
+    rank?: number;
+    /**
+     * The invited rank, RELATIVE to the inviter: `1` = one rung below me, `2` =
+     * two rungs below, and so on. The documented happy path — every governance
+     * rule about rank is relative, so this is what callers usually mean.
+     *
+     * Must be `>= 1` on a write. `0` would mean "a peer", which the assign rule
+     * forbids (you cannot clone your own authority), and a negative offset would
+     * mint someone senior to you; both are a 400. Both rank fields are also capped at `2147483647` (int4), and the RESOLVED sum is bounded too — an in-range anchor plus an in-range offset can still overflow, which is a 400 rather than a 500.
+     *
+     * The anchor is the inviter's OWN rank if they hold a member row on this
+     * workspace, and apex (one step above rank 0) if they do not — so an owner's
+     * `relativeRank: 1` lands on rank 0, while a rank-3 member's lands on rank 4.
+     *
+     * ⚠️ A SNAPSHOT, not a live link: the offset is resolved to an absolute rank
+     * once, at invite time, and frozen. It does not track the inviter's later
+     * promotions or demotions.
+     */
+    relativeRank?: number;
+    title?: string | null;
+}
+/**
+ * Create an invitation (requires the `invite` capability on the workspace). The
+ * inviter is the bearer-token user.
+ *
+ * The invited rank comes in either coordinate — `rank` (absolute) or
+ * `relativeRank` (an offset from the inviter) — never both. Omitting both
+ * defaults to `relativeRank: 1`, one rung below the inviter, which is the
+ * documented happy path and can never fail the rank floor.
+ *
+ * ⚠️ This route doubles as an UPSERT, and the default above applies only to a
+ * NEW invitation. Re-inviting a target who already holds a live pending invite
+ * refreshes THAT invitation in place — same id, expiry reset — and on that
+ * branch an omitted grant field is PRESERVED, not re-defaulted or blanked:
+ * `rank`, `capabilities`, `permissions` and `title` all keep their stored
+ * values. A "Resend invitation" button that posts only the address therefore
+ * cannot silently re-rank the invitee to one below whoever clicked it. An
+ * explicit value still overwrites, and an explicit `relativeRank` re-resolves
+ * against the CURRENT caller. Full semantics:
+ * https://docs.sublay.io/api-reference/workspaces/invitations/create-invite
+ */
+declare function createWorkspaceInvite(client: SublayHttpClient, data: CreateWorkspaceInviteProps): Promise<WorkspaceInvitation>;
+
+interface FetchWorkspaceInvitesProps {
+    workspaceId: string;
+}
+interface FetchWorkspaceInvitesResponse {
+    data: WorkspaceInvitation[];
+}
+/**
+ * List a workspace's LIVE pending invites (`status='pending' AND expiresAt >
+ * now`). Requires the `invite` capability (or owner). Always returned in full —
+ * this list is deliberately unpaginated.
+ *
+ * This is the OUTBOX read — invites this workspace ISSUED. For the invites
+ * addressed TO the caller, use `fetchMyWorkspaceInvites`.
+ */
+declare function fetchWorkspaceInvites(client: SublayHttpClient, data: FetchWorkspaceInvitesProps): Promise<FetchWorkspaceInvitesResponse>;
+
+interface RevokeWorkspaceInviteProps {
+    workspaceId: string;
+    inviteId: string;
+}
+interface RevokeWorkspaceInviteResponse {
+    success: boolean;
+}
+/**
+ * Revoke a pending invitation. Requires the `invite` capability (or owner).
+ * Note the verb-suffixed POST route — this is not a `DELETE`.
+ */
+declare function revokeWorkspaceInvite(client: SublayHttpClient, data: RevokeWorkspaceInviteProps): Promise<RevokeWorkspaceInviteResponse>;
+
+interface ResendWorkspaceInviteProps {
+    workspaceId: string;
+    inviteId: string;
+}
+/**
+ * Resend / refresh a pending invitation (valid on any `pending` invite, even one
+ * past `expiresAt` — resets a 14-day expiry and resends the email). A terminal
+ * invite (accepted/declined/revoked) → 409. Requires `invite` (or owner).
+ */
+declare function resendWorkspaceInvite(client: SublayHttpClient, data: ResendWorkspaceInviteProps): Promise<WorkspaceInvitation>;
+
+interface AcceptWorkspaceInviteProps {
+    inviteId: string;
+}
+interface AcceptWorkspaceInviteResponse {
+    success: boolean;
+    workspaceId: string;
+}
+/**
+ * Accept an invitation — identity-matched to the bearer-token user + verified
+ * email required. Non-secret id. Idempotent when already a member/owner.
+ */
+declare function acceptWorkspaceInvite(client: SublayHttpClient, data: AcceptWorkspaceInviteProps): Promise<AcceptWorkspaceInviteResponse>;
+
+interface DeclineWorkspaceInviteProps {
+    inviteId: string;
+}
+interface DeclineWorkspaceInviteResponse {
+    success: boolean;
+}
+/**
+ * Decline an invitation — identity-matched to the bearer-token user, and
+ * verified-email-gated (the same gate as accept, so an unverified squatter on
+ * someone else's address cannot burn their invite). An unverified decline
+ * returns `403 workspace/email-not-verified`.
+ */
+declare function declineWorkspaceInvite(client: SublayHttpClient, data: DeclineWorkspaceInviteProps): Promise<DeclineWorkspaceInviteResponse>;
+
+interface FetchMyWorkspaceInvitesResponse {
+    data: MyWorkspaceInvitation[];
+}
+/**
+ * The bearer-token user's LIVE pending invites (`status='pending' AND expiresAt
+ * > now`), matched by `userId` from the token. Surfacing is NOT
+ * verification-gated (the verified check applies when the user ACTS on an
+ * invite — accept or decline).
+ *
+ * This is the INBOX read — invites addressed TO the caller. For the invites a
+ * workspace has ISSUED, use `fetchWorkspaceInvites`.
+ */
+declare function fetchMyWorkspaceInvites(client: SublayHttpClient): Promise<FetchMyWorkspaceInvitesResponse>;
+
+interface FetchWorkspaceAuthorityProps {
+    workspaceId: string;
+}
+/**
+ * Authority-as-a-service read — the bearer-token user's resolved standing
+ * (`{ reasons, capabilities, permissions, rank }`) on the workspace. A
+ * permission check is a one-line `.includes()` on the result.
+ *
+ * ⚠️ No `relativeRank` on this read. It is an offset from the caller, and here
+ * the caller IS the subject — so it could only ever be `0`. `rank` is the only
+ * rank coordinate this endpoint exposes. `relativeRank` is meaningful on the
+ * roster and member-standing reads, where the subject is somebody else.
+ */
+declare function fetchWorkspaceAuthority(client: SublayHttpClient, data: FetchWorkspaceAuthorityProps): Promise<WorkspaceAuthority>;
+
+declare const Workspaces_acceptWorkspaceInvite: typeof acceptWorkspaceInvite;
+declare const Workspaces_createWorkspace: typeof createWorkspace;
+declare const Workspaces_createWorkspaceInvite: typeof createWorkspaceInvite;
+declare const Workspaces_declineWorkspaceInvite: typeof declineWorkspaceInvite;
+declare const Workspaces_deleteWorkspace: typeof deleteWorkspace;
+declare const Workspaces_fetchManyWorkspaces: typeof fetchManyWorkspaces;
+declare const Workspaces_fetchMyWorkspaceInvites: typeof fetchMyWorkspaceInvites;
+declare const Workspaces_fetchWorkspace: typeof fetchWorkspace;
+declare const Workspaces_fetchWorkspaceAuthority: typeof fetchWorkspaceAuthority;
+declare const Workspaces_fetchWorkspaceInvites: typeof fetchWorkspaceInvites;
+declare const Workspaces_fetchWorkspaceMemberStanding: typeof fetchWorkspaceMemberStanding;
+declare const Workspaces_fetchWorkspaceMembers: typeof fetchWorkspaceMembers;
+declare const Workspaces_leaveWorkspace: typeof leaveWorkspace;
+declare const Workspaces_removeWorkspaceMember: typeof removeWorkspaceMember;
+declare const Workspaces_removeWorkspaceMemberFromSubtree: typeof removeWorkspaceMemberFromSubtree;
+declare const Workspaces_resendWorkspaceInvite: typeof resendWorkspaceInvite;
+declare const Workspaces_revokeWorkspaceInvite: typeof revokeWorkspaceInvite;
+declare const Workspaces_transferWorkspaceOwnership: typeof transferWorkspaceOwnership;
+declare const Workspaces_updateWorkspace: typeof updateWorkspace;
+declare const Workspaces_updateWorkspaceInheritFlag: typeof updateWorkspaceInheritFlag;
+declare const Workspaces_updateWorkspaceMember: typeof updateWorkspaceMember;
+declare namespace Workspaces {
+  export { Workspaces_acceptWorkspaceInvite as acceptWorkspaceInvite, Workspaces_createWorkspace as createWorkspace, Workspaces_createWorkspaceInvite as createWorkspaceInvite, Workspaces_declineWorkspaceInvite as declineWorkspaceInvite, Workspaces_deleteWorkspace as deleteWorkspace, Workspaces_fetchManyWorkspaces as fetchManyWorkspaces, Workspaces_fetchMyWorkspaceInvites as fetchMyWorkspaceInvites, Workspaces_fetchWorkspace as fetchWorkspace, Workspaces_fetchWorkspaceAuthority as fetchWorkspaceAuthority, Workspaces_fetchWorkspaceInvites as fetchWorkspaceInvites, Workspaces_fetchWorkspaceMemberStanding as fetchWorkspaceMemberStanding, Workspaces_fetchWorkspaceMembers as fetchWorkspaceMembers, Workspaces_leaveWorkspace as leaveWorkspace, Workspaces_removeWorkspaceMember as removeWorkspaceMember, Workspaces_removeWorkspaceMemberFromSubtree as removeWorkspaceMemberFromSubtree, Workspaces_resendWorkspaceInvite as resendWorkspaceInvite, Workspaces_revokeWorkspaceInvite as revokeWorkspaceInvite, Workspaces_transferWorkspaceOwnership as transferWorkspaceOwnership, Workspaces_updateWorkspace as updateWorkspace, Workspaces_updateWorkspaceInheritFlag as updateWorkspaceInheritFlag, Workspaces_updateWorkspaceMember as updateWorkspaceMember };
+}
+
+/**
+ * Custom-table types for the `/db` surface (row ops only — the js-sdk holds no
+ * service key, so it carries no table-management/DDL surface).
+ *
+ * Names mirror the server's `/db` contract exactly.
+ */
+type DbFilterOperator = "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "contains" | "like" | "isNull";
+interface DbFilter {
+    column: string;
+    operator: DbFilterOperator;
+    value?: unknown;
+}
+interface TableQuery {
+    page?: number;
+    limit?: number;
+    sortBy?: string;
+    sortDir?: "asc" | "desc";
+    /** AND-combined filter clauses. Serialized to a JSON query param. */
+    filters?: DbFilter[];
+    /** Surface soft-deleted rows on a paranoid table. */
+    includeDeleted?: boolean;
+}
+/** Shape every custom-table row shares (managed columns). */
+interface TableRow {
+    id: string;
+    createdAt?: string;
+    updatedAt?: string;
+    deletedAt?: string | null;
+    [column: string]: unknown;
+}
+interface DeleteResult {
+    deleted: boolean;
+    soft: boolean;
+}
+interface BulkDeleteResult {
+    deletedCount: number;
+    soft: boolean;
+}
+interface BulkDeleteProps {
+    rowIds?: string[];
+    filters?: DbFilter[];
+    force?: boolean;
+}
+/**
+ * Per-table row-operations accessor returned by `client.table<T>(name)`.
+ * The actor is derived server-side from the user token (js-sdk Rule A) — no
+ * actor params here. No DDL surface (no service key).
+ */
+interface TableAccessor<T = TableRow> {
+    find(query?: TableQuery): Promise<PaginatedResponse<T>>;
+    findOne(rowId: string): Promise<T>;
+    create(data: Partial<T> | Record<string, unknown>): Promise<T>;
+    bulkCreate(rows: Array<Partial<T> | Record<string, unknown>>): Promise<T[]>;
+    update(rowId: string, data: Partial<T> | Record<string, unknown>): Promise<T>;
+    delete(rowId: string, opts?: {
+        force?: boolean;
+    }): Promise<DeleteResult>;
+    bulkDelete(params: BulkDeleteProps): Promise<BulkDeleteResult>;
+    restore(rowId: string): Promise<T>;
+}
+
 type BoundModule<T extends Record<string, (client: SublayHttpClient, ...args: any[]) => any>> = {
     [K in keyof T]: (...args: Parameters<T[K]> extends [any, ...infer R] ? R : never) => ReturnType<T[K]>;
 };
-export declare class SublayClient {
+declare class SublayClient {
     private http;
     auth: BoundModule<typeof Auth>;
     users: BoundModule<typeof Users>;
@@ -54,17 +4394,5 @@ export declare class SublayClient {
     /** Imperatively clear the session tokens, e.g. on logout (SDK-managed mode). */
     clearTokens(): void;
 }
-export type { ClientConfig, AuthTokens } from "./core/client";
-export type { PaginatedResponse, PaginationMetadata, } from "./interfaces/IPaginatedResponse";
-export type { SpaceReputationContextParams, SpaceReputationUserParams, } from "./interfaces/SpaceReputation";
-export type { UserSearchParams } from "./interfaces/UserSearch";
-export type { ReputationGrant, ReputationGrantSourceType, ReputationGrantTargetType, ReputationGrantTargetFilter, GrantSummary, } from "./interfaces/ReputationGrant";
-export type { CreateGrantProps } from "./modules/reputation/createGrant";
-export type { ListGrantsProps, ListGrantsResponse, } from "./modules/reputation/listGrants";
-export type { Workspace, WorkspaceMember, WorkspaceInvitation, WorkspaceCapability, WorkspaceInvitationStatus, WorkspaceAuthorityReason, WorkspaceAuthorityReasonDetail, WorkspaceRosterReason, WorkspaceRosterEntry, WorkspaceRosterResponse, WorkspaceRosterCountsResponse, WorkspaceStandingUser, WorkspaceMemberStanding, WorkspaceAuthority, RemoveWorkspaceMemberFromSubtreeResponse, SkippedWorkspace, } from "./interfaces/Workspace";
-export { PUSH_EVENT_TYPES, MUTE_DURATIONS } from "./interfaces/Push";
-export type { PushEventType, MuteDuration, NotificationPreferences, PushDeviceIdentifier, WebPushSubscription, } from "./interfaces/Push";
-export type { SignOutResult, PushUnbindSkipReason, } from "./modules/auth/signOut";
-export type { UpdateNotificationPreferencesProps } from "./modules/push/updateNotificationPreferences";
-export type { MuteConversationProps, MuteConversationResponse, } from "./modules/chat/muteConversation";
-export type { TableAccessor, TableRow, TableQuery, DbFilter, DbFilterOperator, BulkDeleteProps, DeleteResult, BulkDeleteResult, } from "./interfaces/Table";
+
+export { type AuthTokens, type BulkDeleteProps, type BulkDeleteResult, type ClientConfig, type CreateGrantProps, type DbFilter, type DbFilterOperator, type DeleteResult, type GrantSummary, type ListGrantsProps, type ListGrantsResponse, MUTE_DURATIONS, type MuteConversationProps, type MuteConversationResponse, type MuteDuration, type MyWorkspaceInvitation, type NotificationPreferences, PUSH_EVENT_TYPES, type PaginatedResponse, type PaginationMetadata, type PushDeviceIdentifier, type PushEventType, type PushUnbindSkipReason, type RemoveWorkspaceMemberFromSubtreeResponse, type ReputationGrant, type ReputationGrantSourceType, type ReputationGrantTargetFilter, type ReputationGrantTargetType, type SignOutResult, type SkippedWorkspace, type SpaceReputationContextParams, type SpaceReputationUserParams, SublayClient, type TableAccessor, type TableQuery, type TableRow, type UpdateNotificationPreferencesProps, type UserSearchParams, type WebPushSubscription, type Workspace, type WorkspaceAuthority, type WorkspaceAuthorityReason, type WorkspaceAuthorityReasonDetail, type WorkspaceCapability, type WorkspaceInvitation, type WorkspaceInvitationInviter, type WorkspaceInvitationStatus, type WorkspaceMember, type WorkspaceMemberStanding, type WorkspaceRosterCountsResponse, type WorkspaceRosterEntry, type WorkspaceRosterReason, type WorkspaceRosterResponse, type WorkspaceStandingUser };