@capxul/sdk-react 0.2.0-alpha.4 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,1485 @@
+"use client";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { QueryClient, QueryClientProvider, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { captureExceptionSync, createCapxulClient, isSettingUpLifecycle } from "@capxul/sdk";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/internal/capxul-bootstrap-context.tsx
+const CapxulBootstrapContext = createContext(null);
+function CapxulBootstrapProvider({ value, children }) {
+	return /* @__PURE__ */ jsx(CapxulBootstrapContext.Provider, {
+		value,
+		children
+	});
+}
+function useCapxul() {
+	const state = useContext(CapxulBootstrapContext);
+	if (state === null) throw new Error("useCapxul must be used within <CapxulProvider>");
+	return state;
+}
+//#endregion
+//#region src/internal/capxul-client-context.tsx
+const MISSING_CAPXUL_CLIENT_PROVIDER = Symbol("MISSING_CAPXUL_CLIENT_PROVIDER");
+const CapxulClientContext = createContext(MISSING_CAPXUL_CLIENT_PROVIDER);
+function CapxulClientProvider({ client, children }) {
+	return /* @__PURE__ */ jsx(CapxulClientContext.Provider, {
+		value: client,
+		children
+	});
+}
+function useCapxulClient() {
+	const client = useCapxulClientOrNull();
+	if (client === null) throw new Error("useCapxulClient called before <CapxulProvider> bootstrap resolved");
+	return client;
+}
+/**
+* Returns the client, or `null` while `<CapxulProvider>` is still bootstrapping.
+* Data hooks use this so they can sit in `isPending` (disabled query) until the
+* client resolves, rather than throwing during bootstrap.
+*/
+function useCapxulClientOrNull() {
+	const client = useContext(CapxulClientContext);
+	if (client === MISSING_CAPXUL_CLIENT_PROVIDER) throw new Error("useCapxulClient must be used within <CapxulProvider>");
+	return client;
+}
+//#endregion
+//#region src/provider.tsx
+function makeDefaultQueryClient() {
+	return new QueryClient({ defaultOptions: {
+		queries: {
+			retry: 2,
+			staleTime: 3e4
+		},
+		mutations: { retry: 0 }
+	} });
+}
+function isCapxulQueryKey(queryKey) {
+	return queryKey[0] === "capxul";
+}
+function clearClientScopedQueries(queryClient, ownsQueryClient) {
+	if (ownsQueryClient) {
+		queryClient.clear();
+		return;
+	}
+	queryClient.removeQueries({ predicate: (query) => isCapxulQueryKey(query.queryKey) });
+}
+function CapxulProvider(props) {
+	const { publishableKey, client: injectedClient, requirement, signer, queryClient, children } = props;
+	const [resolvedQueryClient] = useState(() => queryClient ?? makeDefaultQueryClient());
+	const [ownsQueryClient] = useState(() => queryClient === void 0);
+	const [client, setClient] = useState(injectedClient ?? null);
+	const previousClientRef = useRef(injectedClient ?? null);
+	const [status, setStatus] = useState(injectedClient === void 0 ? "bootstrapping" : "ready");
+	const [error, setError] = useState(null);
+	const [attempt, setAttempt] = useState(0);
+	const retry = useCallback(() => {
+		setAttempt((n) => n + 1);
+	}, []);
+	useEffect(() => {
+		if (publishableKey === void 0) return;
+		let cancelled = false;
+		let created = null;
+		setStatus("bootstrapping");
+		setError(null);
+		setClient(null);
+		(async () => {
+			const result = await createCapxulClient({
+				publishableKey,
+				...requirement === void 0 ? {} : { requirement },
+				...signer === void 0 ? {} : { signer }
+			});
+			if (cancelled) {
+				if (result.ok) await result.value._internal.close?.();
+				return;
+			}
+			if (result.ok) {
+				created = result.value;
+				setClient(result.value);
+				setStatus("ready");
+			} else {
+				setError(result.error);
+				setStatus("error");
+			}
+		})();
+		return () => {
+			cancelled = true;
+			created?._internal.close?.();
+		};
+	}, [
+		publishableKey,
+		requirement,
+		signer,
+		attempt
+	]);
+	useEffect(() => {
+		if (injectedClient === void 0) return;
+		setClient(injectedClient);
+		setStatus("ready");
+		setError(null);
+	}, [injectedClient]);
+	useEffect(() => {
+		const previous = previousClientRef.current;
+		if (previous !== null && previous !== client) clearClientScopedQueries(resolvedQueryClient, ownsQueryClient);
+		previousClientRef.current = client;
+	}, [
+		client,
+		ownsQueryClient,
+		resolvedQueryClient
+	]);
+	const bootstrapState = useMemo(() => ({
+		status,
+		error,
+		retry
+	}), [
+		status,
+		error,
+		retry
+	]);
+	if (publishableKey === void 0 === (injectedClient === void 0)) throw new Error("CapxulProvider requires exactly one of `publishableKey` or `client`");
+	return /* @__PURE__ */ jsx(QueryClientProvider, {
+		client: resolvedQueryClient,
+		children: /* @__PURE__ */ jsx(CapxulBootstrapProvider, {
+			value: bootstrapState,
+			children: /* @__PURE__ */ jsx(CapxulClientProvider, {
+				client,
+				children
+			})
+		})
+	});
+}
+//#endregion
+//#region ../errors/src/errors.ts
+const CAPXUL_ERROR_CODES = [
+	"NOT_AUTHENTICATED",
+	"EMAIL_DELIVERY_FAILED",
+	"PROFILE_NOT_FOUND",
+	"SMART_ACCOUNT_MISSING",
+	"PLAYER_NOT_FOUND",
+	"ACCOUNT_NOT_FOUND",
+	"PROVIDER_ERROR",
+	"INVALID_INPUT",
+	"ENV_MISSING",
+	"NOT_IMPLEMENTED",
+	"VERIFICATION_REQUIRED",
+	"INSUFFICIENT_BALANCE",
+	"INVALID_RECIPIENT",
+	"ROLE_PERMISSION_DENIED",
+	"TRANSACTION_FAILED",
+	"RATE_LIMITED",
+	"NETWORK_ERROR",
+	"UNKNOWN",
+	"OTP_EXPIRED",
+	"SIGNER_REJECTED",
+	"CANCELLED",
+	"WRONG_STATE"
+];
+var CapxulError = class extends Error {
+	code;
+	details;
+	correlationId;
+	layer;
+	constructor(code, message, options = {}) {
+		super(message, "cause" in options ? { cause: options.cause } : void 0);
+		this.name = "CapxulError";
+		this.code = code;
+		if (options.details !== void 0) this.details = options.details;
+		if (options.correlationId !== void 0) this.correlationId = options.correlationId;
+		if (options.layer !== void 0) this.layer = options.layer;
+	}
+};
+function isCapxulError(value) {
+	return value instanceof CapxulError;
+}
+const Errors = {
+	notAuthenticated: (message, opts) => new CapxulError("NOT_AUTHENTICATED", message ?? "Not authenticated", opts?.failure_mode ? { details: { failure_mode: opts.failure_mode } } : void 0),
+	emailDeliveryFailed: (detail) => new CapxulError("EMAIL_DELIVERY_FAILED", "Failed to send email", { details: { detail } }),
+	profileNotFound: (authUserId) => new CapxulError("PROFILE_NOT_FOUND", `Profile not found for user ${authUserId}`, { details: { authUserId } }),
+	smartAccountMissing: (authUserId) => new CapxulError("SMART_ACCOUNT_MISSING", "Smart account not provisioned", { details: { authUserId } }),
+	playerNotFound: (playerId) => new CapxulError("PLAYER_NOT_FOUND", playerId ? `Openfort player ${playerId} not found` : "Openfort player not found", playerId === void 0 ? void 0 : { details: { playerId } }),
+	accountNotFound: (accountId) => new CapxulError("ACCOUNT_NOT_FOUND", accountId ? `Openfort account ${accountId} not found` : "Openfort account not found", accountId === void 0 ? void 0 : { details: { accountId } }),
+	providerError: (provider, operation, cause, opts) => {
+		const details = {
+			provider,
+			operation
+		};
+		if (opts?.failure_mode) details.failure_mode = opts.failure_mode;
+		return new CapxulError("PROVIDER_ERROR", `Provider error: ${provider} ${operation}`, {
+			cause,
+			details
+		});
+	},
+	invalidInput: (field, reason) => new CapxulError("INVALID_INPUT", `Invalid ${field}: ${reason}`, { details: {
+		field,
+		reason
+	} }),
+	envMissing: (name) => new CapxulError("ENV_MISSING", `Environment variable ${name} not configured`, { details: { name } }),
+	notImplemented: (domain, method) => new CapxulError("NOT_IMPLEMENTED", `${domain}.${method} is not yet implemented. This feature is planned for a future release.`, { details: {
+		domain,
+		method
+	} }),
+	/**
+	* Sibling factory to {@link Errors.providerError} for the per-state timeout
+	* path in flows (initially ProvisioningFlow's mint_openfort / deploy_safe /
+	* register_indexer `after:` timers). Same `PROVIDER_ERROR` code as
+	* `providerError`, plus a `details.reason: "timeout"` discriminator so
+	* downstream observers can distinguish failure modes without parsing the
+	* message string. The redacted message names the timeout budget; the
+	* native `cause` carries the same information for `reportError` fidelity.
+	*/
+	providerTimeout: (provider, operation, timeoutMs) => new CapxulError("PROVIDER_ERROR", `Provider error: ${provider} ${operation} (timeout exceeded ${timeoutMs}ms)`, {
+		details: {
+			provider,
+			operation,
+			reason: "timeout"
+		},
+		cause: /* @__PURE__ */ new Error(`timeout: ${operation} exceeded ${timeoutMs}ms`)
+	}),
+	verificationRequired: (details) => {
+		return new CapxulError("VERIFICATION_REQUIRED", "rail" in details ? `Verification is required before ${details.rail} can use ${details.currentKind}.` : `Verification tier ${details.requiredTier} is required.`, { details });
+	},
+	insufficientBalance: (asset, available, required) => new CapxulError("INSUFFICIENT_BALANCE", `Insufficient ${asset} balance`, { details: {
+		asset,
+		available,
+		required
+	} }),
+	invalidRecipient: (reason) => new CapxulError("INVALID_RECIPIENT", `Invalid recipient: ${reason}`, { details: { reason } }),
+	/**
+	* The org Zodiac Roles modifier REFUSED the spend on-chain (G4 · #547): the
+	* member's role condition (per-tx cap, per-day allowance, allowed recipient,
+	* or membership) was violated, so `execTransactionWithRole` reverted. This is
+	* a PERMISSION denial — explicitly NOT an `INSUFFICIENT_BALANCE` (the treasury
+	* held the funds; the role's authority is what bound). `reason` discriminates
+	* the violated condition (`over_cap` / `daily_cap` / `not_member` /
+	* `disallowed_recipient` / `condition_violation`); leak-safe — no on-chain
+	* identifiers ever enter the details.
+	*/
+	rolePermissionDenied: (details) => new CapxulError("ROLE_PERMISSION_DENIED", `Org role denied this spend on-chain (${details.reason}).`, { details: details.operation === void 0 ? { reason: details.reason } : {
+		reason: details.reason,
+		operation: details.operation
+	} }),
+	/**
+	* A transaction (or sponsored UserOp) failed. `details.reason` discriminates
+	* the failure mode for callers that must distinguish a CONFIRMED on-chain
+	* revert (`"onchain_revert"` — the op executed and reverted, e.g. a Zodiac
+	* Roles condition violation) from an inconclusive infra failure. A confirmed
+	* revert is the ONLY mode the org spend port may map to a roles denial.
+	*/
+	transactionFailed: (operation, cause, extra) => new CapxulError("TRANSACTION_FAILED", `Transaction failed: ${operation}`, {
+		cause,
+		details: extra?.reason === void 0 ? { operation } : {
+			operation,
+			reason: extra.reason
+		}
+	}),
+	rateLimited: (details) => new CapxulError("RATE_LIMITED", "Rate limit exceeded", details === void 0 ? void 0 : { details: { ...details } }),
+	networkError: (operation, cause) => new CapxulError("NETWORK_ERROR", `Network error during ${operation}`, {
+		cause,
+		details: { operation }
+	}),
+	unknown: (cause) => new CapxulError("UNKNOWN", "Unknown error", { cause }),
+	otpExpired: (details) => new CapxulError("OTP_EXPIRED", "Verification code has expired. Request a new one.", details === void 0 ? void 0 : { details: { ...details } }),
+	signerRejected: (details) => new CapxulError("SIGNER_REJECTED", "Signer rejected the request.", {
+		cause: details.cause,
+		details: details.reason === void 0 ? { source: details.source } : {
+			source: details.source,
+			reason: details.reason
+		}
+	}),
+	cancelled: (details) => new CapxulError("CANCELLED", "Operation was cancelled.", details === void 0 ? void 0 : { details: { ...details } }),
+	/**
+	* Method called from a flow state where its precondition fails (TA16). The
+	* SDK's method API short-circuits with this error before driving the
+	* internal state machine. `currentState` is the Effect-machine snapshot
+	* tag (stringified — substrate is `@effect/experimental/Machine` per
+	* `docs/canon/decisions/state-machine-substrate.md`); `validStates`
+	* enumerates the states the method accepts.
+	*/
+	wrongState: (details) => new CapxulError("WRONG_STATE", `${details.method} called from state '${details.currentState}'; valid states: ${details.validStates.join(", ")}`, { details: {
+		...details,
+		validStates: [...details.validStates]
+	} })
+};
+new Set(CAPXUL_ERROR_CODES);
+//#endregion
+//#region src/internal/require-bootstrapped-client.ts
+/**
+* Narrow the bootstrap-nullable client to a ready client inside a query /
+* mutation function (sdk-provider-owned-bootstrap.md). Data hooks gate their
+* queries on `enabled: client !== null`, so this only ever throws for a mutation
+* triggered while `<CapxulProvider>` is still bootstrapping.
+*/
+function requireBootstrappedClient(client, method) {
+	if (client === null) throw Errors.wrongState({
+		method,
+		currentState: "bootstrapping",
+		validStates: ["ready"]
+	});
+	return client;
+}
+//#endregion
+//#region src/internal/reactivity-keys.ts
+function actorKey(actor) {
+	if (actor === void 0) return ["pending"];
+	return actor.kind === "account" ? ["account"] : ["org", actor.orgId];
+}
+const capxulKeys = {
+	session: ["capxul", "session"],
+	profile: ["capxul", "profile"],
+	account: ["capxul", "account"],
+	accountLifecycle: ["capxul", "accountLifecycle"],
+	provisioning: ["capxul", "provisioning"],
+	binding: ["capxul", "binding"],
+	accountBalance: ["capxul", "accountBalance"],
+	subAccounts: (accountId) => [
+		"capxul",
+		"subAccounts",
+		accountId ?? "pending"
+	],
+	orgs: ["capxul", "orgs"],
+	org: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending"
+	],
+	orgMembers: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"members"
+	],
+	orgRoles: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"roles"
+	],
+	orgTreasury: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"treasury"
+	],
+	actorAddressBook: (actor) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"addressBook"
+	],
+	actorAddressBookEntry: (actor, entryId) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"addressBook",
+		entryId ?? "pending"
+	],
+	actorRequests: (actor) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"requests"
+	],
+	actorRequest: (actor, requestId) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"requests",
+		requestId ?? "pending"
+	],
+	actorInbox: (actor) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"inbox"
+	],
+	actorInsightsSummary: (actor) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"insights",
+		"summary"
+	],
+	actorInsightsHistory: (actor) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"insights",
+		"history"
+	],
+	actorDestinationsScope: (actor) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"destinations"
+	],
+	actorDestinations: (actor, refKey) => [
+		"capxul",
+		"actor",
+		...actorKey(actor),
+		"destinations",
+		refKey ?? "pending"
+	],
+	payments: ["capxul", "payments"],
+	payment: (paymentId) => [
+		"capxul",
+		"payments",
+		paymentId ?? "pending"
+	],
+	paymentRequests: ["capxul", "paymentRequests"],
+	payrollRoster: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"payroll",
+		"roster"
+	]
+};
+//#endregion
+//#region src/internal/unwrap-capxul-result.ts
+/**
+* Unwrap a `CapxulResult` for TanStack query/mutation functions —
+* throws into error paths, optionally reporting the error to telemetry first.
+*
+* When `telemetry` is provided and the result is `{ ok: false }`,
+* `captureExceptionSync` is called (fire-and-forget) before the throw. `operation`
+* tags the telemetry event so query reads and mutation writes stay
+* distinguishable in error tracking (defaults to `"query"`).
+*/
+function unwrapCapxulResult(result, telemetry, operation = "query") {
+	if (result.ok) return result.value;
+	if (telemetry) try {
+		captureExceptionSync(telemetry, result.error, {
+			layer: "react-query",
+			operation
+		});
+	} catch {}
+	throw result.error;
+}
+//#endregion
+//#region src/hooks/use-capxul-session.ts
+function useCapxulSession() {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.session,
+		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "auth.getSession").auth.getSession(), client._internal.telemetry),
+		enabled: client !== null
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-profile.ts
+function useCapxulProfile() {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.profile,
+		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "identity.loadCurrent").identity.loadCurrent(), client._internal.telemetry),
+		enabled: client !== null
+	});
+}
+//#endregion
+//#region src/internal/is-vitest-runtime.ts
+/** True under Vitest — disables hook polling intervals that fight fake timers. */
+function isVitestRuntime() {
+	return typeof process !== "undefined" && process.env["VITEST"] === "true";
+}
+//#endregion
+//#region src/internal/invalidate-auth-boundary.ts
+/** Background refetch after verifyOtp — avoids hard reset cancel errors in UI. */
+async function invalidateAuthBoundary(queryClient) {
+	await Promise.all([
+		queryClient.invalidateQueries({ queryKey: capxulKeys.session }),
+		queryClient.invalidateQueries({ queryKey: capxulKeys.profile }),
+		queryClient.invalidateQueries({ queryKey: capxulKeys.accountLifecycle }),
+		queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance })
+	]);
+}
+/** Hard reset after signOut — drop cached authenticated rows immediately. */
+async function resetAuthBoundary(queryClient) {
+	await queryClient.cancelQueries({ queryKey: capxulKeys.accountBalance });
+	await Promise.all([
+		queryClient.resetQueries({ queryKey: capxulKeys.session }),
+		queryClient.resetQueries({ queryKey: capxulKeys.profile }),
+		queryClient.resetQueries({ queryKey: capxulKeys.accountLifecycle }),
+		queryClient.resetQueries({ queryKey: capxulKeys.accountBalance })
+	]);
+}
+//#endregion
+//#region src/hooks/use-capxul-account-lifecycle.ts
+const LOADING_LIFECYCLE = { status: "loading" };
+function useCapxulAccountLifecycle() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	const query = useQuery({
+		queryKey: capxulKeys.accountLifecycle,
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "account.getLifecycle");
+			return unwrapCapxulResult(await bootstrappedClient.account.getLifecycle(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null,
+		refetchInterval: (q) => {
+			if (isVitestRuntime()) return false;
+			const data = q.state.data;
+			if (data === void 0) return false;
+			if (data.status === "loading" || isSettingUpLifecycle(data)) return 2e3;
+			return false;
+		}
+	});
+	const retryMutation = useMutation({
+		mutationFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "account.retrySetup");
+			return unwrapCapxulResult(await bootstrappedClient.account.retrySetup(), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async () => {
+			await invalidateAuthBoundary(queryClient);
+		}
+	});
+	const lifecycle = query.data ?? LOADING_LIFECYCLE;
+	const failedError = lifecycle.status === "failed" ? lifecycle.error : null;
+	const queryError = query.isError ? query.error : null;
+	return {
+		lifecycle: queryError !== null && lifecycle.status === "loading" ? {
+			status: "failed",
+			at: "connecting",
+			error: queryError
+		} : lifecycle,
+		isSettingUp: isSettingUpLifecycle(lifecycle),
+		error: failedError ?? queryError,
+		isLoading: query.isLoading,
+		isFetching: query.isFetching,
+		isError: query.isError,
+		retry: retryMutation.mutateAsync,
+		isRetrying: retryMutation.isPending
+	};
+}
+//#endregion
+//#region src/hooks/use-capxul-account-balance.ts
+function useCapxulAccountBalance(options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.accountBalance,
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "accounts.read");
+			return unwrapCapxulResult(await bootstrappedClient.accounts.read(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-account-fund.ts
+function useCapxulAccountFund() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (amount) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "_internal.accounts.fund");
+			return unwrapCapxulResult(await bootstrappedClient._internal.accounts.fund(amount), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-sign-in.ts
+function useCapxulSignIn() {
+	const client = useCapxulClientOrNull();
+	return useMutation({ mutationFn: async (input) => {
+		const bootstrappedClient = requireBootstrappedClient(client, "auth.signIn");
+		return unwrapCapxulResult(await bootstrappedClient.auth.signIn(input), bootstrappedClient._internal.telemetry, "mutation");
+	} });
+}
+//#endregion
+//#region src/hooks/use-capxul-verify-otp.ts
+function useCapxulVerifyOtp() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "auth.verifyOtp");
+			return unwrapCapxulResult(await bootstrappedClient.auth.verifyOtp(input), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async () => {
+			await invalidateAuthBoundary(queryClient);
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-sign-out.ts
+function useCapxulSignOut() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: async () => {
+			await queryClient.cancelQueries({ queryKey: capxulKeys.accountBalance });
+		},
+		mutationFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "auth.signOut");
+			return unwrapCapxulResult(await bootstrappedClient.auth.signOut(), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: () => resetAuthBoundary(queryClient)
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-sub-accounts.ts
+function useCapxulSubAccountsList(accountId, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.subAccounts(accountId),
+		queryFn: async () => {
+			if (accountId === void 0) throw Errors.invalidInput("accountId", "required for subAccounts.list");
+			const bootstrappedClient = requireBootstrappedClient(client, "subAccounts.list");
+			return unwrapCapxulResult(await bootstrappedClient.subAccounts.list(accountId), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && (options?.enabled ?? true) && accountId !== void 0
+	});
+}
+function useCapxulSubAccountCreate() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "subAccounts.create");
+			return unwrapCapxulResult(await bootstrappedClient.subAccounts.create(input.accountId, { name: input.name }), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.subAccounts(variables.accountId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+function useCapxulSubAccountRename() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "subAccounts.rename");
+			return unwrapCapxulResult(await bootstrappedClient.subAccounts.rename(input.subAccountId, input.name), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.subAccounts(variables.accountId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+function useCapxulSubAccountDelete() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "subAccounts.delete");
+			return unwrapCapxulResult(await bootstrappedClient.subAccounts.delete(input.subAccountId), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.subAccounts(variables.accountId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+function useCapxulTransfer() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async ({ from, to, amount }) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "subAccounts.transfer");
+			return unwrapCapxulResult(await bootstrappedClient.subAccounts.transfer({
+				from,
+				to,
+				amount
+			}), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.subAccounts(variables.accountId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+//#endregion
+//#region src/internal/invalidate-money-state.ts
+function isPayment(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return typeof record.id === "string" && typeof record.status === "string" && typeof record.paymentType === "string" && typeof record.amount === "object" && record.amount !== null;
+}
+function paymentsFromValue(value) {
+	if (Array.isArray(value)) return value.filter(isPayment);
+	if (isPayment(value)) return [value];
+	if (typeof value !== "object" || value === null) return [];
+	const payments = value.payments;
+	return Array.isArray(payments) ? payments.filter(isPayment) : [];
+}
+async function invalidateMoneyState(queryClient, input) {
+	const invalidations = [
+		queryClient.invalidateQueries({ queryKey: capxulKeys.payments }),
+		queryClient.invalidateQueries({ queryKey: capxulKeys.actorInsightsSummary(input.actor) }),
+		queryClient.invalidateQueries({ queryKey: capxulKeys.actorInsightsHistory(input.actor) })
+	];
+	if (input.payment !== void 0) invalidations.push(queryClient.invalidateQueries({ queryKey: capxulKeys.payment(input.payment.id) }));
+	if (input.actor.kind === "account") invalidations.push(queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance }));
+	else invalidations.push(queryClient.invalidateQueries({ queryKey: capxulKeys.orgTreasury(input.actor.orgId) }));
+	if (input.includeAddressBook === true) invalidations.push(queryClient.invalidateQueries({ queryKey: capxulKeys.actorAddressBook(input.actor) }));
+	await Promise.all(invalidations);
+}
+//#endregion
+//#region src/hooks/use-capxul-money.ts
+function useCapxulPay() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "payments.pay");
+			return unwrapCapxulResult(await bootstrappedClient.payments.pay(input), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (payment) => {
+			await invalidateMoneyState(queryClient, {
+				actor: { kind: "account" },
+				payment,
+				includeAddressBook: true
+			});
+		}
+	});
+}
+function useCapxulPayout() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "payments.payout");
+			return unwrapCapxulResult(await bootstrappedClient.payments.payout(input), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (payment, variables) => {
+			await invalidateMoneyState(queryClient, {
+				actor: variables.actor ?? { kind: "account" },
+				payment
+			});
+		}
+	});
+}
+function useCapxulWithdraw() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "payments.withdraw");
+			return unwrapCapxulResult(await bootstrappedClient.payments.withdraw(input), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (payment) => {
+			await invalidateMoneyState(queryClient, {
+				actor: { kind: "account" },
+				payment
+			});
+		}
+	});
+}
+function useCapxulPayments(options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.payments,
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "payments.list");
+			return unwrapCapxulResult(await bootstrappedClient.payments.list(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && (options?.enabled ?? true)
+	});
+}
+function useCapxulPayment(paymentId, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.payment(paymentId),
+		queryFn: async () => {
+			if (paymentId === void 0) throw Errors.invalidInput("paymentId", "required for payments.get");
+			const bootstrappedClient = requireBootstrappedClient(client, "payments.get");
+			return unwrapCapxulResult(await bootstrappedClient.payments.get(paymentId), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && paymentId !== void 0 && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-actor-scope.ts
+const capxulAccountScope = { kind: "account" };
+function capxulOrgScope(orgId) {
+	return orgId === void 0 ? void 0 : {
+		kind: "org",
+		orgId
+	};
+}
+function requireActorScope(actor, operation) {
+	if (actor === void 0) throw Errors.invalidInput("actor", `required for ${operation}`);
+	return actor;
+}
+function actorMethods(client, actor) {
+	return actor.kind === "account" ? client.account : client.org(actor.orgId);
+}
+function entryIdFromData(data) {
+	if (typeof data !== "object" || data === null) return void 0;
+	const id = data.id;
+	return typeof id === "string" ? id : void 0;
+}
+function requestIdFromMutation(data, variables) {
+	if (typeof variables === "string") return variables;
+	if (typeof variables === "object" && variables !== null) {
+		const requestId = variables.requestId;
+		if (typeof requestId === "string") return requestId;
+	}
+	if (isPayment(data)) return void 0;
+	return entryIdFromData(data);
+}
+function useCapxulAddressBook(actor, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.actorAddressBook(actor),
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "addressBook.list");
+			return unwrapCapxulResult(await actorMethods(bootstrappedClient, requireActorScope(actor, "addressBook.list")).addressBook.list(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && actor !== void 0 && (options?.enabled ?? true)
+	});
+}
+function useCapxulAddressBookEntry(actor, entryId, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.actorAddressBookEntry(actor, entryId),
+		queryFn: async () => {
+			if (entryId === void 0) throw Errors.invalidInput("entryId", "required for addressBook.get");
+			const bootstrappedClient = requireBootstrappedClient(client, "addressBook.get");
+			return unwrapCapxulResult(await actorMethods(bootstrappedClient, requireActorScope(actor, "addressBook.get")).addressBook.get(entryId), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && actor !== void 0 && entryId !== void 0 && (options?.enabled ?? true)
+	});
+}
+function useAddressBookMutation(actor, operation, run) {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (variables) => {
+			const bootstrappedClient = requireBootstrappedClient(client, operation);
+			return unwrapCapxulResult(await run(actorMethods(bootstrappedClient, requireActorScope(actor, operation)), variables), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (data) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorAddressBook(actor) });
+			const entryId = entryIdFromData(data);
+			if (entryId !== void 0) await queryClient.invalidateQueries({ queryKey: capxulKeys.actorAddressBookEntry(actor, entryId) });
+		}
+	});
+}
+const useCapxulAddAddressBookEntry = (actor = capxulAccountScope) => useAddressBookMutation(actor, "addressBook.add", (methods, input) => methods.addressBook.add(input));
+const useCapxulHideAddressBookEntry = (actor = capxulAccountScope) => useAddressBookMutation(actor, "addressBook.hide", (methods, entryId) => methods.addressBook.hide(entryId));
+const useCapxulUnhideAddressBookEntry = (actor = capxulAccountScope) => useAddressBookMutation(actor, "addressBook.unhide", (methods, entryId) => methods.addressBook.unhide(entryId));
+const useCapxulLabelAddressBookEntry = (actor = capxulAccountScope) => useAddressBookMutation(actor, "addressBook.label", (methods, input) => methods.addressBook.label(input));
+function useCapxulRequests(actor, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.actorRequests(actor),
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "requests.list");
+			return unwrapCapxulResult(await actorMethods(bootstrappedClient, requireActorScope(actor, "requests.list")).requests.list(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && actor !== void 0 && (options?.enabled ?? true)
+	});
+}
+function useCapxulRequest(actor, requestId, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.actorRequest(actor, requestId),
+		queryFn: async () => {
+			if (requestId === void 0) throw Errors.invalidInput("requestId", "required for requests.get");
+			const bootstrappedClient = requireBootstrappedClient(client, "requests.get");
+			return unwrapCapxulResult(await actorMethods(bootstrappedClient, requireActorScope(actor, "requests.get")).requests.get(requestId), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && actor !== void 0 && requestId !== void 0 && (options?.enabled ?? true)
+	});
+}
+function useRequestMutation(actor, operation, run, invalidateInbox = false) {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (variables) => {
+			const bootstrappedClient = requireBootstrappedClient(client, operation);
+			return unwrapCapxulResult(await run(actorMethods(bootstrappedClient, requireActorScope(actor, operation)), variables), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (data, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorRequests(actor) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorAddressBook(actor) });
+			const requestId = requestIdFromMutation(data, variables);
+			if (requestId !== void 0) await queryClient.invalidateQueries({ queryKey: capxulKeys.actorRequest(actor, requestId) });
+			if (invalidateInbox) await queryClient.invalidateQueries({ queryKey: capxulKeys.actorInbox(actor) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorInsightsSummary(actor) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorInsightsHistory(actor) });
+			if (isPayment(data)) await invalidateMoneyState(queryClient, {
+				actor: requireActorScope(actor, operation),
+				payment: data
+			});
+		}
+	});
+}
+const useCapxulIssueRequest = (actor = capxulAccountScope) => useRequestMutation(actor, "requests.issue", (methods, input) => methods.requests.issue(input));
+const useCapxulCancelRequest = (actor = capxulAccountScope) => useRequestMutation(actor, "requests.cancel", (methods, requestId) => methods.requests.cancel(requestId), true);
+const useCapxulReconcileRequests = (actor = capxulAccountScope) => useRequestMutation(actor, "requests.reconcile", (methods) => methods.requests.reconcile());
+function useCapxulInbox(actor, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.actorInbox(actor),
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "inbox.list");
+			return unwrapCapxulResult(await actorMethods(bootstrappedClient, requireActorScope(actor, "inbox.list")).inbox.list(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && actor !== void 0 && (options?.enabled ?? true)
+	});
+}
+const useCapxulApproveInboxRequest = (actor = capxulAccountScope) => useRequestMutation(actor, "inbox.approve", (methods, input) => methods.inbox.approve(input), true);
+const useCapxulDeclineInboxRequest = (actor = capxulAccountScope) => useRequestMutation(actor, "inbox.decline", (methods, requestId) => methods.inbox.decline(requestId), true);
+function useCapxulInsightsSummary(actor, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.actorInsightsSummary(actor),
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "insights.summary");
+			return unwrapCapxulResult(await actorMethods(bootstrappedClient, requireActorScope(actor, "insights.summary")).insights.summary(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && actor !== void 0 && (options?.enabled ?? true)
+	});
+}
+function useCapxulInsightsHistory(actor, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.actorInsightsHistory(actor),
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "insights.history");
+			return unwrapCapxulResult(await actorMethods(bootstrappedClient, requireActorScope(actor, "insights.history")).insights.history(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && actor !== void 0 && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-destinations.ts
+function refKeyForRef(ref) {
+	switch (ref.kind) {
+		case "handle": return `handle:${ref.handle}`;
+		case "email": return `email:${ref.email}`;
+		case "orgHandle": return `orgHandle:${ref.orgHandle}`;
+		case "capxulUserId": return `capxulUserId:${ref.capxulUserId}`;
+		case "payeeId": return `payeeId:${ref.payeeId}`;
+	}
+}
+function refCacheKey(input) {
+	return input === void 0 ? void 0 : refKeyForRef(input.ref);
+}
+function useCapxulDestinations(input, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.actorDestinations(input?.actor ?? { kind: "account" }, refCacheKey(input)),
+		queryFn: async () => {
+			if (input === void 0) throw Errors.invalidInput("ref", "required for destinations.list");
+			const bootstrappedClient = requireBootstrappedClient(client, "destinations.list");
+			return unwrapCapxulResult(await bootstrappedClient.destinations.list(input), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && input !== void 0 && (options?.enabled ?? true)
+	});
+}
+function useCapxulAddDestination() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "destinations.add");
+			return unwrapCapxulResult(await bootstrappedClient.destinations.add(input), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorDestinationsScope(variables.actor ?? { kind: "account" }) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorAddressBook(variables.actor ?? { kind: "account" }) });
+		}
+	});
+}
+function useCapxulRemoveDestination() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrappedClient = requireBootstrappedClient(client, "destinations.remove");
+			return unwrapCapxulResult(await bootstrappedClient.destinations.remove(input), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (_value, variables) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorDestinationsScope(variables.actor ?? { kind: "account" }) });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-payroll.ts
+function useCapxulPayrollRoster(orgId, options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.payrollRoster(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for payroll.roster.list");
+			const bootstrappedClient = requireBootstrappedClient(client, "payroll.roster.list");
+			return unwrapCapxulResult(await bootstrappedClient.org(orgId).payroll.roster.list(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && orgId !== void 0 && (options?.enabled ?? true)
+	});
+}
+function usePayrollMutation(orgId, operation, run) {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (variables) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", `required for ${operation}`);
+			const bootstrappedClient = requireBootstrappedClient(client, operation);
+			return unwrapCapxulResult(await run(bootstrappedClient.org(orgId), variables), bootstrappedClient._internal.telemetry, "mutation");
+		},
+		onSuccess: async (data) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.payrollRoster(orgId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorInsightsSummary(orgId === void 0 ? void 0 : {
+				kind: "org",
+				orgId
+			}) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.actorInsightsHistory(orgId === void 0 ? void 0 : {
+				kind: "org",
+				orgId
+			}) });
+			if (orgId === void 0) return;
+			const actor = {
+				kind: "org",
+				orgId
+			};
+			const payments = paymentsFromValue(data);
+			if (payments.length === 0) return;
+			await Promise.all(payments.map((payment) => invalidateMoneyState(queryClient, {
+				actor,
+				payment,
+				includeAddressBook: true
+			})));
+		}
+	});
+}
+const useCapxulAddPayrollRosterLine = (orgId) => usePayrollMutation(orgId, "payroll.roster.add", (org, input) => org.payroll.roster.add(input));
+const useCapxulUpdatePayrollRosterLine = (orgId) => usePayrollMutation(orgId, "payroll.roster.update", (org, variables) => org.payroll.roster.update(variables.rosterLineId, variables.input));
+const useCapxulRemovePayrollRosterLine = (orgId) => usePayrollMutation(orgId, "payroll.roster.remove", (org, rosterLineId) => org.payroll.roster.remove(rosterLineId));
+const useCapxulRunPayroll = (orgId) => usePayrollMutation(orgId, "payroll.run", (org, input) => org.payroll.run(input));
+//#endregion
+//#region src/hooks/use-capxul-orgs.ts
+function useCapxulOrgs(options) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.orgs,
+		queryFn: async () => {
+			const bootstrappedClient = requireBootstrappedClient(client, "orgs");
+			return unwrapCapxulResult(await bootstrappedClient.orgs(), bootstrappedClient._internal.telemetry);
+		},
+		enabled: client !== null && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org.ts
+function useCapxulOrg(orgId, options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.org(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrg");
+			return unwrapCapxulResult(await client.orgs(), client._internal.telemetry).find((org) => org.id === orgId) ?? null;
+		},
+		enabled: (options?.enabled ?? true) && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-members.ts
+function useCapxulOrgMembers(orgId, options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.orgMembers(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgMembers");
+			return unwrapCapxulResult(await client.org(orgId).members(), client._internal.telemetry);
+		},
+		enabled: (options?.enabled ?? true) && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-roles.ts
+function useCapxulOrgRoles(orgId, options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.orgRoles(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgRoles");
+			return unwrapCapxulResult(await client.org(orgId).roles(), client._internal.telemetry);
+		},
+		enabled: (options?.enabled ?? true) && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-deploy-roles.ts
+function useCapxulOrgDeployRoles() {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (orgId) => {
+			return unwrapCapxulResult(await client.org(orgId).deployRoles(), client._internal.telemetry, "mutation");
+		},
+		onSuccess: async (_roles, orgId) => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgRoles(orgId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.org(orgId) });
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgs });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-org-treasury.ts
+function useCapxulOrgTreasury(orgId, options) {
+	const client = useCapxulClient();
+	return useQuery({
+		queryKey: capxulKeys.orgTreasury(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgTreasury");
+			return unwrapCapxulResult(await client.org(orgId).treasury(), client._internal.telemetry);
+		},
+		enabled: (options?.enabled ?? true) && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-create-org.ts
+function useCapxulCreateOrg() {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => unwrapCapxulResult(await client.createOrg(input), client._internal.telemetry, "mutation"),
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgs });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-complete-personal-onboarding.ts
+function useCapxulCompletePersonalOnboarding() {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => unwrapCapxulResult(await client.onboarding.completePersonal(input), client._internal.telemetry, "mutation"),
+		onSuccess: async () => {
+			await Promise.all([queryClient.invalidateQueries({ queryKey: capxulKeys.profile }), queryClient.invalidateQueries({ queryKey: capxulKeys.accountLifecycle })]);
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-complete-organization-onboarding.ts
+function useCapxulCompleteOrganizationOnboarding() {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => unwrapCapxulResult(await client.onboarding.completeOrganization(input), client._internal.telemetry, "mutation"),
+		onSuccess: async () => {
+			await Promise.all([
+				queryClient.invalidateQueries({ queryKey: capxulKeys.profile }),
+				queryClient.invalidateQueries({ queryKey: capxulKeys.accountLifecycle }),
+				queryClient.invalidateQueries({ queryKey: capxulKeys.orgs })
+			]);
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-invite-member.ts
+function useCapxulInviteMember(orgId) {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulInviteMember");
+			return unwrapCapxulResult(await client.org(orgId).invite(input), client._internal.telemetry, "mutation");
+		},
+		onSuccess: async () => {
+			if (orgId === void 0) return;
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgMembers(orgId) });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-remove-member.ts
+function useCapxulRemoveMember(orgId) {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulRemoveMember");
+			return unwrapCapxulResult(await client.org(orgId).removeMember(input), client._internal.telemetry, "mutation");
+		},
+		onSuccess: async () => {
+			if (orgId === void 0) return;
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgMembers(orgId) });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-assign-role.ts
+function useCapxulAssignRole(orgId) {
+	const client = useCapxulClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulAssignRole");
+			return unwrapCapxulResult(await client.org(orgId).assignRole(input), client._internal.telemetry, "mutation");
+		},
+		onSuccess: async () => {
+			if (orgId === void 0) return;
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgMembers(orgId) });
+		}
+	});
+}
+//#endregion
+//#region src/hooks/use-capxul-switch-acting-entity.ts
+function useCapxulSwitchActingEntity() {
+	return useMutation({ mutationFn: async (_input) => void 0 });
+}
+//#endregion
+//#region src/headless/shared/headless-error-view.ts
+const FAILURE_MODES = new Set([
+	"auth-origin-mismatch",
+	"stale-openfort-cache",
+	"app-env-allowlist",
+	"no-secure-context",
+	"unknown"
+]);
+function isFailureMode(value) {
+	return typeof value === "string" && FAILURE_MODES.has(value);
+}
+function getFailureMode(error) {
+	const candidate = error.details?.failure_mode;
+	return isFailureMode(candidate) ? candidate : void 0;
+}
+const FAILURE_USER_MESSAGES = {
+	"auth-origin-mismatch": "Your sign-in session is not visible to the wallet. Sign out and sign in again.",
+	"stale-openfort-cache": "Stale wallet data from a previous session is blocking setup. Sign out, then sign in with your current email.",
+	"app-env-allowlist": "This app origin is not authorized for the publishable key. Check configuration.",
+	"no-secure-context": "Your browser cannot access secure wallet features. Open the app in a standard browser window.",
+	unknown: "Something went wrong setting up your wallet. Try again or sign out and sign in."
+};
+const FAILURE_SUGGESTED_ACTIONS = {
+	"auth-origin-mismatch": "sign_out_and_in",
+	"stale-openfort-cache": "sign_out_and_in",
+	"app-env-allowlist": "check_configuration",
+	"no-secure-context": "check_configuration",
+	unknown: "retry"
+};
+const FAILURE_RECOVERABLE = {
+	"auth-origin-mismatch": false,
+	"stale-openfort-cache": true,
+	"app-env-allowlist": false,
+	"no-secure-context": false,
+	unknown: true
+};
+function coerceToCapxulError(cause) {
+	if (isCapxulError(cause)) return cause;
+	if (cause instanceof Error) return Errors.unknown(cause);
+	return Errors.unknown(String(cause));
+}
+function toHeadlessErrorView(error) {
+	const failureMode = getFailureMode(error);
+	const suggestedAction = failureMode ? FAILURE_SUGGESTED_ACTIONS[failureMode] : defaultSuggestedAction(error);
+	const userMessage = failureMode ? FAILURE_USER_MESSAGES[failureMode] : defaultUserMessage(error);
+	const recoverable = failureMode ? FAILURE_RECOVERABLE[failureMode] : defaultRecoverable(error);
+	return {
+		code: error.code,
+		failureMode,
+		userMessage,
+		suggestedAction,
+		recoverable,
+		diagnostics: buildDiagnostics(error, failureMode),
+		correlationId: error.correlationId
+	};
+}
+function defaultUserMessage(error) {
+	if (error.code === "OTP_EXPIRED") return "Verification code has expired. Request a new one.";
+	if (error.code === "NOT_AUTHENTICATED") return "You are not signed in. Sign in and try again.";
+	if (error.code === "RATE_LIMITED") return "Too many attempts. Wait a moment and try again.";
+	if (error.code === "NETWORK_ERROR") return "Network error. Check your connection and try again.";
+	return error.message;
+}
+function defaultSuggestedAction(error) {
+	switch (error.code) {
+		case "NOT_AUTHENTICATED":
+		case "OTP_EXPIRED":
+		case "WRONG_STATE": return "sign_out_and_in";
+		case "ENV_MISSING": return "check_configuration";
+		case "RATE_LIMITED":
+		case "NETWORK_ERROR":
+		case "PROVIDER_ERROR":
+		case "TRANSACTION_FAILED": return "retry";
+		default: return "contact_support";
+	}
+}
+function defaultRecoverable(error) {
+	switch (error.code) {
+		case "ENV_MISSING":
+		case "NOT_IMPLEMENTED": return false;
+		default: return true;
+	}
+}
+function buildDiagnostics(error, failureMode) {
+	const parts = [`code=${error.code}`];
+	if (failureMode !== void 0) parts.push(`failure_mode=${failureMode}`);
+	if (error.layer !== void 0) parts.push(`layer=${error.layer}`);
+	const provider = error.details?.provider;
+	if (typeof provider === "string") parts.push(`provider=${provider}`);
+	const operation = error.details?.operation;
+	if (typeof operation === "string") parts.push(`operation=${operation}`);
+	return parts.join(" ");
+}
+//#endregion
+//#region src/headless/shared/types.ts
+function toQuerySlotState(query) {
+	return {
+		data: query.data,
+		isLoading: query.isLoading,
+		isFetching: query.isFetching,
+		isError: query.isError,
+		error: query.error === null ? null : toHeadlessErrorView(query.error)
+	};
+}
+//#endregion
+//#region ../types/src/index.ts
+const SUPPORTED_CURRENCIES = [
+	{
+		code: "USD",
+		symbol: "$",
+		name: "US Dollar"
+	},
+	{
+		code: "NGN",
+		symbol: "NGN",
+		name: "Nigerian Naira"
+	},
+	{
+		code: "GHS",
+		symbol: "GHS",
+		name: "Ghanaian Cedi"
+	},
+	{
+		code: "KES",
+		symbol: "KSh",
+		name: "Kenyan Shilling"
+	},
+	{
+		code: "UGX",
+		symbol: "USh",
+		name: "Ugandan Shilling"
+	}
+];
+SUPPORTED_CURRENCIES.map((currency) => currency.code);
+Object.fromEntries(SUPPORTED_CURRENCIES.map((currency) => [currency.code, currency.symbol]));
+Math.floor(Number.MAX_SAFE_INTEGER / 1e3);
+//#endregion
+//#region src/headless/money/SendMoney.tsx
+function SendMoney({ initialValue = null, slots, onSent }) {
+	const pay = useCapxulPay();
+	const [value, setValue] = useState(initialValue);
+	const [error, setError] = useState(null);
+	const submit = async () => {
+		setError(null);
+		if (value === null) return;
+		try {
+			await pay.mutateAsync(value);
+			onSent?.();
+		} catch (cause) {
+			setError(toHeadlessErrorView(coerceToCapxulError(cause)));
+		}
+	};
+	const slot = slots.form?.({
+		value,
+		setValue,
+		submit: () => void submit(),
+		pending: pay.isPending,
+		disabled: pay.isPending || value === null,
+		succeeded: pay.isSuccess,
+		error
+	});
+	const children = /* @__PURE__ */ jsxs(Fragment, { children: [slot, error === null ? null : slots.error?.(error)] });
+	return slots.root?.({ children }) ?? children;
+}
+//#endregion
+//#region src/headless/relationship/AddressBook.tsx
+function AddressBook(props) {
+	const { slots } = props;
+	const actor = "actor" in props ? props.actor : capxulAccountScope;
+	const entries = useCapxulAddressBook(actor);
+	const add = useCapxulAddAddressBookEntry(actor);
+	const hide = useCapxulHideAddressBookEntry(actor);
+	const unhide = useCapxulUnhideAddressBookEntry(actor);
+	const label = useCapxulLabelAddressBookEntry(actor);
+	const pending = add.isPending || hide.isPending || unhide.isPending || label.isPending;
+	const children = /* @__PURE__ */ jsxs(Fragment, { children: [slots.entries?.(toQuerySlotState(entries)), slots.actions?.({
+		add: (input) => add.mutateAsync(input),
+		hide: (entryId) => hide.mutateAsync(entryId),
+		unhide: (entryId) => unhide.mutateAsync(entryId),
+		label: (input) => label.mutateAsync(input),
+		pending,
+		disabled: pending || actor === void 0
+	})] });
+	return slots.root?.({ children }) ?? children;
+}
+//#endregion
+//#region src/headless/relationship/RequestInbox.tsx
+function RequestInbox(props) {
+	const { slots } = props;
+	const actor = "actor" in props ? props.actor : capxulAccountScope;
+	const requests = useCapxulRequests(actor);
+	const inbox = useCapxulInbox(actor);
+	const issue = useCapxulIssueRequest(actor);
+	const cancel = useCapxulCancelRequest(actor);
+	const approve = useCapxulApproveInboxRequest(actor);
+	const decline = useCapxulDeclineInboxRequest(actor);
+	const pending = issue.isPending || cancel.isPending || approve.isPending || decline.isPending;
+	const children = /* @__PURE__ */ jsxs(Fragment, { children: [
+		slots.requests?.(toQuerySlotState(requests)),
+		slots.inbox?.(toQuerySlotState(inbox)),
+		slots.actions?.({
+			issue: (input) => issue.mutateAsync(input),
+			cancel: (requestId) => cancel.mutateAsync(requestId),
+			approve: (input) => approve.mutateAsync(input),
+			decline: (requestId) => decline.mutateAsync(requestId),
+			pending,
+			disabled: pending || actor === void 0
+		})
+	] });
+	return slots.root?.({ children }) ?? children;
+}
+//#endregion
+//#region src/headless/relationship/InsightsSummary.tsx
+function InsightsSummary(props) {
+	const { slots } = props;
+	const summary = useCapxulInsightsSummary("actor" in props ? props.actor : capxulAccountScope);
+	const children = slots.summary?.(toQuerySlotState(summary));
+	return slots.root?.({ children }) ?? children;
+}
+//#endregion
+//#region src/headless/relationship/PayrollRoster.tsx
+function PayrollRoster({ orgId, slots }) {
+	const roster = useCapxulPayrollRoster(orgId);
+	const add = useCapxulAddPayrollRosterLine(orgId);
+	const update = useCapxulUpdatePayrollRosterLine(orgId);
+	const remove = useCapxulRemovePayrollRosterLine(orgId);
+	const run = useCapxulRunPayroll(orgId);
+	const pending = add.isPending || update.isPending || remove.isPending || run.isPending;
+	const children = /* @__PURE__ */ jsxs(Fragment, { children: [slots.roster?.(toQuerySlotState(roster)), slots.actions?.({
+		add: (input) => add.mutateAsync(input),
+		update: (input) => update.mutateAsync(input),
+		remove: (rosterLineId) => remove.mutateAsync(rosterLineId),
+		run: (input) => run.mutateAsync(input),
+		pending,
+		disabled: pending
+	})] });
+	return slots.root?.({ children }) ?? children;
+}
+//#endregion
+//#region src/headless/relationship/Destinations.tsx
+function Destinations({ input, slots }) {
+	const destinations = useCapxulDestinations(input);
+	const add = useCapxulAddDestination();
+	const remove = useCapxulRemoveDestination();
+	const pending = add.isPending || remove.isPending;
+	const children = /* @__PURE__ */ jsxs(Fragment, { children: [slots.destinations?.(toQuerySlotState(destinations)), slots.actions?.({
+		add: (value) => add.mutateAsync(value),
+		remove: (value) => remove.mutateAsync(value),
+		pending,
+		disabled: pending
+	})] });
+	return slots.root?.({ children }) ?? children;
+}
+//#endregion
+export { AddressBook, CapxulProvider, Destinations, InsightsSummary, PayrollRoster, RequestInbox, SendMoney, capxulAccountScope, capxulOrgScope, useCapxul, useCapxulAccountBalance, useCapxulAccountFund, useCapxulAccountLifecycle, useCapxulAddAddressBookEntry, useCapxulAddDestination, useCapxulAddPayrollRosterLine, useCapxulAddressBook, useCapxulAddressBookEntry, useCapxulApproveInboxRequest, useCapxulAssignRole, useCapxulCancelRequest, useCapxulClientOrNull, useCapxulCompleteOrganizationOnboarding, useCapxulCompletePersonalOnboarding, useCapxulCreateOrg, useCapxulDeclineInboxRequest, useCapxulDestinations, useCapxulHideAddressBookEntry, useCapxulInbox, useCapxulInsightsHistory, useCapxulInsightsSummary, useCapxulInviteMember, useCapxulIssueRequest, useCapxulLabelAddressBookEntry, useCapxulOrg, useCapxulOrgDeployRoles, useCapxulOrgMembers, useCapxulOrgRoles, useCapxulOrgTreasury, useCapxulOrgs, useCapxulPay, useCapxulPayment, useCapxulPayments, useCapxulPayout, useCapxulPayrollRoster, useCapxulProfile, useCapxulReconcileRequests, useCapxulRemoveDestination, useCapxulRemoveMember, useCapxulRemovePayrollRosterLine, useCapxulRequest, useCapxulRequests, useCapxulRunPayroll, useCapxulSession, useCapxulSignIn, useCapxulSignOut, useCapxulSubAccountCreate, useCapxulSubAccountDelete, useCapxulSubAccountRename, useCapxulSubAccountsList, useCapxulSwitchActingEntity, useCapxulTransfer, useCapxulUnhideAddressBookEntry, useCapxulUpdatePayrollRosterLine, useCapxulVerifyOtp, useCapxulWithdraw };
+
+//# sourceMappingURL=index.mjs.map