@sublay/js 5.0.0 → 7.0.1

package/dist/index.d.mts

@@ -1,33 +1,824 @@
 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 {
-    instance: AxiosInstance;
-    constructor({ projectId }: ClientConfig);
+    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;
+    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>;
+
+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;
+}
+declare function signOut(client: SublayHttpClient, data?: SignOutProps): Promise<void>;
+
+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;
+}
+interface ChangePasswordResponse {
+    success: boolean;
+    message: string;
+}
+declare function changePassword(client: SublayHttpClient, data: ChangePasswordProps): Promise<ChangePasswordResponse>;
+
+interface VerifyEmailProps {
+    token: string;
+}
+declare function verifyEmail(client: SublayHttpClient, data: VerifyEmailProps): Promise<void>;
+
+interface SendVerificationEmailProps {
+    /** "code" emails a short token; "link" emails a verification URL. Defaults to "code". */
+    mode?: "code" | "link";
+    tokenFormat?: "hex" | "numeric" | "alpha" | "alphanumeric";
+    tokenLength?: number;
+    /** For mode "link": where to send the user after the link is verified. */
+    redirectUrl?: string;
+}
+interface SendVerificationEmailResponse {
+    success: boolean;
+}
+declare function sendVerificationEmail(client: SublayHttpClient, data?: SendVerificationEmailProps): Promise<SendVerificationEmailResponse>;
+
+declare const Auth_changePassword: typeof changePassword;
+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_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_requestNewAccessToken as requestNewAccessToken, Auth_requestPasswordReset as requestPasswordReset, Auth_resetPassword as resetPassword, Auth_sendVerificationEmail as sendVerificationEmail, Auth_signIn as signIn, Auth_signOut as signOut, Auth_signUp as signUp, Auth_verifyEmail as verifyEmail, Auth_verifyExternalUser as verifyExternalUser };
 }
 
 interface FetchUserByIdProps {
     userId: string;
+    include?: string;
 }
-declare function fetchUserById(client: SublayHttpClient, data: FetchUserByIdProps): Promise<any>;
+declare function fetchUserById(client: SublayHttpClient, data: FetchUserByIdProps): Promise<User>;
 
 interface FetchUserByForeignIdProps {
     foreignId: string;
+    include?: string;
+}
+declare function fetchUserByForeignId(client: SublayHttpClient, data: FetchUserByForeignIdProps): Promise<User>;
+
+interface FetchUserByUsernameProps {
+    username: string;
+    include?: string;
+}
+declare function fetchUserByUsername(client: SublayHttpClient, data: FetchUserByUsernameProps): Promise<User>;
+
+interface FetchUserSuggestionsProps {
+    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;
+}
+
+interface FetchFollowersByUserIdProps {
+    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 {
+    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 {
+    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 fetchUserByForeignId(client: SublayHttpClient, data: FetchUserByForeignIdProps): Promise<any>;
+declare function removeConnectionByUserId(client: SublayHttpClient, data: RemoveConnectionByUserIdProps): Promise<RemoveConnectionByUserIdResponse>;
 
+declare const Users_checkUsernameAvailability: typeof checkUsernameAvailability;
+declare const Users_createFollow: typeof createFollow;
+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_fetchUserByForeignId as fetchUserByForeignId, Users_fetchUserById as fetchUserById };
+  export { Users_checkUsernameAvailability as checkUsernameAvailability, Users_createFollow as createFollow, deleteFollow$1 as deleteFollow, 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 };
+}
+
+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 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;
+    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;
+    requireJoinApproval: 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;
+    deletedSpace: {
+        id: string;
+        name: string;
+    };
+    counts: {
+        entities: number;
+        members: number;
+        childSpaces: number;
+    };
+}
+interface DigestConfig {
+    digestEnabled: boolean;
+    digestWebhookUrl: string | null;
+    digestWebhookSecret: string | null;
+    digestScheduleHour: number | null;
+    digestTimezone: string | null;
+}
+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>;
+    topComment: TopComment | null;
+    isSaved?: boolean;
+    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 {
@@ -38,42 +829,36 @@ interface CreateEntityProps {
     content?: string;
     attachments?: Record<string, any>[];
     keywords?: string[];
+    mentions?: Mention[];
     location?: {
         latitude: number;
         longitude: number;
     };
     metadata?: Record<string, any>;
-    userId?: string;
+    isDraft?: boolean;
+    /** Create the entity without attributing it to the logged-in user (authorless). */
+    excludeUserId?: boolean;
 }
-declare function createEntity(client: SublayHttpClient, data: CreateEntityProps): Promise<any>;
+declare function createEntity(client: SublayHttpClient, data: CreateEntityProps): Promise<Entity>;
 
 interface FetchEntityProps {
     entityId: string;
+    include?: string;
 }
-declare function fetchEntity(client: SublayHttpClient, data: FetchEntityProps): Promise<any>;
+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<any>;
+declare function fetchEntityByForeignId(client: SublayHttpClient, data: FetchEntityByForeignIdProps): Promise<Entity>;
 
 interface FetchEntityByShortIdProps {
     shortId: string;
+    include?: string;
 }
-declare function fetchEntityByShortId(client: SublayHttpClient, data: FetchEntityByShortIdProps): Promise<any>;
-
-interface PaginationMetadata {
-    page: number;
-    pageSize: number;
-    totalPages: number;
-    totalItems: number;
-    hasMore: boolean;
-}
-interface PaginatedResponse<T> {
-    data: T[];
-    pagination: PaginationMetadata;
-}
+declare function fetchEntityByShortId(client: SublayHttpClient, data: FetchEntityByShortIdProps): Promise<Entity>;
 
 interface KeywordsFilters {
     includes?: string[];
@@ -83,6 +868,9 @@ interface MetadataFilters {
     includes?: {
         [key: string]: any;
     };
+    includesAny?: {
+        [key: string]: any;
+    }[];
     doesNotInclude?: {
         [key: string]: any;
     };
@@ -105,12 +893,16 @@ interface LocationFilters {
 interface FetchManyEntitiesProps {
     sourceId?: string;
     spaceId?: string;
-    sortBy?: "hot" | "top" | "controversial";
+    sortBy?: "new" | "hot" | "top" | "controversial" | (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";
+    followedOnly?: "true" | "false";
     keywordsFilters?: KeywordsFilters;
     metadataFilters?: MetadataFilters;
     titleFilters?: TextFilters;
@@ -122,7 +914,7 @@ interface FetchManyEntitiesProps {
     attachmentsFilters?: AttachmentsFilters;
     locationFilters?: LocationFilters;
 }
-declare function fetchManyEntities(client: SublayHttpClient, data: FetchManyEntitiesProps): Promise<PaginatedResponse<any>>;
+declare function fetchManyEntities(client: SublayHttpClient, data: FetchManyEntitiesProps): Promise<PaginatedResponse<Entity>>;
 
 interface UpdateEntityProps {
     entityId: string;
@@ -130,48 +922,1707 @@ interface UpdateEntityProps {
     content?: string;
     attachments?: Record<string, any>[];
     keywords?: string[];
+    mentions?: Mention[];
     location?: {
-        type: "Point";
-        coordinates: [number, number];
+        latitude: number;
+        longitude: number;
     };
     metadata?: Record<string, any>;
-    mentions?: {
-        id: string;
-        username: string;
-    }[];
 }
-declare function updateEntity(client: SublayHttpClient, data: UpdateEntityProps): Promise<any>;
+declare function updateEntity(client: SublayHttpClient, data: UpdateEntityProps): Promise<Entity>;
 
 interface DeleteEntityProps {
     entityId: string;
 }
-declare function deleteEntity(client: SublayHttpClient, data: DeleteEntityProps): Promise<any>;
+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 {
+    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 { Entities_createEntity as createEntity, Entities_deleteEntity as deleteEntity, Entities_fetchEntity as fetchEntity, Entities_fetchEntityByForeignId as fetchEntityByForeignId, Entities_fetchEntityByShortId as fetchEntityByShortId, Entities_fetchManyEntities as fetchManyEntities, Entities_updateEntity as updateEntity };
+  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 };
 }
 
-interface FetchCommentProps {
-    commentId: string;
+interface GifData {
+    id: string;
+    url: string;
+    gifUrl: string;
+    gifPreviewUrl: string;
+    altText: string;
+    aspectRatio: string;
 }
-declare function fetchComment(client: SublayHttpClient, data: FetchCommentProps): Promise<any>;
-
-interface FetchCommentByForeignIdProps {
+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;
+    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 {
+    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;
+    content: string;
+}
+declare function updateComment(client: SublayHttpClient, data: UpdateCommentProps): Promise<Comment>;
+
+interface DeleteCommentProps {
+    commentId: string;
+}
+declare function deleteComment(client: SublayHttpClient, data: DeleteCommentProps): Promise<void>;
+
+interface FetchManyCommentsProps {
+    entityId?: string;
+    userId?: string;
+    parentId?: string;
+    page?: number;
+    limit?: number;
+    sortBy?: "new" | "old" | "top" | "controversial";
+    include?: string;
+    sourceId?: string;
+}
+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 fetchCommentByForeignId(client: SublayHttpClient, data: FetchCommentByForeignIdProps): Promise<any>;
+declare function removeReaction(client: SublayHttpClient, data: RemoveCommentReactionProps): Promise<Comment>;
 
+interface FetchCommentReactionsProps {
+    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_fetchComment as fetchComment, Comments_fetchCommentByForeignId as fetchCommentByForeignId };
+  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 };
+}
+
+interface CreateSpaceProps {
+    name: string;
+    slug?: string;
+    description?: string;
+    readingPermission?: ReadingPermission;
+    postingPermission?: PostingPermission;
+    requireJoinApproval?: boolean;
+    parentSpaceId?: string;
+    metadata?: Record<string, any>;
+}
+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";
+    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";
+}
+declare function fetchUserSpaces(client: SublayHttpClient, data: FetchUserSpacesProps): Promise<UserSpacesResponse>;
+
+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;
+    metadata?: Record<string, any>;
+}
+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 {
+    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 {
+    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 ModerateSpaceCommentProps {
+    spaceId: string;
+    commentId: string;
+    action: "approve" | "remove";
+    reason?: string;
+}
+declare function moderateSpaceComment(client: SublayHttpClient, data: ModerateSpaceCommentProps): Promise<ModerationResponse>;
+
+interface FetchDigestConfigProps {
+    spaceId: string;
+}
+declare function fetchDigestConfig(client: SublayHttpClient, data: FetchDigestConfigProps): Promise<DigestConfig>;
+
+interface UpdateDigestConfigProps {
+    spaceId: string;
+    digestEnabled?: boolean;
+    digestWebhookUrl?: string;
+    digestWebhookSecret?: string;
+    digestScheduleHour?: number;
+    digestTimezone?: string;
+}
+declare function updateDigestConfig(client: SublayHttpClient, data: UpdateDigestConfigProps): Promise<DigestConfig>;
+
+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[];
+    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;
+    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;
+}
+
+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_fetchDigestConfig: typeof fetchDigestConfig;
+declare const Spaces_fetchManyRules: typeof fetchManyRules;
+declare const Spaces_fetchManySpaces: typeof fetchManySpaces;
+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_unbanMember: typeof unbanMember;
+declare const Spaces_updateDigestConfig: typeof updateDigestConfig;
+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_fetchDigestConfig as fetchDigestConfig, Spaces_fetchManyRules as fetchManyRules, Spaces_fetchManySpaces as fetchManySpaces, 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_unbanMember as unbanMember, Spaces_updateDigestConfig as updateDigestConfig, 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 {
+    page?: number;
+    limit?: number;
+}
+declare function fetchFollowing(client: SublayHttpClient, data: FetchFollowingProps): Promise<PaginatedResponse<FollowListItem>>;
+
+interface FetchFollowersProps {
+    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 {
+    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";
+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: string;
+    details?: string;
+}
+declare function createReport(client: SublayHttpClient, data: CreateReportProps): Promise<CreateReportResponse>;
+
+interface FetchModeratedReportsProps {
+    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 SearchContentProps {
+    query: string;
+    sourceTypes?: ("entity" | "comment" | "message")[];
+    spaceId?: string;
+    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 {
+    query: string;
+    sourceTypes?: ("entity" | "comment" | "message")[];
+    spaceId?: string;
+    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>;
+
+declare const Search_askContent: typeof askContent;
+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_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 may be set. */
+    entityId?: string;
+    commentId?: string;
+    spaceId?: 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[];
+}
+
+/** 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 {
+    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 ListMessagesProps {
+    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, e.g. "files". */
+    include?: string;
+}
+interface ListMessagesResponse {
+    messages: ChatMessage[];
+    hasMore: boolean;
+    oldestCreatedAt: string | null;
+    newestCreatedAt: string | null;
+}
+declare function listMessages(client: SublayHttpClient, data: ListMessagesProps): Promise<ListMessagesResponse>;
+
+interface SendMessageProps {
+    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 {
+    conversationId: string;
+    messageId: string;
+}
+declare function getMessage(client: SublayHttpClient, data: GetMessageProps): Promise<ChatMessage>;
+
+interface EditMessageProps {
+    conversationId: string;
+    messageId: string;
+    content?: string;
+    /** A GIF URL, or null to clear it. */
+    gif?: string | 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 {
+    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 ReportMessageProps {
+    conversationId: string;
+    messageId: string;
+    reason: string;
+    details?: string;
+}
+interface ReportMessageResponse {
+    message: string;
+    code: string;
+}
+declare function reportMessage(client: SublayHttpClient, data: ReportMessageProps): Promise<ReportMessageResponse>;
+
+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_removeMember: typeof removeMember;
+declare const Chat_reportMessage: typeof reportMessage;
+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_removeMember as removeMember, Chat_reportMessage as reportMessage, Chat_sendMessage as sendMessage, Chat_toggleReaction as toggleReaction, Chat_updateConversation as updateConversation };
 }
 
 type BoundModule<T extends Record<string, (client: SublayHttpClient, ...args: any[]) => any>> = {
@@ -179,11 +2630,26 @@ type BoundModule<T extends Record<string, (client: SublayHttpClient, ...args: an
 };
 declare class SublayClient {
     private http;
+    auth: BoundModule<typeof Auth>;
     users: BoundModule<typeof Users>;
     entities: BoundModule<typeof Entities>;
     comments: BoundModule<typeof Comments>;
+    spaces: BoundModule<typeof Spaces>;
+    collections: BoundModule<typeof Collections>;
+    follows: BoundModule<typeof Follows>;
+    connections: BoundModule<typeof Connections>;
+    appNotifications: BoundModule<typeof AppNotifications>;
+    reports: BoundModule<typeof Reports>;
+    search: BoundModule<typeof Search>;
+    storage: BoundModule<typeof Storage>;
+    oauth: BoundModule<typeof OAuth>;
+    chat: BoundModule<typeof Chat>;
     private constructor();
     static init(config: ClientConfig): Promise<SublayClient>;
+    /** Imperatively set the session tokens (SDK-managed mode). */
+    setTokens(tokens: AuthTokens): void;
+    /** Imperatively clear the session tokens, e.g. on logout (SDK-managed mode). */
+    clearTokens(): void;
 }
 
-export { type PaginatedResponse, type PaginationMetadata, SublayClient };
+export { type AuthTokens, type ClientConfig, type PaginatedResponse, type PaginationMetadata, SublayClient };