@oxyhq/services 30.0.0 → 30.0.1

package/lib/typescript/commonjs/ui/context/passkeyFlow.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Pure passkey (WebAuthn) sign-in / registration orchestration.
+ *
+ * Extracted from `OxyContext` so the fixed `options → ceremony → verify → commit`
+ * ordering is unit-testable with injected deps — the exact pattern
+ * `commitSessionFlow.ts` (`commitDeviceSetAndResolve`) uses. The context methods
+ * (`signInWithPasskey` / `registerWithPasskey` / `addPasskey`) are thin wrappers
+ * that supply the real deps: the core `webauthn*` methods, the platform ceremony
+ * client (`webauthn/passkeyClient`), and the internal `commitSession` funnel.
+ *
+ * All three GATE on `isSupported()` first (the platform client returns `false`
+ * off the web) so an unsupported surface fails loudly before touching a ceremony.
+ */
+import type { LoginResult } from '@oxyhq/contracts';
+import type { CommitInput } from './oxyContextTypes';
+/**
+ * The result of `OxyServices.webauthnRegisterVerify` — either the LINK branch
+ * (`{ success, message }`, bearer present, no session) or the SIGNUP branch (a
+ * full {@link LoginResult}, which carries a `sessionId` on its session arm).
+ */
+export type PasskeyRegisterVerifyResult = {
+    success: true;
+    message: string;
+} | LoginResult;
+/** Thrown when a passkey flow is attempted on a surface that cannot run WebAuthn. */
+export declare const PASSKEY_UNSUPPORTED_MESSAGE = "Passkeys are not available in this environment. Use another sign-in method.";
+/** Injected dependencies for {@link runPasskeyLogin}. */
+export interface RunPasskeyLoginDeps {
+    isSupported: () => boolean;
+    getLoginOptions: (username?: string) => Promise<unknown>;
+    runCeremony: (optionsJSON: unknown) => Promise<unknown>;
+    loginVerify: (response: unknown, envelope: {
+        deviceName?: string;
+        deviceFingerprint?: string;
+        deviceId?: string;
+    }) => Promise<LoginResult>;
+    commit: (input: CommitInput) => Promise<void>;
+    /**
+     * When present, scopes login options to that user's registered passkeys
+     * (username-first) — the path a NON-discoverable hardware key (e.g. a U2F
+     * security key) needs, since it can't be found by a usernameless ceremony.
+     * Omit for the discoverable / resident-credential path.
+     */
+    username?: string;
+    deviceId?: string;
+    deviceName?: string;
+    deviceFingerprint?: string;
+}
+/**
+ * Passkey SIGN-IN. With no `username` this is the usernameless
+ * (discoverable-credential) flow; with a `username` it is username-first —
+ * the server scopes `allowCredentials` to that user's passkeys so a
+ * non-discoverable hardware key (U2F/security key) can be selected. Either way:
+ * request login options, run the authentication ceremony, verify, then commit
+ * the session. A passkey assertion is itself the strong factor — sign-in always
+ * resolves to a completed session.
+ */
+export declare function runPasskeyLogin(deps: RunPasskeyLoginDeps): Promise<void>;
+/** Injected dependencies for {@link runPasskeyRegister}. */
+export interface RunPasskeyRegisterDeps {
+    isSupported: () => boolean;
+    getRegisterOptions: (username: string) => Promise<unknown>;
+    runCeremony: (optionsJSON: unknown) => Promise<unknown>;
+    registerVerify: (response: unknown, envelope: {
+        username: string;
+        deviceName?: string;
+    }) => Promise<PasskeyRegisterVerifyResult>;
+    commit: (input: CommitInput) => Promise<void>;
+    username: string;
+    deviceName?: string;
+}
+/**
+ * Passkey SIGNUP: create a brand-new account whose first auth method is a
+ * passkey. The verify signup branch mints a session (a {@link LoginSessionResult}
+ * carrying `sessionId`), which is committed exactly like a password signup.
+ */
+export declare function runPasskeyRegister(deps: RunPasskeyRegisterDeps): Promise<void>;
+/** Injected dependencies for {@link runPasskeyAdd}. */
+export interface RunPasskeyAddDeps {
+    isSupported: () => boolean;
+    getRegisterOptions: () => Promise<unknown>;
+    runCeremony: (optionsJSON: unknown) => Promise<unknown>;
+    registerVerify: (response: unknown, envelope: {
+        deviceName?: string;
+    }) => Promise<PasskeyRegisterVerifyResult>;
+    onLinked: () => void;
+    deviceName?: string;
+}
+/**
+ * ADD a passkey to the already-signed-in account (bearer present). The verify
+ * link branch returns `{ success, message }` with NO session — so this never
+ * commits a session; it just fires `onLinked` (which invalidates the
+ * auth-methods query). A session arm here would be a server contract violation.
+ */
+export declare function runPasskeyAdd(deps: RunPasskeyAddDeps): Promise<void>;
+//# sourceMappingURL=passkeyFlow.d.ts.map

package/lib/typescript/commonjs/ui/context/passkeyFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"passkeyFlow.d.ts","sourceRoot":"","sources":["../../../../../src/ui/context/passkeyFlow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GAAG;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,WAAW,CAAC;AAE3F,qFAAqF;AACrF,eAAO,MAAM,2BAA2B,gFACuC,CAAC;AAehF,yDAAyD;AACzD,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,eAAe,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,WAAW,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxD,WAAW,EAAE,CACX,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,KAC7E,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1B,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAY9E;AAED,4DAA4D;AAC5D,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,WAAW,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxD,cAAc,EAAE,CACd,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,KAChD,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAC1C,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBpF;AAED,uDAAuD;AACvD,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,kBAAkB,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3C,WAAW,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxD,cAAc,EAAE,CACd,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,KAC9B,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAC1C,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAW1E"}

package/lib/typescript/commonjs/ui/context/useOxyAccountGraph.d.ts

@@ -0,0 +1,30 @@
+import { type RefObject } from 'react';
+import type { OxyServices, AccountNode, CreateAccountInput, AccountDialogController, SessionClient } from '@oxyhq/core';
+import type { CommitInput } from './oxyContextTypes';
+interface UseOxyAccountGraphParams {
+    isAuthenticated: boolean;
+    tokenReady: boolean;
+    initialized: boolean;
+    /**
+     * `sessionMode: 'identity'`. The account graph is a switcher surface, and an
+     * identity-bound client authenticates as the owner of the local identity key —
+     * permanently. The graph is therefore never fetched and every switch rejects.
+     */
+    identityBound: boolean;
+    oxyServices: OxyServices;
+    sessionClient: SessionClient;
+    syncFromClient: () => Promise<void>;
+    commitSession: (input: CommitInput, options: {
+        activate: boolean;
+    }) => Promise<void>;
+    accountDialogControllerRef: RefObject<AccountDialogController | null>;
+    clearSessionStateRef: RefObject<() => Promise<void>>;
+}
+export declare function useOxyAccountGraph({ isAuthenticated, tokenReady, initialized, identityBound, oxyServices, sessionClient, syncFromClient, commitSession, accountDialogControllerRef, clearSessionStateRef, }: UseOxyAccountGraphParams): {
+    accounts: AccountNode[];
+    refreshAccounts: () => Promise<void>;
+    switchToAccount: (accountId: string) => Promise<void>;
+    createAccount: (data: CreateAccountInput) => Promise<AccountNode>;
+};
+export {};
+//# sourceMappingURL=useOxyAccountGraph.d.ts.map

package/lib/typescript/commonjs/ui/context/useOxyAccountGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOxyAccountGraph.d.ts","sourceRoot":"","sources":["../../../../../src/ui/context/useOxyAccountGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIxH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,UAAU,wBAAwB;IAChC,eAAe,EAAE,OAAO,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;IAC7B,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,0BAA0B,EAAE,SAAS,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;IACtE,oBAAoB,EAAE,SAAS,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;CACtD;AAED,wBAAgB,kBAAkB,CAAC,EACjC,eAAe,EACf,UAAU,EACV,WAAW,EACX,aAAa,EACb,WAAW,EACX,aAAa,EACb,cAAc,EACd,aAAa,EACb,0BAA0B,EAC1B,oBAAoB,GACrB,EAAE,wBAAwB;;2BAGqB,OAAO,CAAC,IAAI,CAAC;iCA4BvC,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;0BAyC3B,kBAAkB,KAAG,OAAO,CAAC,WAAW,CAAC;EAczD"}

package/lib/typescript/commonjs/ui/hooks/accountDialogSnapshot.d.ts

@@ -0,0 +1,15 @@
+import type { AccountDialogSnapshot } from '@oxyhq/core';
+/**
+ * The snapshot `useSyncExternalStore` reads before a controller exists.
+ *
+ * `useSyncExternalStore` calls `getSnapshot` several times per commit and
+ * compares by identity, so the no-controller answer has to be one constant
+ * reference — a fresh object literal loops.
+ *
+ * It is ONE constant because there were three, byte-identical, in the hook and
+ * both dialog surfaces. Adding a field to `AccountDialogSnapshot` broke all
+ * three at once and would have gone on doing so; a shared constant makes the
+ * compiler point at one place.
+ */
+export declare const EMPTY_ACCOUNT_DIALOG_SNAPSHOT: AccountDialogSnapshot;
+//# sourceMappingURL=accountDialogSnapshot.d.ts.map

package/lib/typescript/commonjs/ui/hooks/accountDialogSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accountDialogSnapshot.d.ts","sourceRoot":"","sources":["../../../../../src/ui/hooks/accountDialogSnapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,6BAA6B,EAAE,qBAsB3C,CAAC"}

package/lib/typescript/commonjs/ui/hooks/mutations/mutationFactory.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Mutation Factory - Creates standardized mutations with optimistic updates
+ *
+ * This factory reduces boilerplate code for mutations that follow the common pattern:
+ * 1. Cancel outgoing queries
+ * 2. Snapshot previous data
+ * 3. Apply optimistic update
+ * 4. On error: rollback and show toast
+ * 5. On success: update cache, stores, and invalidate queries
+ */
+import type { QueryClient, UseMutationOptions } from '@tanstack/react-query';
+import type { User } from '@oxyhq/core';
+/**
+ * Configuration for creating a standard profile mutation
+ */
+export interface ProfileMutationConfig<TData, TVariables> {
+    /** The mutation function that makes the API call */
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    /**
+     * Stable mutation key for the offline queue. Required so TanStack Query
+     * can correlate paused mutations across refetches/resume cycles.
+     */
+    mutationKey: readonly unknown[];
+    /** Query keys to cancel before mutation */
+    cancelQueryKeys?: unknown[][];
+    /** Function to apply optimistic update to the user data */
+    optimisticUpdate?: (previousUser: User, variables: TVariables) => Partial<User>;
+    /** Error message to show on failure */
+    errorMessage?: string | ((error: Error) => string);
+    /** Success message to show (optional) */
+    successMessage?: string;
+    /** Whether to update authStore on success (default: true) */
+    updateAuthStore?: boolean;
+    /** Whether to invalidate user queries on success (default: true) */
+    invalidateUserQueries?: boolean;
+    /** Whether to invalidate account queries on success (default: true) */
+    invalidateAccountQueries?: boolean;
+    /** Custom onSuccess handler */
+    onSuccess?: (data: TData, variables: TVariables, queryClient: QueryClient) => void;
+}
+/**
+ * Creates a standard profile mutation with optimistic updates
+ *
+ * @example
+ * ```ts
+ * const updateProfile = createProfileMutation({
+ *   mutationKey: mutationKeys.account.updateProfile,
+ *   mutationFn: (updates) => oxyServices.updateProfile(updates),
+ *   optimisticUpdate: (user, updates) => updates,
+ *   errorMessage: 'Failed to update profile',
+ * });
+ * ```
+ */
+export declare function createProfileMutation<TVariables>(config: ProfileMutationConfig<User, TVariables>, queryClient: QueryClient, activeSessionId: string | null): UseMutationOptions<User, Error, TVariables, {
+    previousUser?: User;
+}>;
+/**
+ * Configuration for creating a generic mutation (non-profile)
+ */
+export interface GenericMutationConfig<TData, TVariables, TContext> {
+    /** The mutation function */
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    /**
+     * Stable mutation key for the offline queue. Required so TanStack Query
+     * can correlate paused mutations across refetches/resume cycles.
+     */
+    mutationKey: readonly unknown[];
+    /** Query key for optimistic data */
+    queryKey: unknown[];
+    /** Function to create optimistic data */
+    optimisticData?: (previous: TData | undefined, variables: TVariables) => TData;
+    /** Error message */
+    errorMessage?: string;
+    /** Success message */
+    successMessage?: string;
+    /** Additional queries to invalidate on success */
+    invalidateQueries?: unknown[][];
+}
+/**
+ * Creates a generic mutation with optimistic updates
+ */
+export declare function createGenericMutation<TData, TVariables>(config: GenericMutationConfig<TData, TVariables, {
+    previous?: TData;
+}>, queryClient: QueryClient): UseMutationOptions<TData, Error, TVariables, {
+    previous?: TData;
+}>;
+//# sourceMappingURL=mutationFactory.d.ts.map

package/lib/typescript/commonjs/ui/hooks/mutations/mutationFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutationFactory.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/mutations/mutationFactory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAKxC;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,KAAK,EAAE,UAAU;IACtD,oDAAoD;IACpD,UAAU,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IACtD;;;OAGG;IACH,WAAW,EAAE,SAAS,OAAO,EAAE,CAAC;IAChC,2CAA2C;IAC3C,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC;IAC9B,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,CAAC;IACnD,yCAAyC;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,oEAAoE;IACpE,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,uEAAuE;IACvE,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,+BAA+B;IAC/B,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;CACpF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAC9C,MAAM,EAAE,qBAAqB,CAAC,IAAI,EAAE,UAAU,CAAC,EAC/C,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,MAAM,GAAG,IAAI,GAC7B,kBAAkB,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;IAAE,YAAY,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC,CA0FtE;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ;IAChE,4BAA4B;IAC5B,UAAU,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IACtD;;;OAGG;IACH,WAAW,EAAE,SAAS,OAAO,EAAE,CAAC;IAChC,oCAAoC;IACpC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,yCAAyC;IACzC,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,GAAG,SAAS,EAAE,SAAS,EAAE,UAAU,KAAK,KAAK,CAAC;IAC/E,oBAAoB;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sBAAsB;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kDAAkD;IAClD,iBAAiB,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC;CACjC;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,EACrD,MAAM,EAAE,qBAAqB,CAAC,KAAK,EAAE,UAAU,EAAE;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC,EACtE,WAAW,EAAE,WAAW,GACvB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC,CA6CpE"}

package/lib/typescript/commonjs/ui/hooks/mutations/mutationKeys.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Stable mutation key factories.
+ *
+ * Mutations that may be queued while offline MUST declare a stable
+ * `mutationKey`. When the network comes back, TanStack Query resumes
+ * paused mutations grouped by key — so the keys here should be stable
+ * across renders and across reloads when persistence is enabled.
+ */
+export declare const mutationKeys: {
+    readonly account: {
+        readonly updateProfile: readonly ["mutation", "account", "updateProfile"];
+        readonly uploadAvatar: readonly ["mutation", "account", "uploadAvatar"];
+        readonly updateSettings: readonly ["mutation", "account", "updateSettings"];
+        readonly updatePrivacySettings: readonly ["mutation", "account", "updatePrivacySettings"];
+        readonly updateNotificationPreferences: readonly ["mutation", "account", "updateNotificationPreferences"];
+        readonly updateUserPreferences: readonly ["mutation", "account", "updateUserPreferences"];
+        readonly uploadFile: readonly ["mutation", "account", "uploadFile"];
+    };
+    readonly session: {
+        readonly switch: readonly ["mutation", "session", "switch"];
+        readonly logout: readonly ["mutation", "session", "logout"];
+        readonly logoutAll: readonly ["mutation", "session", "logoutAll"];
+        readonly updateDeviceName: readonly ["mutation", "session", "updateDeviceName"];
+        readonly removeDevice: readonly ["mutation", "session", "removeDevice"];
+    };
+    readonly connectedApps: {
+        readonly revoke: readonly ["mutation", "connectedApps", "revoke"];
+    };
+};
+//# sourceMappingURL=mutationKeys.d.ts.map

package/lib/typescript/commonjs/ui/hooks/mutations/mutationKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutationKeys.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/mutations/mutationKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;CA6Bf,CAAC"}

package/lib/typescript/commonjs/ui/hooks/mutations/useAccountMutations.d.ts

@@ -0,0 +1,301 @@
+import type { AssetUploadInput, NotificationPreferences, PrivacySettings, User, UserPreferences } from '@oxyhq/core';
+/**
+ * Update user profile with optimistic updates and offline queue support
+ */
+export declare const useUpdateProfile: () => import("@tanstack/react-query").UseMutationResult<User, Error, import("zod").objectOutputType<{
+    name: import("zod").ZodOptional<import("zod").ZodObject<{
+        first: import("zod").ZodOptional<import("zod").ZodString>;
+        last: import("zod").ZodOptional<import("zod").ZodString>;
+        displayName: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        first?: string | undefined;
+        last?: string | undefined;
+        displayName?: string | undefined;
+    }, {
+        first?: string | undefined;
+        last?: string | undefined;
+        displayName?: string | undefined;
+    }>>;
+    username: import("zod").ZodOptional<import("zod").ZodString>;
+    email: import("zod").ZodOptional<import("zod").ZodString>;
+    avatar: import("zod").ZodOptional<import("zod").ZodString>;
+    color: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    bio: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    phone: import("zod").ZodOptional<import("zod").ZodString>;
+    address: import("zod").ZodOptional<import("zod").ZodString>;
+    birthday: import("zod").ZodOptional<import("zod").ZodString>;
+    locations: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown, "many">>;
+    links: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    linksMetadata: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        title: import("zod").ZodOptional<import("zod").ZodString>;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        image: import("zod").ZodOptional<import("zod").ZodString>;
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+        id?: string | undefined;
+        title?: string | undefined;
+        image?: string | undefined;
+    }, {
+        url: string;
+        description?: string | undefined;
+        id?: string | undefined;
+        title?: string | undefined;
+        image?: string | undefined;
+    }>, "many">>;
+    languages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    accountExpiresAfterInactivityDays: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+    notificationPreferences: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    userPreferences: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    privacySettings: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    themePreference: import("zod").ZodOptional<import("zod").ZodType<import("@oxyhq/contracts").ThemePreference, import("zod").ZodTypeDef, import("@oxyhq/contracts").ThemePreference>>;
+}, import("zod").ZodTypeAny, "passthrough">, {
+    previousUser: User | undefined;
+}>;
+/**
+ * Upload avatar with progress tracking and offline queue support
+ */
+export declare const useUploadAvatar: () => import("@tanstack/react-query").UseMutationResult<User, Error, {
+    uri: string;
+    type?: string;
+    name?: string;
+    size?: number;
+}, {
+    previousUser: User | undefined;
+}>;
+/**
+ * Variables accepted by the `useUpdateAccountSettings` mutation.
+ *
+ * `currentUser` is captured at dispatch time so the rebuilt user object the
+ * mutation returns is computed against a stable snapshot — NOT the cache
+ * value at the moment the API call settles. Reading from the cache inside
+ * `mutationFn` would race with sibling optimistic updates: a concurrent
+ * write could already have overwritten the cache by the time the privacy
+ * update returns, causing the rebuilt user to clobber the sibling's
+ * optimistic value.
+ */
+interface UpdateAccountSettingsVariables {
+    /** Subset of privacy fields to write. */
+    updates: Partial<PrivacySettings>;
+    /**
+     * The User snapshot captured at mutation dispatch time. The mutation
+     * rebuilds this user with the updated `privacySettings` and returns it
+     * to `onSuccess`. Required to avoid the race described above.
+     */
+    currentUser: User;
+}
+/**
+ * Update account settings (privacy preferences).
+ *
+ * Privacy settings are not part of the `PUT /users/me` allow-list; the API
+ * would silently drop them. Route through `updatePrivacySettings` so the
+ * dedicated `PATCH /privacy/:id/privacy` endpoint performs a dot-path merge
+ * and returns the updated `privacySettings` object.
+ *
+ * The returned object exposes the standard mutation surface PLUS a
+ * convenience `mutate(updates)` / `mutateAsync(updates)` that snapshots
+ * the current user from `useOxy()` at dispatch time. Callers that need to
+ * supply their own user snapshot (testing, server-side) can call the
+ * underlying `.mutate({ updates, currentUser })` form via `.mutation`.
+ */
+export declare const useUpdateAccountSettings: () => {
+    mutate: (updates: Partial<PrivacySettings>) => void;
+    mutateAsync: (updates: Partial<PrivacySettings>) => Promise<User>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: {
+        previousUser: User | undefined;
+    } | undefined;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (updates: Partial<PrivacySettings>) => void;
+    mutateAsync: (updates: Partial<PrivacySettings>) => Promise<User>;
+    data: undefined;
+    variables: UpdateAccountSettingsVariables;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: {
+        previousUser: User | undefined;
+    } | undefined;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (updates: Partial<PrivacySettings>) => void;
+    mutateAsync: (updates: Partial<PrivacySettings>) => Promise<User>;
+    data: undefined;
+    error: Error;
+    variables: UpdateAccountSettingsVariables;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: {
+        previousUser: User | undefined;
+    } | undefined;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (updates: Partial<PrivacySettings>) => void;
+    mutateAsync: (updates: Partial<PrivacySettings>) => Promise<User>;
+    data: {
+        privacySettings: PrivacySettings;
+        id: string;
+        publicKey: string;
+        username: string;
+        email?: string;
+        avatar?: string | null;
+        color?: string | null;
+        name: import("@oxyhq/contracts").UserNameResponse;
+        bio?: string;
+        description?: string;
+        phone?: string;
+        address?: string;
+        birthday?: string;
+        website?: string;
+        createdAt?: string;
+        updatedAt?: string;
+        links?: string[];
+        linksMetadata?: Array<{
+            url: string;
+            title?: string;
+            description?: string;
+            image?: string;
+            id?: string;
+        }>;
+        _count?: {
+            followers?: number;
+            following?: number;
+        };
+        accountExpiresAfterInactivityDays?: number | null;
+        kind?: import("@oxyhq/contracts").AccountKind;
+        type?: "local" | "federated" | "agent" | "automated";
+        isFederated?: boolean;
+        fediverseSharing?: boolean;
+        isAgent?: boolean;
+        isAutomated?: boolean;
+        instance?: string;
+        federation?: {
+            actorUri?: string;
+            domain?: string;
+            actorId?: string;
+        };
+        automation?: {
+            ownerId?: string;
+        };
+        isManagedAccount?: boolean;
+        managedBy?: string;
+        accountCategories?: import("@oxyhq/contracts").AccountCategoryId[];
+        languages?: string[];
+        notificationPreferences?: NotificationPreferences;
+        userPreferences?: UserPreferences;
+        themePreference?: import("@oxyhq/contracts").ThemePreference;
+        relationship?: import("@oxyhq/contracts").UserRelationship;
+    };
+    error: null;
+    variables: UpdateAccountSettingsVariables;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: {
+        previousUser: User | undefined;
+    } | undefined;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+};
+/**
+ * Update privacy settings with optimistic updates and authentication handling
+ */
+export declare const useUpdatePrivacySettings: () => import("@tanstack/react-query").UseMutationResult<PrivacySettings, Error, {
+    settings: Partial<PrivacySettings>;
+    userId?: string;
+}, {
+    previousPrivacySettings: unknown;
+    previousUser: User | undefined;
+} | undefined>;
+/** Uploaded file data structure from API */
+interface UploadedFile {
+    id: string;
+    originalName?: string;
+    sha256?: string;
+    mime?: string;
+    size?: number;
+    createdAt?: string;
+    metadata?: Record<string, unknown>;
+    variants?: Array<{
+        type: string;
+        key: string;
+        width?: number;
+        height?: number;
+        readyAt?: string;
+        metadata?: Record<string, unknown>;
+    }>;
+}
+/** Upload result type that supports both single file and batch responses */
+interface UploadResult {
+    file?: UploadedFile;
+    files?: UploadedFile[];
+    id?: string;
+}
+/**
+ * Update the authenticated user's notification preferences with optimistic
+ * updates. Persisted on the User document via `PUT /users/me` — same cache-
+ * invalidation behaviour as `useUpdateProfile`.
+ */
+export declare const useUpdateNotificationPreferences: () => import("@tanstack/react-query").UseMutationResult<User, Error, Partial<NotificationPreferences>, {
+    previousUser: User | undefined;
+}>;
+/**
+ * Update the authenticated user's general preferences (language, theme,
+ * reduce-motion, timezone). Persisted on the User document via
+ * `PUT /users/me`.
+ */
+export declare const useUpdateUserPreferences: () => import("@tanstack/react-query").UseMutationResult<User, Error, Partial<UserPreferences>, {
+    previousUser: User | undefined;
+}>;
+/**
+ * Revoke the current user's grant for a connected application (by its
+ * `applicationId`). Removes the grant so the app no longer appears in the user's
+ * "Connected apps" list — next sign-in for that app will require explicit
+ * re-consent.
+ */
+export declare const useRevokeConnectedApp: () => import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+/**
+ * Upload file with authentication handling and progress tracking
+ */
+export declare const useUploadFile: () => import("@tanstack/react-query").UseMutationResult<UploadResult, Error, {
+    file: AssetUploadInput;
+    visibility?: "private" | "public" | "unlisted";
+    metadata?: Record<string, unknown>;
+    onProgress?: (progress: number) => void;
+}, unknown>;
+export {};
+//# sourceMappingURL=useAccountMutations.d.ts.map

package/lib/typescript/commonjs/ui/hooks/mutations/useAccountMutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAccountMutations.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/mutations/useAccountMutations.ts"],"names":[],"mappings":"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"}

package/lib/typescript/commonjs/ui/hooks/mutations/useServicesMutations.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Switch active session
+ */
+export declare const useSwitchSession: () => import("@tanstack/react-query").UseMutationResult<import("@oxyhq/core").User, Error, string, unknown>;
+/**
+ * Logout from a session
+ */
+export declare const useLogoutSession: () => import("@tanstack/react-query").UseMutationResult<string, Error, string | undefined, {
+    previousSessions: unknown;
+}>;
+/**
+ * Logout from all sessions
+ */
+export declare const useLogoutAll: () => import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+/**
+ * Update device name
+ */
+export declare const useUpdateDeviceName: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
+/**
+ * Remove a device
+ */
+export declare const useRemoveDevice: () => import("@tanstack/react-query").UseMutationResult<string, Error, string, unknown>;
+//# sourceMappingURL=useServicesMutations.d.ts.map

package/lib/typescript/commonjs/ui/hooks/mutations/useServicesMutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useServicesMutations.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/mutations/useServicesMutations.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,gBAAgB,6GAuB5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;;EAiD5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,qFAuBxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,sFAuB/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,yFAoB3B,CAAC"}