@powerhousedao/reactor-browser 6.0.0-dev.11 → 6.0.0-dev.110

package/dist/index.d.ts

@@ -0,0 +1,2719 @@
+import { PHDocumentController } from "document-model";
+import { Action, Author, DocumentAction, DocumentModelLib, DocumentModelModule, DocumentModelPHState, DocumentModelUtils, DocumentOperations, DocumentSpecification, EditorModule, ISigner, ImportScriptModule, Manifest, Operation, PHBaseState, PHDocument as PHDocument$1, PHDocumentHeader, Reducer, SubgraphModule, UpgradeManifest, ValidationError } from "@powerhousedao/shared/document-model";
+import * as _powerhousedao_shared_document_drive0 from "@powerhousedao/shared/document-drive";
+import { DocumentDriveAction, DocumentDriveDocument, DriveInput, FileNode, FolderNode, Node, SharingType } from "@powerhousedao/shared/document-drive";
+import * as _powerhousedao_reactor0 from "@powerhousedao/reactor";
+import { ChannelScheme, ConnectionState, ConnectionStateSnapshot, ConnectionStateSnapshot as ConnectionStateSnapshot$1, Database, Database as Database$1, DocumentChangeType, DocumentIntegrityService, GqlRequestChannel, IChannel, IDocumentModelLoader, IDocumentModelRegistry, IProcessor, IProcessorHostModule, IReactorClient, IRelationalDb, ISyncManager, InMemoryQueue, IntervalPollTimer, Job, JwtHandler, KeyframeValidationIssue, OperationWithContext, ParsedDriveUrl, ProcessorFactory, ProcessorFilter, ProcessorRecord, REACTOR_SCHEMA, ReactorBuilder, ReactorClientBuilder, ReactorClientModule, RebuildResult, RelationalDbProcessor, Remote, SignerConfig, SnapshotValidationIssue, SyncOperation, SyncOperationStatus, ValidationResult, driveCollectionId, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
+import { BrowserAnalyticsStore, BrowserAnalyticsStoreOptions } from "@powerhousedao/analytics-engine-browser";
+import { AnalyticsPath, AnalyticsQuery, AnalyticsQueryEngine, AnalyticsSeries, AnalyticsSeriesInput, AnalyticsSeriesQuery, GroupedPeriodResults, IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import { QueryClient, UseMutationOptions, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+import { CSSProperties, PropsWithChildren, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { GraphQLClient, RequestOptions } from "graphql-request";
+import * as _renown_sdk0 from "@renown/sdk";
+import { IRenown, LoginStatus, User } from "@renown/sdk";
+import { CompiledQuery, Kysely } from "kysely";
+import * as _powerhousedao_reactor_browser0 from "@powerhousedao/reactor-browser";
+import { AddPHGlobalEventHandler as AddPHGlobalEventHandler$1, BrowserReactorClientModule as BrowserReactorClientModule$1, DocumentDispatch as DocumentDispatch$1, PHDocumentEditorConfig as PHDocumentEditorConfig$1, PHDocumentEditorConfigHooks as PHDocumentEditorConfigHooks$1, PHDocumentEditorConfigKey as PHDocumentEditorConfigKey$1, PHDocumentEditorConfigSetters as PHDocumentEditorConfigSetters$1, PHDriveEditorConfig as PHDriveEditorConfig$1, PHDriveEditorConfigHooks as PHDriveEditorConfigHooks$1, PHDriveEditorConfigKey as PHDriveEditorConfigKey$1, PHDriveEditorConfigSetters as PHDriveEditorConfigSetters$1, PHGlobal as PHGlobal$1, PHGlobalConfig as PHGlobalConfig$1, PHGlobalConfigHooks as PHGlobalConfigHooks$1, PHGlobalConfigKey as PHGlobalConfigKey$1, PHGlobalConfigSetters as PHGlobalConfigSetters$1, PHGlobalKey as PHGlobalKey$1, PHModal as PHModal$1, QueryCallbackReturnType as QueryCallbackReturnType$1, SetPHGlobalValue as SetPHGlobalValue$1, UsePHGlobalValue as UsePHGlobalValue$1, VetraDocumentModelModule as VetraDocumentModelModule$1, VetraEditorModule as VetraEditorModule$1, VetraPackage as VetraPackage$1, VetraPackageManifest as VetraPackageManifest$1, useRelationalQueryOptions as useRelationalQueryOptions$1 } from "@powerhousedao/reactor-browser";
+import { LiveNamespace, LiveQueryResults, PGliteWithLive } from "@electric-sql/pglite/live";
+import { IRelationalDb as IRelationalDb$1, IRelationalQueryBuilder, ProcessorFactoryBuilder, ProcessorRecord as ProcessorRecord$1, RelationalDbProcessorClass } from "@powerhousedao/shared/processors";
+import { PackageInfo, RegistryPackageSource } from "@powerhousedao/shared/registry";
+import { PGlite } from "@electric-sql/pglite";
+
+//#region src/actions/dispatch.d.ts
+/**
+ * Dispatches actions to a document.
+ * @param actionOrActions - The action or actions to dispatch.
+ * @param document - The document to dispatch actions to.
+ * @param onErrors - Callback invoked with any errors that occurred during action execution.
+ * @returns The updated document, or undefined if the dispatch failed.
+ */
+declare function dispatchActions<TDocument = PHDocument$1, TAction = Action>(actionOrActions: TAction[] | TAction | undefined, document: TDocument | undefined, onErrors?: (errors: Error[]) => void, onSuccess?: (result: PHDocument$1) => void): Promise<PHDocument$1 | undefined>;
+/**
+ * Dispatches actions to a document.
+ * @param actionOrActions - The action or actions to dispatch.
+ * @param documentId - The ID of the document to dispatch actions to.
+ * @param onErrors - Callback invoked with any errors that occurred during action execution.
+ * @returns The updated document, or undefined if the dispatch failed.
+ */
+declare function dispatchActions(actionOrActions: Action[] | Action | undefined, documentId: string, onErrors?: (errors: Error[]) => void, onSuccess?: (result: PHDocument$1) => void): Promise<PHDocument$1 | undefined>;
+//#endregion
+//#region src/actions/document.d.ts
+declare function exportFile(document: PHDocument$1, suggestedName?: string): Promise<void | FileSystemFileHandle>;
+declare function addDocument(driveId: string, name: string, documentType: string, parentFolder?: string, document?: PHDocument$1, id?: string, preferredEditor?: string): Promise<{
+  id: string;
+  name: string;
+  documentType: string;
+  parentFolder: string | null;
+  kind: "file";
+}>;
+declare function addFolder(driveId: string, name: string, parentFolder?: string): Promise<_powerhousedao_shared_document_drive0.FolderNode>;
+declare function deleteNode(driveId: string, nodeId: string): Promise<void>;
+declare function renameDriveNode(driveId: string, nodeId: string, name: string): Promise<Node | undefined>;
+//#endregion
+//#region src/actions/drive.d.ts
+declare function addDrive(input: DriveInput, preferredEditor?: string): Promise<PHDocument$1<any>>;
+declare function addRemoteDrive(url: string, driveId?: string): Promise<string>;
+declare function deleteDrive(driveId: string): Promise<void>;
+declare function renameDrive(driveId: string, name: string): Promise<PHDocument$1 | undefined>;
+declare function setDriveAvailableOffline(driveId: string, availableOffline: boolean): Promise<PHDocument$1 | undefined>;
+declare function setDriveSharingType(driveId: string, sharingType: SharingType): Promise<PHDocument$1 | undefined>;
+//#endregion
+//#region src/analytics/context.d.ts
+type CreateStoreOptions = BrowserAnalyticsStoreOptions;
+declare const analyticsOptionsKey: readonly ["analytics", "options"];
+declare const analyticsStoreKey: readonly ["analytics", "store"];
+declare const analyticsEngineKey: readonly ["analytics", "store"];
+declare function createAnalyticsStore(options: CreateStoreOptions): Promise<{
+  store: BrowserAnalyticsStore;
+  engine: AnalyticsQueryEngine;
+  options: BrowserAnalyticsStoreOptions;
+}>;
+declare function getAnalyticsStore(): Promise<IAnalyticsStore | null>;
+declare function useAnalyticsStoreOptions(): BrowserAnalyticsStoreOptions | undefined;
+declare function useCreateAnalyticsStore(options?: CreateStoreOptions): _tanstack_react_query0.UseMutationResult<IAnalyticsStore | null, Error, void, unknown>;
+declare function useAnalyticsStoreQuery(options?: CreateStoreOptions): _tanstack_react_query0.UseSuspenseQueryResult<IAnalyticsStore | null, Error>;
+declare function useAnalyticsStore(options?: CreateStoreOptions): IAnalyticsStore | null;
+declare function useAnalyticsStoreAsync(options?: CreateStoreOptions): _tanstack_react_query0.UseQueryResult<IAnalyticsStore | null, Error>;
+interface BaseAnalyticsProviderProps extends PropsWithChildren {
+  /**
+   * Custom QueryClient instance
+   * @default undefined
+   */
+  queryClient?: QueryClient;
+}
+type CreateAnalyticsStoreProps = {
+  options?: CreateStoreOptions;
+} | {
+  databaseName?: string;
+};
+type AnalyticsProviderProps = BaseAnalyticsProviderProps & CreateAnalyticsStoreProps;
+declare function AnalyticsProvider({
+  children,
+  queryClient,
+  ...props
+}: AnalyticsProviderProps): react_jsx_runtime0.JSX.Element;
+declare function useAnalyticsEngine(): AnalyticsQueryEngine | undefined;
+declare function useAnalyticsEngineAsync(): _tanstack_react_query0.UseQueryResult<AnalyticsQueryEngine, Error>;
+//#endregion
+//#region src/analytics/hooks/analytics-query.d.ts
+type UseAnalyticsQueryOptions<TData = GroupedPeriodResults> = Omit<UseQueryOptions<GroupedPeriodResults, Error, TData>, "queryKey" | "queryFn"> & {
+  sources?: AnalyticsPath[];
+};
+type UseAnalyticsQueryResult<TData = GroupedPeriodResults> = UseQueryResult<TData>;
+declare function useAnalyticsQuery<TData = GroupedPeriodResults>(query: AnalyticsQuery, options?: UseAnalyticsQueryOptions<TData>): UseAnalyticsQueryResult<TData>;
+type UseAnalyticsSeriesOptions = Omit<UseQueryOptions<AnalyticsSeries[], Error, AnalyticsSeries[]>, "queryKey" | "queryFn">;
+declare function useAnalyticsSeries(query: AnalyticsSeriesQuery, options?: UseAnalyticsSeriesOptions): UseQueryResult<AnalyticsSeries[], Error>;
+type UseAddSeriesValueOptions = Omit<UseMutationOptions<void, Error, AnalyticsSeriesInput>, "mutationKey" | "mutationFn">;
+declare function useAddSeriesValue(options?: UseAddSeriesValueOptions): _tanstack_react_query0.UseMutationResult<void, Error, AnalyticsSeriesInput, unknown>;
+type UseClearSeriesBySourceOptions = Omit<UseMutationOptions<number, Error, {
+  source: AnalyticsPath;
+  cleanUpDimensions?: boolean;
+}>, "mutationKey" | "mutationFn">;
+declare function useClearSeriesBySource(options?: UseClearSeriesBySourceOptions): _tanstack_react_query0.UseMutationResult<number, Error, {
+  source: AnalyticsPath;
+  cleanUpDimensions?: boolean;
+}, unknown>;
+type UseClearEmptyAnalyticsDimensionsOptions = Omit<UseMutationOptions<number>, "mutationKey" | "mutationFn">;
+declare function useClearEmptyAnalyticsDimensions(options?: UseClearEmptyAnalyticsDimensionsOptions): _tanstack_react_query0.UseMutationResult<number, Error, void, unknown>;
+type UseAddSeriesValuesOptions = Omit<UseMutationOptions<void, Error, AnalyticsSeriesInput[]>, "mutationKey" | "mutationFn">;
+declare function useAddSeriesValues(options?: UseAddSeriesValuesOptions): _tanstack_react_query0.UseMutationResult<void, Error, AnalyticsSeriesInput[], unknown>;
+type UseGetDimensionsOptions<TData> = Omit<UseQueryOptions<any, Error, TData>, "queryKey" | "queryFn">;
+declare function useGetDimensions<TData = any>(options?: UseGetDimensionsOptions<TData>): UseQueryResult<_tanstack_react_query0.NoInfer<TData>, Error>;
+type UseMatchingSeriesOptions = Omit<UseQueryOptions<AnalyticsSeries[], Error, AnalyticsSeries[]>, "queryKey" | "queryFn">;
+declare function useMatchingSeries(query: AnalyticsSeriesQuery, options?: UseMatchingSeriesOptions): UseQueryResult<AnalyticsSeries[], Error>;
+type UseQuerySourcesOptions = Omit<UseQueryOptions<AnalyticsPath[] | undefined>, "queryKey" | "queryFn">;
+declare function useQuerySources(query: AnalyticsSeriesQuery, options?: UseQuerySourcesOptions): UseQueryResult<AnalyticsPath[] | undefined, Error>;
+//#endregion
+//#region src/analytics/hooks/document-timeline.d.ts
+declare function useDocumentTimeline(documentId?: string): ({
+  id: string;
+  type: "bar";
+  addSize: 0 | 1 | 2 | 3 | 4;
+  delSize: 0 | 1 | 2 | 3 | 4;
+  additions: number;
+  deletions: number;
+  timestampUtcMs: string;
+  startDate: Date;
+  endDate: Date;
+  revision?: number;
+} | {
+  id: string;
+  type: "divider";
+  revision?: number;
+  startDate?: Date;
+  endDate?: Date;
+})[];
+//#endregion
+//#region src/analytics/hooks/timeline-items.d.ts
+type BarItem = {
+  id: string;
+  type: "bar";
+  addSize: 0 | 1 | 2 | 3 | 4;
+  delSize: 0 | 1 | 2 | 3 | 4;
+  additions: number;
+  deletions: number;
+  timestampUtcMs: string;
+  startDate: Date;
+  endDate: Date;
+  revision?: number;
+};
+type DividerItem = {
+  id: string;
+  type: "divider";
+  revision?: number;
+  startDate?: Date;
+  endDate?: Date;
+};
+type TimelineItem$1 = BarItem | DividerItem;
+type UseTimelineItemsResult = UseAnalyticsQueryResult<TimelineItem$1[]>;
+declare const useTimelineItems: (documentId?: string, startTimestamp?: string, driveId?: string) => UseTimelineItemsResult;
+//#endregion
+//#region src/analytics/types.d.ts
+type IAnalyticsStoreOptions = BrowserAnalyticsStoreOptions;
+type IPowerhouseAnalytics = {
+  store: IAnalyticsStore;
+  engine: AnalyticsQueryEngine;
+  options: IAnalyticsStoreOptions;
+};
+//#endregion
+//#region src/constants.d.ts
+declare const DEFAULT_DRIVE_EDITOR_ID = "powerhouse/generic-drive-explorer";
+declare const COMMON_PACKAGE_ID = "powerhouse/common";
+//#endregion
+//#region src/types/documents.d.ts
+type DocumentDispatch<TAction extends Action> = (actionOrActions: TAction | TAction[] | DocumentAction | DocumentAction[] | undefined, onErrors?: (errors: Error[]) => void, onSuccess?: (result: PHDocument$1) => 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$1>;
+  getBatch(ids: string[], refetch?: boolean): Promise<PHDocument$1[]>;
+  subscribe(id: string | string[], callback: () => void): () => void;
+}
+//#endregion
+//#region src/document-cache.d.ts
+declare function addPromiseState<T>(promise: Promise<T>): PromiseWithState<T>;
+declare function readPromiseState<T>(promise: Promise<T> | PromiseWithState<T>): PromiseState<T>;
+/**
+ * Document cache implementation that uses the new ReactorClient API.
+ *
+ * This cache subscribes to document change events via IReactorClient.subscribe()
+ * and automatically updates the cache when documents are created, updated, or deleted.
+ */
+declare class DocumentCache implements IDocumentCache {
+  private client;
+  private documents;
+  private batchPromises;
+  private listeners;
+  private unsubscribe;
+  constructor(client: IReactorClient);
+  private handleDocumentChange;
+  private handleDocumentDeleted;
+  private handleDocumentUpdated;
+  private invalidateBatchesContaining;
+  get(id: string, refetch?: boolean): Promise<PHDocument$1>;
+  getBatch(ids: string[]): Promise<PHDocument$1[]>;
+  subscribe(id: string | string[], callback: () => void): () => void;
+  /**
+   * Disposes of the cache and unsubscribes from document change events.
+   */
+  dispose(): void;
+}
+//#endregion
+//#region src/document-model.d.ts
+declare const baseDocumentModelsMap: Record<string, DocumentModelModule<DocumentModelPHState>>;
+declare const baseDocumentModels: DocumentModelModule<DocumentModelPHState>[];
+//#endregion
+//#region src/global/types.d.ts
+interface PGliteState {
+  db: PGliteWithLive | null;
+  isLoading: boolean;
+  error: Error | null;
+}
+interface PowerhouseGlobal {
+  analytics?: Promise<IPowerhouseAnalytics>;
+  pglite?: PGliteState;
+}
+declare global {
+  interface Window {
+    powerhouse?: PowerhouseGlobal;
+  }
+} //# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/global/core.d.ts
+declare function getGlobal<K extends keyof PowerhouseGlobal>(namespace: K): PowerhouseGlobal[K] | undefined;
+declare function setGlobal<K extends keyof PowerhouseGlobal>(namespace: K, value: PowerhouseGlobal[K]): void;
+declare function clearGlobal(namespace: keyof PowerhouseGlobal): void;
+//#endregion
+//#region src/graphql/gen/schema.d.ts
+type InputMaybe<T> = T | null | undefined;
+type Exact<T extends {
+  [key: string]: unknown;
+}> = { [K in keyof T]: T[K] };
+type GraphQLClientRequestHeaders = RequestOptions["requestHeaders"];
+/** All built-in and custom scalars, mapped to their actual values */
+type Scalars = {
+  ID: {
+    input: string;
+    output: string;
+  };
+  String: {
+    input: string;
+    output: string;
+  };
+  Boolean: {
+    input: boolean;
+    output: boolean;
+  };
+  Int: {
+    input: number;
+    output: number;
+  };
+  Float: {
+    input: number;
+    output: number;
+  };
+  DateTime: {
+    input: string | Date;
+    output: string | Date;
+  };
+  JSONObject: {
+    input: NonNullable<unknown>;
+    output: NonNullable<unknown>;
+  };
+};
+type ActionContextInput = {
+  readonly signer?: InputMaybe<ReactorSignerInput>;
+};
+type ActionInput = {
+  readonly attachments?: InputMaybe<ReadonlyArray<AttachmentInput>>;
+  readonly context?: InputMaybe<ActionContextInput>;
+  readonly id: Scalars["String"]["input"];
+  readonly input: Scalars["JSONObject"]["input"];
+  readonly scope: Scalars["String"]["input"];
+  readonly timestampUtcMs: Scalars["String"]["input"];
+  readonly type: Scalars["String"]["input"];
+};
+type AttachmentInput = {
+  readonly data: Scalars["String"]["input"];
+  readonly extension?: InputMaybe<Scalars["String"]["input"]>;
+  readonly fileName?: InputMaybe<Scalars["String"]["input"]>;
+  readonly hash: Scalars["String"]["input"];
+  readonly mimeType: Scalars["String"]["input"];
+};
+type ChannelMetaInput = {
+  readonly id: Scalars["String"]["input"];
+};
+declare enum DocumentChangeType$2 {
+  ChildAdded = "CHILD_ADDED",
+  ChildRemoved = "CHILD_REMOVED",
+  Created = "CREATED",
+  Deleted = "DELETED",
+  ParentAdded = "PARENT_ADDED",
+  ParentRemoved = "PARENT_REMOVED",
+  Updated = "UPDATED"
+}
+type DocumentOperationsFilterInput = {
+  readonly actionTypes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  readonly branch?: InputMaybe<Scalars["String"]["input"]>;
+  readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  readonly sinceRevision?: InputMaybe<Scalars["Int"]["input"]>;
+  readonly timestampFrom?: InputMaybe<Scalars["String"]["input"]>;
+  readonly timestampTo?: InputMaybe<Scalars["String"]["input"]>;
+};
+type OperationContextInput = {
+  readonly branch: Scalars["String"]["input"];
+  readonly documentId: Scalars["String"]["input"];
+  readonly documentType: Scalars["String"]["input"];
+  readonly ordinal: Scalars["Int"]["input"];
+  readonly scope: Scalars["String"]["input"];
+};
+type OperationInput = {
+  readonly action: ActionInput;
+  readonly error?: InputMaybe<Scalars["String"]["input"]>;
+  readonly hash: Scalars["String"]["input"];
+  readonly id?: InputMaybe<Scalars["String"]["input"]>;
+  readonly index: Scalars["Int"]["input"];
+  readonly skip: Scalars["Int"]["input"];
+  readonly timestampUtcMs: Scalars["String"]["input"];
+};
+type OperationWithContextInput = {
+  readonly context: OperationContextInput;
+  readonly operation: OperationInput;
+};
+type OperationsFilterInput = {
+  readonly actionTypes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  readonly branch?: InputMaybe<Scalars["String"]["input"]>;
+  readonly documentId: Scalars["String"]["input"];
+  readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  readonly sinceRevision?: InputMaybe<Scalars["Int"]["input"]>;
+  readonly timestampFrom?: InputMaybe<Scalars["String"]["input"]>;
+  readonly timestampTo?: InputMaybe<Scalars["String"]["input"]>;
+};
+type PagingInput = {
+  readonly cursor?: InputMaybe<Scalars["String"]["input"]>;
+  readonly limit?: InputMaybe<Scalars["Int"]["input"]>;
+  readonly offset?: InputMaybe<Scalars["Int"]["input"]>;
+};
+declare enum PropagationMode {
+  Cascade = "CASCADE",
+  Orphan = "ORPHAN"
+}
+type ReactorSignerAppInput = {
+  readonly key: Scalars["String"]["input"];
+  readonly name: Scalars["String"]["input"];
+};
+type ReactorSignerInput = {
+  readonly app?: InputMaybe<ReactorSignerAppInput>;
+  readonly signatures: ReadonlyArray<Scalars["String"]["input"]>;
+  readonly user?: InputMaybe<ReactorSignerUserInput>;
+};
+type ReactorSignerUserInput = {
+  readonly address: Scalars["String"]["input"];
+  readonly chainId: Scalars["Int"]["input"];
+  readonly networkId: Scalars["String"]["input"];
+};
+type RemoteCursorInput = {
+  readonly cursorOrdinal: Scalars["Int"]["input"];
+  readonly lastSyncedAtUtcMs?: InputMaybe<Scalars["String"]["input"]>;
+  readonly remoteName: Scalars["String"]["input"];
+};
+type RemoteFilterInput = {
+  readonly branch: Scalars["String"]["input"];
+  readonly documentId: ReadonlyArray<Scalars["String"]["input"]>;
+  readonly scope: ReadonlyArray<Scalars["String"]["input"]>;
+};
+type SearchFilterInput = {
+  readonly identifiers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  readonly parentId?: InputMaybe<Scalars["String"]["input"]>;
+  readonly type?: InputMaybe<Scalars["String"]["input"]>;
+};
+type SyncEnvelopeInput = {
+  readonly channelMeta: ChannelMetaInput;
+  readonly cursor?: InputMaybe<RemoteCursorInput>;
+  readonly dependsOn?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  readonly key?: InputMaybe<Scalars["String"]["input"]>;
+  readonly operations?: InputMaybe<ReadonlyArray<OperationWithContextInput>>;
+  readonly type: SyncEnvelopeType;
+};
+declare enum SyncEnvelopeType {
+  Ack = "ACK",
+  Operations = "OPERATIONS"
+}
+type TouchChannelInput = {
+  readonly collectionId: Scalars["String"]["input"];
+  readonly filter: RemoteFilterInput;
+  readonly id: Scalars["String"]["input"];
+  readonly name: Scalars["String"]["input"];
+  readonly sinceTimestampUtcMs: Scalars["String"]["input"];
+};
+type ViewFilterInput = {
+  readonly branch?: InputMaybe<Scalars["String"]["input"]>;
+  readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+};
+type PhDocumentFieldsFragment = {
+  readonly id: string;
+  readonly slug?: string | null | undefined;
+  readonly name: string;
+  readonly documentType: string;
+  readonly state: NonNullable<unknown>;
+  readonly createdAtUtcIso: string | Date;
+  readonly lastModifiedAtUtcIso: string | Date;
+  readonly revisionsList: ReadonlyArray<{
+    readonly scope: string;
+    readonly revision: number;
+  }>;
+};
+type GetDocumentModelsQueryVariables = Exact<{
+  namespace?: InputMaybe<Scalars["String"]["input"]>;
+  paging?: InputMaybe<PagingInput>;
+}>;
+type GetDocumentModelsQuery = {
+  readonly documentModels: {
+    readonly totalCount: number;
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly cursor?: string | null | undefined;
+    readonly items: ReadonlyArray<{
+      readonly id: string;
+      readonly name: string;
+      readonly namespace?: string | null | undefined;
+      readonly version?: string | null | undefined;
+      readonly specification: NonNullable<unknown>;
+    }>;
+  };
+};
+type GetDocumentQueryVariables = Exact<{
+  identifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+}>;
+type GetDocumentQuery = {
+  readonly document?: {
+    readonly childIds: ReadonlyArray<string>;
+    readonly document: {
+      readonly id: string;
+      readonly slug?: string | null | undefined;
+      readonly name: string;
+      readonly documentType: string;
+      readonly state: NonNullable<unknown>;
+      readonly createdAtUtcIso: string | Date;
+      readonly lastModifiedAtUtcIso: string | Date;
+      readonly revisionsList: ReadonlyArray<{
+        readonly scope: string;
+        readonly revision: number;
+      }>;
+    };
+  } | null | undefined;
+};
+type GetDocumentWithOperationsQueryVariables = Exact<{
+  identifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+  operationsFilter?: InputMaybe<DocumentOperationsFilterInput>;
+  operationsPaging?: InputMaybe<PagingInput>;
+}>;
+type GetDocumentWithOperationsQuery = {
+  readonly document?: {
+    readonly childIds: ReadonlyArray<string>;
+    readonly document: {
+      readonly id: string;
+      readonly slug?: string | null | undefined;
+      readonly name: string;
+      readonly documentType: string;
+      readonly state: NonNullable<unknown>;
+      readonly createdAtUtcIso: string | Date;
+      readonly lastModifiedAtUtcIso: string | Date;
+      readonly operations?: {
+        readonly totalCount: number;
+        readonly hasNextPage: boolean;
+        readonly hasPreviousPage: boolean;
+        readonly cursor?: string | null | undefined;
+        readonly items: ReadonlyArray<{
+          readonly index: number;
+          readonly timestampUtcMs: string;
+          readonly hash: string;
+          readonly skip: number;
+          readonly error?: string | null | undefined;
+          readonly id?: string | null | undefined;
+          readonly action: {
+            readonly id: string;
+            readonly type: string;
+            readonly timestampUtcMs: string;
+            readonly input: NonNullable<unknown>;
+            readonly scope: string;
+            readonly attachments?: ReadonlyArray<{
+              readonly data: string;
+              readonly mimeType: string;
+              readonly hash: string;
+              readonly extension?: string | null | undefined;
+              readonly fileName?: string | null | undefined;
+            }> | null | undefined;
+            readonly context?: {
+              readonly signer?: {
+                readonly signatures: ReadonlyArray<string>;
+                readonly user?: {
+                  readonly address: string;
+                  readonly networkId: string;
+                  readonly chainId: number;
+                } | null | undefined;
+                readonly app?: {
+                  readonly name: string;
+                  readonly key: string;
+                } | null | undefined;
+              } | null | undefined;
+            } | null | undefined;
+          };
+        }>;
+      } | null | undefined;
+      readonly revisionsList: ReadonlyArray<{
+        readonly scope: string;
+        readonly revision: number;
+      }>;
+    };
+  } | null | undefined;
+};
+type GetDocumentChildrenQueryVariables = Exact<{
+  parentIdentifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+  paging?: InputMaybe<PagingInput>;
+}>;
+type GetDocumentChildrenQuery = {
+  readonly documentChildren: {
+    readonly totalCount: number;
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly cursor?: string | null | undefined;
+    readonly items: ReadonlyArray<{
+      readonly id: string;
+      readonly slug?: string | null | undefined;
+      readonly name: string;
+      readonly documentType: string;
+      readonly state: NonNullable<unknown>;
+      readonly createdAtUtcIso: string | Date;
+      readonly lastModifiedAtUtcIso: string | Date;
+      readonly revisionsList: ReadonlyArray<{
+        readonly scope: string;
+        readonly revision: number;
+      }>;
+    }>;
+  };
+};
+type GetDocumentParentsQueryVariables = Exact<{
+  childIdentifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+  paging?: InputMaybe<PagingInput>;
+}>;
+type GetDocumentParentsQuery = {
+  readonly documentParents: {
+    readonly totalCount: number;
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly cursor?: string | null | undefined;
+    readonly items: ReadonlyArray<{
+      readonly id: string;
+      readonly slug?: string | null | undefined;
+      readonly name: string;
+      readonly documentType: string;
+      readonly state: NonNullable<unknown>;
+      readonly createdAtUtcIso: string | Date;
+      readonly lastModifiedAtUtcIso: string | Date;
+      readonly revisionsList: ReadonlyArray<{
+        readonly scope: string;
+        readonly revision: number;
+      }>;
+    }>;
+  };
+};
+type FindDocumentsQueryVariables = Exact<{
+  search: SearchFilterInput;
+  view?: InputMaybe<ViewFilterInput>;
+  paging?: InputMaybe<PagingInput>;
+}>;
+type FindDocumentsQuery = {
+  readonly findDocuments: {
+    readonly totalCount: number;
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly cursor?: string | null | undefined;
+    readonly items: ReadonlyArray<{
+      readonly id: string;
+      readonly slug?: string | null | undefined;
+      readonly name: string;
+      readonly documentType: string;
+      readonly state: NonNullable<unknown>;
+      readonly createdAtUtcIso: string | Date;
+      readonly lastModifiedAtUtcIso: string | Date;
+      readonly revisionsList: ReadonlyArray<{
+        readonly scope: string;
+        readonly revision: number;
+      }>;
+    }>;
+  };
+};
+type GetDocumentOperationsQueryVariables = Exact<{
+  filter: OperationsFilterInput;
+  paging?: InputMaybe<PagingInput>;
+}>;
+type GetDocumentOperationsQuery = {
+  readonly documentOperations: {
+    readonly totalCount: number;
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly cursor?: string | null | undefined;
+    readonly items: ReadonlyArray<{
+      readonly index: number;
+      readonly timestampUtcMs: string;
+      readonly hash: string;
+      readonly skip: number;
+      readonly error?: string | null | undefined;
+      readonly id?: string | null | undefined;
+      readonly action: {
+        readonly id: string;
+        readonly type: string;
+        readonly timestampUtcMs: string;
+        readonly input: NonNullable<unknown>;
+        readonly scope: string;
+        readonly attachments?: ReadonlyArray<{
+          readonly data: string;
+          readonly mimeType: string;
+          readonly hash: string;
+          readonly extension?: string | null | undefined;
+          readonly fileName?: string | null | undefined;
+        }> | null | undefined;
+        readonly context?: {
+          readonly signer?: {
+            readonly signatures: ReadonlyArray<string>;
+            readonly user?: {
+              readonly address: string;
+              readonly networkId: string;
+              readonly chainId: number;
+            } | null | undefined;
+            readonly app?: {
+              readonly name: string;
+              readonly key: string;
+            } | null | undefined;
+          } | null | undefined;
+        } | null | undefined;
+      };
+    }>;
+  };
+};
+type GetJobStatusQueryVariables = Exact<{
+  jobId: Scalars["String"]["input"];
+}>;
+type GetJobStatusQuery = {
+  readonly jobStatus?: {
+    readonly id: string;
+    readonly status: string;
+    readonly result: NonNullable<unknown>;
+    readonly error?: string | null | undefined;
+    readonly createdAt: string | Date;
+    readonly completedAt?: string | Date | null | undefined;
+  } | null | undefined;
+};
+type CreateDocumentMutationVariables = Exact<{
+  document: Scalars["JSONObject"]["input"];
+  parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type CreateDocumentMutation = {
+  readonly createDocument: {
+    readonly id: string;
+    readonly slug?: string | null | undefined;
+    readonly name: string;
+    readonly documentType: string;
+    readonly state: NonNullable<unknown>;
+    readonly createdAtUtcIso: string | Date;
+    readonly lastModifiedAtUtcIso: string | Date;
+    readonly revisionsList: ReadonlyArray<{
+      readonly scope: string;
+      readonly revision: number;
+    }>;
+  };
+};
+type CreateEmptyDocumentMutationVariables = Exact<{
+  documentType: Scalars["String"]["input"];
+  parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type CreateEmptyDocumentMutation = {
+  readonly createEmptyDocument: {
+    readonly id: string;
+    readonly slug?: string | null | undefined;
+    readonly name: string;
+    readonly documentType: string;
+    readonly state: NonNullable<unknown>;
+    readonly createdAtUtcIso: string | Date;
+    readonly lastModifiedAtUtcIso: string | Date;
+    readonly revisionsList: ReadonlyArray<{
+      readonly scope: string;
+      readonly revision: number;
+    }>;
+  };
+};
+type MutateDocumentMutationVariables = Exact<{
+  documentIdentifier: Scalars["String"]["input"];
+  actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
+  view?: InputMaybe<ViewFilterInput>;
+}>;
+type MutateDocumentMutation = {
+  readonly mutateDocument: {
+    readonly id: string;
+    readonly slug?: string | null | undefined;
+    readonly name: string;
+    readonly documentType: string;
+    readonly state: NonNullable<unknown>;
+    readonly createdAtUtcIso: string | Date;
+    readonly lastModifiedAtUtcIso: string | Date;
+    readonly revisionsList: ReadonlyArray<{
+      readonly scope: string;
+      readonly revision: number;
+    }>;
+  };
+};
+type MutateDocumentAsyncMutationVariables = Exact<{
+  documentIdentifier: Scalars["String"]["input"];
+  actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
+  view?: InputMaybe<ViewFilterInput>;
+}>;
+type MutateDocumentAsyncMutation = {
+  readonly mutateDocumentAsync: string;
+};
+type RenameDocumentMutationVariables = Exact<{
+  documentIdentifier: Scalars["String"]["input"];
+  name: Scalars["String"]["input"];
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type RenameDocumentMutation = {
+  readonly renameDocument: {
+    readonly id: string;
+    readonly slug?: string | null | undefined;
+    readonly name: string;
+    readonly documentType: string;
+    readonly state: NonNullable<unknown>;
+    readonly createdAtUtcIso: string | Date;
+    readonly lastModifiedAtUtcIso: string | Date;
+    readonly revisionsList: ReadonlyArray<{
+      readonly scope: string;
+      readonly revision: number;
+    }>;
+  };
+};
+type AddChildrenMutationVariables = Exact<{
+  parentIdentifier: Scalars["String"]["input"];
+  documentIdentifiers: ReadonlyArray<Scalars["String"]["input"]>;
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type AddChildrenMutation = {
+  readonly addChildren: {
+    readonly id: string;
+    readonly slug?: string | null | undefined;
+    readonly name: string;
+    readonly documentType: string;
+    readonly state: NonNullable<unknown>;
+    readonly createdAtUtcIso: string | Date;
+    readonly lastModifiedAtUtcIso: string | Date;
+    readonly revisionsList: ReadonlyArray<{
+      readonly scope: string;
+      readonly revision: number;
+    }>;
+  };
+};
+type RemoveChildrenMutationVariables = Exact<{
+  parentIdentifier: Scalars["String"]["input"];
+  documentIdentifiers: ReadonlyArray<Scalars["String"]["input"]>;
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type RemoveChildrenMutation = {
+  readonly removeChildren: {
+    readonly id: string;
+    readonly slug?: string | null | undefined;
+    readonly name: string;
+    readonly documentType: string;
+    readonly state: NonNullable<unknown>;
+    readonly createdAtUtcIso: string | Date;
+    readonly lastModifiedAtUtcIso: string | Date;
+    readonly revisionsList: ReadonlyArray<{
+      readonly scope: string;
+      readonly revision: number;
+    }>;
+  };
+};
+type MoveChildrenMutationVariables = Exact<{
+  sourceParentIdentifier: Scalars["String"]["input"];
+  targetParentIdentifier: Scalars["String"]["input"];
+  documentIdentifiers: ReadonlyArray<Scalars["String"]["input"]>;
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type MoveChildrenMutation = {
+  readonly moveChildren: {
+    readonly source: {
+      readonly id: string;
+      readonly slug?: string | null | undefined;
+      readonly name: string;
+      readonly documentType: string;
+      readonly state: NonNullable<unknown>;
+      readonly createdAtUtcIso: string | Date;
+      readonly lastModifiedAtUtcIso: string | Date;
+      readonly revisionsList: ReadonlyArray<{
+        readonly scope: string;
+        readonly revision: number;
+      }>;
+    };
+    readonly target: {
+      readonly id: string;
+      readonly slug?: string | null | undefined;
+      readonly name: string;
+      readonly documentType: string;
+      readonly state: NonNullable<unknown>;
+      readonly createdAtUtcIso: string | Date;
+      readonly lastModifiedAtUtcIso: string | Date;
+      readonly revisionsList: ReadonlyArray<{
+        readonly scope: string;
+        readonly revision: number;
+      }>;
+    };
+  };
+};
+type DeleteDocumentMutationVariables = Exact<{
+  identifier: Scalars["String"]["input"];
+  propagate?: InputMaybe<PropagationMode>;
+}>;
+type DeleteDocumentMutation = {
+  readonly deleteDocument: boolean;
+};
+type DeleteDocumentsMutationVariables = Exact<{
+  identifiers: ReadonlyArray<Scalars["String"]["input"]>;
+  propagate?: InputMaybe<PropagationMode>;
+}>;
+type DeleteDocumentsMutation = {
+  readonly deleteDocuments: boolean;
+};
+type DocumentChangesSubscriptionVariables = Exact<{
+  search: SearchFilterInput;
+  view?: InputMaybe<ViewFilterInput>;
+}>;
+type DocumentChangesSubscription = {
+  readonly documentChanges: {
+    readonly type: DocumentChangeType$2;
+    readonly documents: ReadonlyArray<{
+      readonly id: string;
+      readonly slug?: string | null | undefined;
+      readonly name: string;
+      readonly documentType: string;
+      readonly state: NonNullable<unknown>;
+      readonly createdAtUtcIso: string | Date;
+      readonly lastModifiedAtUtcIso: string | Date;
+      readonly revisionsList: ReadonlyArray<{
+        readonly scope: string;
+        readonly revision: number;
+      }>;
+    }>;
+    readonly context?: {
+      readonly parentId?: string | null | undefined;
+      readonly childId?: string | null | undefined;
+    } | null | undefined;
+  };
+};
+type JobChangesSubscriptionVariables = Exact<{
+  jobId: Scalars["String"]["input"];
+}>;
+type JobChangesSubscription = {
+  readonly jobChanges: {
+    readonly jobId: string;
+    readonly status: string;
+    readonly result: NonNullable<unknown>;
+    readonly error?: string | null | undefined;
+  };
+};
+type PollSyncEnvelopesQueryVariables = Exact<{
+  channelId: Scalars["String"]["input"];
+  outboxAck: Scalars["Int"]["input"];
+  outboxLatest: Scalars["Int"]["input"];
+}>;
+type PollSyncEnvelopesQuery = {
+  readonly pollSyncEnvelopes: {
+    readonly ackOrdinal: number;
+    readonly envelopes: ReadonlyArray<{
+      readonly type: SyncEnvelopeType;
+      readonly key?: string | null | undefined;
+      readonly dependsOn?: ReadonlyArray<string> | null | undefined;
+      readonly channelMeta: {
+        readonly id: string;
+      };
+      readonly operations?: ReadonlyArray<{
+        readonly operation: {
+          readonly index: number;
+          readonly timestampUtcMs: string;
+          readonly hash: string;
+          readonly skip: number;
+          readonly error?: string | null | undefined;
+          readonly id?: string | null | undefined;
+          readonly action: {
+            readonly id: string;
+            readonly type: string;
+            readonly timestampUtcMs: string;
+            readonly input: NonNullable<unknown>;
+            readonly scope: string;
+            readonly attachments?: ReadonlyArray<{
+              readonly data: string;
+              readonly mimeType: string;
+              readonly hash: string;
+              readonly extension?: string | null | undefined;
+              readonly fileName?: string | null | undefined;
+            }> | null | undefined;
+            readonly context?: {
+              readonly signer?: {
+                readonly signatures: ReadonlyArray<string>;
+                readonly user?: {
+                  readonly address: string;
+                  readonly networkId: string;
+                  readonly chainId: number;
+                } | null | undefined;
+                readonly app?: {
+                  readonly name: string;
+                  readonly key: string;
+                } | null | undefined;
+              } | null | undefined;
+            } | null | undefined;
+          };
+        };
+        readonly context: {
+          readonly documentId: string;
+          readonly documentType: string;
+          readonly scope: string;
+          readonly branch: string;
+        };
+      }> | null | undefined;
+      readonly cursor?: {
+        readonly remoteName: string;
+        readonly cursorOrdinal: number;
+        readonly lastSyncedAtUtcMs?: string | null | undefined;
+      } | null | undefined;
+    }>;
+    readonly deadLetters: ReadonlyArray<{
+      readonly documentId: string;
+      readonly error: string;
+    }>;
+  };
+};
+type TouchChannelMutationVariables = Exact<{
+  input: TouchChannelInput;
+}>;
+type TouchChannelMutation = {
+  readonly touchChannel: boolean;
+};
+type PushSyncEnvelopesMutationVariables = Exact<{
+  envelopes: ReadonlyArray<SyncEnvelopeInput>;
+}>;
+type PushSyncEnvelopesMutation = {
+  readonly pushSyncEnvelopes: boolean;
+};
+type SdkFunctionWrapper = <T>(action: (requestHeaders?: Record<string, string>) => Promise<T>, operationName: string, operationType?: string, variables?: any) => Promise<T>;
+declare function getSdk(client: GraphQLClient, withWrapper?: SdkFunctionWrapper): {
+  GetDocumentModels(variables?: GetDocumentModelsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetDocumentModelsQuery>;
+  GetDocument(variables: GetDocumentQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetDocumentQuery>;
+  GetDocumentWithOperations(variables: GetDocumentWithOperationsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetDocumentWithOperationsQuery>;
+  GetDocumentChildren(variables: GetDocumentChildrenQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetDocumentChildrenQuery>;
+  GetDocumentParents(variables: GetDocumentParentsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetDocumentParentsQuery>;
+  FindDocuments(variables: FindDocumentsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<FindDocumentsQuery>;
+  GetDocumentOperations(variables: GetDocumentOperationsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetDocumentOperationsQuery>;
+  GetJobStatus(variables: GetJobStatusQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetJobStatusQuery>;
+  CreateDocument(variables: CreateDocumentMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<CreateDocumentMutation>;
+  CreateEmptyDocument(variables: CreateEmptyDocumentMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<CreateEmptyDocumentMutation>;
+  MutateDocument(variables: MutateDocumentMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<MutateDocumentMutation>;
+  MutateDocumentAsync(variables: MutateDocumentAsyncMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<MutateDocumentAsyncMutation>;
+  RenameDocument(variables: RenameDocumentMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<RenameDocumentMutation>;
+  AddChildren(variables: AddChildrenMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<AddChildrenMutation>;
+  RemoveChildren(variables: RemoveChildrenMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<RemoveChildrenMutation>;
+  MoveChildren(variables: MoveChildrenMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<MoveChildrenMutation>;
+  DeleteDocument(variables: DeleteDocumentMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<DeleteDocumentMutation>;
+  DeleteDocuments(variables: DeleteDocumentsMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<DeleteDocumentsMutation>;
+  DocumentChanges(variables: DocumentChangesSubscriptionVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<DocumentChangesSubscription>;
+  JobChanges(variables: JobChangesSubscriptionVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<JobChangesSubscription>;
+  PollSyncEnvelopes(variables: PollSyncEnvelopesQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<PollSyncEnvelopesQuery>;
+  TouchChannel(variables: TouchChannelMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<TouchChannelMutation>;
+  PushSyncEnvelopes(variables: PushSyncEnvelopesMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<PushSyncEnvelopesMutation>;
+};
+type Sdk = ReturnType<typeof getSdk>;
+//#endregion
+//#region src/graphql/types.d.ts
+type DocumentOperationsPage = GetDocumentOperationsQuery["documentOperations"];
+type DocumentResult = NonNullable<GetDocumentQuery["document"]>;
+type ReactorGraphQLClient = Pick<Sdk, "GetDocument" | "GetDocumentWithOperations" | "GetDocumentOperations" | "MutateDocument" | "CreateDocument" | "CreateEmptyDocument" | "DeleteDocument"> & {
+  /** Fetch multiple documentOperations in a single request via aliases. */BatchGetDocumentOperations?: (filters: OperationsFilterInput[], pagings: (PagingInput | undefined | null)[]) => Promise<DocumentOperationsPage[]>; /** Fetch a document and multiple documentOperations in a single request. */
+  BatchGetDocumentWithOperations?: (identifier: string, view: ViewFilterInput | undefined, filters: OperationsFilterInput[], pagings: (PagingInput | undefined)[]) => Promise<{
+    document: DocumentResult | null;
+    operations: DocumentOperationsPage[];
+  }>;
+};
+//#endregion
+//#region src/graphql/client.d.ts
+/**
+ * Creates a GraphQL client for the Reactor Subgraph API.
+ * @param urlOrGQLClient The URL of the GraphQL API or a GraphQL client instance.
+ * @param middleware An optional middleware function to wrap the GraphQL client calls.
+ * @returns A GraphQL client for the Reactor Subgraph API.
+ */
+declare function createClient(urlOrGQLClient: string | GraphQLClient, middleware?: SdkFunctionWrapper): ReactorGraphQLClient;
+//#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: () => void;
+  logout: () => Promise<void>;
+  openProfile: () => void;
+}
+declare function useRenownAuth(): RenownAuth;
+//#endregion
+//#region src/hooks/add-ph-event-handlers.d.ts
+declare function addPHEventHandlers(): void;
+//#endregion
+//#region src/types/vetra.d.ts
+type Processors = (module: {
+  analyticsStore: IAnalyticsStore;
+  relationalDb: IRelationalDb$1;
+}) => (driveHeader: PHDocumentHeader) => ProcessorRecord$1[];
+type VetraMeta = {
+  id: string;
+  name: string;
+};
+type VetraModule = Record<string, unknown> & VetraMeta;
+type VetraPackageMeta = {
+  id: string;
+  name: string;
+  description: string;
+  category: string;
+  author: Author;
+};
+type BaseVetraPackage<TModules extends { [K in keyof TModules]: VetraMeta[] }> = VetraPackageMeta & {
+  modules: { [K in keyof TModules]: TModules[K] };
+};
+type VetraDocumentModelModule = VetraMeta & {
+  documentType: string;
+  extension: string;
+  specifications: DocumentSpecification[];
+  reducer: Reducer<any>;
+  actions: Record<string, (input: any) => Action>;
+  utils: DocumentModelUtils<any>;
+  documentModel: DocumentModelPHState;
+  version?: number;
+};
+type VetraEditorModule = VetraMeta & {
+  documentTypes: string[];
+  Component: React.ComponentType<any>;
+};
+type VetraProcessorModule = VetraMeta & {
+  processors: Processors;
+};
+type VetraModules = {
+  documentModelModules?: VetraDocumentModelModule[];
+  editorModules?: VetraEditorModule[];
+  subgraphModules?: SubgraphModule[];
+  importScriptModules?: ImportScriptModule[];
+};
+type VetraPackage = BaseVetraPackage<VetraModules> & {
+  upgradeManifests: UpgradeManifest<readonly number[]>[] | undefined;
+  processorFactory?: ProcessorFactoryBuilder;
+};
+type VetraPackageManifest = VetraPackageMeta & {
+  modules: { [K in keyof VetraModules]: VetraMeta[] };
+};
+type IPackagesListener = (data: {
+  packages: VetraPackage[];
+}) => void;
+type IPackageListerUnsubscribe = () => void;
+type PackageManagerInstallResult = {
+  type: "success";
+  package: VetraPackage;
+} | {
+  type: "error";
+  error: Error;
+};
+interface IPackageManager extends IDocumentModelLoader {
+  registryUrl: string | null;
+  packages: VetraPackage[];
+  addPackage(packageName: string): Promise<PackageManagerInstallResult> | PackageManagerInstallResult;
+  addPackages(packageNames: string[]): Promise<PackageManagerInstallResult[]> | PackageManagerInstallResult[];
+  removePackage(name: string): void;
+  subscribe(handler: IPackagesListener): IPackageListerUnsubscribe;
+  getPackageSource: (packageName: string) => RegistryPackageSource | null;
+}
+//#endregion
+//#region src/hooks/allowed-document-model-modules.d.ts
+declare function useAllowedDocumentModelModules(): VetraDocumentModelModule[] | undefined;
+//#endregion
+//#region src/hooks/child-nodes.d.ts
+/** Returns the child nodes for the selected drive or folder. */
+declare function useNodesInSelectedDriveOrFolder(): Node[];
+//#endregion
+//#region src/hooks/config/connect.d.ts
+declare const useRouterBasename: () => string | undefined, setRouterBasename: (value: string | undefined) => void, addRouterBasenameEventHandler: () => void;
+declare const useVersion: () => string | undefined, setVersion: (value: string | undefined) => void, addVersionEventHandler: () => void;
+declare const useRequiresHardRefresh: () => boolean | undefined, setRequiresHardRefresh: (value: boolean | undefined) => void, addRequiresHardRefreshEventHandler: () => void;
+declare const useWarnOutdatedApp: () => boolean | undefined, setWarnOutdatedApp: (value: boolean | undefined) => void, addWarnOutdatedAppEventHandler: () => void;
+declare const useStudioMode: () => boolean | undefined, setStudioMode: (value: boolean | undefined) => void, addStudioModeEventHandler: () => void;
+declare const useBasePath: () => string | undefined, setBasePath: (value: string | undefined) => void, addBasePathEventHandler: () => void;
+declare const useVersionCheckInterval: () => number | undefined, setVersionCheckInterval: (value: number | undefined) => void, addVersionCheckIntervalEventHandler: () => void;
+declare const useCliVersion: () => string | undefined, setCliVersion: (value: string | undefined) => void, addCliVersionEventHandler: () => void;
+declare const useFileUploadOperationsChunkSize: () => number | undefined, setFileUploadOperationsChunkSize: (value: number | undefined) => void, addFileUploadOperationsChunkSizeEventHandler: () => void;
+declare const useIsDocumentModelSelectionSettingsEnabled: () => boolean | undefined, setIsDocumentModelSelectionSettingsEnabled: (value: boolean | undefined) => void, addIsDocumentModelSelectionSettingsEnabledEventHandler: () => void;
+declare const useGaTrackingId: () => string | undefined, setGaTrackingId: (value: string | undefined) => void, addGaTrackingIdEventHandler: () => void;
+declare const useDefaultDrivesUrl: () => string | undefined, setDefaultDrivesUrl: (value: string | undefined) => void, addDefaultDrivesUrlEventHandler: () => void;
+declare const useDrivesPreserveStrategy: () => string | undefined, setDrivesPreserveStrategy: (value: string | undefined) => void, addDrivesPreserveStrategyEventHandler: () => void;
+declare const useIsLocalDrivesEnabled: () => boolean | undefined, setIsLocalDrivesEnabled: (value: boolean | undefined) => void, addIsLocalDrivesEnabledEventHandler: () => void;
+declare const useIsAddDriveEnabled: () => boolean | undefined, setIsAddDriveEnabled: (value: boolean | undefined) => void, addIsAddDriveEnabledEventHandler: () => void;
+declare const useIsPublicDrivesEnabled: () => boolean | undefined, setIsPublicDrivesEnabled: (value: boolean | undefined) => void, addIsPublicDrivesEnabledEventHandler: () => void;
+declare const useIsAddPublicDrivesEnabled: () => boolean | undefined, setIsAddPublicDrivesEnabled: (value: boolean | undefined) => void, addIsAddPublicDrivesEnabledEventHandler: () => void;
+declare const useIsDeletePublicDrivesEnabled: () => boolean | undefined, setIsDeletePublicDrivesEnabled: (value: boolean | undefined) => void, addIsDeletePublicDrivesEnabledEventHandler: () => void;
+declare const useIsCloudDrivesEnabled: () => boolean | undefined, setIsCloudDrivesEnabled: (value: boolean | undefined) => void, addIsCloudDrivesEnabledEventHandler: () => void;
+declare const useIsAddCloudDrivesEnabled: () => boolean | undefined, setIsAddCloudDrivesEnabled: (value: boolean | undefined) => void, addIsAddCloudDrivesEnabledEventHandler: () => void;
+declare const useIsDeleteCloudDrivesEnabled: () => boolean | undefined, setIsDeleteCloudDrivesEnabled: (value: boolean | undefined) => void, addIsDeleteCloudDrivesEnabledEventHandler: () => void;
+declare const useLocalDrivesEnabled: () => boolean | undefined, setLocalDrivesEnabled: (value: boolean | undefined) => void, addLocalDrivesEnabledEventHandler: () => void;
+declare const useIsAddLocalDrivesEnabled: () => boolean | undefined, setIsAddLocalDrivesEnabled: (value: boolean | undefined) => void, addIsAddLocalDrivesEnabledEventHandler: () => void;
+declare const useIsDeleteLocalDrivesEnabled: () => boolean | undefined, setIsDeleteLocalDrivesEnabled: (value: boolean | undefined) => void, addIsDeleteLocalDrivesEnabledEventHandler: () => void;
+declare const useIsEditorDebugModeEnabled: () => boolean | undefined, setIsEditorDebugModeEnabled: (value: boolean | undefined) => void, addIsEditorDebugModeEnabledEventHandler: () => void;
+declare const useIsEditorReadModeEnabled: () => boolean | undefined, setIsEditorReadModeEnabled: (value: boolean | undefined) => void, addIsEditorReadModeEnabledEventHandler: () => void;
+declare const useIsAnalyticsDatabaseWorkerEnabled: () => boolean | undefined, setIsAnalyticsDatabaseWorkerEnabled: (value: boolean | undefined) => void, addIsAnalyticsDatabaseWorkerEnabledEventHandler: () => void;
+declare const useIsDiffAnalyticsEnabled: () => boolean | undefined, setIsDiffAnalyticsEnabled: (value: boolean | undefined) => void, addIsDiffAnalyticsEnabledEventHandler: () => void;
+declare const useIsDriveAnalyticsEnabled: () => boolean | undefined, setIsDriveAnalyticsEnabled: (value: boolean | undefined) => void, addIsDriveAnalyticsEnabledEventHandler: () => void;
+declare const useRenownUrl: () => string | undefined, setRenownUrl: (value: string | undefined) => void, addRenownUrlEventHandler: () => void;
+declare const useRenownNetworkId: () => string | undefined, setRenownNetworkId: (value: string | undefined) => void, addRenownNetworkIdEventHandler: () => void;
+declare const useRenownChainId: () => number | undefined, setRenownChainId: (value: number | undefined) => void, addRenownChainIdEventHandler: () => void;
+declare const useSentryRelease: () => string | undefined, setSentryRelease: (value: string | undefined) => void, addSentryReleaseEventHandler: () => void;
+declare const useSentryDsn: () => string | undefined, setSentryDsn: (value: string | undefined) => void, addSentryDsnEventHandler: () => void;
+declare const useSentryEnv: () => string | undefined, setSentryEnv: (value: string | undefined) => void, addSentryEnvEventHandler: () => void;
+declare const useIsSentryTracingEnabled: () => boolean | undefined, setIsSentryTracingEnabled: (value: boolean | undefined) => void, addIsSentryTracingEnabledEventHandler: () => void;
+declare const useIsExternalProcessorsEnabled: () => boolean | undefined, setIsExternalProcessorsEnabled: (value: boolean | undefined) => void, addIsExternalProcessorsEnabledEventHandler: () => void;
+declare const useIsExternalPackagesEnabled: () => boolean | undefined, setIsExternalPackagesEnabled: (value: boolean | undefined) => void, addIsExternalPackagesEnabledEventHandler: () => void;
+/** Sets the enabled editors for Connect. */
+declare const setEnabledEditors: (value: string[] | undefined) => void;
+/** Gets the enabled editors for Connect. */
+declare const useEnabledEditors: () => string[] | undefined;
+/** Adds an event handler for when the enabled editors for Connect changes. */
+declare const addEnabledEditorsEventHandler: () => void;
+/** Sets the disabled editors for Connect. */
+declare const setDisabledEditors: (value: string[] | undefined) => void;
+/** Gets the disabled editors for Connect. */
+declare const useDisabledEditors: () => string[] | undefined;
+/** Adds an event handler for when the disabled editors for Connect changes. */
+declare const addDisabledEditorsEventHandler: () => void;
+/** Sets the isRelationalProcessorsEnabled for Connect. */
+declare const setIsRelationalProcessorsEnabled: (value: boolean | undefined) => void;
+/** Gets the isRelationalProcessorsEnabled for Connect. */
+declare const useIsRelationalProcessorsEnabled: () => boolean | undefined;
+/** Adds an event handler for when the isRelationalProcessorsEnabled for Connect changes. */
+declare const addIsRelationalProcessorsEnabledEventHandler: () => void;
+/** Sets the isExternalRelationalProcessorsEnabled for Connect. */
+declare const setIsExternalRelationalProcessorsEnabled: (value: boolean | undefined) => void;
+/** Gets the isExternalRelationalProcessorsEnabled for Connect. */
+declare const useIsExternalRelationalProcessorsEnabled: () => boolean | undefined;
+/** Adds an event handler for when the isExternalRelationalProcessorsEnabled for Connect changes. */
+declare const addIsExternalRelationalProcessorsEnabledEventHandler: () => void;
+/** Sets the isAnalyticsEnabled for Connect. */
+declare const setIsAnalyticsEnabled: (value: boolean | undefined) => void;
+/** Gets the isAnalyticsEnabled for Connect. */
+declare const useIsAnalyticsEnabled: () => boolean | undefined;
+/** Adds an event handler for when the isAnalyticsEnabled for Connect changes. */
+declare const addIsAnalyticsEnabledEventHandler: () => void;
+/** Sets the isAnalyticsExternalProcessorsEnabled for Connect. */
+declare const setIsAnalyticsExternalProcessorsEnabled: (value: boolean | undefined) => void;
+/** Gets the isAnalyticsExternalProcessorsEnabled for Connect. */
+declare const useIsAnalyticsExternalProcessorsEnabled: () => boolean | undefined;
+/** Adds an event handler for when the isAnalyticsExternalProcessorsEnabled for Connect changes. */
+declare const addIsAnalyticsExternalProcessorsEnabledEventHandler: () => void;
+/** Sets the analytics database name for Connect. */
+declare const setAnalyticsDatabaseName: (value: string | undefined) => void;
+/** Gets the analytics database name for Connect. */
+declare const useAnalyticsDatabaseName: () => string | undefined;
+/** Adds an event handler for when the analytics database name for Connect changes. */
+declare const addAnalyticsDatabaseNameEventHandler: () => void;
+/** Sets the log level for Connect. */
+declare const setLogLevel: (value: "debug" | "info" | "warn" | "error" | undefined) => void;
+/** Gets the log level for Connect. */
+declare const useLogLevel: () => "debug" | "info" | "warn" | "error" | undefined;
+/** Adds an event handler for when the log level for Connect changes. */
+declare const addLogLevelEventHandler: () => void;
+/** Sets the allow list for Connect. */
+declare const setAllowList: (value: string[] | undefined) => void;
+/** Gets the allow list for Connect. */
+declare const useAllowList: () => string[] | undefined;
+/** Adds an event handler for when the allow list for Connect changes. */
+declare const addAllowListEventHandler: () => void;
+declare const phGlobalConfigSetters: PHGlobalConfigSetters$1;
+declare const phGlobalConfigHooks: PHGlobalConfigHooks$1;
+//#endregion
+//#region src/hooks/config/editor.d.ts
+declare const isExternalControlsEnabledEventFunctions: {
+  useValue: () => boolean | undefined;
+  setValue: (value: boolean | undefined) => void;
+  addEventHandler: () => void;
+};
+/** Sets whether external controls are enabled for a given editor. */
+declare const setIsExternalControlsEnabled: (value: boolean | undefined) => void;
+/** Gets whether external controls are enabled for a given editor. */
+declare const useIsExternalControlsEnabled: () => boolean | undefined;
+/** Adds an event handler for when the external controls enabled state changes. */
+declare const addIsExternalControlsEnabledEventHandler: () => void;
+/** Sets whether drag and drop is enabled for a given drive editor. */
+declare const setIsDragAndDropEnabled: (value: boolean | undefined) => void;
+/** Gets whether drag and drop is enabled for a given drive editor. */
+declare const useIsDragAndDropEnabled: () => boolean | undefined;
+/** Adds an event handler for when the drag and drop enabled state changes. */
+declare const addIsDragAndDropEnabledEventHandler: () => void;
+/** Sets the allowed document types for a given drive editor. */
+declare const setAllowedDocumentTypes: (value: string[] | undefined) => void;
+/** Defines the document types a drive supports.
+ *
+ * Defaults to all of the document types registered in the reactor.
+ */
+declare function useAllowedDocumentTypes(): string[] | undefined;
+/** Adds an event handler for when the allowed document types for a given drive editor changes. */
+declare const addAllowedDocumentTypesEventHandler: () => void;
+declare const phDriveEditorConfigSetters: PHDriveEditorConfigSetters$1;
+declare const phDocumentEditorConfigSetters: PHDocumentEditorConfigSetters$1;
+declare const phDriveEditorConfigHooks: PHDriveEditorConfigHooks$1;
+declare const phDocumentEditorConfigHooks: PHDocumentEditorConfigHooks$1;
+//#endregion
+//#region src/hooks/config/set-config-by-key.d.ts
+declare function setPHGlobalConfigByKey<TKey extends PHGlobalConfigKey$1>(key: TKey, value: PHGlobalConfig$1[TKey] | undefined): void;
+declare function setPHDriveEditorConfigByKey<TKey extends PHDriveEditorConfigKey$1>(key: TKey, value: PHDriveEditorConfig$1[TKey] | undefined): void;
+declare function setPHDocumentEditorConfigByKey<TKey extends PHDocumentEditorConfigKey$1>(key: TKey, value: PHDocumentEditorConfig$1[TKey] | undefined): void;
+//#endregion
+//#region src/hooks/config/set-config-by-object.d.ts
+declare function setDefaultPHGlobalConfig(config: PHGlobalConfig$1): void;
+declare function useSetDefaultPHGlobalConfig(config: PHGlobalConfig$1): void;
+declare function useResetPHGlobalConfig(defaultConfigForReset: PHGlobalConfig$1): () => void;
+declare function setPHGlobalConfig(config: Partial<PHGlobalConfig$1>): void;
+declare function useSetPHGlobalConfig(config: Partial<PHGlobalConfig$1>): void;
+/** Sets the global drive config.
+ *
+ * Pass in a partial object of the global drive config to set.
+ */
+declare function setPHDriveEditorConfig(config: Partial<PHDriveEditorConfig$1>): void;
+/** Sets the global document config.
+ *
+ * Pass in a partial object of the global document config to set.
+ */
+declare function setPHDocumentEditorConfig(config: Partial<PHDocumentEditorConfig$1>): void;
+/** Wrapper hook for setting the global drive editor config.
+ *
+ * Automatically sets the global drive editor config when the component mounts.
+ *
+ * Pass in a partial object of the global drive editor config to set.
+ */
+declare function useSetPHDriveEditorConfig(config: Partial<PHDriveEditorConfig$1>): void;
+/** Wrapper hook for setting the global document editor config.
+ *
+ * Automatically sets the global document editor config when the component mounts.
+ *
+ * Pass in a partial object of the global document editor config to set.
+ */
+declare function useSetPHDocumentEditorConfig(config: Partial<PHDocumentEditorConfig$1>): void;
+//#endregion
+//#region src/hooks/config/use-value-by-key.d.ts
+declare function usePHGlobalConfigByKey<TKey extends PHGlobalConfigKey$1>(key: TKey): _powerhousedao_reactor_browser0.PHGlobalConfig[TKey];
+/** Gets the value of an item in the global drive config for a given key.
+ *
+ * Strongly typed, inferred from type definition for the key.
+ */
+declare function usePHDriveEditorConfigByKey<TKey extends PHDriveEditorConfigKey$1>(key: TKey): _powerhousedao_reactor_browser0.PHGlobalConfig[TKey];
+/** Gets the value of an item in the global document config for a given key.
+ *
+ * Strongly typed, inferred from type definition for the key.
+ */
+declare function usePHDocumentEditorConfigByKey<TKey extends PHDocumentEditorConfigKey$1>(key: TKey): _powerhousedao_reactor_browser0.PHGlobalConfig[TKey];
+//#endregion
+//#region src/hooks/config/utils.d.ts
+declare function callGlobalSetterForKey<TKey extends PHGlobalConfigKey$1>(key: TKey, value: PHGlobalConfig$1[TKey] | undefined): void;
+//#endregion
+//#region src/renown/utils.d.ts
+declare function openRenown(documentId?: string): void;
+/**
+ * Log in the user. Resolves the user DID from (in order):
+ * 1. Explicit `userDid` argument
+ * 2. `?user=` URL parameter (from Renown portal redirect)
+ * 3. Previously stored session in the Renown instance
+ */
+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 & PHDriveEditorConfig & 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 drive editors.
+ *
+ * Setting these will override the defaults when your editor is mounted.
+ */
+type PHDriveEditorConfig = {
+  /** 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 drive editor. */
+  isDragAndDropEnabled?: boolean;
+};
+type PHDriveEditorConfigKey = keyof PHDriveEditorConfig;
+type PHDriveEditorConfigSetters = PHGlobalConfigSettersForKey<PHDriveEditorConfigKey>;
+type PHDriveEditorConfigHooks = PHGlobalConfigHooksForKey<PHDriveEditorConfigKey>;
+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;
+};
+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: "exportDocumentWithErrors";
+  documentId: string;
+} | {
+  type: "inspector";
+} | {
+  type: "missingPackage";
+  documentType: string;
+};
+//#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/global.d.ts
+type BrowserReactorClientModule = ReactorClientModule & {
+  pg: PGlite;
+};
+type LOADING = null;
+type PHGlobal = PHGlobalConfig & {
+  loading?: boolean;
+  reactorClientModule?: BrowserReactorClientModule;
+  reactorClient?: IReactorClient;
+  renown?: IRenown | LOADING;
+  vetraPackageManager?: IPackageManager;
+  drives?: DocumentDriveDocument[];
+  documentCache?: IDocumentCache;
+  selectedDriveId?: string;
+  selectedNodeId?: string;
+  modal?: PHModal;
+  selectedTimelineRevision?: string | number | null;
+  revisionHistoryVisible?: boolean;
+  selectedTimelineItem?: TimelineItem | null;
+  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;
+  }
+} //# sourceMappingURL=global.d.ts.map
+//#endregion
+//#region src/hooks/document-cache.d.ts
+/** Returns all documents in the reactor. */
+declare const useDocumentCache: UsePHGlobalValue<IDocumentCache>;
+/** Sets all of the documents in the reactor. */
+declare const setDocumentCache: SetPHGlobalValue<IDocumentCache>;
+/** Adds an event handler for all of the documents in the reactor. */
+declare const addDocumentCacheEventHandler: () => void;
+/**
+ * Retrieves a document from the reactor and subscribes to changes using React Suspense.
+ * This hook will suspend rendering while the document is loading.
+ * @param id - The document ID to retrieve, or null/undefined to skip retrieval
+ * @returns The document if found, or undefined if id is null/undefined
+ */
+declare function useDocument(id: string | null | undefined): PHDocument$1 | undefined;
+/**
+ * Retrieves multiple documents from the reactor using React Suspense.
+ * This hook will suspend rendering while any of the documents are loading.
+ *
+ * Uses getBatch from the document cache which handles promise caching internally,
+ * ensuring stable references for useSyncExternalStore.
+ *
+ * @param ids - Array of document IDs to retrieve, or null/undefined to skip retrieval
+ * @returns An array of documents if found, or empty array if ids is null/undefined
+ */
+declare function useDocuments(ids: string[] | null | undefined): PHDocument$1[];
+/**
+ * Returns a function to retrieve a document from the cache.
+ * The returned function fetches and returns a document by ID.
+ * @returns A function that takes a document ID and returns a Promise of the document
+ */
+declare function useGetDocument(): (id: string) => Promise<PHDocument$1>;
+/**
+ * Returns a function to retrieve multiple documents from the cache.
+ * The returned function fetches and returns documents by their IDs.
+ * @returns A function that takes an array of document IDs and returns a Promise of the documents
+ */
+declare function useGetDocuments(): (ids: string[]) => Promise<PHDocument$1[]>;
+/**
+ * Retrieves a document from the reactor without suspending rendering.
+ * Returns the current state of the document loading operation.
+ * @param id - The document ID to retrieve, or null/undefined to skip retrieval
+ * @returns An object containing:
+ *   - status: "initial" | "pending" | "success" | "error"
+ *   - data: The document if successfully loaded
+ *   - isPending: Boolean indicating if the document is currently loading
+ *   - error: Any error that occurred during loading
+ *   - reload: Function to force reload the document from cache
+ */
+declare function useGetDocumentAsync(id: string | null | undefined): {
+  readonly status: "initial";
+  readonly data: undefined;
+  readonly isPending: false;
+  readonly error: undefined;
+  readonly reload: undefined;
+} | {
+  readonly reload: () => Promise<PHDocument$1>;
+  readonly status: "pending";
+  readonly isPending: true;
+  readonly error: undefined;
+  readonly data: undefined;
+} | {
+  readonly reload: () => Promise<PHDocument$1>;
+  readonly status: "success";
+  readonly isPending: false;
+  readonly error: undefined;
+  readonly data: PHDocument$1;
+} | {
+  readonly reload: () => Promise<PHDocument$1>;
+  readonly status: "error";
+  readonly isPending: false;
+  readonly error: unknown;
+  readonly data: undefined;
+};
+//#endregion
+//#region src/hooks/drives.d.ts
+/** Returns all of the drives in the reactor */
+declare const useDrives: UsePHGlobalValue<DocumentDriveDocument[]>;
+/** Sets the drives in the reactor */
+declare const setDrives: SetPHGlobalValue<DocumentDriveDocument[]>;
+/** Adds an event handler for the drives */
+declare const addDrivesEventHandler: () => void;
+//#endregion
+//#region src/hooks/loading.d.ts
+declare const useLoading: () => boolean | undefined, setLoading: (value: boolean | undefined) => void, addLoadingEventHandler: () => void;
+declare const loading: LOADING;
+//#endregion
+//#region src/hooks/reactor.d.ts
+/** Returns the reactor client module */
+declare const useReactorClientModule: UsePHGlobalValue$1<BrowserReactorClientModule$1>;
+/** Sets the reactor client module */
+declare const setReactorClientModule: SetPHGlobalValue$1<BrowserReactorClientModule$1>;
+/** Adds an event handler for the reactor client module */
+declare const addReactorClientModuleEventHandler: AddPHGlobalEventHandler$1;
+/** Returns the reactor client */
+declare const useReactorClient: UsePHGlobalValue$1<IReactorClient>;
+/** Sets the reactor client */
+declare const setReactorClient: SetPHGlobalValue$1<IReactorClient>;
+/** Adds an event handler for the reactor client */
+declare const addReactorClientEventHandler: AddPHGlobalEventHandler$1;
+declare const useSync: () => ISyncManager | undefined;
+declare const useSyncList: () => _powerhousedao_reactor0.Remote[];
+declare const useModelRegistry: () => IDocumentModelRegistry | undefined;
+declare const useDatabase: () => Kysely<Database$1> | undefined;
+declare const usePGlite: () => PGlite | undefined;
+//#endregion
+//#region src/hooks/connection-state.d.ts
+/**
+ * Returns a map of remote name to connection state snapshot for all remotes.
+ * Re-renders when any remote's connection state changes.
+ */
+declare function useConnectionStates(): ReadonlyMap<string, ConnectionStateSnapshot$1>;
+/**
+ * Returns the connection state snapshot for a specific remote by name.
+ */
+declare function useConnectionState(remoteName: string): ConnectionStateSnapshot$1 | undefined;
+//#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/hooks/dispatch.d.ts
+/**
+ * Returns a dispatch function for dispatching actions to a document.
+ * Used internally by other hooks to provide action dispatching capabilities.
+ * @param document - The document to dispatch actions to.
+ * @returns A tuple containing the document and a dispatch function.
+ */
+type DispatchFn<TAction> = (actionOrActions: TAction[] | TAction | undefined, onErrors?: (errors: Error[]) => void, onSuccess?: (result: PHDocument$1) => void) => void;
+type UseDispatchResult<TDocument, TAction> = readonly [TDocument | undefined, DispatchFn<TAction>];
+declare function useDispatch<TDocument = PHDocument$1, TAction = Action>(document: TDocument | undefined): UseDispatchResult<TDocument, TAction>;
+//#endregion
+//#region src/hooks/document-by-id.d.ts
+/** Returns a document by id. */
+declare function useDocumentById(id: string | null | undefined): UseDispatchResult<PHDocument$1, Action>;
+/** Returns documents by ids. */
+declare function useDocumentsByIds(ids: string[] | null | undefined): PHDocument$1[];
+//#endregion
+//#region src/hooks/document-model-modules.d.ts
+declare function useDocumentModelModules(): VetraDocumentModelModule$1[] | undefined;
+declare function useDocumentModelModuleById(id: string | null | undefined): VetraDocumentModelModule$1 | undefined;
+//#endregion
+//#region src/hooks/document-of-type.d.ts
+/** Returns a document of a specific type, throws an error if the found document has a different type */
+declare function useDocumentOfType<TDocument extends PHDocument$1, TAction extends Action>(documentId: string | null | undefined, documentType: string | null | undefined): never[] | [TDocument, DocumentDispatch$1<TAction>];
+//#endregion
+//#region src/hooks/document-operations.d.ts
+type InternalState = {
+  globalOperations: Operation[];
+  localOperations: Operation[];
+  isLoading: boolean;
+  error: Error | undefined;
+};
+type DocumentOperationsState = InternalState & {
+  refetch: () => void;
+};
+/**
+ * Hook to fetch document operations via the reactor client.
+ * Operations are no longer auto-populated on documents and must be fetched explicitly.
+ *
+ * @param documentId - The document ID to fetch operations for
+ * @returns Object containing globalOperations, localOperations, isLoading, and error
+ */
+declare function useDocumentOperations(documentId: string | null | undefined): DocumentOperationsState;
+//#endregion
+//#region src/hooks/document-types.d.ts
+/** Returns the document types a drive editor supports.
+ *
+ * If present, uses the `allowedDocumentTypes` config value.
+ * Otherwise, uses the supported document types from the reactor.
+ */
+declare function useDocumentTypes(): string[] | undefined;
+//#endregion
+//#region src/hooks/drive-by-id.d.ts
+declare function useDriveById(driveId: string | undefined | null): [DocumentDriveDocument, DocumentDispatch<DocumentDriveAction>];
+//#endregion
+//#region src/hooks/editor-modules.d.ts
+declare function useEditorModules(): VetraEditorModule[] | undefined;
+declare function useDriveEditorModules(): VetraEditorModule[] | undefined;
+declare function useFallbackEditorModule(documentType: string | null | undefined): VetraEditorModule | undefined;
+declare function useDriveEditorModuleById(id: string | null | undefined): VetraEditorModule | undefined;
+declare function useDefaultDriveEditorModule(): VetraEditorModule | undefined;
+declare function useEditorModuleById(id: string | null | undefined): VetraEditorModule | undefined;
+declare function useEditorModulesForDocumentType(documentType: string | null | undefined): VetraEditorModule[] | undefined;
+//#endregion
+//#region src/hooks/features.d.ts
+declare const useFeatures: UsePHGlobalValue<Map<string, boolean>>;
+declare const setFeatures: SetPHGlobalValue<Map<string, boolean>>;
+declare const addFeaturesEventHandler: AddPHGlobalEventHandler;
+//#endregion
+//#region src/hooks/folder-by-id.d.ts
+declare function useFolderById(id: string | null | undefined): FolderNode | undefined;
+//#endregion
+//#region src/hooks/import-script-modules.d.ts
+declare function useImportScriptModules(): ImportScriptModule[] | undefined;
+//#endregion
+//#region src/hooks/items-in-selected-drive.d.ts
+/** Returns the nodes in the selected drive. */
+declare function useNodesInSelectedDrive(): any;
+/** Returns the file nodes in the selected drive. */
+declare function useFileNodesInSelectedDrive(): FileNode[] | undefined;
+/** Returns the folder nodes in the selected drive. */
+declare function useFolderNodesInSelectedDrive(): FolderNode[] | undefined;
+/** Returns the documents in the selected drive. */
+declare function useDocumentsInSelectedDrive(): PHDocument$1[] | undefined;
+/** Returns the document types supported by the selected drive, as defined by the document model documents present in the drive */
+declare function useDocumentTypesInSelectedDrive(): string[] | undefined;
+//#endregion
+//#region src/hooks/items-in-selected-folder.d.ts
+/** Returns the nodes in the selected folder. */
+declare function useNodesInSelectedFolder(): Node[] | undefined;
+/** Returns the file nodes in the selected folder. */
+declare function useFileNodesInSelectedFolder(): FileNode[] | undefined;
+/** Returns the folder nodes in the selected folder. */
+declare function useFolderNodesInSelectedFolder(): FolderNode[] | undefined;
+/** Returns the documents in the selected folder. */
+declare function useDocumentsInSelectedFolder(): PHDocument$1[] | undefined;
+//#endregion
+//#region src/hooks/make-ph-event-functions.d.ts
+declare function makePHEventFunctions<TKey extends PHGlobalKey$1>(key: TKey): {
+  useValue: () => PHGlobal$1[TKey] | undefined;
+  setValue: (value: PHGlobal$1[TKey] | undefined) => void;
+  addEventHandler: () => void;
+};
+//#endregion
+//#region src/hooks/modals.d.ts
+/** Returns the current modal */
+declare const usePHModal: () => PHModal$1 | undefined;
+/** Sets the current modal */
+declare const setPHModal: (value: PHModal$1 | undefined) => void;
+/** Adds an event handler for the modal */
+declare const addModalEventHandler: () => void;
+/** Shows a modal */
+declare function showPHModal(modal: PHModal$1): void;
+/** Closes the current modal */
+declare function closePHModal(): void;
+/** Shows the create document modal */
+declare function showCreateDocumentModal(documentType: string): void;
+/** Shows the delete node modal */
+declare function showDeleteNodeModal(nodeOrId: Node | string): void;
+//#endregion
+//#region src/hooks/node-actions.d.ts
+declare function useNodeActions(): {
+  onAddFile: (file: File, parent: Node | undefined) => Promise<void>;
+  onAddFolder: (name: string, parent: Node | undefined) => Promise<_powerhousedao_shared_document_drive0.FolderNode | undefined>;
+  onRenameNode: (newName: string, node: Node) => Promise<Node | undefined>;
+  onCopyNode: (src: Node, target: Node | undefined) => Promise<void>;
+  onMoveNode: (src: Node, target: Node | undefined) => Promise<void>;
+  onDuplicateNode: (src: Node) => Promise<void>;
+  onAddAndSelectNewFolder: (name: string) => Promise<void>;
+  onRenameDriveNodes: (newName: string, nodeId: string) => Promise<void>;
+};
+//#endregion
+//#region src/hooks/node-by-id.d.ts
+/** Returns a node in the selected drive by id. */
+declare function useNodeById(id: string | null | undefined): Node | undefined;
+//#endregion
+//#region src/hooks/node-path.d.ts
+/** Returns the path to a node in the selected drive */
+declare function useNodePathById(id: string | null | undefined): Node[];
+/** Returns the path to the currently selected node in the selected drive. */
+declare function useSelectedNodePath(): Node[];
+//#endregion
+//#region src/hooks/parent-folder.d.ts
+declare function useNodeParentFolderById(id: string | null | undefined): FolderNode | undefined;
+declare function useParentFolderForSelectedNode(): FolderNode | undefined;
+//#endregion
+//#region src/hooks/revision-history.d.ts
+/** Returns whether revision history is visible */
+declare const useRevisionHistoryVisible: () => boolean | undefined;
+/** Sets revision history visibility */
+declare const setRevisionHistoryVisible: (value: boolean | undefined) => void;
+/** Adds event handler for revision history visibility */
+declare const addRevisionHistoryVisibleEventHandler: () => void;
+/** Shows the revision history */
+declare function showRevisionHistory(): void;
+/** Hides the revision history */
+declare function hideRevisionHistory(): void;
+//#endregion
+//#region src/hooks/selected-document.d.ts
+/** Returns the selected document id */
+declare function useSelectedDocumentId(): string | undefined;
+/** Returns the selected document. */
+declare function useSelectedDocument(): readonly [PHDocument$1, DispatchFn<Action>];
+/** Returns the selected document. */
+declare function useSelectedDocumentSafe(): UseDispatchResult<PHDocument$1, Action>;
+/** Returns the selected document of a specific type, throws an error if the found document has a different type */
+declare function useSelectedDocumentOfType(documentType: null | undefined): never[];
+declare function useSelectedDocumentOfType<TDocument extends PHDocument$1, TAction extends Action>(documentType: string): [TDocument, DocumentDispatch$1<TAction>];
+//#endregion
+//#region src/hooks/selected-drive.d.ts
+/** Returns the selected drive id */
+declare const useSelectedDriveId: () => string | undefined;
+/** Adds an event handler for the selected drive id */
+declare const addSelectedDriveIdEventHandler: () => void;
+/** Returns the selected drive */
+declare function useSelectedDrive(): readonly [undefined, undefined] | [PHDocument<any>, DocumentDispatch$1<any>];
+/** Returns the selected drive, or undefined if no drive is selected */
+declare function useSelectedDriveSafe(): readonly [undefined, undefined] | [PHDocument<any>, DocumentDispatch$1<any>];
+declare function setSelectedDrive(driveOrDriveSlug: string | DocumentDriveDocument | undefined): void;
+declare function addSetSelectedDriveOnPopStateEventHandler(): void;
+//#endregion
+//#region src/hooks/selected-folder.d.ts
+/** Returns the selected folder. */
+declare function useSelectedFolder(): FolderNode | undefined;
+//#endregion
+//#region src/hooks/selected-node.d.ts
+declare const addSelectedNodeIdEventHandler: () => void;
+/** Returns the selected node. */
+declare function useSelectedNode(): Node | undefined;
+/** Sets the selected node (file or folder). */
+declare function setSelectedNode(nodeOrNodeSlug: Node | string | undefined): void;
+declare function addResetSelectedNodeEventHandler(): void;
+declare function addSetSelectedNodeOnPopStateEventHandler(): void;
+//#endregion
+//#region src/hooks/selected-timeline-item.d.ts
+/** Returns the selected timeline item */
+declare const useSelectedTimelineItem: () => TimelineItem | null | undefined;
+/** Sets the selected timeline item */
+declare const setSelectedTimelineItem: (value: TimelineItem | null | undefined) => void;
+/** Adds event handler for selected timeline item */
+declare const addSelectedTimelineItemEventHandler: () => void;
+//#endregion
+//#region src/hooks/subgraph-modules.d.ts
+declare function useSubgraphModules(): SubgraphModule[] | undefined;
+//#endregion
+//#region src/hooks/supported-document-types.d.ts
+/** Returns the supported document types for the reactor (derived from the document model modules) */
+declare function useSupportedDocumentTypesInReactor(): string[] | undefined;
+//#endregion
+//#region src/hooks/timeline-revision.d.ts
+/** Returns the selected timeline revision. */
+declare const useSelectedTimelineRevision: () => string | number | null | undefined;
+/** Sets the selected timeline revision. */
+declare const setSelectedTimelineRevision: (value: string | number | null | undefined) => void;
+/** Adds an event handler for the selected timeline revision. */
+declare const addSelectedTimelineRevisionEventHandler: () => void;
+//#endregion
+//#region src/hooks/toast.d.ts
+/** Returns the toast function */
+declare const usePHToast: () => PHToastFn | undefined;
+/** Sets the toast function */
+declare const setPHToast: (value: PHToastFn | undefined) => void;
+/** Adds an event handler for the toast */
+declare const addToastEventHandler: () => void;
+//#endregion
+//#region src/hooks/use-feature-flags.d.ts
+/**
+ * Synchronous helper to check if inspector is enabled.
+ */
+declare function isInspectorEnabledSync(): boolean;
+/**
+ * React hook to check if inspector is enabled.
+ */
+declare function useInspectorEnabled(): boolean;
+//#endregion
+//#region src/hooks/use-get-switchboard-link.d.ts
+/**
+ * Hook that returns a function to generate a document's switchboard URL.
+ * Only returns a function for documents in remote drives.
+ * Returns null for local drives or when the document/drive cannot be determined.
+ *
+ * The returned function generates a fresh bearer token and builds the switchboard URL
+ * with authentication when called.
+ *
+ * @param document - The document to create a switchboard URL generator for
+ * @returns An async function that returns the switchboard URL, or null if not applicable
+ */
+declare function useGetSwitchboardLink(document: PHDocument$1 | undefined): (() => Promise<string>) | null;
+//#endregion
+//#region src/types/upload.d.ts
+type DocumentTypeIcon = "analytics-processor" | "relational-processor" | "codegen-processor" | "app" | "document-model" | "editor" | "package" | "subgraph";
+type ConflictResolution = "replace" | "duplicate";
+interface FileUploadProgress {
+  stage: "loading" | "initializing" | "uploading" | "complete" | "failed" | "conflict" | "unsupported-document-type";
+  progress: number;
+  totalOperations?: number;
+  uploadedOperations?: number;
+  message?: string;
+  error?: string;
+  documentType?: DocumentTypeIcon;
+  duplicateType?: "id" | "name";
+}
+type FileUploadProgressCallback = (progress: FileUploadProgress) => void;
+type UseOnDropFile = () => (file: File, onProgress?: FileUploadProgressCallback, resolveConflict?: ConflictResolution) => Promise<FileNode | undefined>;
+//#endregion
+//#region src/hooks/use-on-drop-file.d.ts
+declare const useOnDropFile: UseOnDropFile;
+//#endregion
+//#region src/hooks/user-permissions.d.ts
+declare function useUserPermissions(): {
+  isAllowedToCreateDocuments: boolean;
+  isAllowedToEditDocuments: boolean;
+};
+//#endregion
+//#region src/hooks/vetra-packages.d.ts
+declare const useVetraPackageManager: () => IPackageManager | undefined;
+/** Returns all of the Vetra packages loaded by the Connect instance */
+declare const useVetraPackages: () => VetraPackage[];
+/** Adds the Vetra package manager event handler */
+declare const addVetraPackageManagerEventHandler: () => void;
+/** Sets the Vetra package manager and registers its packages */
+declare function setVetraPackageManager(packageManager: IPackageManager): void;
+//#endregion
+//#region src/pglite/drop.d.ts
+declare function truncateAllTables(pg: PGlite, schema?: string): Promise<void>;
+declare function dropAllReactorStorage(pg: PGlite): Promise<void>;
+//#endregion
+//#region src/reactor.d.ts
+type ReactorDefaultDrivesConfig = {
+  defaultDrivesUrl?: string[];
+};
+type RefreshReactorDataConfig = {
+  debounceDelayMs?: number;
+  immediateThresholdMs?: number;
+};
+declare const refreshReactorData: (reactor: IReactorClient, immediate?: boolean) => Promise<void>;
+declare const refreshReactorDataClient: (reactor: IReactorClient | undefined, immediate?: boolean) => Promise<void>;
+/**
+ * @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/registry/types.d.ts
+interface RegistryPackageInfo {
+  name: string;
+  description?: string;
+  version?: string;
+  category?: string;
+  publisher?: string;
+  publisherUrl?: string;
+}
+interface PublishEvent {
+  packageName: string;
+  version: string | null;
+}
+//#endregion
+//#region src/registry/client.d.ts
+declare class RegistryClient {
+  readonly apiUrl: string;
+  constructor(cdnUrl: string);
+  getPackages(): Promise<RegistryPackageInfo[]>;
+  getPackagesByDocumentType(documentType: string): Promise<string[]>;
+  searchPackages(query: string): Promise<RegistryPackageInfo[]>;
+  onPublish(callback: (event: PublishEvent) => void): () => void;
+}
+//#endregion
+//#region src/registry/fetchers.d.ts
+declare function getPackages(registryUrl: string): Promise<PackageInfo[]>;
+declare function getPackagesByDocumentType(registryUrl: string, documentType: string): Promise<string[]>;
+//#endregion
+//#region src/relational/hooks/useRelationalDb.d.ts
+type RelationalDbWithLive<Schema> = IRelationalDb$1<Schema> & {
+  live: LiveNamespace;
+};
+interface IRelationalDbState<Schema> {
+  db: RelationalDbWithLive<Schema> | null;
+  isLoading: boolean;
+  error: Error | null;
+}
+declare const useRelationalDb: <Schema>() => IRelationalDbState<Schema>;
+//#endregion
+//#region src/relational/hooks/useRelationalQuery.d.ts
+type QueryCallbackReturnType = {
+  sql: string;
+  parameters?: readonly unknown[];
+};
+type useRelationalQueryOptions = {
+  hashNamespace?: boolean;
+};
+declare function useRelationalQuery<Schema, T = unknown, TParams = undefined>(ProcessorClass: RelationalDbProcessorClass<Schema>, driveId: string, queryCallback: (db: IRelationalQueryBuilder<Schema>, parameters?: TParams) => QueryCallbackReturnType, parameters?: TParams, options?: useRelationalQueryOptions): {
+  readonly isLoading: boolean;
+  readonly error: Error | null;
+  readonly result: LiveQueryResults<T> | null;
+};
+//#endregion
+//#region src/relational/utils/createProcessorQuery.d.ts
+declare function createProcessorQuery<TSchema>(ProcessorClass: RelationalDbProcessorClass<TSchema>): {
+  <TQueryBuilder extends (db: IRelationalQueryBuilder<TSchema>) => QueryCallbackReturnType$1>(driveId: string, queryCallback: TQueryBuilder): {
+    isLoading: boolean;
+    error: Error | null;
+    result: LiveQueryResults<ReturnType<TQueryBuilder> extends CompiledQuery<infer R> ? R : any> | null;
+  };
+  <TParams, TQueryBuilder extends (db: IRelationalQueryBuilder<TSchema>, parameters: TParams) => QueryCallbackReturnType$1>(driveId: string, queryCallback: TQueryBuilder, parameters: TParams, options?: useRelationalQueryOptions$1): {
+    isLoading: boolean;
+    error: Error | null;
+    result: LiveQueryResults<ReturnType<TQueryBuilder> extends CompiledQuery<infer R> ? R : any> | null;
+  };
+};
+//#endregion
+//#region src/remote-controller/types.d.ts
+type RemoteDocumentData = PhDocumentFieldsFragment;
+type RemoteOperation = GetDocumentOperationsQuery["documentOperations"]["items"][number];
+type RemoteOperationResultPage = GetDocumentOperationsQuery["documentOperations"];
+/**
+ * Options for creating a RemoteDocumentController.
+ */
+type RemoteControllerOptions = {
+  client: ReactorGraphQLClient; /** Remote document id. Omit for new documents. */
+  documentId?: string; /** "batch" requires explicit push(), "streaming" auto-pushes after actions. Defaults to "batch" */
+  mode?: "batch" | "streaming"; /** Optional signer for action signing. */
+  signer?: ISigner; /** Branch name, defaults to "main". */
+  branch?: string; /** Parent document identifier for creating new documents. */
+  parentIdentifier?: string; /** Conflict resolution strategy when remote has new operations. Default: no check (current behavior). */
+  onConflict?: ConflictStrategy; /** Called when a streaming-mode push fails. If not provided, errors are silently swallowed. */
+  onPushError?: (error: unknown) => void; /** Number of operations to fetch per page. Defaults to 100. */
+  operationsPageSize?: number;
+};
+/**
+ * Result of a push operation.
+ */
+type PushResult = {
+  remoteDocument: RemoteDocumentData;
+  actionCount: number; /** The actions that were sent to the server (after signing, if applicable). */
+  operations: ReadonlyArray<Action>;
+};
+/**
+ * Sync status of the controller.
+ */
+type SyncStatus = {
+  pendingActionCount: number;
+  connected: boolean;
+  documentId: string;
+  remoteRevision: Record<string, number>;
+};
+/**
+ * A tracked action with operation context for signing.
+ */
+type TrackedAction = {
+  action: Action;
+  prevOpHash: string;
+  prevOpIndex: number;
+};
+/** Information about a detected conflict. */
+type ConflictInfo = {
+  /** Remote operations added since the last pull, grouped by scope. */remoteOperations: Record<string, RemoteOperation[]>; /** Local actions pending push. */
+  localActions: TrackedAction[]; /** Remote revision at last pull. */
+  knownRevision: Record<string, number>; /** Current remote revision. */
+  currentRevision: Record<string, number>;
+};
+/** Custom merge handler receives conflict info and returns actions to push (or throws to abort). */
+type MergeHandler = (conflict: ConflictInfo) => Action[] | Promise<Action[]>;
+/** Conflict resolution strategy. */
+type ConflictStrategy = "reject" | "rebase" | MergeHandler;
+/** Event emitted when the document changes. */
+type RemoteDocumentChangeEvent = {
+  source: "action" | "pull";
+  document: PHDocument$1<PHBaseState>;
+};
+/** Listener for document change events. */
+type DocumentChangeListener = (event: RemoteDocumentChangeEvent) => void;
+/** Result of fetching operations. */
+type GetOperationsResult = {
+  operationsByScope: Record<string, RemoteOperation[]>;
+};
+/** Result of fetching a document together with its operations. */
+type GetDocumentWithOperationsResult = {
+  document: RemoteDocumentData;
+  childIds: ReadonlyArray<string>;
+  operations: GetOperationsResult;
+};
+interface IRemoteClient {
+  getDocument(identifier: string, branch?: string): Promise<GetDocumentResult | null>;
+  /** Fetch document metadata and operations in a single call. */
+  getDocumentWithOperations(identifier: string, branch?: string, sinceRevision?: Record<string, number>, scopes?: string[]): Promise<GetDocumentWithOperationsResult | null>;
+  getAllOperations(documentId: string, branch?: string, sinceRevision?: Record<string, number>, scopes?: string[]): Promise<GetOperationsResult>;
+  pushActions(documentIdentifier: string, actions: ReadonlyArray<NonNullable<unknown>>, branch?: string): Promise<RemoteDocumentData>;
+  createDocument(document: NonNullable<unknown>, parentIdentifier?: string): Promise<RemoteDocumentData>;
+  createEmptyDocument(documentType: string, parentIdentifier?: string): Promise<RemoteDocumentData>;
+  deleteDocument(identifier: string, propagate?: PropagationMode): Promise<boolean>;
+}
+type GetDocumentResult = {
+  document: RemoteDocumentData;
+  childIds: ReadonlyArray<string>;
+};
+interface IRemoteController<TState extends PHBaseState = PHBaseState> {
+  readonly header: PHDocumentHeader;
+  readonly state: TState;
+  readonly operations: DocumentOperations;
+  readonly document: PHDocument$1<TState>;
+  readonly status: SyncStatus;
+  onChange(listener: DocumentChangeListener): () => void;
+  push(): Promise<PushResult>;
+  pull(): Promise<RemoteDocumentData>;
+  delete(propagate?: PropagationMode): Promise<boolean>;
+}
+//#endregion
+//#region src/remote-controller/action-tracker.d.ts
+/**
+ * Tracks pending actions with their operation context (prevOpHash, prevOpIndex).
+ * Actions are accumulated until flushed (on push).
+ */
+declare class ActionTracker {
+  private pending;
+  /** Track a new action with its operation context. */
+  track(action: Action, prevOpHash: string, prevOpIndex: number): void;
+  /** Flush all pending actions and return them. Clears the internal queue. */
+  flush(): TrackedAction[];
+  /** Number of pending actions. */
+  get count(): number;
+  /** Prepend previously flushed actions back to the queue (for retry on failure). */
+  restore(actions: TrackedAction[]): void;
+  /** Clear all pending actions without returning them. */
+  clear(): void;
+}
+//#endregion
+//#region src/remote-controller/remote-client.d.ts
+declare class RemoteClient implements IRemoteClient {
+  private readonly client;
+  private readonly pageSize;
+  constructor(client: ReactorGraphQLClient, pageSize?: number);
+  /** Fetch a document by identifier. Returns null if not found. */
+  getDocument(identifier: string, branch?: string): Promise<GetDocumentResult | null>;
+  /**
+   * Fetch a document and its operations.
+   *
+   * When scopes are provided and BatchGetDocumentWithOperations is available,
+   * fetches the document and per-scope operations in a single HTTP request.
+   * Otherwise falls back to GetDocumentWithOperations for the first page,
+   * then paginates remaining operations per scope.
+   */
+  getDocumentWithOperations(identifier: string, branch?: string, sinceRevision?: Record<string, number>, scopes?: string[]): Promise<GetDocumentWithOperationsResult | null>;
+  /**
+   * Fetch document + per-scope operations in a single HTTP request
+   * via BatchGetDocumentWithOperations, then paginate any remaining pages.
+   */
+  private batchGetDocumentWithOperations;
+  /**
+   * Fetch all operations for a document, paginating through all pages.
+   * Each scope is queried individually because the API only returns
+   * pagination cursors for single-scope queries.
+   */
+  getAllOperations(documentId: string, branch?: string, sinceRevision?: Record<string, number>, scopes?: string[]): Promise<GetOperationsResult>;
+  /**
+   * Fetch one page of operations per filter.
+   * Uses the composed query (single HTTP request) when available,
+   * otherwise falls back to parallel individual requests.
+   */
+  private fetchOperationPages;
+  /** Fetch all pages of operations for a single scope (or all scopes if none specified). */
+  private fetchOperationsForScope;
+  /** Push actions to an existing document via MutateDocument. */
+  pushActions(documentIdentifier: string, actions: ReadonlyArray<NonNullable<unknown>>, branch?: string): Promise<RemoteDocumentData>;
+  /** Create a new document on the remote. */
+  createDocument(document: NonNullable<unknown>, parentIdentifier?: string): Promise<RemoteDocumentData>;
+  /** Create an empty document of a given type on the remote. */
+  createEmptyDocument(documentType: string, parentIdentifier?: string): Promise<RemoteDocumentData>;
+  /** Delete a document on the remote. Returns true if successful. */
+  deleteDocument(identifier: string, propagate?: PropagationMode): Promise<boolean>;
+}
+//#endregion
+//#region src/remote-controller/remote-controller.d.ts
+/** Extract TState from a PHDocumentController subclass. */
+type InferState<C> = C extends PHDocumentController<infer S> ? S : never;
+/**
+ * Extract action methods from a controller type.
+ * These are the dynamically-added methods (not on the base PHDocumentController prototype).
+ */
+type ActionMethodsOf<C, TRemote> = { [K in Exclude<keyof C, keyof PHDocumentController<any>>]: C[K] extends ((input: infer I) => unknown) ? (input: I) => TRemote & ActionMethodsOf<C, TRemote> : C[K] };
+/** The full return type: RemoteDocumentController + action methods. */
+type RemoteDocumentControllerWith<C extends PHDocumentController<any>> = RemoteDocumentController<C> & ActionMethodsOf<C, RemoteDocumentController<C>>;
+/**
+ * A controller that wraps a PHDocumentController with remote push/pull capabilities.
+ * Composes a local controller and adds GraphQL-based sync with a reactor server.
+ */
+declare class RemoteDocumentController<TController extends PHDocumentController<any>> implements IRemoteController<InferState<TController>> {
+  private inner;
+  private readonly remoteClient;
+  private readonly tracker;
+  private readonly options;
+  private documentId;
+  private remoteRevision;
+  private hasPulled;
+  private pushScheduled;
+  private pushQueue;
+  private listeners;
+  private constructor();
+  get header(): PHDocumentHeader;
+  get state(): InferState<TController>;
+  get operations(): DocumentOperations;
+  get document(): PHDocument$1<InferState<TController>>;
+  get status(): SyncStatus;
+  /** Register a listener for document changes. Returns an unsubscribe function. */
+  onChange(listener: DocumentChangeListener): () => void;
+  private notifyListeners;
+  /** Push all pending actions to remote, then pull latest state. */
+  push(): Promise<PushResult>;
+  /** Delete the document on the remote. */
+  delete(propagate?: PropagationMode): Promise<boolean>;
+  /** Pull latest state from remote, replacing local document. Returns the remote document data. */
+  pull(): Promise<RemoteDocumentData>;
+  /**
+   * Pull an existing document from remote and create a controller for it.
+   */
+  static pull<C extends PHDocumentController<any>>(ControllerClass: new (doc?: PHDocument$1<any>) => C, options: RemoteControllerOptions): Promise<RemoteDocumentControllerWith<C>>;
+  /**
+   * Wrap an existing controller instance with remote capabilities.
+   * Pending local actions on the inner controller are NOT tracked
+   * (only new actions through the remote controller are tracked).
+   */
+  static from<C extends PHDocumentController<any>>(controller: C, options: RemoteControllerOptions): RemoteDocumentControllerWith<C>;
+  /** Create the document on the remote if it doesn't exist yet. */
+  private ensureRemoteDocument;
+  /** Set up interceptors for all action methods on the inner controller. */
+  private setupActionInterceptors;
+  /**
+   * Find the new operation added after applying an action,
+   * by comparing current operation counts against a previous snapshot.
+   */
+  private findNewOperation;
+  /**
+   * Get the last operation in a specific scope, optionally excluding
+   * a given operation (e.g. the one just added).
+   */
+  private getLastOperationInScope;
+  /**
+   * Detect and handle conflicts between local pending actions and remote state.
+   * Returns the (possibly rebased) tracked actions to push.
+   */
+  private handleConflicts;
+  /**
+   * Pull latest remote state and replay actions through interceptors.
+   * Returns newly tracked actions with correct prevOpHash values.
+   */
+  private pullAndReplay;
+  /** Prepare actions for push, optionally signing them. */
+  private prepareActionsForPush;
+  /** Sign an action using the configured signer, preserving existing signatures. */
+  private signAction;
+  /**
+   * Fetch document and operations from the remote.
+   *
+   * On the first pull, uses the combined document+operations query.
+   * On subsequent pulls, fetches only new operations per scope using
+   * sinceRevision, then merges with existing local operations.
+   * Falls back to a full fetch if the merge produces a count mismatch.
+   */
+  private fetchDocumentAndOperations;
+  /**
+   * Incremental fetch: fetches the document and only new operations per scope
+   * using sinceRevision in a single request when possible.
+   * Falls back to a full fetch on count mismatch.
+   */
+  private incrementalFetch;
+  /**
+   * Full fetch fallback: fetches all operations from the beginning.
+   * Used when an incremental fetch produces a count mismatch.
+   */
+  private fullFetch;
+  /**
+   * Validate that the merged operations match the expected revision per scope.
+   * Each scope's operation count should equal its revision number.
+   */
+  private hasExpectedOperationCounts;
+  /**
+   * Merge existing local operations with newly fetched operations.
+   * Appends new operations to existing ones per scope.
+   */
+  private mergeOperations;
+  /** Schedule a push via microtask (for streaming mode coalescing). */
+  private schedulePush;
+}
+//#endregion
+//#region src/remote-controller/utils.d.ts
+/** Error thrown when a push conflict is detected with the "reject" strategy. */
+declare class ConflictError extends Error {
+  readonly conflict: ConflictInfo;
+  constructor(conflict: ConflictInfo);
+}
+/** Convert remote operations to local DocumentOperations format. */
+declare function convertRemoteOperations(operationsByScope: Record<string, RemoteOperation[]>): DocumentOperations;
+//#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,
+  darkMode,
+  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/constants.d.ts
+declare const RENOWN_URL = "https://www.renown.id";
+declare const RENOWN_NETWORK_ID = "eip155";
+declare const RENOWN_CHAIN_ID = "1";
+declare const DOMAIN_TYPE: readonly [{
+  readonly name: "name";
+  readonly type: "string";
+}, {
+  readonly name: "version";
+  readonly type: "string";
+}, {
+  readonly name: "chainId";
+  readonly type: "uint256";
+}, {
+  readonly name: "verifyingContract";
+  readonly type: "address";
+}];
+declare const VERIFIABLE_CREDENTIAL_EIP712_TYPE: readonly [{
+  readonly name: "@context";
+  readonly type: "string[]";
+}, {
+  readonly name: "type";
+  readonly type: "string[]";
+}, {
+  readonly name: "id";
+  readonly type: "string";
+}, {
+  readonly name: "issuer";
+  readonly type: "Issuer";
+}, {
+  readonly name: "credentialSubject";
+  readonly type: "CredentialSubject";
+}, {
+  readonly name: "credentialSchema";
+  readonly type: "CredentialSchema";
+}, {
+  readonly name: "issuanceDate";
+  readonly type: "string";
+}, {
+  readonly name: "expirationDate";
+  readonly type: "string";
+}];
+declare const CREDENTIAL_SCHEMA_EIP712_TYPE: readonly [{
+  readonly name: "id";
+  readonly type: "string";
+}, {
+  readonly name: "type";
+  readonly type: "string";
+}];
+declare const CREDENTIAL_SUBJECT_TYPE: readonly [{
+  readonly name: "app";
+  readonly type: "string";
+}, {
+  readonly name: "id";
+  readonly type: "string";
+}, {
+  readonly name: "name";
+  readonly type: "string";
+}];
+declare const ISSUER_TYPE: readonly [{
+  readonly name: "id";
+  readonly type: "string";
+}, {
+  readonly name: "ethereumAddress";
+  readonly type: "string";
+}];
+declare const CREDENTIAL_TYPES: {
+  readonly EIP712Domain: readonly [{
+    readonly name: "name";
+    readonly type: "string";
+  }, {
+    readonly name: "version";
+    readonly type: "string";
+  }, {
+    readonly name: "chainId";
+    readonly type: "uint256";
+  }, {
+    readonly name: "verifyingContract";
+    readonly type: "address";
+  }];
+  readonly VerifiableCredential: readonly [{
+    readonly name: "@context";
+    readonly type: "string[]";
+  }, {
+    readonly name: "type";
+    readonly type: "string[]";
+  }, {
+    readonly name: "id";
+    readonly type: "string";
+  }, {
+    readonly name: "issuer";
+    readonly type: "Issuer";
+  }, {
+    readonly name: "credentialSubject";
+    readonly type: "CredentialSubject";
+  }, {
+    readonly name: "credentialSchema";
+    readonly type: "CredentialSchema";
+  }, {
+    readonly name: "issuanceDate";
+    readonly type: "string";
+  }, {
+    readonly name: "expirationDate";
+    readonly type: "string";
+  }];
+  readonly CredentialSchema: readonly [{
+    readonly name: "id";
+    readonly type: "string";
+  }, {
+    readonly name: "type";
+    readonly type: "string";
+  }];
+  readonly CredentialSubject: readonly [{
+    readonly name: "app";
+    readonly type: "string";
+  }, {
+    readonly name: "id";
+    readonly type: "string";
+  }, {
+    readonly name: "name";
+    readonly type: "string";
+  }];
+  readonly Issuer: readonly [{
+    readonly name: "id";
+    readonly type: "string";
+  }, {
+    readonly name: "ethereumAddress";
+    readonly type: "string";
+  }];
+};
+//#endregion
+//#region src/renown/use-renown-init.d.ts
+interface RenownInitOptions {
+  appName: string;
+  /**
+   * Prefix for localStorage keys, allowing multiple apps
+   * to use Renown on the same domain without conflicts.
+   */
+  namespace?: string;
+  url?: string;
+}
+/**
+ * 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
+}: 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/storage/base-storage.d.ts
+declare abstract class BaseStorage<V> implements Iterable<[string, V]> {
+  abstract get(key: string): V | undefined;
+  abstract set(key: string, value: V): void;
+  abstract delete(key: string): boolean;
+  abstract has(key: string): boolean;
+  abstract clear(): void;
+  abstract entries(): IterableIterator<[string, V]>;
+  abstract keys(): IterableIterator<string>;
+  abstract values(): IterableIterator<V>;
+  [Symbol.iterator](): IterableIterator<[string, V]>;
+  forEach(callback: (value: V, key: string, storage: BaseStorage<V>) => void): void;
+}
+//#endregion
+//#region src/storage/local-storage.d.ts
+declare class BrowserLocalStorage<V> extends BaseStorage<V> {
+  #private;
+  constructor(namespace: string);
+  get(key: string): V | undefined;
+  set(key: string, value: V): void;
+  delete(key: string): boolean;
+  has(key: string): boolean;
+  clear(): void;
+  entries(): IterableIterator<[string, V]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<V>;
+  [Symbol.iterator](): IterableIterator<[string, V]>;
+}
+//#endregion
+//#region src/storage/types.d.ts
+interface IStorage<TValue> {
+  get(key: string): TValue | undefined;
+  set(key: string, value: TValue): void;
+  delete(key: string): void;
+}
+//#endregion
+//#region src/types/reactor.d.ts
+type NodeKind = "FOLDER" | "FILE";
+//#endregion
+//#region src/utils/documents.d.ts
+declare function isDocumentTypeSupported(documentType: string, supportedDocuments: string[] | null | undefined): boolean;
+//#endregion
+//#region src/utils/drives.d.ts
+type UISyncStatus = "INITIAL_SYNC" | "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR" | "SYNCING";
+declare function getDrives(reactor: IReactorClient): Promise<DocumentDriveDocument[]>;
+declare function getSyncStatus(documentId: string, sharingType: SharingType): Promise<UISyncStatus | undefined>;
+declare function getSyncStatusSync(documentId: string, sharingType: SharingType): UISyncStatus | undefined;
+//#endregion
+//#region src/utils/export-document.d.ts
+declare const exportDocument: (document?: PHDocument$1) => Promise<void | FileSystemFileHandle> | undefined;
+//#endregion
+//#region src/utils/get-revision-from-date.d.ts
+declare const getRevisionFromDate: (startDate?: Date, endDate?: Date, operations?: Operation[]) => number;
+//#endregion
+//#region src/utils/nodes.d.ts
+/** Sorts nodes by name. */
+declare function sortNodesByName<T extends Node>(nodes: T[]): T[];
+/** Returns whether a node is a file. */
+declare function isFileNodeKind(node: Node | null | undefined): node is FileNode;
+/** Returns whether a node is a folder. */
+declare function isFolderNodeKind(node: Node | null | undefined): node is FolderNode;
+//#endregion
+//#region src/utils/switchboard.d.ts
+declare function getDriveIdBySlug(driveUrl: string, slug: string): Promise<string | undefined>;
+declare function getSlugFromDriveUrl(driveUrl: string): string | undefined;
+declare function getSwitchboardGatewayUrlFromDriveUrl(driveUrl: string): string;
+declare function getDocumentGraphqlQuery(): string;
+declare function buildDocumentSubgraphQuery(driveUrl: string, documentId: string, authToken?: string): string;
+declare function buildDocumentSubgraphUrl(driveUrl: string, documentId: string, authToken?: string): string;
+//#endregion
+//#region src/utils/url.d.ts
+declare function resolveUrlPathname(path: string): string;
+/** Returns the current path without the base path */
+declare function getPathWithoutBase(path: string): string;
+/** Makes a URL component for a drive. */
+declare function makeDriveUrlComponent(drive: DocumentDriveDocument | undefined): string;
+/** Makes a URL component for a node. */
+declare function makeNodeSlug(node: Node | undefined): string;
+/** Extracts the node slug from a path.
+ *
+ * The path is expected to be in the format `/d/<drive-slug>/<node-slug>`.
+ */
+declare function extractNodeSlugFromPath(path: string): string | undefined;
+/** Finds a UUID in a string, used for extracting node ids from node slugs in the URL. */
+declare function findUuid(input: string | undefined): string | undefined;
+declare function extractNodeIdFromSlug(nodeSlug: string | undefined): string | undefined;
+declare function extractNodeIdFromPath(path: string): string | undefined;
+/** Extracts the drive slug from a path.
+ * Used for extracting drive ids from drive slugs in the URL.
+ * Expects the path to be in the format `/d/<drive-slug>`.
+ */
+declare function extractDriveSlugFromPath(path: string): string;
+declare function extractDriveIdFromSlug(driveSlug: string | undefined): string | undefined;
+declare function extractDriveIdFromPath(path: string): string | undefined;
+/**
+ * Creates a URL string with the given pathname while preserving existing query parameters.
+ */
+declare function createUrlWithPreservedParams(pathname: string): string;
+//#endregion
+//#region src/utils/user.d.ts
+declare function getUserPermissions(): {
+  isAllowedToCreateDocuments: boolean;
+  isAllowedToEditDocuments: boolean;
+};
+//#endregion
+//#region src/utils/validate-document.d.ts
+declare const validateDocument: (document: PHDocument$1) => ValidationError[];
+//#endregion
+//#region src/utils/vetra.d.ts
+declare function convertLegacyLibToVetraPackage(legacyLib: DocumentModelLib): VetraPackage$1;
+declare function convertLegacyDocumentModelModuleToVetraDocumentModelModule(legacyDocumentModelModule: DocumentModelModule): VetraDocumentModelModule$1;
+declare function convertLegacyEditorModuleToVetraEditorModule(legacyEditorModule: EditorModule, manifest?: Manifest): VetraEditorModule$1;
+declare function makeVetraPackageManifest(vetraPackage: VetraPackage$1): VetraPackageManifest$1;
+//#endregion
+export { ActionTracker, AddPHGlobalEventHandler, AnalyticsProvider, BaseStorage, BrowserLocalStorage, BrowserReactorClientModule, COMMON_PACKAGE_ID, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ChannelScheme, ChevronDownIcon, ConflictError, type ConflictInfo, ConflictResolution, type ConflictStrategy, type ConnectionState, type ConnectionStateSnapshot, CopyIcon, DEFAULT_DRIVE_EDITOR_ID, DOMAIN_TYPE, type Database, DisconnectIcon, DispatchFn, DocumentCache, type RemoteDocumentChangeEvent as DocumentChangeEvent, type DocumentChangeListener, DocumentChangeType, DocumentDispatch, DocumentIntegrityService, DocumentTypeIcon, FileUploadProgress, FileUploadProgressCallback, FulfilledPromise, FullPHGlobalConfig, type GetDocumentResult, type GetDocumentWithOperationsResult, type GetOperationsResult, GqlRequestChannel, IAnalyticsStoreOptions, type IChannel, IDocumentCache, type IDocumentModelLoader, IPackageListerUnsubscribe, IPackageManager, IPackagesListener, IPowerhouseAnalytics, type IProcessor, type IProcessorHostModule, type IRelationalDb, type IRemoteClient, type IRemoteController, ISSUER_TYPE, IStorage, InMemoryQueue, IntervalPollTimer, type Job, type JwtHandler, type KeyframeValidationIssue, LOADING, type MergeHandler, NodeKind, type OperationWithContext, PHAnalyticsGlobalConfig, PHCommonGlobalConfig, PHDocumentEditorConfig, PHDocumentEditorConfigHooks, PHDocumentEditorConfigKey, PHDocumentEditorConfigSetters, PHDriveEditorConfig, PHDriveEditorConfigHooks, PHDriveEditorConfigKey, PHDriveEditorConfigSetters, PHDrivesGlobalConfig, PHGlobal, PHGlobalConfig, PHGlobalConfigHooks, PHGlobalConfigHooksForKey, PHGlobalConfigKey, PHGlobalConfigSetters, PHGlobalConfigSettersForKey, PHGlobalEventHandlerAdders, PHGlobalKey, PHGlobalValue, PHModal, PHProcessorsGlobalConfig, PHRelationalProcessorsGlobalConfig, PHRenownGlobalConfig, PHSentryGlobalConfig, PHToastFn, PHToastOptions, PHToastType, PackageManagerInstallResult, type ParsedDriveUrl, type ProcessorFactory, type ProcessorFilter, type ProcessorRecord, Processors, PromiseState, PromiseWithState, PropagationMode, PublishEvent, type PushResult, QueryCallbackReturnType, REACTOR_SCHEMA, RENOWN_CHAIN_ID, RENOWN_NETWORK_ID, RENOWN_URL, ReactorBuilder, ReactorClientBuilder, ReactorDefaultDrivesConfig, type ReactorGraphQLClient, type RebuildResult, RefreshReactorDataConfig, RegistryClient, RegistryPackageInfo, RejectedPromise, RelationalDbProcessor, RelationalDbWithLive, type Remote, RemoteClient, type RemoteControllerOptions, RemoteDocumentController, type RemoteDocumentControllerWith, type RemoteDocumentData, type RemoteOperation, type RemoteOperationResultPage, Renown, type RenownAuth, RenownAuthButton, type RenownAuthButtonProps, type RenownAuthStatus, type RenownInitOptions, RenownLoginButton, type RenownLoginButtonProps, RenownLogo, type RenownProps, RenownUserButton, type RenownUserButtonMenuItem, type RenownUserButtonProps, SetEvent, SetPHGlobalValue, type SignerConfig, type SnapshotValidationIssue, SpinnerIcon, type SyncOperation, SyncOperationStatus, type SyncStatus, TimelineBarItem, TimelineDividerItem, TimelineItem, type TrackedAction, UISyncStatus, UseAddSeriesValueOptions, UseAddSeriesValuesOptions, UseAnalyticsQueryOptions, UseAnalyticsQueryResult, UseAnalyticsSeriesOptions, UseClearEmptyAnalyticsDimensionsOptions, UseClearSeriesBySourceOptions, UseDispatchResult, UseGetDimensionsOptions, UseMatchingSeriesOptions, UseOnDropFile, UsePHGlobalValue, UseQuerySourcesOptions, UseTimelineItemsResult, UserIcon, VERIFIABLE_CREDENTIAL_EIP712_TYPE, type ValidationResult, VetraDocumentModelModule, VetraEditorModule, VetraMeta, VetraModule, VetraModules, VetraPackage, VetraPackageManifest, VetraPackageMeta, VetraProcessorModule, addAllowListEventHandler, addAllowedDocumentTypesEventHandler, addAnalyticsDatabaseNameEventHandler, addBasePathEventHandler, addCliVersionEventHandler, addDefaultDrivesUrlEventHandler, addDisabledEditorsEventHandler, addDocument, addDocumentCacheEventHandler, addDrive, addDrivesEventHandler, addDrivesPreserveStrategyEventHandler, addEnabledEditorsEventHandler, addFeaturesEventHandler, addFileUploadOperationsChunkSizeEventHandler, addFolder, addGaTrackingIdEventHandler, addIsAddCloudDrivesEnabledEventHandler, addIsAddDriveEnabledEventHandler, addIsAddLocalDrivesEnabledEventHandler, addIsAddPublicDrivesEnabledEventHandler, addIsAnalyticsDatabaseWorkerEnabledEventHandler, addIsAnalyticsEnabledEventHandler, addIsAnalyticsExternalProcessorsEnabledEventHandler, addIsCloudDrivesEnabledEventHandler, addIsDeleteCloudDrivesEnabledEventHandler, addIsDeleteLocalDrivesEnabledEventHandler, addIsDeletePublicDrivesEnabledEventHandler, addIsDiffAnalyticsEnabledEventHandler, addIsDocumentModelSelectionSettingsEnabledEventHandler, addIsDragAndDropEnabledEventHandler, addIsDriveAnalyticsEnabledEventHandler, addIsEditorDebugModeEnabledEventHandler, addIsEditorReadModeEnabledEventHandler, addIsExternalControlsEnabledEventHandler, addIsExternalPackagesEnabledEventHandler, addIsExternalProcessorsEnabledEventHandler, addIsExternalRelationalProcessorsEnabledEventHandler, addIsLocalDrivesEnabledEventHandler, addIsPublicDrivesEnabledEventHandler, addIsRelationalProcessorsEnabledEventHandler, addIsSentryTracingEnabledEventHandler, addLoadingEventHandler, addLocalDrivesEnabledEventHandler, addLogLevelEventHandler, addModalEventHandler, addPHEventHandlers, addPromiseState, addReactorClientEventHandler, addReactorClientModuleEventHandler, addRemoteDrive, addRenownChainIdEventHandler, addRenownEventHandler, addRenownNetworkIdEventHandler, addRenownUrlEventHandler, addRequiresHardRefreshEventHandler, addResetSelectedNodeEventHandler, addRevisionHistoryVisibleEventHandler, addRouterBasenameEventHandler, addSelectedDriveIdEventHandler, addSelectedNodeIdEventHandler, addSelectedTimelineItemEventHandler, addSelectedTimelineRevisionEventHandler, addSentryDsnEventHandler, addSentryEnvEventHandler, addSentryReleaseEventHandler, addSetSelectedDriveOnPopStateEventHandler, addSetSelectedNodeOnPopStateEventHandler, addStudioModeEventHandler, addToastEventHandler, addVersionCheckIntervalEventHandler, addVersionEventHandler, addVetraPackageManagerEventHandler, addWarnOutdatedAppEventHandler, analyticsEngineKey, analyticsOptionsKey, analyticsStoreKey, baseDocumentModels, baseDocumentModelsMap, buildDocumentSubgraphQuery, buildDocumentSubgraphUrl, callGlobalSetterForKey, clearGlobal, closePHModal, convertLegacyDocumentModelModuleToVetraDocumentModelModule, convertLegacyEditorModuleToVetraEditorModule, convertLegacyLibToVetraPackage, convertRemoteOperations, createAnalyticsStore, createClient, createProcessorQuery, createUrlWithPreservedParams, deleteDrive, deleteNode, dispatchActions, driveCollectionId, driveIdFromUrl, dropAllReactorStorage, exportDocument, exportFile, extractDriveIdFromPath, extractDriveIdFromSlug, extractDriveSlugFromPath, extractNodeIdFromPath, extractNodeIdFromSlug, extractNodeSlugFromPath, findUuid, getAnalyticsStore, getDocumentGraphqlQuery, getDriveIdBySlug, getDrives, getGlobal, getPackages, getPackagesByDocumentType, getPathWithoutBase, getRevisionFromDate, getSlugFromDriveUrl, getSwitchboardGatewayUrlFromDriveUrl, getSyncStatus, getSyncStatusSync, getUserPermissions, hideRevisionHistory, initConnectCrypto, initRenownCrypto, isDocumentTypeSupported, isExternalControlsEnabledEventFunctions, isFileNodeKind, isFolderNodeKind, isInspectorEnabledSync, loading, login, logout, makeDriveUrlComponent, makeNodeSlug, makePHEventFunctions, makeVetraPackageManifest, openRenown, parseDriveUrl, phDocumentEditorConfigHooks, phDocumentEditorConfigSetters, phDriveEditorConfigHooks, phDriveEditorConfigSetters, phGlobalConfigHooks, phGlobalConfigSetters, readPromiseState, refreshReactorData, refreshReactorDataClient, renameDrive, renameDriveNode, resolveUrlPathname, setAllowList, setAllowedDocumentTypes, setAnalyticsDatabaseName, setBasePath, setCliVersion, setDefaultDrivesUrl, setDefaultPHGlobalConfig, setDisabledEditors, setDocumentCache, setDriveAvailableOffline, setDriveSharingType, setDrives, setDrivesPreserveStrategy, setEnabledEditors, setFeatures, setFileUploadOperationsChunkSize, setGaTrackingId, setGlobal, setIsAddCloudDrivesEnabled, setIsAddDriveEnabled, setIsAddLocalDrivesEnabled, setIsAddPublicDrivesEnabled, setIsAnalyticsDatabaseWorkerEnabled, setIsAnalyticsEnabled, setIsAnalyticsExternalProcessorsEnabled, setIsCloudDrivesEnabled, setIsDeleteCloudDrivesEnabled, setIsDeleteLocalDrivesEnabled, setIsDeletePublicDrivesEnabled, setIsDiffAnalyticsEnabled, setIsDocumentModelSelectionSettingsEnabled, setIsDragAndDropEnabled, setIsDriveAnalyticsEnabled, setIsEditorDebugModeEnabled, setIsEditorReadModeEnabled, setIsExternalControlsEnabled, setIsExternalPackagesEnabled, setIsExternalProcessorsEnabled, setIsExternalRelationalProcessorsEnabled, setIsLocalDrivesEnabled, setIsPublicDrivesEnabled, setIsRelationalProcessorsEnabled, setIsSentryTracingEnabled, setLoading, setLocalDrivesEnabled, setLogLevel, setPHDocumentEditorConfig, setPHDocumentEditorConfigByKey, setPHDriveEditorConfig, setPHDriveEditorConfigByKey, setPHGlobalConfig, setPHGlobalConfigByKey, setPHModal, setPHToast, setReactorClient, setReactorClientModule, setRenown, setRenownChainId, setRenownNetworkId, setRenownUrl, setRequiresHardRefresh, setRevisionHistoryVisible, setRouterBasename, setSelectedDrive, setSelectedNode, setSelectedTimelineItem, setSelectedTimelineRevision, setSentryDsn, setSentryEnv, setSentryRelease, setStudioMode, setVersion, setVersionCheckInterval, setVetraPackageManager, setWarnOutdatedApp, showCreateDocumentModal, showDeleteNodeModal, showPHModal, showRevisionHistory, sortNodesByName, truncateAllTables, useAddSeriesValue, useAddSeriesValues, useAllowList, useAllowedDocumentModelModules, useAllowedDocumentTypes, useAnalyticsDatabaseName, useAnalyticsEngine, useAnalyticsEngineAsync, useAnalyticsQuery, useAnalyticsSeries, useAnalyticsStore, useAnalyticsStoreAsync, useAnalyticsStoreOptions, useAnalyticsStoreQuery, useBasePath, useClearEmptyAnalyticsDimensions, useClearSeriesBySource, useCliVersion, useConnectionState, useConnectionStates, useCreateAnalyticsStore, useDatabase, useDefaultDriveEditorModule, useDefaultDrivesUrl, useDid, useDisabledEditors, useDispatch, useDocument, useDocumentById, useDocumentCache, useDocumentModelModuleById, useDocumentModelModules, useDocumentOfType, useDocumentOperations, useDocumentTimeline, useDocumentTypes, useDocumentTypesInSelectedDrive, useDocuments, useDocumentsByIds, useDocumentsInSelectedDrive, useDocumentsInSelectedFolder, useDriveById, useDriveEditorModuleById, useDriveEditorModules, useDrives, useDrivesPreserveStrategy, useEditorModuleById, useEditorModules, useEditorModulesForDocumentType, useEnabledEditors, useFallbackEditorModule, useFeatures, useFileNodesInSelectedDrive, useFileNodesInSelectedFolder, useFileUploadOperationsChunkSize, useFolderById, useFolderNodesInSelectedDrive, useFolderNodesInSelectedFolder, useGaTrackingId, useGetDimensions, useGetDocument, useGetDocumentAsync, useGetDocuments, useGetSwitchboardLink, useImportScriptModules, useInspectorEnabled, useIsAddCloudDrivesEnabled, useIsAddDriveEnabled, useIsAddLocalDrivesEnabled, useIsAddPublicDrivesEnabled, useIsAnalyticsDatabaseWorkerEnabled, useIsAnalyticsEnabled, useIsAnalyticsExternalProcessorsEnabled, useIsCloudDrivesEnabled, useIsDeleteCloudDrivesEnabled, useIsDeleteLocalDrivesEnabled, useIsDeletePublicDrivesEnabled, useIsDiffAnalyticsEnabled, useIsDocumentModelSelectionSettingsEnabled, useIsDragAndDropEnabled, useIsDriveAnalyticsEnabled, useIsEditorDebugModeEnabled, useIsEditorReadModeEnabled, useIsExternalControlsEnabled, useIsExternalPackagesEnabled, useIsExternalProcessorsEnabled, useIsExternalRelationalProcessorsEnabled, useIsLocalDrivesEnabled, useIsPublicDrivesEnabled, useIsRelationalProcessorsEnabled, useIsSentryTracingEnabled, useLoading, useLocalDrivesEnabled, useLogLevel, useLoginStatus, useMatchingSeries, useModelRegistry, useNodeActions, useNodeById, useNodeParentFolderById, useNodePathById, useNodesInSelectedDrive, useNodesInSelectedDriveOrFolder, useNodesInSelectedFolder, useOnDropFile, usePGlite, usePHDocumentEditorConfigByKey, usePHDriveEditorConfigByKey, usePHGlobalConfigByKey, usePHModal, usePHToast, useParentFolderForSelectedNode, useQuerySources, useReactorClient, useReactorClientModule, useRelationalDb, useRelationalQuery, useRelationalQueryOptions, useRenown, useRenownAuth, useRenownChainId, useRenownInit, useRenownNetworkId, useRenownUrl, useRequiresHardRefresh, useResetPHGlobalConfig, useRevisionHistoryVisible, useRouterBasename, useSelectedDocument, useSelectedDocumentId, useSelectedDocumentOfType, useSelectedDocumentSafe, useSelectedDrive, useSelectedDriveId, useSelectedDriveSafe, useSelectedFolder, useSelectedNode, useSelectedNodePath, useSelectedTimelineItem, useSelectedTimelineRevision, useSentryDsn, useSentryEnv, useSentryRelease, useSetDefaultPHGlobalConfig, useSetPHDocumentEditorConfig, useSetPHDriveEditorConfig, useSetPHGlobalConfig, useStudioMode, useSubgraphModules, useSupportedDocumentTypesInReactor, useSync, useSyncList, useTimelineItems, useUser, useUserPermissions, useVersion, useVersionCheckInterval, useVetraPackageManager, useVetraPackages, useWarnOutdatedApp, validateDocument };
+//# sourceMappingURL=index.d.ts.map