The account-level login — email/password credentials, a global profile, and cross-company query methods. This is distinct from Member (company/member/member.ts, see Members): a User is one row in the top-level users table; a Memberis that account's (or an unlinked invitee's) profile row within a single company. A User may have zero, one, or many Memberrows (one per company it's joined); Member.userID is the optional link back. Member has no roleID — company staff/role assignment is a Staff concern (see Company), not a User or Member field.

new User(id: string);                              // lazy — triggers preloadData(true)
new User(data: LazyUserData | UserData, lazy?);     // pre-seeded, e.g. from a query result

User.create(data: CreateUserRequest): Promise<SimpleResult<EventData>>

User.Login(data: LoginUserRequest): Promise<boolean>

user.save(): Promise<SimpleResult<EventData>>                       // PATCH /users
user.delete(): Promise<SimpleResult<EventData>>                     // DELETE /users?ids={id}
user.SetPassword(newPassword: string): Promise<SimpleResult<EventData>>  // PATCH /users/password, no current password required

user.UploadPhoto(file: File | Blob, contentType = "image/jpeg"): Promise<SimpleResult<EventData>>
user.GetPhoto(): Promise<string | undefined>

user.GetListOfCompanies(): Promise<SimpleResult<Company[]>>

user.idLink(): Promise<string | undefined>

user.notifications(opts: { limit?, offset?, lazy?, isRead? }): Promise<{ status, data: Notification[], total?, unreadCount? }>
user.visits(opts: QueryRequest): Promise<{ status, data: Visit[], total? }>
user.invoices(opts: QueryRequest): Promise<{ status, data: Invoice[], total? }>
user.subscriptions(opts: QueryRequest): Promise<{ status, data: Subscription[], total? }>
user.checkouts(opts: QueryRequest): Promise<{ status, data: Checkout[], total? }>
user.payments(opts: QueryRequest): Promise<{ status, data: Payment[], total? }>
user.bookings(opts: QueryRequest): Promise<{ status, data: Booking[], total? }>
user.appointments(opts: QueryRequest): Promise<{ status, data: Appointment[], total? }>

Three primitives, all guarded for SSR:

SetCookie(name: string, val: string): void      // 7-day expiry, path=/
GetCookie(name: string): string | undefined
DeleteCookie(name: string): void                 // expires immediately (sets expiry to yesterday)

Default implementation reads/writes document.cookie directly, and every function checks typeof document === "undefined" first — SetCookie/DeleteCookie silently no-op on the server, GetCookie returns undefined. This is what makes the same session code safe to import in both Next.js server and client contexts without crashing at import/SSR time.

interface CookieAdapter {
  get(name: string): string | undefined;
  set(name: string, val: string): void;
  remove(name: string): void;
}
SetCookieAdapter(adapter: CookieAdapter): void

GetActiveUser(): Promise<User | undefined>

Reads ss-user-id; if present, returns a memoized User instance (module-level currentUservariable, recreated only if the cookie's id changes from the last call). Returns undefined if unset, or on any thrown error (caught and logged).

LogoutActiveUser(): boolean

DeleteCookie("ss-user-id") then also calls LogoutOfActiveCompany() — clears the account session and any active company session together. Returns false (instead of throwing) on error.

GetActiveCompany(): Promise<Company | undefined>

Same memoization pattern as GetActiveUser(), keyed off ss-company-id (module-level activeCompany variable).

LogoutOfActiveCompany(): boolean

DeleteCookie("ss-company-id") only — leaves the account-level login intact. This is the one to call when a user backs out of a company back to the account dashboard without logging out entirely.

interface MeData {
  memberID: string;
  roleID: string | null;
  firstName: string;
  permissions: Permission[];
}
getMe(companyID: string): Promise<MeData>

GET /company/{companyID}/members/me— resolves the signed-in user's Member/Staff identity within one company: their memberID, roleID (null if they're a plain member with no staff/role grant), display firstName, and resolved Permission[] (see Management's role.ts and nav.tsx's loadPermissions() in the app for how this feeds nav gating). Requires authentication (ss-user-id cookie) — unlike GetActiveUser()/GetActiveCompany(), it throws (Error(result.message ?? "getMe failed.")) on a non-200/no-data response rather than returning undefined, so callers should wrap it in try/catch.

Based only on what the code above actually supports — no invented convenience wrapper exists that chains these steps for you:

import { User } from "zensile-sdk/user";
import { GetActiveUser, GetActiveCompany } from "zensile-sdk/simple";

// 1. Register (optional — skip straight to Login if the account exists)
const created = await User.create({ email, password, firstName, lastName });
if (created.status !== 200) throw new Error(created.message);

// 2. Authenticate — sets ss-token-expire and ss-user-id (see cookie-origin note above)
const ok = await User.Login({ email, password });
if (!ok) throw new Error("Login failed");

// 3. Resolve the now-active User
const user = await GetActiveUser(); // memoized, undefined if the cookie didn't take

// 4. List companies this account belongs to and select one
const { data: companies } = await user!.GetListOfCompanies();
await companies?.[0]?.SetActiveCompany(); // sets ss-company-id

// 5. Resolve the now-active Company, and this account's role/permissions within it
const company = await GetActiveCompany();
const me = await getMe(company!.id); // throws on failure — wrap in try/catch

Disposable demo/test companies — seed data plus an admin login — for exploring the app without touching real data. Not a DataStructure subclass; all standalone functions.

interface SandboxMember { name: string; email: string; }

interface SandboxData {
  companyID: string;
  adminEmail: string;
  adminPassword: string;
  expiresAt: string;
  members: SandboxMember[];
}

CreateSandbox(): Promise<SimpleResult<SandboxData>>

POST /v1/sandbox (called via a raw fetch, not APIRequest — bypasses the needUser/retry/timeout machinery entirely, though it still sends credentials: "include"). Provisions a new sandbox company with seed data and an admin login for the current session.

GetSandbox(): Promise<SimpleResult<SandboxData>>

GET /sandbox (via APIRequest, unlike the other four functions in this file) — fetches the current session's active sandbox, if any.

DeleteUserSandbox(companyID: string): Promise<SimpleResult<void>>

DELETE /sandbox/{companyID} (via APIRequest) — deletes the calling user's own sandbox company.

DeleteSandbox(secret: string, companyID: string): Promise<SimpleResult<void>>
CleanupSandboxes(secret: string): Promise<SimpleResult<void>>