@powerhousedao/reactor-browser 6.2.2-dev.2 → 6.2.2-dev.21

package/dist/index-Cj_YGHcz.d.ts

@@ -0,0 +1,692 @@
+import { t as PGlite } from "./pglite-CntadC_p-BgIvrYtV.js";
+import { c as ReactorGraphQLClient, r as GraphQLClientWindowEvents } from "./types-CVZRGBXo.js";
+import { r as IWorkerAdminClient, t as IInspectorProxy } from "./inspector-proxy-Doocf0nD.js";
+import { Action, DocumentAction, DocumentModelModule, PHDocument } from "@powerhousedao/shared/document-model";
+import { DocumentDriveDocument } from "@powerhousedao/shared/document-drive";
+import { IDocumentModelLoader, IReactorClient, InProcessReactorClientModule, InProcessReactorModule, ReactorClientModule, ReactorModule } from "@powerhousedao/reactor";
+import { CSSProperties, DragEventHandler, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as _renown_sdk0 from "@renown/sdk";
+import { CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, DOMAIN_TYPE, IRenown, ISSUER_TYPE, LoginStatus, User, VERIFIABLE_CREDENTIAL_EIP712_TYPE } from "@renown/sdk";
+import { IAttachmentService } from "@powerhousedao/reactor-attachments/client";
+import { LoginMethod, WalletAdaptersConfig, WalletSession, WalletTheme } from "@renown/sdk/wallet";
+import { DocumentModelLib, RegistryPackageSource } from "@powerhousedao/shared";
+import { PHConnectRenownAdapters } from "@powerhousedao/shared/clis";
+
+//#region src/types/documents.d.ts
+type DocumentDispatch<TAction extends Action> = (actionOrActions: TAction | TAction[] | DocumentAction | DocumentAction[] | undefined, onErrors?: (errors: Error[]) => void, onSuccess?: (result: PHDocument) => void) => void;
+type PromiseWithState<T> = Promise<T> & PromiseState<T>;
+type FulfilledPromise<T> = Promise<T> & {
+  status: "fulfilled";
+  value: T;
+};
+type RejectedPromise<T> = Promise<T> & {
+  status: "rejected";
+  reason: unknown;
+};
+type PromiseState<T> = {
+  status: "pending";
+} | {
+  status: "fulfilled";
+  value: T;
+} | {
+  status: "rejected";
+  reason: unknown;
+};
+interface IDocumentCache {
+  get(id: string, refetch?: boolean): Promise<PHDocument>;
+  getBatch(ids: string[], refetch?: boolean): Promise<PHDocument[]>;
+  subscribe(id: string | string[], callback: () => void): () => void;
+}
+//#endregion
+//#region src/renown/use-renown-auth.d.ts
+type RenownAuthStatus = LoginStatus | "loading";
+interface RenownAuth {
+  status: RenownAuthStatus | undefined;
+  user: User | undefined;
+  address: string | undefined;
+  ensName: string | undefined;
+  avatarUrl: string | undefined;
+  profileId: string | undefined;
+  displayName: string | undefined;
+  displayAddress: string | undefined;
+  login: (session?: WalletSession, method?: LoginMethod) => void;
+  pending: boolean;
+  error: Error | undefined;
+  logout: () => Promise<void>;
+  openProfile: () => void;
+}
+declare function useRenownAuth(): RenownAuth;
+type RenownAuthResolution = "authenticated" | "resolving" | "unauthenticated";
+interface RenownAuthAsync extends RenownAuth {
+  /** Collapsed routing state; "resolving" until auth is known. */
+  state: RenownAuthResolution;
+  isResolving: boolean;
+}
+declare function useRenownAuthAsync(): RenownAuthAsync;
+//#endregion
+//#region src/renown/session.d.ts
+declare function openRenown(documentId?: string): void;
+declare function login(userDid: string | undefined, renown: IRenown | undefined): Promise<User | undefined>;
+declare function logout(): Promise<void>;
+//#endregion
+//#region src/types/config.d.ts
+type PHGlobalConfig = PHCommonGlobalConfig & PHAppConfig & PHDocumentEditorConfig & PHDrivesGlobalConfig & PHAnalyticsGlobalConfig & PHRelationalProcessorsGlobalConfig & PHProcessorsGlobalConfig & PHRenownGlobalConfig & PHSentryGlobalConfig;
+type PHGlobalConfigKey = keyof PHGlobalConfig;
+type PHGlobalConfigSetters = PHGlobalConfigSettersForKey<PHGlobalConfigKey>;
+type PHGlobalConfigHooks = PHGlobalConfigHooksForKey<PHGlobalConfigKey>;
+/**
+ * Editor configuration settings which are globally available to your custom apps.
+ *
+ * Setting these will override the defaults when your editor is mounted.
+ */
+type PHAppConfig = {
+  /** Allows you to specify the document types that are allowed to be added to the drive.
+   * An empty array means that any document type is allowed.
+   */
+  allowedDocumentTypes?: string[]; /** Whether drag and drop is enabled for the app. */
+  isDragAndDropEnabled?: boolean;
+};
+type PHAppConfigKey = keyof PHAppConfig;
+type PHAppConfigSetters = PHGlobalConfigSettersForKey<PHAppConfigKey>;
+type PHAppConfigHooks = PHGlobalConfigHooksForKey<PHAppConfigKey>;
+type PHDocumentEditorConfig = {
+  /** Whether external controls are enabled for the document editor. */isExternalControlsEnabled?: boolean;
+};
+type PHDocumentEditorConfigKey = keyof PHDocumentEditorConfig;
+type PHDocumentEditorConfigSetters = PHGlobalConfigSettersForKey<PHDocumentEditorConfigKey>;
+type PHDocumentEditorConfigHooks = PHGlobalConfigHooksForKey<PHDocumentEditorConfigKey>;
+type PHCommonGlobalConfig = {
+  basePath?: string;
+  routerBasename?: string;
+  version?: string;
+  requiresHardRefresh?: boolean;
+  warnOutdatedApp?: boolean;
+  studioMode?: boolean;
+  versionCheckInterval?: number;
+  cliVersion?: string;
+  fileUploadOperationsChunkSize?: number;
+  gaTrackingId?: string;
+  isDocumentModelSelectionSettingsEnabled?: boolean;
+  isAddDriveEnabled?: boolean;
+  isPublicDrivesEnabled?: boolean;
+  isAddPublicDrivesEnabled?: boolean;
+  isDeletePublicDrivesEnabled?: boolean;
+  isCloudDrivesEnabled?: boolean;
+  isAddCloudDrivesEnabled?: boolean;
+  isDeleteCloudDrivesEnabled?: boolean;
+  isLocalDrivesEnabled?: boolean;
+  isAddLocalDrivesEnabled?: boolean;
+  isDeleteLocalDrivesEnabled?: boolean;
+  allowList?: string[];
+  analyticsDatabaseName?: string;
+  logLevel?: "debug" | "info" | "warn" | "error";
+  isEditorDebugModeEnabled?: boolean;
+  isEditorReadModeEnabled?: boolean;
+  disabledEditors?: string[];
+  enabledEditors?: string[];
+};
+type PHDrivesGlobalConfig = {
+  defaultDrivesUrl?: string;
+  drivesPreserveStrategy?: string;
+};
+type PHAnalyticsGlobalConfig = {
+  isAnalyticsEnabled?: boolean;
+  isAnalyticsDatabaseWorkerEnabled?: boolean;
+  isDiffAnalyticsEnabled?: boolean;
+  isDriveAnalyticsEnabled?: boolean;
+  isAnalyticsExternalProcessorsEnabled?: boolean;
+};
+type PHRelationalProcessorsGlobalConfig = {
+  isRelationalProcessorsEnabled?: boolean;
+  isExternalRelationalProcessorsEnabled?: boolean;
+};
+type PHProcessorsGlobalConfig = {
+  isExternalProcessorsEnabled?: boolean;
+  isExternalPackagesEnabled?: boolean;
+};
+type PHRenownGlobalConfig = {
+  renownUrl?: string;
+  renownNetworkId?: string;
+  renownChainId?: number;
+  switchboardUrl?: string;
+  renownAdapters?: PHConnectRenownAdapters;
+};
+type PHSentryGlobalConfig = {
+  sentryRelease?: string;
+  sentryDsn?: string;
+  sentryEnv?: string;
+  isSentryTracingEnabled?: boolean;
+};
+type PHGlobalConfigSettersForKey<T extends PHGlobalConfigKey> = { [K in T]: (value: PHGlobalConfig[K]) => void };
+type PHGlobalConfigHooksForKey<TKey extends PHGlobalConfigKey> = { [K in TKey]: () => PHGlobalConfig[K] };
+/** Helper type for ensuring keys are all present while still allowing them to be set */
+type FullPHGlobalConfig = Record<PHGlobalConfigKey, PHGlobalConfig[PHGlobalConfigKey]>;
+//#endregion
+//#region src/types/modals.d.ts
+type PHModal = {
+  type: "createDocument";
+  documentType: string;
+} | {
+  type: "deleteItem";
+  id: string;
+} | {
+  type: "addDrive";
+} | {
+  type: "upgradeDrive";
+  driveId: string;
+} | {
+  type: "deleteDrive";
+  driveId: string;
+} | {
+  type: "driveSettings";
+  driveId: string;
+} | {
+  type: "settings";
+} | {
+  type: "clearStorage";
+} | {
+  type: "debugSettings";
+} | {
+  type: "disclaimer";
+} | {
+  type: "cookiesPolicy";
+} | {
+  type: "downloadDocumentWithErrors";
+  documentId: string;
+} | {
+  type: "inspector";
+} | {
+  type: "missingPackage";
+  documentType: string;
+} | {
+  type: "driveAuthRequired";
+} | {
+  type: "openFileDocuments";
+} | {
+  type: "login";
+};
+//#endregion
+//#region src/types/package-discovery.d.ts
+type PendingInstallation = {
+  documentType: string;
+  packageNames: string[];
+};
+type FailedInstallationReason = "no-registry" | "not-in-registry" | "registry-error" | "install-failed" | "dismissed" | "offline";
+type FailedInstallation = {
+  documentType: string;
+  reason: FailedInstallationReason;
+  packageNames: string[];
+  error: Error | null;
+};
+type DiscoveryEvent = {
+  type: "type-discovered";
+  documentType: string;
+  packageNames: string[];
+} | {
+  type: "installation-prompted";
+  documentType: string;
+  packageNames: string[];
+} | {
+  type: "installation-approved";
+  packageName: string;
+  documentTypes: string[];
+} | {
+  type: "installation-dismissed";
+  packageName: string;
+  documentTypes: string[];
+} | {
+  type: "installation-failed";
+  packageName: string;
+  error: Error;
+} | {
+  type: "registry-query-failed";
+  documentType: string;
+  error: Error;
+} | {
+  type: "load-failed";
+  documentType: string;
+  reason: FailedInstallationReason;
+};
+type DiscoveryEventListener = (event: DiscoveryEvent) => void;
+interface IPackageDiscoveryService {
+  load(documentType: string): Promise<DocumentModelModule<any>>;
+  getPendingInstallations(): PendingInstallation[];
+  subscribePending(listener: () => void): () => void;
+  getFailedInstallations(): FailedInstallation[];
+  subscribeFailed(listener: () => void): () => void;
+  subscribeEvents(listener: DiscoveryEventListener): () => void;
+  approveInstallation(packageName: string): Promise<void>;
+  dismissInstallation(packageName: string): void;
+  promptInstallation(documentType: string): void;
+  retryInstallation(documentType: string): Promise<void>;
+}
+//#endregion
+//#region src/types/timeline.d.ts
+type TimelineBarItem = {
+  id: string;
+  type: "bar";
+  addSize?: 0 | 1 | 2 | 3 | 4;
+  delSize?: 0 | 1 | 2 | 3 | 4;
+  timestampUtcMs?: string;
+  additions?: number;
+  deletions?: number;
+  revision?: number;
+  startDate?: Date;
+  endDate?: Date;
+};
+type TimelineDividerItem = {
+  id: string;
+  type: "divider";
+  timestampUtcMs?: string;
+  title?: string;
+  subtitle?: string;
+  revision?: number;
+  startDate?: Date;
+  endDate?: Date;
+};
+type TimelineItem = TimelineBarItem | TimelineDividerItem;
+//#endregion
+//#region src/types/toast.d.ts
+type PHToastType = "default" | "success" | "error" | "warning" | "info" | "connect-success" | "connect-warning" | "connect-loading" | "connect-deleted";
+type PHToastOptions = {
+  type?: PHToastType;
+  autoClose?: number | false;
+  containerId?: string;
+};
+type PHToastFn = (content: ReactNode | string, options?: PHToastOptions) => void;
+//#endregion
+//#region src/types/vetra.d.ts
+type IPackagesListener = (data: {
+  packages: DocumentModelLib[];
+}) => void;
+type IPackageListerUnsubscribe = () => void;
+type PackageManagerInstallResult = {
+  type: "success";
+  package: DocumentModelLib;
+} | {
+  type: "error";
+  error: Error;
+};
+interface IPackageManager extends IDocumentModelLoader {
+  registryUrl: string | null;
+  packages: DocumentModelLib[];
+  addPackage(packageName: string): Promise<PackageManagerInstallResult> | PackageManagerInstallResult;
+  addPackages(packageNames: string[]): Promise<PackageManagerInstallResult[]> | PackageManagerInstallResult[];
+  removePackage(name: string): void;
+  updateLocalPackage(pkg: DocumentModelLib, version?: string): void;
+  subscribe(handler: IPackagesListener): IPackageListerUnsubscribe;
+  getPackageSource: (packageName: string) => RegistryPackageSource | null;
+  getPackageVersion: (packageName: string) => string | undefined;
+  /**
+   * Registry-installed packages keyed by their storage name (the registry
+   * spec, e.g. "@powerhousedao/clint-common"). Used by callers that need to
+   * diff against an external source of truth such as the publish-reload
+   * channel's `/__packages` SSE feed.
+   */
+  getRegistryPackages: () => {
+    name: string;
+    version: string | undefined;
+  }[];
+  addLocalPackage: (name: string, loadedPackage: DocumentModelLib, version?: string) => void;
+}
+//#endregion
+//#region src/hooks/node-drag-and-drop.d.ts
+type DraggingNode = {
+  srcId: string;
+  parentId: string | null | undefined;
+};
+declare const addDraggingNodeEventHandler: () => void;
+declare function useDragNode(args: {
+  srcId: string | undefined;
+  parentId: string | null | undefined;
+}): {
+  isDragging: boolean;
+  draggable: boolean;
+  onDragStart: DragEventHandler;
+  onDragEnd: DragEventHandler;
+};
+declare function useDropNode(targetId: string | undefined): {
+  isDropTarget: boolean;
+  onDragEnter: DragEventHandler;
+  onDragOver: DragEventHandler;
+  onDragLeave: DragEventHandler;
+  onDrop: DragEventHandler;
+};
+//#endregion
+//#region src/types/global.d.ts
+interface BrowserReactorModule extends InProcessReactorModule {
+  pg: PGlite;
+}
+interface BrowserReactorClientModule extends InProcessReactorClientModule {
+  kind: "browser";
+  reactorModule: BrowserReactorModule | undefined;
+}
+type WorkerReactorModule = ReactorModule;
+interface WorkerReactorClientModule extends ReactorClientModule {
+  kind: "worker";
+  reactorModule: WorkerReactorModule;
+  adminClient: IWorkerAdminClient;
+  inspector: IInspectorProxy;
+}
+type LOADING = null;
+type PHGlobal = PHGlobalConfig & {
+  loading?: boolean;
+  reactorClientModule?: BrowserReactorClientModule | WorkerReactorClientModule;
+  reactorClient?: IReactorClient;
+  attachmentService?: IAttachmentService;
+  reactorGraphQLClient?: ReactorGraphQLClient | undefined;
+  renown?: IRenown | LOADING;
+  vetraPackageManager?: IPackageManager;
+  drives?: DocumentDriveDocument[];
+  documentCache?: IDocumentCache;
+  selectedDriveId?: string;
+  selectedNodeId?: string;
+  draggingNode?: DraggingNode;
+  modal?: PHModal;
+  selectedTimelineRevision?: string | number | null;
+  revisionHistoryVisible?: boolean;
+  selectedTimelineItem?: TimelineItem | null;
+  packageDiscoveryService?: IPackageDiscoveryService;
+  features?: Map<string, boolean>;
+  toast?: PHToastFn;
+};
+type PHGlobalKey = keyof PHGlobal;
+type PHGlobalValue = PHGlobal[PHGlobalKey];
+type UsePHGlobalValue<TValue extends PHGlobalValue> = () => TValue | undefined;
+type SetPHGlobalValue<TValue extends PHGlobalValue> = (value: TValue | undefined) => void;
+type AddPHGlobalEventHandler = () => void;
+type PHGlobalEventHandlerAdders = Record<PHGlobalKey, AddPHGlobalEventHandler>;
+type SetEvent<TKey extends PHGlobalKey> = CustomEvent<{ [key in TKey]: PHGlobal[TKey] | undefined }>;
+declare global {
+  interface Window {
+    ph?: PHGlobal;
+  }
+  interface WindowEventMap extends GraphQLClientWindowEvents {}
+} //# sourceMappingURL=global.d.ts.map
+//#endregion
+//#region src/hooks/renown.d.ts
+/** Adds an event handler for the renown instance */
+declare const addRenownEventHandler: () => void;
+/** Returns the renown instance */
+declare const useRenown: () => IRenown | LOADING | undefined;
+/** Sets the renown instance */
+declare const setRenown: (value: IRenown | LOADING | undefined) => void;
+/** Returns the DID from the renown instance */
+declare function useDid(): string | undefined;
+/** Returns the current user from the renown instance, subscribing to user events */
+declare function useUser(): User | undefined;
+/** Returns the login status, subscribing to renown status events */
+declare function useLoginStatus(): LoginStatus | "loading" | undefined;
+//#endregion
+//#region src/renown/components/RenownAuthButton.d.ts
+interface RenownAuthButtonProps {
+  className?: string;
+  darkMode?: boolean;
+  loginContent?: ReactNode;
+  userContent?: ReactNode;
+  loadingContent?: ReactNode;
+  children?: (auth: RenownAuth) => ReactNode;
+}
+declare function RenownAuthButton({
+  className,
+  darkMode,
+  loginContent,
+  userContent,
+  loadingContent,
+  children
+}: RenownAuthButtonProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/renown/components/RenownLoginButton.d.ts
+interface RenownLoginButtonProps {
+  onLogin?: () => void;
+  darkMode?: boolean;
+  style?: CSSProperties;
+  className?: string;
+  asChild?: boolean;
+  children?: ReactNode;
+}
+declare function RenownLoginButton({
+  onLogin: onLoginProp,
+  style,
+  className,
+  asChild,
+  children
+}: RenownLoginButtonProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/renown/components/RenownUserButton.d.ts
+interface RenownUserButtonMenuItem {
+  label: string;
+  icon?: ReactNode;
+  onClick: () => void;
+  style?: CSSProperties;
+}
+interface RenownUserButtonProps {
+  address?: string;
+  username?: string;
+  avatarUrl?: string;
+  userId?: string;
+  onDisconnect?: () => void;
+  style?: CSSProperties;
+  className?: string;
+  asChild?: boolean;
+  children?: ReactNode;
+  menuItems?: RenownUserButtonMenuItem[];
+}
+declare function RenownUserButton({
+  address: addressProp,
+  username: usernameProp,
+  avatarUrl: avatarUrlProp,
+  userId: userIdProp,
+  onDisconnect: onDisconnectProp,
+  style,
+  className,
+  asChild,
+  children,
+  menuItems
+}: RenownUserButtonProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/renown/components/icons.d.ts
+interface IconProps {
+  size?: number;
+  width?: number;
+  height?: number;
+  color?: string;
+  style?: CSSProperties;
+  className?: string;
+}
+interface RenownLogoProps extends IconProps {
+  hovered?: boolean;
+}
+declare function RenownLogo({
+  width,
+  height,
+  hovered,
+  color,
+  className
+}: RenownLogoProps): react_jsx_runtime0.JSX.Element;
+declare function CopyIcon({
+  size,
+  color
+}: IconProps): react_jsx_runtime0.JSX.Element;
+declare function DisconnectIcon({
+  size,
+  color
+}: IconProps): react_jsx_runtime0.JSX.Element;
+declare function SpinnerIcon({
+  size,
+  color
+}: IconProps): react_jsx_runtime0.JSX.Element;
+declare function ChevronDownIcon({
+  size,
+  color,
+  style
+}: IconProps): react_jsx_runtime0.JSX.Element;
+declare function UserIcon({
+  size,
+  color
+}: IconProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/renown/crypto.d.ts
+/**
+ * @deprecated Use {@link initRenownCrypto} instead
+ *
+ * Initialize ConnectCrypto
+ * @returns ConnectCrypto instance
+ */
+declare function initConnectCrypto(): Promise<_renown_sdk0.RenownCrypto>;
+/**
+ * Initialize RenownCrypto
+ * @returns RenownCrypto instance
+ */
+declare function initRenownCrypto(): Promise<_renown_sdk0.RenownCrypto>;
+//#endregion
+//#region src/renown/constants.d.ts
+declare const RENOWN_URL = "https://www.renown.id";
+declare const RENOWN_NETWORK_ID = "eip155";
+declare const RENOWN_CHAIN_ID = "1";
+//#endregion
+//#region src/renown/initial-user.d.ts
+interface RenownInitialUserProviderProps {
+  /** User resolved from a verified session cookie (see `verifyRenownSession`). */
+  initialUser?: User;
+  children: ReactNode;
+}
+declare function RenownInitialUserProvider({
+  initialUser,
+  children
+}: RenownInitialUserProviderProps): react_jsx_runtime0.JSX.Element;
+declare function useRenownInitialUser(): User | undefined;
+//#endregion
+//#region src/renown/use-renown-session-cookie.d.ts
+interface RenownSessionCookieOptions {
+  /** Route handler that sets (POST) / clears (DELETE) the session cookie. */
+  endpoint?: string;
+  /** Bearer-token lifetime in seconds (default 7 days). */
+  expiresIn?: number;
+  /** When false the hook is inert (client-only apps with no server cookie). */
+  enabled?: boolean;
+}
+interface RenownSessionCookieState {
+  /** True once the cookie reflects the current authenticated user. */
+  synced: boolean;
+}
+declare function useRenownSessionCookie(options?: RenownSessionCookieOptions): RenownSessionCookieState;
+declare function useRenownSessionSynced(): boolean;
+//#endregion
+//#region src/renown/use-renown-init.d.ts
+interface RenownInitOptions {
+  appName: string;
+  /** Prefix for localStorage keys, so multiple apps can share a domain. */
+  namespace?: string;
+  url?: string;
+  switchboardUrl?: string;
+  /** Re-check the restored credential against the source (default "always"). */
+  revalidate?: "always" | "never";
+}
+/**
+ * Hook that initializes the Renown SDK.
+ * Call once at the top of your app. Options are read only on first mount.
+ * Returns a promise that resolves with the Renown instance.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const renownPromise = useRenownInit({ appName: "my-app" });
+ *   return <MyApp />;
+ * }
+ * ```
+ */
+declare function useRenownInit({
+  appName,
+  namespace,
+  url,
+  switchboardUrl,
+  revalidate
+}: RenownInitOptions): Promise<IRenown>;
+//#endregion
+//#region src/renown/renown-init.d.ts
+interface RenownProps extends RenownInitOptions {
+  onError?: (error: unknown) => void;
+}
+/**
+ * Side-effect component that initializes the Renown SDK.
+ * Renders nothing — place it alongside your app tree.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <>
+ *       <Renown appName="my-app" onError={console.error} />
+ *       <MyApp />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function Renown({
+  onError,
+  ...initOptions
+}: RenownProps): null;
+//#endregion
+//#region src/renown/provider.d.ts
+interface RenownProviderProps {
+  appName: string;
+  /** Prefix for localStorage keys, so multiple apps can share a domain. */
+  namespace?: string;
+  url?: string;
+  switchboardUrl?: string;
+  /** Wallet adapters for in-page sign-in; omit for redirect-only. */
+  adapters?: WalletAdaptersConfig;
+  theme?: WalletTheme;
+  /** Re-check the restored credential against the source (default "always"). */
+  revalidate?: "always" | "never";
+  /** Server-resolved session (SSR); its presence seeds from the cookie + enables cookie sync. Omit for client-only (seed = localStorage). */
+  session?: {
+    user?: User;
+  } | null;
+  /** Endpoint for the session-cookie sync (SSR). Default /api/renown/session. */
+  sessionEndpoint?: string;
+  onError?: (error: unknown) => void;
+  children: ReactNode;
+}
+declare function RenownProvider({
+  appName,
+  namespace,
+  url,
+  switchboardUrl,
+  adapters,
+  theme,
+  revalidate,
+  session,
+  sessionEndpoint,
+  onError,
+  children
+}: RenownProviderProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/renown/wallet-provider.d.ts
+interface RenownWalletProviderProps {
+  /** Per-adapter wallet config (e.g. `connect.renown.adapters`); a key's presence enables that adapter. Libraries load lazily on first login; `undefined`/empty = redirect-only. */
+  adapters: WalletAdaptersConfig | undefined;
+  /** Theme handed to each adapter UI: `"light"`, `"dark"`, or `{ mode, accentColor?, accentColorForeground? }`. */
+  theme?: WalletTheme;
+  children: ReactNode;
+}
+/** Drop-in provider for Renown in-page wallet sign-in: registers the login activator, lazy-mounts the configured adapters on first click, and merges their controllers for {@link useRenownAuth}. Full walkthrough + examples: the `@powerhousedao/reactor-browser` README ("Renown in-page sign-in") and the Academy Renown authentication guide. Pair with {@link useRenownLoginMethods} to build the login UI. */
+declare function RenownWalletProvider({
+  adapters: adaptersConfig,
+  theme,
+  children
+}: RenownWalletProviderProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/renown/login-methods.d.ts
+interface RenownLoginMethod {
+  id: LoginMethod;
+  label: string;
+}
+/** Derive the offered login methods (wallet + Privy's methods) from an adapters config, for building a login UI. Reads config only — no wallet libraries load. Wire each to `useRenownAuth().login(undefined, id)`. Labels are overridable. See the reactor-browser README + Academy Renown auth guide. */
+declare function useRenownLoginMethods(adapters: WalletAdaptersConfig | undefined, labels?: Partial<Record<LoginMethod, string>>): RenownLoginMethod[];
+//#endregion
+export { PHGlobalEventHandlerAdders as $, RenownAuth as $t, CopyIcon as A, PHAppConfig as At, RenownAuthButton as B, PHGlobalConfig as Bt, RENOWN_CHAIN_ID as C, FailedInstallation as Ct, initConnectCrypto as D, PHModal as Dt, VERIFIABLE_CREDENTIAL_EIP712_TYPE as E, PendingInstallation as Et, RenownUserButton as F, PHDocumentEditorConfig as Ft, useLoginStatus as G, PHGlobalConfigSettersForKey as Gt, addRenownEventHandler as H, PHGlobalConfigHooksForKey as Ht, RenownUserButtonMenuItem as I, PHDocumentEditorConfigHooks as It, AddPHGlobalEventHandler as J, PHRenownGlobalConfig as Jt, useRenown as K, PHProcessorsGlobalConfig as Kt, RenownUserButtonProps as L, PHDocumentEditorConfigKey as Lt, RenownLogo as M, PHAppConfigKey as Mt, SpinnerIcon as N, PHAppConfigSetters as Nt, initRenownCrypto as O, FullPHGlobalConfig as Ot, UserIcon as P, PHCommonGlobalConfig as Pt, PHGlobal as Q, openRenown as Qt, RenownLoginButton as R, PHDocumentEditorConfigSetters as Rt, ISSUER_TYPE as S, DiscoveryEventListener as St, RENOWN_URL as T, IPackageDiscoveryService as Tt, setRenown as U, PHGlobalConfigKey as Ut, RenownAuthButtonProps as V, PHGlobalConfigHooks as Vt, useDid as W, PHGlobalConfigSetters as Wt, BrowserReactorModule as X, login as Xt, BrowserReactorClientModule as Y, PHSentryGlobalConfig as Yt, LOADING as Z, logout as Zt, useRenownInitialUser as _, PHToastType as _t, RenownProvider as a, DocumentDispatch as an, WorkerReactorClientModule as at, CREDENTIAL_TYPES as b, TimelineItem as bt, RenownProps as c, PromiseState as cn, addDraggingNodeEventHandler as ct, RenownSessionCookieOptions as d, IPackageListerUnsubscribe as dt, RenownAuthAsync as en, PHGlobalKey as et, RenownSessionCookieState as f, IPackageManager as ft, RenownInitialUserProviderProps as g, PHToastOptions as gt, RenownInitialUserProvider as h, PHToastFn as ht, RenownWalletProviderProps as i, useRenownAuthAsync as in, UsePHGlobalValue as it, DisconnectIcon as j, PHAppConfigHooks as jt, ChevronDownIcon as k, PHAnalyticsGlobalConfig as kt, RenownInitOptions as l, PromiseWithState as ln, useDragNode as lt, useRenownSessionSynced as m, PackageManagerInstallResult as mt, useRenownLoginMethods as n, RenownAuthStatus as nn, SetEvent as nt, RenownProviderProps as o, FulfilledPromise as on, WorkerReactorModule as ot, useRenownSessionCookie as p, IPackagesListener as pt, useUser as q, PHRelationalProcessorsGlobalConfig as qt, RenownWalletProvider as r, useRenownAuth as rn, SetPHGlobalValue as rt, Renown as s, IDocumentCache as sn, DraggingNode as st, RenownLoginMethod as t, RenownAuthResolution as tn, PHGlobalValue as tt, useRenownInit as u, RejectedPromise as un, useDropNode as ut, CREDENTIAL_SCHEMA_EIP712_TYPE as v, TimelineBarItem as vt, RENOWN_NETWORK_ID as w, FailedInstallationReason as wt, DOMAIN_TYPE as x, DiscoveryEvent as xt, CREDENTIAL_SUBJECT_TYPE as y, TimelineDividerItem as yt, RenownLoginButtonProps as z, PHDrivesGlobalConfig as zt };
+//# sourceMappingURL=index-Cj_YGHcz.d.ts.map