@powerhousedao/reactor-api 6.0.0-dev.21 → 6.0.0-dev.211

package/dist/index.d.mts

@@ -0,0 +1,2991 @@
+import { i as IPackageManagerOptions, n as IPackageLoaderOptions, r as IPackageManager, s as PackageManagerResult, t as IPackageLoader } from "./types-Do4QTfT3.mjs";
+import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
+import { AnalyticsModel } from "@powerhousedao/analytics-engine-graphql";
+import * as graphql from "graphql";
+import { DocumentNode, GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig, GraphQLSchema } from "graphql";
+import { ILogger } from "document-model";
+import { CorsOptions } from "cors";
+import http from "node:http";
+import { DocumentModelGlobalState as DocumentModelGlobalState$1, DocumentModelModule, Operation, PHDocument, PHDocumentHeader } from "@powerhousedao/shared/document-model";
+import { IDocumentModelLoader, IDocumentModelRegistry, IReactorClient, IRelationalDb, ISyncManager, ParsedDriveUrl, ReactorClientModule, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
+import * as z$1 from "zod";
+import { DocumentDriveDocument, DocumentDriveGlobalState } from "@powerhousedao/shared/document-drive";
+import { AttachmentBuildResult } from "@powerhousedao/reactor-attachments";
+import { WebSocketServer } from "ws";
+import { IProcessorHostModule, IRelationalDb as IRelationalDb$1, ProcessorApp, ProcessorRecord } from "@powerhousedao/shared/processors";
+import { Generated, Kysely } from "kysely";
+import { PGlite } from "@electric-sql/pglite";
+import { Knex } from "knex";
+import { GraphQLResolverMap, GraphQLSchemaModule } from "@apollo/subgraph/dist/schema-helper/resolverMap.js";
+import { Context as Context$1, GqlDocument as GqlDocument$1, GqlDriveDocument as GqlDriveDocument$1, GqlOperation as GqlOperation$1, GraphQLManager as GraphQLManager$1, ISubgraph as ISubgraph$1, Processor as Processor$1, SubgraphArgs as SubgraphArgs$1, SubgraphClass as SubgraphClass$1 } from "@powerhousedao/reactor-api";
+import { IncomingHttpHeaders } from "http";
+import { Pool } from "pg";
+
+//#region src/utils/db.d.ts
+/**
+ * Permission levels for documents:
+ * - READ: Can fetch and read the document
+ * - WRITE: Can push updates and modify the document
+ * - ADMIN: Can manage document permissions and settings
+ */
+type DocumentPermissionLevel = "READ" | "WRITE" | "ADMIN";
+/**
+ * Database schema for document permissions
+ */
+interface DocumentProtectionTable {
+  documentId: string;
+  protected: boolean;
+  ownerAddress: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface DocumentPermissionDatabase {
+  DocumentPermission: DocumentPermissionTable;
+  Group: GroupTable;
+  UserGroup: UserGroupTable;
+  DocumentGroupPermission: DocumentGroupPermissionTable;
+  OperationUserPermission: OperationUserPermissionTable;
+  OperationGroupPermission: OperationGroupPermissionTable;
+  DocumentProtection: DocumentProtectionTable;
+}
+interface DocumentPermissionTable {
+  id: Generated<number>;
+  documentId: string;
+  userAddress: string;
+  permission: DocumentPermissionLevel;
+  grantedBy: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface GroupTable {
+  id: Generated<number>;
+  name: string;
+  description: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface UserGroupTable {
+  userAddress: string;
+  groupId: number;
+  createdAt: Date;
+}
+interface DocumentGroupPermissionTable {
+  id: Generated<number>;
+  documentId: string;
+  groupId: number;
+  permission: DocumentPermissionLevel;
+  grantedBy: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface OperationUserPermissionTable {
+  id: Generated<number>;
+  documentId: string;
+  operationType: string;
+  userAddress: string;
+  grantedBy: string;
+  createdAt: Date;
+}
+interface OperationGroupPermissionTable {
+  id: Generated<number>;
+  documentId: string;
+  operationType: string;
+  groupId: number;
+  grantedBy: string;
+  createdAt: Date;
+}
+type Db = Kysely<any>;
+declare function getDbClient(connectionString?: string | undefined): {
+  db: Db;
+  knex: Knex;
+};
+declare const initAnalyticsStoreSql: string[];
+//#endregion
+//#region src/services/document-permission.service.d.ts
+interface DocumentPermissionEntry {
+  documentId: string;
+  userAddress: string;
+  permission: DocumentPermissionLevel;
+  grantedBy: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface Group {
+  id: number;
+  name: string;
+  description: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface DocumentGroupPermissionEntry {
+  documentId: string;
+  groupId: number;
+  permission: DocumentPermissionLevel;
+  grantedBy: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface OperationUserPermissionEntry {
+  documentId: string;
+  operationType: string;
+  userAddress: string;
+  grantedBy: string;
+  createdAt: Date;
+}
+interface OperationGroupPermissionEntry {
+  documentId: string;
+  operationType: string;
+  groupId: number;
+  grantedBy: string;
+  createdAt: Date;
+}
+/**
+ * Function type for getting parent document IDs
+ * This is injected to avoid circular dependencies with the reactor client
+ */
+type GetParentIdsFn = (documentId: string) => Promise<string[]>;
+/**
+ * Configuration for the DocumentPermissionService
+ */
+interface DocumentPermissionConfig {
+  defaultProtection: boolean;
+}
+/**
+ * Service for managing document-level permissions.
+ *
+ * Permission levels for documents:
+ * - READ: Can fetch and read the document
+ * - WRITE: Can push updates and modify the document
+ * - ADMIN: Can manage document permissions and settings
+ *
+ * Operation permissions:
+ * - Users and groups can be granted permission to execute specific operations
+ */
+declare class DocumentPermissionService {
+  private readonly db;
+  readonly config: DocumentPermissionConfig;
+  constructor(db: Kysely<DocumentPermissionDatabase>, config?: DocumentPermissionConfig);
+  /**
+   * Get the permission level for a user on a specific document.
+   * Returns null if no permission is set.
+   */
+  getUserPermission(documentId: string, userAddress: string): Promise<DocumentPermissionLevel | null>;
+  /**
+   * Get all permissions for a document
+   */
+  getDocumentPermissions(documentId: string): Promise<DocumentPermissionEntry[]>;
+  /**
+   * Get all documents a user has explicit access to
+   */
+  getUserDocuments(userAddress: string): Promise<DocumentPermissionEntry[]>;
+  /**
+   * Grant or update a user's permission on a document.
+   */
+  grantPermission(documentId: string, userAddress: string, permission: DocumentPermissionLevel, grantedBy: string): Promise<DocumentPermissionEntry>;
+  /**
+   * Revoke a user's permission on a document
+   */
+  revokePermission(documentId: string, userAddress: string): Promise<void>;
+  /**
+   * Delete all permissions for a document (used when deleting a document)
+   */
+  deleteAllDocumentPermissions(documentId: string): Promise<void>;
+  /**
+   * Check if a user can read a document.
+   * Returns true if user has READ, WRITE, or ADMIN permission (direct or via group)
+   */
+  canReadDocument(documentId: string, userAddress: string | undefined): Promise<boolean>;
+  /**
+   * Check if a user can write to a document.
+   * Returns true if user has WRITE or ADMIN permission (direct or via group)
+   */
+  canWriteDocument(documentId: string, userAddress: string | undefined): Promise<boolean>;
+  /**
+   * Check if a user can manage a document (change permissions, settings).
+   * Returns true if user has ADMIN permission (direct or via group)
+   */
+  canManageDocument(documentId: string, userAddress: string | undefined): Promise<boolean>;
+  /**
+   * Check if a user can read a document, including parent permission inheritance.
+   * Returns true if user has permission on the document OR any parent in the hierarchy.
+   */
+  canRead(documentId: string, userAddress: string | undefined, getParentIds: GetParentIdsFn): Promise<boolean>;
+  /**
+   * Check if a user can write to a document, including parent permission inheritance.
+   * Returns true if user has write permission on the document OR any parent in the hierarchy.
+   */
+  canWrite(documentId: string, userAddress: string | undefined, getParentIds: GetParentIdsFn): Promise<boolean>;
+  /**
+   * Filter a list of document IDs to only include those the user can read.
+   */
+  filterReadableDocuments(documentIds: string[], userAddress: string | undefined, getParentIds: GetParentIdsFn): Promise<string[]>;
+  /**
+   * Create a new group
+   */
+  createGroup(name: string, description?: string): Promise<Group>;
+  /**
+   * Delete a group and all its associations
+   */
+  deleteGroup(groupId: number): Promise<void>;
+  /**
+   * Get a group by ID
+   */
+  getGroup(groupId: number): Promise<Group | null>;
+  /**
+   * List all groups
+   */
+  listGroups(): Promise<Group[]>;
+  /**
+   * Add a user to a group
+   */
+  addUserToGroup(userAddress: string, groupId: number): Promise<void>;
+  /**
+   * Remove a user from a group
+   */
+  removeUserFromGroup(userAddress: string, groupId: number): Promise<void>;
+  /**
+   * Get all groups a user belongs to
+   */
+  getUserGroups(userAddress: string): Promise<Group[]>;
+  /**
+   * Get all members of a group
+   */
+  getGroupMembers(groupId: number): Promise<string[]>;
+  /**
+   * Grant a group permission on a document
+   */
+  grantGroupPermission(documentId: string, groupId: number, permission: DocumentPermissionLevel, grantedBy: string): Promise<DocumentGroupPermissionEntry>;
+  /**
+   * Revoke a group's permission on a document
+   */
+  revokeGroupPermission(documentId: string, groupId: number): Promise<void>;
+  /**
+   * Get all group permissions for a document
+   */
+  getDocumentGroupPermissions(documentId: string): Promise<DocumentGroupPermissionEntry[]>;
+  /**
+   * Get best permission level a user has on a document via groups
+   */
+  getUserGroupPermission(documentId: string, userAddress: string): Promise<DocumentPermissionLevel | null>;
+  /**
+   * Grant a user permission to execute an operation on a document
+   */
+  grantOperationPermission(documentId: string, operationType: string, userAddress: string, grantedBy: string): Promise<OperationUserPermissionEntry>;
+  /**
+   * Revoke a user's permission to execute an operation
+   */
+  revokeOperationPermission(documentId: string, operationType: string, userAddress: string): Promise<void>;
+  /**
+   * Grant a group permission to execute an operation on a document
+   */
+  grantGroupOperationPermission(documentId: string, operationType: string, groupId: number, grantedBy: string): Promise<OperationGroupPermissionEntry>;
+  /**
+   * Revoke a group's permission to execute an operation
+   */
+  revokeGroupOperationPermission(documentId: string, operationType: string, groupId: number): Promise<void>;
+  /**
+   * Get all users with permission to execute an operation
+   */
+  getOperationUserPermissions(documentId: string, operationType: string): Promise<OperationUserPermissionEntry[]>;
+  /**
+   * Get all groups with permission to execute an operation
+   */
+  getOperationGroupPermissions(documentId: string, operationType: string): Promise<OperationGroupPermissionEntry[]>;
+  /**
+   * Check if a user can execute a specific operation on a document.
+   * Returns true if user has direct permission or is in a group with permission.
+   */
+  canExecuteOperation(documentId: string, operationType: string, userAddress: string | undefined): Promise<boolean>;
+  /**
+   * Check if an operation has any permissions set (is restricted)
+   */
+  isOperationRestricted(documentId: string, operationType: string): Promise<boolean>;
+  /**
+   * Check if a specific document has a protection row set to true.
+   * Falls back to `config.defaultProtection` if no row exists.
+   */
+  isDocumentProtected(documentId: string): Promise<boolean>;
+  /**
+   * Walk the parent chain: if the document itself or any ancestor is protected, return true.
+   * Collects all ancestor IDs first (with cycle detection), then batch-checks protection.
+   */
+  isProtectedWithAncestors(documentId: string, getParentIds: GetParentIdsFn): Promise<boolean>;
+  /**
+   * Collect all ancestor IDs (including the document itself) with cycle detection.
+   */
+  private collectAncestorIds;
+  /**
+   * Upsert protection status for a document.
+   */
+  setDocumentProtection(documentId: string, isProtected: boolean): Promise<void>;
+  /**
+   * Get the owner address for a document, or null if not set.
+   */
+  getDocumentOwner(documentId: string): Promise<string | null>;
+  /**
+   * Upsert owner address for a document.
+   */
+  setDocumentOwner(documentId: string, ownerAddress: string): Promise<void>;
+  /**
+   * Initialize protection for a newly created document.
+   * Sets protection status and grants ADMIN to the owner.
+   */
+  initializeDocumentProtection(documentId: string, ownerAddress: string, defaultProtection?: boolean): Promise<void>;
+  /**
+   * Get the full protection info for a document.
+   */
+  getDocumentProtection(documentId: string): Promise<{
+    documentId: string;
+    protected: boolean;
+    ownerAddress: string | null;
+  }>;
+}
+//#endregion
+//#region src/services/authorization.service.d.ts
+interface AuthorizationConfig {
+  admins: string[];
+  defaultProtection: boolean;
+}
+/**
+ * Central authorization service — single source of truth for all permission checks.
+ *
+ * Authorization model:
+ * 1. Supreme admin (ADMINS env) → ALLOW ALL
+ * 2. Is document protected?
+ *    a. NOT protected:
+ *       - READ: anyone (even anonymous) → ALLOW
+ *       - WRITE: authenticated user → ALLOW
+ *    b. PROTECTED:
+ *       - READ: requires explicit READ/WRITE/ADMIN grant (direct or via group/parent)
+ *       - WRITE: requires explicit WRITE/ADMIN grant (direct or via group/parent)
+ * 3. Operation restricted? → Check OperationUserPermission
+ * 4. Document owner = implicit ADMIN
+ * 5. Drive protected = all children effectively protected
+ */
+declare class AuthorizationService {
+  private readonly documentPermissionService;
+  readonly config: AuthorizationConfig;
+  constructor(documentPermissionService: DocumentPermissionService, config: AuthorizationConfig);
+  /**
+   * Check if a user is a supreme admin (from ADMINS env var).
+   */
+  isSupremeAdmin(userAddress?: string): boolean;
+  /**
+   * Check if a user can read a document.
+   *
+   * - Supreme admin → yes
+   * - Not protected → anyone can read (even anonymous)
+   * - Protected → requires READ/WRITE/ADMIN grant (direct, group, or parent inheritance)
+   * - Owner → yes (implicit ADMIN)
+   */
+  canRead(documentId: string, userAddress?: string, getParentIds?: GetParentIdsFn): Promise<boolean>;
+  /**
+   * Check if a user can write to a document.
+   *
+   * - Supreme admin → yes
+   * - Not protected → anyone can write (even anonymous)
+   * - Protected → requires authentication + WRITE/ADMIN grant
+   * - Owner → yes (implicit ADMIN)
+   */
+  canWrite(documentId: string, userAddress?: string, getParentIds?: GetParentIdsFn): Promise<boolean>;
+  /**
+   * Check if a user can manage a document (change permissions, protection, transfer ownership).
+   *
+   * - Supreme admin → yes
+   * - Owner → yes
+   * - Has ADMIN grant → yes
+   */
+  canManage(documentId: string, userAddress?: string, getParentIds?: GetParentIdsFn): Promise<boolean>;
+  /**
+   * Check if a user can execute a specific operation.
+   * If the operation is not restricted, falls through to the standard write check.
+   * If the operation is restricted, requires an explicit OperationUserPermission grant.
+   */
+  canExecuteOperation(documentId: string, operationType: string, userAddress?: string, getParentIds?: GetParentIdsFn): Promise<boolean>;
+  /**
+   * Combined check for mutations: can the user write + execute the operation?
+   * This enables READ-only users with operation grants to execute specific operations.
+   * For restricted operations, only the operation grant is checked (bypasses write check),
+   * allowing READ-only users with an explicit operation grant to execute that operation.
+   */
+  canMutate(documentId: string, operationType: string, userAddress?: string, getParentIds?: GetParentIdsFn): Promise<boolean>;
+}
+//#endregion
+//#region src/graphql/types.d.ts
+type SubgraphClass = typeof BaseSubgraph;
+type Context = {
+  driveId?: string;
+  document?: PHDocument;
+  headers: IncomingHttpHeaders;
+  db: unknown;
+  isAdmin?: (address: string) => boolean;
+  user?: {
+    address: string;
+    chainId: number;
+    networkId: string;
+  };
+  documentPermissionService?: DocumentPermissionService;
+  authorizationService?: AuthorizationService;
+};
+type ISubgraph = {
+  name: string;
+  path?: string;
+  resolvers: Record<string, any>;
+  typeDefs: DocumentNode;
+  reactorClient: IReactorClient;
+  relationalDb: IRelationalDb;
+  hasSubscriptions?: boolean;
+  onSetup?: () => Promise<void>;
+};
+type SubgraphArgs = {
+  reactorClient: IReactorClient;
+  relationalDb: IRelationalDb;
+  analyticsStore: IAnalyticsStore;
+  graphqlManager: GraphQLManager$1;
+  syncManager: ISyncManager;
+  documentPermissionService?: DocumentPermissionService;
+  authorizationService?: AuthorizationService;
+  path?: string;
+};
+type GqlSigner = {
+  user: {
+    address: string;
+    networkId: string;
+    chainId: number;
+  };
+  app: {
+    name: string;
+    key: string;
+  };
+  signatures: string[];
+};
+type GqlOperationContext = {
+  signer: GqlSigner | undefined;
+};
+type GqlSignerUser = {
+  address: string;
+  networkId: string;
+  chainId: number;
+};
+type GqlSignerApp = {
+  name: string;
+  key: string;
+};
+type GqlOperation = {
+  id: string;
+  type: string;
+  index: number;
+  timestampUtcMs: string;
+  hash: string;
+  skip: number;
+  inputText: string;
+  error: string | undefined;
+  context: GqlOperationContext;
+};
+type GqlDocument = {
+  __typename?: string;
+  id: string;
+  name: string;
+  documentType: string;
+  revision: number;
+  createdAtUtcIso: string;
+  lastModifiedAtUtcIso: string;
+  operations: GqlOperation[];
+  stateJSON: JSON;
+  state: unknown;
+  initialState: unknown;
+};
+type GqlDriveDocument = GqlDocument & {
+  meta: {
+    preferredEditor?: string;
+  };
+  slug: string;
+  state: DocumentDriveGlobalState;
+  initialState: DocumentDriveGlobalState;
+};
+//#endregion
+//#region src/graphql/base-subgraph.d.ts
+declare class BaseSubgraph implements ISubgraph$1 {
+  name: string;
+  path: string;
+  resolvers: Record<string, any>;
+  typeDefs: DocumentNode;
+  reactorClient: IReactorClient;
+  graphqlManager: GraphQLManager$1;
+  relationalDb: IRelationalDb;
+  syncManager: ISyncManager;
+  documentPermissionService?: DocumentPermissionService;
+  authorizationService?: AuthorizationService;
+  constructor(args: SubgraphArgs$1);
+  onSetup(): Promise<void>;
+  protected getParentIdsFn(): GetParentIdsFn;
+  protected hasGlobalAdminAccess(ctx: Context): boolean;
+  protected canReadDocument(documentId: string, ctx: Context): Promise<boolean>;
+  protected assertCanRead(documentId: string, ctx: Context): Promise<void>;
+  protected assertCanWrite(documentId: string, ctx: Context): Promise<void>;
+  protected assertCanExecuteOperation(documentId: string, operationType: string, ctx: Context): Promise<void>;
+}
+//#endregion
+//#region src/graphql/analytics-subgraph.d.ts
+declare class AnalyticsSubgraph extends BaseSubgraph {
+  analyticsStore: IAnalyticsStore;
+  analyticsModel: AnalyticsModel;
+  name: string;
+  typeDefs: graphql.DocumentNode;
+  resolvers: GraphQLResolverMap<Context$1>;
+  constructor(args: SubgraphArgs$1);
+}
+//#endregion
+//#region src/graphql/auth/resolvers.d.ts
+type DocumentAccessInfo = {
+  documentId: string;
+  permissions: Array<{
+    documentId: string;
+    userAddress: string;
+    permission: DocumentPermissionLevel;
+    grantedBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+  }>;
+  groupPermissions: Array<{
+    documentId: string;
+    groupId: number;
+    permission: DocumentPermissionLevel;
+    grantedBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+  }>;
+};
+type Group$1 = {
+  id: number;
+  name: string;
+  description: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+};
+type DocumentGroupPermission = {
+  documentId: string;
+  groupId: number;
+  permission: DocumentPermissionLevel;
+  grantedBy: string;
+  createdAt: Date;
+  updatedAt: Date;
+};
+type OperationUserPermission = {
+  documentId: string;
+  operationType: string;
+  userAddress: string;
+  grantedBy: string;
+  createdAt: Date;
+};
+type OperationGroupPermission = {
+  documentId: string;
+  operationType: string;
+  groupId: number;
+  grantedBy: string;
+  createdAt: Date;
+};
+type OperationPermissionsInfo = {
+  documentId: string;
+  operationType: string;
+  userPermissions: OperationUserPermission[];
+  groupPermissions: OperationGroupPermission[];
+};
+type DocumentProtectionInfo = {
+  documentId: string;
+  protected: boolean;
+  ownerAddress: string | null;
+};
+//#endregion
+//#region src/graphql/auth/subgraph.d.ts
+/**
+ * Auth Subgraph - handles all document permission and authorization operations
+ *
+ * This subgraph is conditionally registered based on the DOCUMENT_PERMISSIONS_ENABLED
+ * feature flag. When enabled, it provides GraphQL operations for:
+ * - Document permissions (grant/revoke user access)
+ * - Group management (create/delete groups, manage membership)
+ * - Group document permissions (grant/revoke group access)
+ * - Operation-level permissions (fine-grained operation control)
+ */
+declare class AuthSubgraph extends BaseSubgraph {
+  private logger;
+  constructor(args: SubgraphArgs);
+  name: string;
+  hasSubscriptions: boolean;
+  typeDefs: graphql.DocumentNode;
+  resolvers: {
+    Query: {
+      documentAccess: (_parent: unknown, args: {
+        documentId: string;
+      }) => Promise<DocumentAccessInfo>;
+      userDocumentPermissions: (_parent: unknown, _args: unknown, ctx: {
+        user?: {
+          address: string;
+        };
+      }) => Promise<{
+        documentId: string;
+        userAddress: string;
+        permission: DocumentPermissionLevel;
+        grantedBy: string;
+        createdAt: Date;
+        updatedAt: Date;
+      }[]>;
+      groups: () => Promise<Group$1[]>;
+      group: (_parent: unknown, args: {
+        id: number;
+      }) => Promise<Group$1 | null>;
+      userGroups: (_parent: unknown, args: {
+        userAddress: string;
+      }) => Promise<Group$1[]>;
+      operationPermissions: (_parent: unknown, args: {
+        documentId: string;
+        operationType: string;
+      }) => Promise<OperationPermissionsInfo>;
+      canExecuteOperation: (_parent: unknown, args: {
+        documentId: string;
+        operationType: string;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+      }) => Promise<boolean>;
+      documentProtection: (_parent: unknown, args: {
+        documentId: string;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+      }) => Promise<DocumentProtectionInfo>;
+    };
+    Mutation: {
+      setDocumentProtection: (_parent: unknown, args: {
+        documentId: string;
+        protected: boolean;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<DocumentProtectionInfo>;
+      transferDocumentOwnership: (_parent: unknown, args: {
+        documentId: string;
+        newOwnerAddress: string;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<DocumentProtectionInfo>;
+      grantDocumentPermission: (_parent: unknown, args: {
+        documentId: string;
+        userAddress: string;
+        permission: string;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<{
+        documentId: string;
+        userAddress: string;
+        permission: DocumentPermissionLevel;
+        grantedBy: string;
+        createdAt: Date;
+        updatedAt: Date;
+      }>;
+      revokeDocumentPermission: (_parent: unknown, args: {
+        documentId: string;
+        userAddress: string;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<boolean>;
+      createGroup: (_parent: unknown, args: {
+        name: string;
+        description?: string | null;
+      }) => Promise<Group$1>;
+      deleteGroup: (_parent: unknown, args: {
+        id: number;
+      }) => Promise<boolean>;
+      addUserToGroup: (_parent: unknown, args: {
+        userAddress: string;
+        groupId: number;
+      }) => Promise<boolean>;
+      removeUserFromGroup: (_parent: unknown, args: {
+        userAddress: string;
+        groupId: number;
+      }) => Promise<boolean>;
+      grantGroupPermission: (_parent: unknown, args: {
+        documentId: string;
+        groupId: number;
+        permission: string;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<DocumentGroupPermission>;
+      revokeGroupPermission: (_parent: unknown, args: {
+        documentId: string;
+        groupId: number;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<boolean>;
+      grantOperationPermission: (_parent: unknown, args: {
+        documentId: string;
+        operationType: string;
+        userAddress: string;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<OperationUserPermission>;
+      revokeOperationPermission: (_parent: unknown, args: {
+        documentId: string;
+        operationType: string;
+        userAddress: string;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<boolean>;
+      grantGroupOperationPermission: (_parent: unknown, args: {
+        documentId: string;
+        operationType: string;
+        groupId: number;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<OperationGroupPermission>;
+      revokeGroupOperationPermission: (_parent: unknown, args: {
+        documentId: string;
+        operationType: string;
+        groupId: number;
+      }, ctx: {
+        user?: {
+          address: string;
+        };
+        isAdmin?: (address: string) => boolean;
+      }) => Promise<boolean>;
+    };
+    Group: {
+      members: (parent: {
+        id: number;
+      }) => Promise<string[]>;
+    };
+    DocumentGroupPermission: {
+      group: (parent: {
+        groupId: number;
+      }) => Promise<Group$1>;
+    };
+    OperationGroupPermission: {
+      group: (parent: {
+        groupId: number;
+      }) => Promise<Group$1>;
+    };
+  };
+  onSetup(): Promise<void>;
+}
+//#endregion
+//#region src/services/auth.service.d.ts
+interface AuthConfig {
+  enabled: boolean;
+  admins: string[];
+  cacheTtl?: number;
+  skipCredentialVerification?: boolean;
+}
+interface User {
+  address: string;
+  chainId: number;
+  networkId: string;
+}
+interface AuthContext {
+  user?: User;
+  admins: string[];
+  auth_enabled: boolean;
+}
+declare class AuthService {
+  private readonly config;
+  constructor(config: AuthConfig);
+  authenticateRequest(request: globalThis.Request): Promise<AuthContext | globalThis.Response>;
+  /**
+   * Verify a Bearer token regardless of HTTP method. Use this from non-GraphQL
+   * middleware that must enforce authentication on every request.
+   */
+  verifyBearer(authorization: string | undefined): Promise<AuthContext | globalThis.Response>;
+  authenticateWebSocketConnection(connectionParams: Record<string, unknown>): Promise<User | null>;
+  /**
+   * Verify the auth bearer token
+   */
+  private verifyToken;
+  /**
+   * Extract user information from verification result
+   */
+  private extractUserFromVerification;
+  /**
+   * Get additional context fields for GraphQL
+   */
+  getAdditionalContextFields(): {
+    isAdmin: (address: string) => boolean;
+  };
+  /**
+   * Get user context for GraphQL
+   */
+  getUserContext(user?: User): {
+    user?: undefined;
+  } | {
+    user: {
+      address: string;
+      chainId: number;
+      networkId: string;
+    };
+  };
+  /**
+   * Verify that the credential still exists on the Renown API
+   */
+  private verifyCredentialExists;
+}
+//#endregion
+//#region src/graphql/gateway/types.d.ts
+type TlsOptions = {
+  keyPath: string;
+  certPath: string;
+} | {
+  cert: Buffer | string;
+  key: Buffer | string;
+} | true;
+type GatewayContextFactory<TContext = unknown> = (request: Request) => Promise<TContext>;
+type WsContextFactory<TContext = unknown> = (connectionParams: Record<string, unknown>) => Promise<TContext>;
+type WsDisposer = {
+  dispose: () => void | Promise<void>;
+};
+type FetchHandler = (request: Request) => Promise<Response>;
+/**
+ * A framework-agnostic description of a federated subgraph service.
+ * Used by IGatewayAdapter.createSupergraphHandler() to compose the supergraph SDL.
+ */
+type SubgraphDefinition = {
+  name: string;
+  typeDefs: DocumentNode;
+  url: string;
+};
+interface IGatewayAdapter<TContext = unknown> {
+  /** One-time startup. */
+  start(httpServer: http.Server): Promise<void>;
+  /**
+   * Returns a Fetch API handler for the given schema.
+   * Caller (IHttpAdapter) is responsible for mounting it at a path.
+   */
+  createHandler(schema: GraphQLSchema, contextFactory: GatewayContextFactory<TContext>): Promise<FetchHandler>;
+  /**
+   * Create a federation gateway handler that composes all subgraphs into a supergraph.
+   * getSubgraphs is called eagerly (during setup) and again on every updateSupergraph() call.
+   */
+  createSupergraphHandler(getSubgraphs: () => SubgraphDefinition[], httpServer: http.Server, contextFactory: GatewayContextFactory<TContext>): Promise<FetchHandler>;
+  /**
+   * Recompose the supergraph SDL from the current subgraph list and push the update
+   * to the running federation gateway. No-op if createSupergraphHandler() has not
+   * been called yet.
+   */
+  updateSupergraph(): Promise<void>;
+  /** Attach WebSocket subscriptions. Returns a disposer. */
+  attachWebSocket(wsServer: WebSocketServer, schema: GraphQLSchema, contextFactory: WsContextFactory<TContext>): WsDisposer;
+  stop(): Promise<void>;
+}
+interface IHttpAdapter {
+  /** Set up CORS and body-parser equivalent middleware. */
+  setupMiddleware(config: {
+    corsOptions?: CorsOptions;
+    bodyLimit?: string;
+  }): void;
+  /**
+   * Mount a Fetch API handler.
+   * - exact = false (default): exact path match via internal dispatch map.
+   * - exact = true: prefix match - handler also receives all sub-paths
+   *   (uses framework router.use() semantics).
+   */
+  mount(path: string, handler: FetchHandler, options?: {
+    exact?: boolean;
+  }): void;
+  /**
+   * Register a GET route that returns a Fetch Response (for health, explorer, etc.).
+   * Registered directly on the underlying framework app, bypassing the sub-router.
+   */
+  getRoute(path: string, handler: (request: Request) => Response | Promise<Response>): void;
+  /**
+   * Start listening on the given port. Returns the underlying http.Server
+   * so callers can attach WebSocket servers.
+   */
+  listen(port: number, tls?: TlsOptions): Promise<http.Server>;
+  /**
+   * Mount a raw Connect/Express-compatible middleware function (e.g. Vite dev
+   * server middleware). The implementation is adapter-specific; for Express this
+   * is equivalent to `app.use(middleware)`.
+   */
+  mountRawMiddleware(middleware: unknown): void;
+  /**
+   * Register a method-specific route handler using Node.js core HTTP types.
+   * Use this when a Fetch API FetchHandler is not possible (e.g. streaming
+   * protocols that require direct access to IncomingMessage/ServerResponse).
+   *
+   * The req/res objects are `http.IncomingMessage`/`http.ServerResponse`
+   * (Express Request/Response are compatible subtypes).
+   */
+  mountNodeRoute(method: "DELETE" | "GET" | "POST" | "PUT", path: string, handler: (req: http.IncomingMessage, res: http.ServerResponse, body?: unknown) => void): void;
+  /**
+   * Register framework-specific Sentry error-capturing middleware after all routes
+   * are mounted. Each adapter calls the Sentry setup function appropriate for its
+   * framework (e.g. setupExpressErrorHandler, setupFastifyErrorHandler).
+   * No-op if Sentry is not relevant for the adapter.
+   */
+  setupSentryErrorHandler(sentry: object): void;
+  /** The raw framework handle (e.g. Express app). Cast as needed at call sites. */
+  readonly handle: unknown;
+}
+//#endregion
+//#region src/graphql/gateway/auth-middleware.d.ts
+type AuthFetchMiddleware = (handler: FetchHandler) => FetchHandler;
+/** Internal — only `graphql-manager.ts` should call this. */
+declare function getAuthContext(request: globalThis.Request): AuthContext | undefined;
+declare function createAuthFetchMiddleware(authService: AuthService): AuthFetchMiddleware;
+//#endregion
+//#region src/graphql/gateway/factory.d.ts
+type GatewayAdapterType = "apollo" | "mercurius";
+type HttpAdapterType = "express" | "fastify";
+declare function createGatewayAdapter(type: GatewayAdapterType, logger: ILogger): IGatewayAdapter<Context>;
+type HttpAdapterSetup = {
+  adapter: IHttpAdapter;
+};
+declare function createHttpAdapter(type: HttpAdapterType): HttpAdapterSetup;
+//#endregion
+//#region src/graphql/graphql-manager.d.ts
+type GraphqlManagerFeatureFlags = {
+  enableDocumentModelSubgraphs?: boolean;
+};
+declare class GraphQLManager {
+  #private;
+  private readonly path;
+  private readonly httpServer;
+  private readonly wsServer;
+  private readonly reactorClient;
+  private readonly relationalDb;
+  private readonly analyticsStore;
+  private readonly syncManager;
+  private readonly logger;
+  private readonly httpAdapter;
+  private readonly gatewayAdapter;
+  private readonly authConfig?;
+  private readonly documentPermissionService?;
+  private readonly featureFlags;
+  private readonly port;
+  private readonly authorizationService?;
+  private initialized;
+  private coreSubgraphsMap;
+  private contextFields;
+  private readonly subgraphs;
+  private authService;
+  private readonly subgraphWsDisposers;
+  /** Cached document models for schema generation - updated on init and regenerate */
+  private cachedDocumentModels;
+  private readonly subgraphHandlerCache;
+  constructor(path: string, httpServer: http.Server, wsServer: WebSocketServer, reactorClient: IReactorClient, relationalDb: IRelationalDb, analyticsStore: IAnalyticsStore, syncManager: ISyncManager, logger: ILogger, httpAdapter: IHttpAdapter, gatewayAdapter: IGatewayAdapter<Context$1>, authConfig?: AuthConfig | undefined, documentPermissionService?: DocumentPermissionService | undefined, featureFlags?: GraphqlManagerFeatureFlags, port?: number, authorizationService?: AuthorizationService | undefined);
+  init(coreSubgraphs: SubgraphClass$1[], authMiddleware?: AuthFetchMiddleware): Promise<void>;
+  /**
+   * Regenerate document model subgraphs when models are dynamically loaded.
+   * Fetches current modules from reactor client (source of truth).
+   */
+  regenerateDocumentModelSubgraphs(): Promise<void>;
+  /**
+   * Register a pre-constructed subgraph instance.
+   * Use this when you need to pass custom dependencies to a subgraph.
+   */
+  registerSubgraphInstance(subgraphInstance: ISubgraph$1, supergraph?: string, core?: boolean): Promise<ISubgraph$1>;
+  /**
+   * Get the base path used for subgraph registration.
+   */
+  getBasePath(): string;
+  registerSubgraph(subgraph: SubgraphClass$1, supergraph?: string, core?: boolean): Promise<ISubgraph$1>;
+  updateRouter: (immediate?: boolean) => Promise<void>;
+  private _updateRouter;
+  getAdditionalContextFields: () => Record<string, any>;
+  setAdditionalContextFields(fields: Record<string, any>): void;
+  setSupergraph(supergraph: string, subgraphs: ISubgraph$1[]): Promise<void>;
+  shutdown(): Promise<void>;
+}
+//#endregion
+//#region src/services/package-storage.d.ts
+interface InstalledPackageInfo {
+  name: string;
+  version?: string;
+  registryUrl: string;
+  installedAt: Date;
+  documentTypes: string[];
+}
+interface IPackageStorage {
+  get(name: string): Promise<InstalledPackageInfo | undefined>;
+  getAll(): Promise<InstalledPackageInfo[]>;
+  set(name: string, info: InstalledPackageInfo): Promise<void>;
+  delete(name: string): Promise<boolean>;
+  has(name: string): Promise<boolean>;
+}
+declare class InMemoryPackageStorage implements IPackageStorage {
+  private packages;
+  get(name: string): Promise<InstalledPackageInfo | undefined>;
+  getAll(): Promise<InstalledPackageInfo[]>;
+  set(name: string, info: InstalledPackageInfo): Promise<void>;
+  delete(name: string): Promise<boolean>;
+  has(name: string): Promise<boolean>;
+}
+//#endregion
+//#region src/types.d.ts
+type API = {
+  httpAdapter: IHttpAdapter;
+  graphqlManager: GraphQLManager$1;
+  packages: IPackageManager;
+  attachments: AttachmentBuildResult;
+  authService: AuthService | undefined;
+};
+type ReactorModule = {
+  analyticsStore: IAnalyticsStore;
+  relationalDb: IRelationalDb$1;
+};
+/** Per-drive factory after the host `module` has been applied once. */
+type ProcessorDriveFactory = (driveHeader: PHDocumentHeader) => ProcessorRecord[] | Promise<ProcessorRecord[]>;
+/**
+ * Builds a per-drive factory from the host module (e.g. vetra `processorFactory`).
+ * Shape: `(module) => (driveHeader) => ...`
+ */
+type ProcessorFactoryBuilder = (module: IProcessorHostModule) => ProcessorDriveFactory | Promise<ProcessorDriveFactory>;
+/** Multiple initializers per package name (e.g. Switchboard `processors` option). */
+type Processor = ProcessorFactoryBuilder[];
+//#endregion
+//#region src/packages/http-loader.d.ts
+interface HttpPackageLoaderOptions {
+  registryUrl: string;
+}
+interface HttpPackageLoaderLogger {
+  info: (msg: string) => void;
+  error: (msg: string, err: unknown) => void;
+}
+/**
+ * Loads document models, subgraphs, and processors from an HTTP registry.
+ * Uses Node.js module loader hooks to import directly from HTTP URLs.
+ *
+ * IMPORTANT: Requires https-hooks to be registered before use:
+ *   import { register } from "node:module";
+ *   register("@powerhousedao/reactor-api/https-hooks", import.meta.url);
+ */
+declare class HttpPackageLoader implements IPackageLoader {
+  private readonly registryUrl;
+  private readonly logger;
+  readonly name = "HttpPackageLoader";
+  readonly documentModelLoader: HttpDocumentModelLoader;
+  constructor(options: HttpPackageLoaderOptions);
+  /**
+   * Load document models from a package in the HTTP registry.
+   * Imports directly from HTTP URL using Node.js loader hooks.
+   */
+  /**
+   * Parse a package specifier like "@scope/pkg@tag" into name and optional tag.
+   */
+  private parsePackageSpec;
+  loadDocumentModels(packageSpec: string): Promise<DocumentModelModule[]>;
+  loadSubgraphs(packageSpec: string): Promise<SubgraphClass$1[]>;
+  loadProcessors(packageSpec: string): Promise<ProcessorFactoryBuilder | null>;
+  /**
+   * Load document models from multiple packages.
+   * Continues loading even if some packages fail.
+   */
+  loadPackages(packageNames: string[], logger?: HttpPackageLoaderLogger): Promise<DocumentModelModule[]>;
+  private isValidPackageName;
+}
+declare class HttpDocumentModelLoader implements IDocumentModelLoader {
+  private readonly loader;
+  private readonly logger;
+  private readonly documentTypeCache;
+  private readonly packageModulesCache;
+  private onModelLoaded?;
+  constructor(loader: HttpPackageLoader);
+  setOnModelLoaded(callback: (model: DocumentModelModule) => void): void;
+  clearCache(): void;
+  load(documentType: string): Promise<DocumentModelModule>;
+  private findPackageByDocumentType;
+  getLoadedPackages(): string[];
+  getPackageModules(packageName: string): DocumentModelModule[] | undefined;
+  removeFromCache(packageName: string): void;
+}
+//#endregion
+//#region src/services/package-management.service.d.ts
+interface InstallPackageResult {
+  package: InstalledPackageInfo;
+  documentModelsLoaded: number;
+}
+interface PackageManagementServiceOptions {
+  storage?: IPackageStorage;
+  defaultRegistryUrl?: string;
+  httpLoader?: HttpPackageLoader;
+  documentModelRegistry?: IDocumentModelRegistry;
+}
+declare class PackageManagementService {
+  private readonly storage;
+  private readonly defaultRegistryUrl?;
+  private readonly httpLoader?;
+  private readonly documentModelRegistry?;
+  private readonly logger;
+  private onModelsChanged?;
+  private loadedModulesCache;
+  constructor(options?: PackageManagementServiceOptions);
+  setOnModelsChanged(callback: (models: DocumentModelModule[]) => void): void;
+  installPackage(name: string, registryUrl?: string): Promise<InstallPackageResult>;
+  uninstallPackage(name: string): Promise<boolean>;
+  getInstalledPackages(): Promise<InstalledPackageInfo[]>;
+  getInstalledPackage(name: string): Promise<InstalledPackageInfo | undefined>;
+  getAllLoadedModules(): DocumentModelModule[];
+  private triggerModelsChanged;
+}
+//#endregion
+//#region src/graphql/packages/subgraph.d.ts
+interface PackagesSubgraphArgs extends SubgraphArgs {
+  packageManagementService: PackageManagementService;
+}
+declare class PackagesSubgraph extends BaseSubgraph {
+  private logger;
+  private packageManagementService;
+  constructor(args: PackagesSubgraphArgs);
+  name: string;
+  hasSubscriptions: boolean;
+  typeDefs: graphql.DocumentNode;
+  resolvers: {
+    Query: {
+      Packages: () => {};
+    };
+    PackagesQueries: {
+      installedPackages: () => Promise<{
+        name: string;
+        version: string | null;
+        registryUrl: string;
+        installedAt: string;
+        documentTypes: string[];
+      }[]>;
+      installedPackage: (_parent: unknown, args: {
+        name: string;
+      }) => Promise<{
+        name: string;
+        version: string | null;
+        registryUrl: string;
+        installedAt: string;
+        documentTypes: string[];
+      } | null>;
+    };
+    Mutation: {
+      Packages: () => {};
+    };
+    PackagesMutations: {
+      installPackage: (_parent: unknown, args: {
+        name: string;
+        registryUrl?: string | null;
+      }, ctx: Context) => Promise<{
+        package: ReturnType<(info: InstalledPackageInfo) => {
+          name: string;
+          version: string | null;
+          registryUrl: string;
+          installedAt: string;
+          documentTypes: string[];
+        }>;
+        documentModelsLoaded: number;
+      }>;
+      uninstallPackage: (_parent: unknown, args: {
+        name: string;
+      }, ctx: Context) => Promise<boolean>;
+    };
+  };
+  onSetup(): Promise<void>;
+}
+//#endregion
+//#region src/graphql/playground.d.ts
+declare function renderGraphqlPlayground(url: string, query?: string, headers?: Record<string, string>): string;
+//#endregion
+//#region src/graphql/reactor/gen/graphql.d.ts
+type Maybe<T> = T | null | undefined;
+type InputMaybe<T> = T | null | undefined;
+type Exact<T extends {
+  [key: string]: unknown;
+}> = { [K in keyof T]: T[K] };
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+type MakeEmpty<T extends {
+  [key: string]: unknown;
+}, K extends keyof T> = { [_ in K]?: never };
+type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never };
+type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
+/** 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 Action = {
+  readonly attachments?: Maybe<ReadonlyArray<Attachment>>;
+  readonly context?: Maybe<ActionContext>;
+  readonly id: Scalars["String"]["output"];
+  readonly input: Scalars["JSONObject"]["output"];
+  readonly scope: Scalars["String"]["output"];
+  readonly timestampUtcMs: Scalars["String"]["output"];
+  readonly type: Scalars["String"]["output"];
+};
+type ActionContext = {
+  readonly signer?: Maybe<ReactorSigner>;
+};
+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 Attachment = {
+  readonly data: Scalars["String"]["output"];
+  readonly extension?: Maybe<Scalars["String"]["output"]>;
+  readonly fileName?: Maybe<Scalars["String"]["output"]>;
+  readonly hash: Scalars["String"]["output"];
+  readonly mimeType: Scalars["String"]["output"];
+};
+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 ChannelMeta = {
+  readonly id: Scalars["String"]["output"];
+};
+type ChannelMetaInput = {
+  readonly id: Scalars["String"]["input"];
+};
+type DeadLetterInfo = {
+  readonly branch: Scalars["String"]["output"];
+  readonly documentId: Scalars["String"]["output"];
+  readonly error: Scalars["String"]["output"];
+  readonly jobId: Scalars["String"]["output"];
+  readonly operationCount: Scalars["Int"]["output"];
+  readonly scopes: ReadonlyArray<Scalars["String"]["output"]>;
+};
+type DocumentChangeContext = {
+  readonly childId?: Maybe<Scalars["String"]["output"]>;
+  readonly parentId?: Maybe<Scalars["String"]["output"]>;
+};
+type DocumentChangeEvent = {
+  readonly context?: Maybe<DocumentChangeContext>;
+  readonly documents: ReadonlyArray<PhDocument>;
+  readonly type: DocumentChangeType;
+};
+declare enum DocumentChangeType {
+  ChildAdded = "CHILD_ADDED",
+  ChildRemoved = "CHILD_REMOVED",
+  Created = "CREATED",
+  Deleted = "DELETED",
+  ParentAdded = "PARENT_ADDED",
+  ParentRemoved = "PARENT_REMOVED",
+  Updated = "UPDATED"
+}
+type DocumentModelGlobalState = {
+  readonly id: Scalars["String"]["output"];
+  readonly name: Scalars["String"]["output"];
+  readonly namespace?: Maybe<Scalars["String"]["output"]>;
+  readonly specification: Scalars["JSONObject"]["output"];
+  readonly version?: Maybe<Scalars["String"]["output"]>;
+};
+type DocumentModelResultPage = {
+  readonly cursor?: Maybe<Scalars["String"]["output"]>;
+  readonly hasNextPage: Scalars["Boolean"]["output"];
+  readonly hasPreviousPage: Scalars["Boolean"]["output"];
+  readonly items: ReadonlyArray<DocumentModelGlobalState>;
+  readonly totalCount: Scalars["Int"]["output"];
+};
+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 DocumentWithChildren = {
+  readonly childIds: ReadonlyArray<Scalars["String"]["output"]>;
+  readonly document: PhDocument;
+};
+type JobChangeEvent = {
+  readonly error?: Maybe<Scalars["String"]["output"]>;
+  readonly jobId: Scalars["String"]["output"];
+  readonly result: Scalars["JSONObject"]["output"];
+  readonly status: Scalars["String"]["output"];
+};
+type JobInfo = {
+  readonly completedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  readonly createdAt: Scalars["DateTime"]["output"];
+  readonly error?: Maybe<Scalars["String"]["output"]>;
+  readonly id: Scalars["String"]["output"];
+  readonly result: Scalars["JSONObject"]["output"];
+  readonly status: Scalars["String"]["output"];
+};
+type MoveRelationshipResult = {
+  readonly source: PhDocument;
+  readonly target: PhDocument;
+};
+type Mutation = {
+  readonly addRelationship: PhDocument;
+  readonly createDocument: PhDocument;
+  readonly createEmptyDocument: PhDocument;
+  readonly deleteDocument: Scalars["Boolean"]["output"];
+  readonly deleteDocuments: Scalars["Boolean"]["output"];
+  readonly moveRelationship: MoveRelationshipResult;
+  readonly mutateDocument: PhDocument;
+  readonly mutateDocumentAsync: Scalars["String"]["output"];
+  readonly pushSyncEnvelopes: Scalars["Boolean"]["output"];
+  readonly removeRelationship: PhDocument;
+  readonly renameDocument: PhDocument;
+  readonly touchChannel: TouchChannelResult;
+};
+type MutationAddRelationshipArgs = {
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+  relationshipType: Scalars["String"]["input"];
+  sourceIdentifier: Scalars["String"]["input"];
+  targetIdentifier: Scalars["String"]["input"];
+};
+type MutationCreateDocumentArgs = {
+  document: Scalars["JSONObject"]["input"];
+  parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+};
+type MutationCreateEmptyDocumentArgs = {
+  documentType: Scalars["String"]["input"];
+  parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+};
+type MutationDeleteDocumentArgs = {
+  identifier: Scalars["String"]["input"];
+  propagate?: InputMaybe<PropagationMode>;
+};
+type MutationDeleteDocumentsArgs = {
+  identifiers: ReadonlyArray<Scalars["String"]["input"]>;
+  propagate?: InputMaybe<PropagationMode>;
+};
+type MutationMoveRelationshipArgs = {
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+  relationshipType: Scalars["String"]["input"];
+  sourceParentIdentifier: Scalars["String"]["input"];
+  targetIdentifier: Scalars["String"]["input"];
+  targetParentIdentifier: Scalars["String"]["input"];
+};
+type MutationMutateDocumentArgs = {
+  actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
+  documentIdentifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+};
+type MutationMutateDocumentAsyncArgs = {
+  actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
+  documentIdentifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+};
+type MutationPushSyncEnvelopesArgs = {
+  envelopes: ReadonlyArray<SyncEnvelopeInput>;
+};
+type MutationRemoveRelationshipArgs = {
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+  relationshipType: Scalars["String"]["input"];
+  sourceIdentifier: Scalars["String"]["input"];
+  targetIdentifier: Scalars["String"]["input"];
+};
+type MutationRenameDocumentArgs = {
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier: Scalars["String"]["input"];
+  name: Scalars["String"]["input"];
+};
+type MutationTouchChannelArgs = {
+  input: TouchChannelInput;
+};
+type OperationContext = {
+  readonly branch: Scalars["String"]["output"];
+  readonly documentId: Scalars["String"]["output"];
+  readonly documentType: Scalars["String"]["output"];
+  readonly ordinal: Scalars["Int"]["output"];
+  readonly scope: Scalars["String"]["output"];
+};
+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 OperationWithContext = {
+  readonly context: OperationContext;
+  readonly operation: ReactorOperation;
+};
+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 PhDocument = {
+  readonly createdAtUtcIso: Scalars["DateTime"]["output"];
+  readonly documentType: Scalars["String"]["output"];
+  readonly id: Scalars["String"]["output"];
+  readonly lastModifiedAtUtcIso: Scalars["DateTime"]["output"];
+  readonly name: Scalars["String"]["output"];
+  readonly operations?: Maybe<ReactorOperationResultPage>;
+  readonly preferredEditor?: Maybe<Scalars["String"]["output"]>;
+  readonly revisionsList: ReadonlyArray<Revision>;
+  readonly slug?: Maybe<Scalars["String"]["output"]>;
+  readonly state: Scalars["JSONObject"]["output"];
+};
+type PhDocumentOperationsArgs = {
+  filter?: InputMaybe<DocumentOperationsFilterInput>;
+  paging?: InputMaybe<PagingInput>;
+};
+type PhDocumentResultPage = {
+  readonly cursor?: Maybe<Scalars["String"]["output"]>;
+  readonly hasNextPage: Scalars["Boolean"]["output"];
+  readonly hasPreviousPage: Scalars["Boolean"]["output"];
+  readonly items: ReadonlyArray<PhDocument>;
+  readonly totalCount: Scalars["Int"]["output"];
+};
+type PagingInput = {
+  readonly cursor?: InputMaybe<Scalars["String"]["input"]>;
+  readonly limit?: InputMaybe<Scalars["Int"]["input"]>;
+  readonly offset?: InputMaybe<Scalars["Int"]["input"]>;
+};
+type PollSyncEnvelopesResult = {
+  readonly ackOrdinal: Scalars["Int"]["output"];
+  readonly deadLetters: ReadonlyArray<DeadLetterInfo>;
+  readonly envelopes: ReadonlyArray<SyncEnvelope>;
+  readonly hasMore: Scalars["Boolean"]["output"];
+};
+declare enum PropagationMode {
+  Cascade = "CASCADE",
+  Orphan = "ORPHAN"
+}
+type Query = {
+  readonly document?: Maybe<DocumentWithChildren>;
+  readonly documentIncomingRelationships: PhDocumentResultPage;
+  readonly documentModels: DocumentModelResultPage;
+  readonly documentOperations: ReactorOperationResultPage;
+  readonly documentOutgoingRelationships: PhDocumentResultPage;
+  readonly findDocuments: PhDocumentResultPage;
+  readonly jobStatus?: Maybe<JobInfo>;
+  readonly pollSyncEnvelopes: PollSyncEnvelopesResult;
+};
+type QueryDocumentArgs = {
+  identifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+};
+type QueryDocumentIncomingRelationshipsArgs = {
+  paging?: InputMaybe<PagingInput>;
+  relationshipType: Scalars["String"]["input"];
+  targetIdentifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+};
+type QueryDocumentModelsArgs = {
+  namespace?: InputMaybe<Scalars["String"]["input"]>;
+  paging?: InputMaybe<PagingInput>;
+};
+type QueryDocumentOperationsArgs = {
+  filter: OperationsFilterInput;
+  paging?: InputMaybe<PagingInput>;
+};
+type QueryDocumentOutgoingRelationshipsArgs = {
+  paging?: InputMaybe<PagingInput>;
+  relationshipType: Scalars["String"]["input"];
+  sourceIdentifier: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+};
+type QueryFindDocumentsArgs = {
+  paging?: InputMaybe<PagingInput>;
+  search?: InputMaybe<SearchFilterInput>;
+  view?: InputMaybe<ViewFilterInput>;
+};
+type QueryJobStatusArgs = {
+  jobId: Scalars["String"]["input"];
+};
+type QueryPollSyncEnvelopesArgs = {
+  channelId: Scalars["String"]["input"];
+  outboxAck: Scalars["Int"]["input"];
+  outboxLatest: Scalars["Int"]["input"];
+};
+type ReactorOperation = {
+  readonly action: Action;
+  readonly error?: Maybe<Scalars["String"]["output"]>;
+  readonly hash: Scalars["String"]["output"];
+  readonly id?: Maybe<Scalars["String"]["output"]>;
+  readonly index: Scalars["Int"]["output"];
+  readonly skip: Scalars["Int"]["output"];
+  readonly timestampUtcMs: Scalars["String"]["output"];
+};
+type ReactorOperationResultPage = {
+  readonly cursor?: Maybe<Scalars["String"]["output"]>;
+  readonly hasNextPage: Scalars["Boolean"]["output"];
+  readonly hasPreviousPage: Scalars["Boolean"]["output"];
+  readonly items: ReadonlyArray<ReactorOperation>;
+  readonly totalCount: Scalars["Int"]["output"];
+};
+type ReactorSigner = {
+  readonly app?: Maybe<ReactorSignerApp>;
+  readonly signatures: ReadonlyArray<Scalars["String"]["output"]>;
+  readonly user?: Maybe<ReactorSignerUser>;
+};
+type ReactorSignerApp = {
+  readonly key: Scalars["String"]["output"];
+  readonly name: Scalars["String"]["output"];
+};
+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 ReactorSignerUser = {
+  readonly address: Scalars["String"]["output"];
+  readonly chainId: Scalars["Int"]["output"];
+  readonly networkId: Scalars["String"]["output"];
+};
+type ReactorSignerUserInput = {
+  readonly address: Scalars["String"]["input"];
+  readonly chainId: Scalars["Int"]["input"];
+  readonly networkId: Scalars["String"]["input"];
+};
+type RemoteCursor = {
+  readonly cursorOrdinal: Scalars["Int"]["output"];
+  readonly lastSyncedAtUtcMs?: Maybe<Scalars["String"]["output"]>;
+  readonly remoteName: Scalars["String"]["output"];
+};
+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 Revision = {
+  readonly revision: Scalars["Int"]["output"];
+  readonly scope: Scalars["String"]["output"];
+};
+type SearchFilterInput = {
+  readonly identifiers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  readonly parentId?: InputMaybe<Scalars["String"]["input"]>;
+  readonly type?: InputMaybe<Scalars["String"]["input"]>;
+};
+type Subscription = {
+  readonly documentChanges: DocumentChangeEvent;
+  readonly jobChanges: JobChangeEvent;
+};
+type SubscriptionDocumentChangesArgs = {
+  search?: InputMaybe<SearchFilterInput>;
+  view?: InputMaybe<ViewFilterInput>;
+};
+type SubscriptionJobChangesArgs = {
+  jobId: Scalars["String"]["input"];
+};
+type SyncEnvelope = {
+  readonly channelMeta: ChannelMeta;
+  readonly cursor?: Maybe<RemoteCursor>;
+  readonly dependsOn?: Maybe<ReadonlyArray<Scalars["String"]["output"]>>;
+  readonly key?: Maybe<Scalars["String"]["output"]>;
+  readonly operations?: Maybe<ReadonlyArray<OperationWithContext>>;
+  readonly type: SyncEnvelopeType;
+};
+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 TouchChannelResult = {
+  readonly ackOrdinal: Scalars["Int"]["output"];
+  readonly success: Scalars["Boolean"]["output"];
+};
+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 GetDocumentOutgoingRelationshipsQueryVariables = Exact<{
+  sourceIdentifier: Scalars["String"]["input"];
+  relationshipType: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+  paging?: InputMaybe<PagingInput>;
+}>;
+type GetDocumentOutgoingRelationshipsQuery = {
+  readonly documentOutgoingRelationships: {
+    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 GetDocumentIncomingRelationshipsQueryVariables = Exact<{
+  targetIdentifier: Scalars["String"]["input"];
+  relationshipType: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+  paging?: InputMaybe<PagingInput>;
+}>;
+type GetDocumentIncomingRelationshipsQuery = {
+  readonly documentIncomingRelationships: {
+    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?: InputMaybe<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 AddRelationshipMutationVariables = Exact<{
+  sourceIdentifier: Scalars["String"]["input"];
+  targetIdentifier: Scalars["String"]["input"];
+  relationshipType: Scalars["String"]["input"];
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type AddRelationshipMutation = {
+  readonly addRelationship: {
+    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 RemoveRelationshipMutationVariables = Exact<{
+  sourceIdentifier: Scalars["String"]["input"];
+  targetIdentifier: Scalars["String"]["input"];
+  relationshipType: Scalars["String"]["input"];
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type RemoveRelationshipMutation = {
+  readonly removeRelationship: {
+    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 MoveRelationshipMutationVariables = Exact<{
+  sourceParentIdentifier: Scalars["String"]["input"];
+  targetParentIdentifier: Scalars["String"]["input"];
+  targetIdentifier: Scalars["String"]["input"];
+  relationshipType: Scalars["String"]["input"];
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+type MoveRelationshipMutation = {
+  readonly moveRelationship: {
+    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?: InputMaybe<SearchFilterInput>;
+  view?: InputMaybe<ViewFilterInput>;
+}>;
+type DocumentChangesSubscription = {
+  readonly documentChanges: {
+    readonly type: DocumentChangeType;
+    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 hasMore: boolean;
+    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: {
+    readonly success: boolean;
+    readonly ackOrdinal: number;
+  };
+};
+type PushSyncEnvelopesMutationVariables = Exact<{
+  envelopes: ReadonlyArray<SyncEnvelopeInput>;
+}>;
+type PushSyncEnvelopesMutation = {
+  readonly pushSyncEnvelopes: boolean;
+};
+type WithIndex<TObject> = TObject & Record<string, any>;
+type ResolversObject<TObject> = WithIndex<TObject>;
+type ResolverTypeWrapper<T> = Promise<T> | T;
+type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+type Resolver<TResult, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
+type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
+  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
+}
+interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
+  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
+}
+type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+type SubscriptionResolver<TResult, TKey extends string, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+type TypeResolveFn<TTypes, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+type IsTypeOfResolverFn<T = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+type NextResolverFn<T> = () => Promise<T>;
+type DirectiveResolverFn<TResult = Record<PropertyKey, never>, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+/** Mapping between all available schema types and the resolvers types */
+type ResolversTypes = ResolversObject<{
+  Action: ResolverTypeWrapper<Action>;
+  ActionContext: ResolverTypeWrapper<ActionContext>;
+  ActionContextInput: ActionContextInput;
+  ActionInput: ActionInput;
+  Attachment: ResolverTypeWrapper<Attachment>;
+  AttachmentInput: AttachmentInput;
+  Boolean: ResolverTypeWrapper<Scalars["Boolean"]["output"]>;
+  ChannelMeta: ResolverTypeWrapper<ChannelMeta>;
+  ChannelMetaInput: ChannelMetaInput;
+  DateTime: ResolverTypeWrapper<Scalars["DateTime"]["output"]>;
+  DeadLetterInfo: ResolverTypeWrapper<DeadLetterInfo>;
+  DocumentChangeContext: ResolverTypeWrapper<DocumentChangeContext>;
+  DocumentChangeEvent: ResolverTypeWrapper<DocumentChangeEvent>;
+  DocumentChangeType: DocumentChangeType;
+  DocumentModelGlobalState: ResolverTypeWrapper<DocumentModelGlobalState>;
+  DocumentModelResultPage: ResolverTypeWrapper<DocumentModelResultPage>;
+  DocumentOperationsFilterInput: DocumentOperationsFilterInput;
+  DocumentWithChildren: ResolverTypeWrapper<DocumentWithChildren>;
+  Int: ResolverTypeWrapper<Scalars["Int"]["output"]>;
+  JSONObject: ResolverTypeWrapper<Scalars["JSONObject"]["output"]>;
+  JobChangeEvent: ResolverTypeWrapper<JobChangeEvent>;
+  JobInfo: ResolverTypeWrapper<JobInfo>;
+  MoveRelationshipResult: ResolverTypeWrapper<MoveRelationshipResult>;
+  Mutation: ResolverTypeWrapper<Record<PropertyKey, never>>;
+  OperationContext: ResolverTypeWrapper<OperationContext>;
+  OperationContextInput: OperationContextInput;
+  OperationInput: OperationInput;
+  OperationWithContext: ResolverTypeWrapper<OperationWithContext>;
+  OperationWithContextInput: OperationWithContextInput;
+  OperationsFilterInput: OperationsFilterInput;
+  PHDocument: ResolverTypeWrapper<PhDocument>;
+  PHDocumentResultPage: ResolverTypeWrapper<PhDocumentResultPage>;
+  PagingInput: PagingInput;
+  PollSyncEnvelopesResult: ResolverTypeWrapper<PollSyncEnvelopesResult>;
+  PropagationMode: PropagationMode;
+  Query: ResolverTypeWrapper<Record<PropertyKey, never>>;
+  ReactorOperation: ResolverTypeWrapper<ReactorOperation>;
+  ReactorOperationResultPage: ResolverTypeWrapper<ReactorOperationResultPage>;
+  ReactorSigner: ResolverTypeWrapper<ReactorSigner>;
+  ReactorSignerApp: ResolverTypeWrapper<ReactorSignerApp>;
+  ReactorSignerAppInput: ReactorSignerAppInput;
+  ReactorSignerInput: ReactorSignerInput;
+  ReactorSignerUser: ResolverTypeWrapper<ReactorSignerUser>;
+  ReactorSignerUserInput: ReactorSignerUserInput;
+  RemoteCursor: ResolverTypeWrapper<RemoteCursor>;
+  RemoteCursorInput: RemoteCursorInput;
+  RemoteFilterInput: RemoteFilterInput;
+  Revision: ResolverTypeWrapper<Revision>;
+  SearchFilterInput: SearchFilterInput;
+  String: ResolverTypeWrapper<Scalars["String"]["output"]>;
+  Subscription: ResolverTypeWrapper<Record<PropertyKey, never>>;
+  SyncEnvelope: ResolverTypeWrapper<SyncEnvelope>;
+  SyncEnvelopeInput: SyncEnvelopeInput;
+  SyncEnvelopeType: SyncEnvelopeType;
+  TouchChannelInput: TouchChannelInput;
+  TouchChannelResult: ResolverTypeWrapper<TouchChannelResult>;
+  ViewFilterInput: ViewFilterInput;
+}>;
+/** Mapping between all available schema types and the resolvers parents */
+type ResolversParentTypes = ResolversObject<{
+  Action: Action;
+  ActionContext: ActionContext;
+  ActionContextInput: ActionContextInput;
+  ActionInput: ActionInput;
+  Attachment: Attachment;
+  AttachmentInput: AttachmentInput;
+  Boolean: Scalars["Boolean"]["output"];
+  ChannelMeta: ChannelMeta;
+  ChannelMetaInput: ChannelMetaInput;
+  DateTime: Scalars["DateTime"]["output"];
+  DeadLetterInfo: DeadLetterInfo;
+  DocumentChangeContext: DocumentChangeContext;
+  DocumentChangeEvent: DocumentChangeEvent;
+  DocumentModelGlobalState: DocumentModelGlobalState;
+  DocumentModelResultPage: DocumentModelResultPage;
+  DocumentOperationsFilterInput: DocumentOperationsFilterInput;
+  DocumentWithChildren: DocumentWithChildren;
+  Int: Scalars["Int"]["output"];
+  JSONObject: Scalars["JSONObject"]["output"];
+  JobChangeEvent: JobChangeEvent;
+  JobInfo: JobInfo;
+  MoveRelationshipResult: MoveRelationshipResult;
+  Mutation: Record<PropertyKey, never>;
+  OperationContext: OperationContext;
+  OperationContextInput: OperationContextInput;
+  OperationInput: OperationInput;
+  OperationWithContext: OperationWithContext;
+  OperationWithContextInput: OperationWithContextInput;
+  OperationsFilterInput: OperationsFilterInput;
+  PHDocument: PhDocument;
+  PHDocumentResultPage: PhDocumentResultPage;
+  PagingInput: PagingInput;
+  PollSyncEnvelopesResult: PollSyncEnvelopesResult;
+  Query: Record<PropertyKey, never>;
+  ReactorOperation: ReactorOperation;
+  ReactorOperationResultPage: ReactorOperationResultPage;
+  ReactorSigner: ReactorSigner;
+  ReactorSignerApp: ReactorSignerApp;
+  ReactorSignerAppInput: ReactorSignerAppInput;
+  ReactorSignerInput: ReactorSignerInput;
+  ReactorSignerUser: ReactorSignerUser;
+  ReactorSignerUserInput: ReactorSignerUserInput;
+  RemoteCursor: RemoteCursor;
+  RemoteCursorInput: RemoteCursorInput;
+  RemoteFilterInput: RemoteFilterInput;
+  Revision: Revision;
+  SearchFilterInput: SearchFilterInput;
+  String: Scalars["String"]["output"];
+  Subscription: Record<PropertyKey, never>;
+  SyncEnvelope: SyncEnvelope;
+  SyncEnvelopeInput: SyncEnvelopeInput;
+  TouchChannelInput: TouchChannelInput;
+  TouchChannelResult: TouchChannelResult;
+  ViewFilterInput: ViewFilterInput;
+}>;
+type ActionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Action"] = ResolversParentTypes["Action"]> = ResolversObject<{
+  attachments?: Resolver<Maybe<ReadonlyArray<ResolversTypes["Attachment"]>>, ParentType, ContextType>;
+  context?: Resolver<Maybe<ResolversTypes["ActionContext"]>, ParentType, ContextType>;
+  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  input?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  timestampUtcMs?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  type?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type ActionContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionContext"] = ResolversParentTypes["ActionContext"]> = ResolversObject<{
+  signer?: Resolver<Maybe<ResolversTypes["ReactorSigner"]>, ParentType, ContextType>;
+}>;
+type AttachmentResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Attachment"] = ResolversParentTypes["Attachment"]> = ResolversObject<{
+  data?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  extension?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  fileName?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  hash?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  mimeType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type ChannelMetaResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ChannelMeta"] = ResolversParentTypes["ChannelMeta"]> = ResolversObject<{
+  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["DateTime"], any> {
+  name: "DateTime";
+}
+type DeadLetterInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DeadLetterInfo"] = ResolversParentTypes["DeadLetterInfo"]> = ResolversObject<{
+  branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  error?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  jobId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  operationCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  scopes?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
+}>;
+type DocumentChangeContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeContext"] = ResolversParentTypes["DocumentChangeContext"]> = ResolversObject<{
+  childId?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  parentId?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+}>;
+type DocumentChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeEvent"] = ResolversParentTypes["DocumentChangeEvent"]> = ResolversObject<{
+  context?: Resolver<Maybe<ResolversTypes["DocumentChangeContext"]>, ParentType, ContextType>;
+  documents?: Resolver<ReadonlyArray<ResolversTypes["PHDocument"]>, ParentType, ContextType>;
+  type?: Resolver<ResolversTypes["DocumentChangeType"], ParentType, ContextType>;
+}>;
+type DocumentModelGlobalStateResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelGlobalState"] = ResolversParentTypes["DocumentModelGlobalState"]> = ResolversObject<{
+  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  namespace?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  specification?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  version?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+}>;
+type DocumentModelResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelResultPage"] = ResolversParentTypes["DocumentModelResultPage"]> = ResolversObject<{
+  cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  items?: Resolver<ReadonlyArray<ResolversTypes["DocumentModelGlobalState"]>, ParentType, ContextType>;
+  totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+}>;
+type DocumentWithChildrenResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentWithChildren"] = ResolversParentTypes["DocumentWithChildren"]> = ResolversObject<{
+  childIds?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
+  document?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
+}>;
+interface JsonObjectScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["JSONObject"], any> {
+  name: "JSONObject";
+}
+type JobChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobChangeEvent"] = ResolversParentTypes["JobChangeEvent"]> = ResolversObject<{
+  error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  jobId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  result?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type JobInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobInfo"] = ResolversParentTypes["JobInfo"]> = ResolversObject<{
+  completedAt?: Resolver<Maybe<ResolversTypes["DateTime"]>, ParentType, ContextType>;
+  createdAt?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
+  error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  result?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type MoveRelationshipResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["MoveRelationshipResult"] = ResolversParentTypes["MoveRelationshipResult"]> = ResolversObject<{
+  source?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
+  target?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
+}>;
+type MutationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Mutation"] = ResolversParentTypes["Mutation"]> = ResolversObject<{
+  addRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationAddRelationshipArgs, "relationshipType" | "sourceIdentifier" | "targetIdentifier">>;
+  createDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationCreateDocumentArgs, "document">>;
+  createEmptyDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationCreateEmptyDocumentArgs, "documentType">>;
+  deleteDocument?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationDeleteDocumentArgs, "identifier">>;
+  deleteDocuments?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationDeleteDocumentsArgs, "identifiers">>;
+  moveRelationship?: Resolver<ResolversTypes["MoveRelationshipResult"], ParentType, ContextType, RequireFields<MutationMoveRelationshipArgs, "relationshipType" | "sourceParentIdentifier" | "targetIdentifier" | "targetParentIdentifier">>;
+  mutateDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationMutateDocumentArgs, "actions" | "documentIdentifier">>;
+  mutateDocumentAsync?: Resolver<ResolversTypes["String"], ParentType, ContextType, RequireFields<MutationMutateDocumentAsyncArgs, "actions" | "documentIdentifier">>;
+  pushSyncEnvelopes?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationPushSyncEnvelopesArgs, "envelopes">>;
+  removeRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRemoveRelationshipArgs, "relationshipType" | "sourceIdentifier" | "targetIdentifier">>;
+  renameDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRenameDocumentArgs, "documentIdentifier" | "name">>;
+  touchChannel?: Resolver<ResolversTypes["TouchChannelResult"], ParentType, ContextType, RequireFields<MutationTouchChannelArgs, "input">>;
+}>;
+type OperationContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationContext"] = ResolversParentTypes["OperationContext"]> = ResolversObject<{
+  branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  documentType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  ordinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type OperationWithContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationWithContext"] = ResolversParentTypes["OperationWithContext"]> = ResolversObject<{
+  context?: Resolver<ResolversTypes["OperationContext"], ParentType, ContextType>;
+  operation?: Resolver<ResolversTypes["ReactorOperation"], ParentType, ContextType>;
+}>;
+type PhDocumentResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocument"] = ResolversParentTypes["PHDocument"]> = ResolversObject<{
+  createdAtUtcIso?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
+  documentType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  lastModifiedAtUtcIso?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
+  name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  operations?: Resolver<Maybe<ResolversTypes["ReactorOperationResultPage"]>, ParentType, ContextType, Partial<PhDocumentOperationsArgs>>;
+  preferredEditor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  revisionsList?: Resolver<ReadonlyArray<ResolversTypes["Revision"]>, ParentType, ContextType>;
+  slug?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  state?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+}>;
+type PhDocumentResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocumentResultPage"] = ResolversParentTypes["PHDocumentResultPage"]> = ResolversObject<{
+  cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  items?: Resolver<ReadonlyArray<ResolversTypes["PHDocument"]>, ParentType, ContextType>;
+  totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+}>;
+type PollSyncEnvelopesResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PollSyncEnvelopesResult"] = ResolversParentTypes["PollSyncEnvelopesResult"]> = ResolversObject<{
+  ackOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  deadLetters?: Resolver<ReadonlyArray<ResolversTypes["DeadLetterInfo"]>, ParentType, ContextType>;
+  envelopes?: Resolver<ReadonlyArray<ResolversTypes["SyncEnvelope"]>, ParentType, ContextType>;
+  hasMore?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+}>;
+type QueryResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Query"] = ResolversParentTypes["Query"]> = ResolversObject<{
+  document?: Resolver<Maybe<ResolversTypes["DocumentWithChildren"]>, ParentType, ContextType, RequireFields<QueryDocumentArgs, "identifier">>;
+  documentIncomingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentIncomingRelationshipsArgs, "relationshipType" | "targetIdentifier">>;
+  documentModels?: Resolver<ResolversTypes["DocumentModelResultPage"], ParentType, ContextType, Partial<QueryDocumentModelsArgs>>;
+  documentOperations?: Resolver<ResolversTypes["ReactorOperationResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOperationsArgs, "filter">>;
+  documentOutgoingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOutgoingRelationshipsArgs, "relationshipType" | "sourceIdentifier">>;
+  findDocuments?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, Partial<QueryFindDocumentsArgs>>;
+  jobStatus?: Resolver<Maybe<ResolversTypes["JobInfo"]>, ParentType, ContextType, RequireFields<QueryJobStatusArgs, "jobId">>;
+  pollSyncEnvelopes?: Resolver<ResolversTypes["PollSyncEnvelopesResult"], ParentType, ContextType, RequireFields<QueryPollSyncEnvelopesArgs, "channelId" | "outboxAck" | "outboxLatest">>;
+}>;
+type ReactorOperationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperation"] = ResolversParentTypes["ReactorOperation"]> = ResolversObject<{
+  action?: Resolver<ResolversTypes["Action"], ParentType, ContextType>;
+  error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  hash?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  id?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  index?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  skip?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  timestampUtcMs?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type ReactorOperationResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperationResultPage"] = ResolversParentTypes["ReactorOperationResultPage"]> = ResolversObject<{
+  cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  items?: Resolver<ReadonlyArray<ResolversTypes["ReactorOperation"]>, ParentType, ContextType>;
+  totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+}>;
+type ReactorSignerResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSigner"] = ResolversParentTypes["ReactorSigner"]> = ResolversObject<{
+  app?: Resolver<Maybe<ResolversTypes["ReactorSignerApp"]>, ParentType, ContextType>;
+  signatures?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
+  user?: Resolver<Maybe<ResolversTypes["ReactorSignerUser"]>, ParentType, ContextType>;
+}>;
+type ReactorSignerAppResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerApp"] = ResolversParentTypes["ReactorSignerApp"]> = ResolversObject<{
+  key?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type ReactorSignerUserResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerUser"] = ResolversParentTypes["ReactorSignerUser"]> = ResolversObject<{
+  address?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  chainId?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  networkId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type RemoteCursorResolvers<ContextType = Context, ParentType extends ResolversParentTypes["RemoteCursor"] = ResolversParentTypes["RemoteCursor"]> = ResolversObject<{
+  cursorOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  lastSyncedAtUtcMs?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  remoteName?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type RevisionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Revision"] = ResolversParentTypes["Revision"]> = ResolversObject<{
+  revision?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+type SubscriptionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Subscription"] = ResolversParentTypes["Subscription"]> = ResolversObject<{
+  documentChanges?: SubscriptionResolver<ResolversTypes["DocumentChangeEvent"], "documentChanges", ParentType, ContextType, Partial<SubscriptionDocumentChangesArgs>>;
+  jobChanges?: SubscriptionResolver<ResolversTypes["JobChangeEvent"], "jobChanges", ParentType, ContextType, RequireFields<SubscriptionJobChangesArgs, "jobId">>;
+}>;
+type SyncEnvelopeResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncEnvelope"] = ResolversParentTypes["SyncEnvelope"]> = ResolversObject<{
+  channelMeta?: Resolver<ResolversTypes["ChannelMeta"], ParentType, ContextType>;
+  cursor?: Resolver<Maybe<ResolversTypes["RemoteCursor"]>, ParentType, ContextType>;
+  dependsOn?: Resolver<Maybe<ReadonlyArray<ResolversTypes["String"]>>, ParentType, ContextType>;
+  key?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  operations?: Resolver<Maybe<ReadonlyArray<ResolversTypes["OperationWithContext"]>>, ParentType, ContextType>;
+  type?: Resolver<ResolversTypes["SyncEnvelopeType"], ParentType, ContextType>;
+}>;
+type TouchChannelResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["TouchChannelResult"] = ResolversParentTypes["TouchChannelResult"]> = ResolversObject<{
+  ackOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  success?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+}>;
+type Resolvers<ContextType = Context> = ResolversObject<{
+  Action?: ActionResolvers<ContextType>;
+  ActionContext?: ActionContextResolvers<ContextType>;
+  Attachment?: AttachmentResolvers<ContextType>;
+  ChannelMeta?: ChannelMetaResolvers<ContextType>;
+  DateTime?: GraphQLScalarType;
+  DeadLetterInfo?: DeadLetterInfoResolvers<ContextType>;
+  DocumentChangeContext?: DocumentChangeContextResolvers<ContextType>;
+  DocumentChangeEvent?: DocumentChangeEventResolvers<ContextType>;
+  DocumentModelGlobalState?: DocumentModelGlobalStateResolvers<ContextType>;
+  DocumentModelResultPage?: DocumentModelResultPageResolvers<ContextType>;
+  DocumentWithChildren?: DocumentWithChildrenResolvers<ContextType>;
+  JSONObject?: GraphQLScalarType;
+  JobChangeEvent?: JobChangeEventResolvers<ContextType>;
+  JobInfo?: JobInfoResolvers<ContextType>;
+  MoveRelationshipResult?: MoveRelationshipResultResolvers<ContextType>;
+  Mutation?: MutationResolvers<ContextType>;
+  OperationContext?: OperationContextResolvers<ContextType>;
+  OperationWithContext?: OperationWithContextResolvers<ContextType>;
+  PHDocument?: PhDocumentResolvers<ContextType>;
+  PHDocumentResultPage?: PhDocumentResultPageResolvers<ContextType>;
+  PollSyncEnvelopesResult?: PollSyncEnvelopesResultResolvers<ContextType>;
+  Query?: QueryResolvers<ContextType>;
+  ReactorOperation?: ReactorOperationResolvers<ContextType>;
+  ReactorOperationResultPage?: ReactorOperationResultPageResolvers<ContextType>;
+  ReactorSigner?: ReactorSignerResolvers<ContextType>;
+  ReactorSignerApp?: ReactorSignerAppResolvers<ContextType>;
+  ReactorSignerUser?: ReactorSignerUserResolvers<ContextType>;
+  RemoteCursor?: RemoteCursorResolvers<ContextType>;
+  Revision?: RevisionResolvers<ContextType>;
+  Subscription?: SubscriptionResolvers<ContextType>;
+  SyncEnvelope?: SyncEnvelopeResolvers<ContextType>;
+  TouchChannelResult?: TouchChannelResultResolvers<ContextType>;
+}>;
+type Properties<T> = Required<{ [K in keyof T]: z$1.ZodType<T[K]> }>;
+type definedNonNullAny = {};
+declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
+declare const definedNonNullAnySchema: z$1.ZodAny & z$1.ZodType<definedNonNullAny, any, z$1.core.$ZodTypeInternals<definedNonNullAny, any>>;
+declare const DocumentChangeTypeSchema: z$1.ZodEnum<typeof DocumentChangeType>;
+declare const PropagationModeSchema: z$1.ZodEnum<typeof PropagationMode>;
+declare const SyncEnvelopeTypeSchema: z$1.ZodEnum<typeof SyncEnvelopeType>;
+declare function ActionContextInputSchema(): z$1.ZodObject<Properties<ActionContextInput>>;
+declare function ActionInputSchema(): z$1.ZodObject<Properties<ActionInput>>;
+declare function AttachmentInputSchema(): z$1.ZodObject<Properties<AttachmentInput>>;
+declare function ChannelMetaInputSchema(): z$1.ZodObject<Properties<ChannelMetaInput>>;
+declare function DocumentOperationsFilterInputSchema(): z$1.ZodObject<Properties<DocumentOperationsFilterInput>>;
+declare function OperationContextInputSchema(): z$1.ZodObject<Properties<OperationContextInput>>;
+declare function OperationInputSchema(): z$1.ZodObject<Properties<OperationInput>>;
+declare function OperationWithContextInputSchema(): z$1.ZodObject<Properties<OperationWithContextInput>>;
+declare function OperationsFilterInputSchema(): z$1.ZodObject<Properties<OperationsFilterInput>>;
+declare function PagingInputSchema(): z$1.ZodObject<Properties<PagingInput>>;
+declare function ReactorSignerAppInputSchema(): z$1.ZodObject<Properties<ReactorSignerAppInput>>;
+declare function ReactorSignerInputSchema(): z$1.ZodObject<Properties<ReactorSignerInput>>;
+declare function ReactorSignerUserInputSchema(): z$1.ZodObject<Properties<ReactorSignerUserInput>>;
+declare function RemoteCursorInputSchema(): z$1.ZodObject<Properties<RemoteCursorInput>>;
+declare function RemoteFilterInputSchema(): z$1.ZodObject<Properties<RemoteFilterInput>>;
+declare function SearchFilterInputSchema(): z$1.ZodObject<Properties<SearchFilterInput>>;
+declare function SyncEnvelopeInputSchema(): z$1.ZodObject<Properties<SyncEnvelopeInput>>;
+declare function TouchChannelInputSchema(): z$1.ZodObject<Properties<TouchChannelInput>>;
+declare function ViewFilterInputSchema(): z$1.ZodObject<Properties<ViewFilterInput>>;
+declare const PhDocumentFieldsFragmentDoc: DocumentNode;
+declare const GetDocumentModelsDocument: DocumentNode;
+declare const GetDocumentDocument: DocumentNode;
+declare const GetDocumentWithOperationsDocument: DocumentNode;
+declare const GetDocumentOutgoingRelationshipsDocument: DocumentNode;
+declare const GetDocumentIncomingRelationshipsDocument: DocumentNode;
+declare const FindDocumentsDocument: DocumentNode;
+declare const GetDocumentOperationsDocument: DocumentNode;
+declare const GetJobStatusDocument: DocumentNode;
+declare const CreateDocumentDocument: DocumentNode;
+declare const CreateEmptyDocumentDocument: DocumentNode;
+declare const MutateDocumentDocument: DocumentNode;
+declare const MutateDocumentAsyncDocument: DocumentNode;
+declare const RenameDocumentDocument: DocumentNode;
+declare const AddRelationshipDocument: DocumentNode;
+declare const RemoveRelationshipDocument: DocumentNode;
+declare const MoveRelationshipDocument: DocumentNode;
+declare const DeleteDocumentDocument: DocumentNode;
+declare const DeleteDocumentsDocument: DocumentNode;
+declare const DocumentChangesDocument: DocumentNode;
+declare const JobChangesDocument: DocumentNode;
+declare const PollSyncEnvelopesDocument: DocumentNode;
+declare const TouchChannelDocument: DocumentNode;
+declare const PushSyncEnvelopesDocument: DocumentNode;
+type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
+declare function getSdk<C>(requester: Requester<C>): {
+  GetDocumentModels(variables?: GetDocumentModelsQueryVariables, options?: C): Promise<GetDocumentModelsQuery>;
+  GetDocument(variables: GetDocumentQueryVariables, options?: C): Promise<GetDocumentQuery>;
+  GetDocumentWithOperations(variables: GetDocumentWithOperationsQueryVariables, options?: C): Promise<GetDocumentWithOperationsQuery>;
+  GetDocumentOutgoingRelationships(variables: GetDocumentOutgoingRelationshipsQueryVariables, options?: C): Promise<GetDocumentOutgoingRelationshipsQuery>;
+  GetDocumentIncomingRelationships(variables: GetDocumentIncomingRelationshipsQueryVariables, options?: C): Promise<GetDocumentIncomingRelationshipsQuery>;
+  FindDocuments(variables?: FindDocumentsQueryVariables, options?: C): Promise<FindDocumentsQuery>;
+  GetDocumentOperations(variables: GetDocumentOperationsQueryVariables, options?: C): Promise<GetDocumentOperationsQuery>;
+  GetJobStatus(variables: GetJobStatusQueryVariables, options?: C): Promise<GetJobStatusQuery>;
+  CreateDocument(variables: CreateDocumentMutationVariables, options?: C): Promise<CreateDocumentMutation>;
+  CreateEmptyDocument(variables: CreateEmptyDocumentMutationVariables, options?: C): Promise<CreateEmptyDocumentMutation>;
+  MutateDocument(variables: MutateDocumentMutationVariables, options?: C): Promise<MutateDocumentMutation>;
+  MutateDocumentAsync(variables: MutateDocumentAsyncMutationVariables, options?: C): Promise<MutateDocumentAsyncMutation>;
+  RenameDocument(variables: RenameDocumentMutationVariables, options?: C): Promise<RenameDocumentMutation>;
+  AddRelationship(variables: AddRelationshipMutationVariables, options?: C): Promise<AddRelationshipMutation>;
+  RemoveRelationship(variables: RemoveRelationshipMutationVariables, options?: C): Promise<RemoveRelationshipMutation>;
+  MoveRelationship(variables: MoveRelationshipMutationVariables, options?: C): Promise<MoveRelationshipMutation>;
+  DeleteDocument(variables: DeleteDocumentMutationVariables, options?: C): Promise<DeleteDocumentMutation>;
+  DeleteDocuments(variables: DeleteDocumentsMutationVariables, options?: C): Promise<DeleteDocumentsMutation>;
+  DocumentChanges(variables?: DocumentChangesSubscriptionVariables, options?: C): AsyncIterable<DocumentChangesSubscription>;
+  JobChanges(variables: JobChangesSubscriptionVariables, options?: C): AsyncIterable<JobChangesSubscription>;
+  PollSyncEnvelopes(variables: PollSyncEnvelopesQueryVariables, options?: C): Promise<PollSyncEnvelopesQuery>;
+  TouchChannel(variables: TouchChannelMutationVariables, options?: C): Promise<TouchChannelMutation>;
+  PushSyncEnvelopes(variables: PushSyncEnvelopesMutationVariables, options?: C): Promise<PushSyncEnvelopesMutation>;
+};
+type Sdk = ReturnType<typeof getSdk>;
+//#endregion
+//#region src/graphql/reactor/requester.d.ts
+type FetchLike = (input: URL | string, init: RequestInit) => Promise<Response>;
+//#endregion
+//#region src/graphql/reactor/factory.d.ts
+declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike, headers?: Record<string, string>): {
+  GetDocumentModels(variables?: Exact<{
+    namespace?: InputMaybe<Scalars["String"]["input"]>;
+    paging?: InputMaybe<PagingInput>;
+  }> | undefined, options?: {} | undefined): Promise<GetDocumentModelsQuery>;
+  GetDocument(variables: Exact<{
+    identifier: Scalars["String"]["input"];
+    view?: InputMaybe<ViewFilterInput>;
+  }>, options?: {} | undefined): Promise<GetDocumentQuery>;
+  GetDocumentWithOperations(variables: Exact<{
+    identifier: Scalars["String"]["input"];
+    view?: InputMaybe<ViewFilterInput>;
+    operationsFilter?: InputMaybe<DocumentOperationsFilterInput>;
+    operationsPaging?: InputMaybe<PagingInput>;
+  }>, options?: {} | undefined): Promise<GetDocumentWithOperationsQuery>;
+  GetDocumentOutgoingRelationships(variables: Exact<{
+    sourceIdentifier: Scalars["String"]["input"];
+    relationshipType: Scalars["String"]["input"];
+    view?: InputMaybe<ViewFilterInput>;
+    paging?: InputMaybe<PagingInput>;
+  }>, options?: {} | undefined): Promise<GetDocumentOutgoingRelationshipsQuery>;
+  GetDocumentIncomingRelationships(variables: Exact<{
+    targetIdentifier: Scalars["String"]["input"];
+    relationshipType: Scalars["String"]["input"];
+    view?: InputMaybe<ViewFilterInput>;
+    paging?: InputMaybe<PagingInput>;
+  }>, options?: {} | undefined): Promise<GetDocumentIncomingRelationshipsQuery>;
+  FindDocuments(variables?: Exact<{
+    search?: InputMaybe<SearchFilterInput>;
+    view?: InputMaybe<ViewFilterInput>;
+    paging?: InputMaybe<PagingInput>;
+  }> | undefined, options?: {} | undefined): Promise<FindDocumentsQuery>;
+  GetDocumentOperations(variables: Exact<{
+    filter: OperationsFilterInput;
+    paging?: InputMaybe<PagingInput>;
+  }>, options?: {} | undefined): Promise<GetDocumentOperationsQuery>;
+  GetJobStatus(variables: Exact<{
+    jobId: Scalars["String"]["input"];
+  }>, options?: {} | undefined): Promise<GetJobStatusQuery>;
+  CreateDocument(variables: Exact<{
+    document: Scalars["JSONObject"]["input"];
+    parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  }>, options?: {} | undefined): Promise<CreateDocumentMutation>;
+  CreateEmptyDocument(variables: Exact<{
+    documentType: Scalars["String"]["input"];
+    parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  }>, options?: {} | undefined): Promise<CreateEmptyDocumentMutation>;
+  MutateDocument(variables: Exact<{
+    documentIdentifier: Scalars["String"]["input"];
+    actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
+    view?: InputMaybe<ViewFilterInput>;
+  }>, options?: {} | undefined): Promise<MutateDocumentMutation>;
+  MutateDocumentAsync(variables: Exact<{
+    documentIdentifier: Scalars["String"]["input"];
+    actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
+    view?: InputMaybe<ViewFilterInput>;
+  }>, options?: {} | undefined): Promise<MutateDocumentAsyncMutation>;
+  RenameDocument(variables: Exact<{
+    documentIdentifier: Scalars["String"]["input"];
+    name: Scalars["String"]["input"];
+    branch?: InputMaybe<Scalars["String"]["input"]>;
+  }>, options?: {} | undefined): Promise<RenameDocumentMutation>;
+  AddRelationship(variables: Exact<{
+    sourceIdentifier: Scalars["String"]["input"];
+    targetIdentifier: Scalars["String"]["input"];
+    relationshipType: Scalars["String"]["input"];
+    branch?: InputMaybe<Scalars["String"]["input"]>;
+  }>, options?: {} | undefined): Promise<AddRelationshipMutation>;
+  RemoveRelationship(variables: Exact<{
+    sourceIdentifier: Scalars["String"]["input"];
+    targetIdentifier: Scalars["String"]["input"];
+    relationshipType: Scalars["String"]["input"];
+    branch?: InputMaybe<Scalars["String"]["input"]>;
+  }>, options?: {} | undefined): Promise<RemoveRelationshipMutation>;
+  MoveRelationship(variables: Exact<{
+    sourceParentIdentifier: Scalars["String"]["input"];
+    targetParentIdentifier: Scalars["String"]["input"];
+    targetIdentifier: Scalars["String"]["input"];
+    relationshipType: Scalars["String"]["input"];
+    branch?: InputMaybe<Scalars["String"]["input"]>;
+  }>, options?: {} | undefined): Promise<MoveRelationshipMutation>;
+  DeleteDocument(variables: Exact<{
+    identifier: Scalars["String"]["input"];
+    propagate?: InputMaybe<PropagationMode>;
+  }>, options?: {} | undefined): Promise<DeleteDocumentMutation>;
+  DeleteDocuments(variables: Exact<{
+    identifiers: ReadonlyArray<Scalars["String"]["input"]>;
+    propagate?: InputMaybe<PropagationMode>;
+  }>, options?: {} | undefined): Promise<DeleteDocumentsMutation>;
+  DocumentChanges(variables?: Exact<{
+    search?: InputMaybe<SearchFilterInput>;
+    view?: InputMaybe<ViewFilterInput>;
+  }> | undefined, options?: {} | undefined): AsyncIterable<DocumentChangesSubscription>;
+  JobChanges(variables: Exact<{
+    jobId: Scalars["String"]["input"];
+  }>, options?: {} | undefined): AsyncIterable<JobChangesSubscription>;
+  PollSyncEnvelopes(variables: Exact<{
+    channelId: Scalars["String"]["input"];
+    outboxAck: Scalars["Int"]["input"];
+    outboxLatest: Scalars["Int"]["input"];
+  }>, options?: {} | undefined): Promise<PollSyncEnvelopesQuery>;
+  TouchChannel(variables: Exact<{
+    input: TouchChannelInput;
+  }>, options?: {} | undefined): Promise<TouchChannelMutation>;
+  PushSyncEnvelopes(variables: Exact<{
+    envelopes: ReadonlyArray<SyncEnvelopeInput>;
+  }>, options?: {} | undefined): Promise<PushSyncEnvelopesMutation>;
+};
+//#endregion
+//#region src/graphql/reactor/subgraph.d.ts
+declare class ReactorSubgraph extends BaseSubgraph {
+  private logger;
+  constructor(args: SubgraphArgs);
+  name: string;
+  hasSubscriptions: boolean;
+  /**
+   * Check operation-level permissions for an array of actions.
+   * Delegates to base assertCanExecuteOperation for each action.
+   */
+  private assertCanExecuteOperations;
+  typeDefs: graphql.DocumentNode;
+  resolvers: Resolvers;
+  onSetup(): Promise<void>;
+}
+//#endregion
+//#region src/graphql/system/env/index.d.ts
+declare const ADMIN_USERS: string[];
+//#endregion
+//#region src/graphql/system/subgraph.d.ts
+declare class SystemSubgraph extends BaseSubgraph {
+  name: string;
+  hasSubscriptions: boolean;
+  typeDefs: graphql.DocumentNode;
+  resolvers: {
+    Query: {
+      system: () => {
+        version: string;
+        gitHash: string;
+      };
+    };
+  };
+}
+//#endregion
+//#region src/graphql/system/version.d.ts
+declare function getVersion(): string;
+declare function getGitHash(): string;
+//#endregion
+//#region src/graphql/utils.d.ts
+declare function isSubgraphClass(candidate: unknown): candidate is SubgraphClass$1;
+declare function buildGraphqlOperations(operations: Operation[], skip: number, first: number): GqlOperation$1[];
+declare function buildGraphqlOperation(operation: Operation): GqlOperation$1;
+declare function buildGraphQlDocument(doc: PHDocument): GqlDocument$1;
+declare function buildGraphQlDriveDocument(doc: DocumentDriveDocument): GqlDriveDocument$1;
+//#endregion
+//#region src/packages/import-loader.d.ts
+/**
+ * This class is used to load packages using the import keyword.
+ */
+declare class ImportPackageLoader implements IPackageLoader {
+  private readonly logger;
+  readonly name = "ImportPackageLoader";
+  loadDocumentModels(identifier: string): Promise<DocumentModelModule[]>;
+  loadSubgraphs(identifier: string): Promise<SubgraphClass$1[]>;
+  loadProcessors(identifier: string): Promise<ProcessorFactoryBuilder | null>;
+}
+//#endregion
+//#region src/packages/package-manager.d.ts
+declare function getUniqueDocumentModels(...documentModels: DocumentModelModule<any>[][]): DocumentModelModule[];
+declare class PackageManager implements IPackageManager {
+  protected options: IPackageManagerOptions;
+  private readonly logger;
+  private loaders;
+  private docModelsMap;
+  private subgraphsMap;
+  private processorMap;
+  private configWatcher;
+  private debouncedUpdateCallbacks;
+  private eventEmitter;
+  constructor(loaders: IPackageLoader[], options: IPackageManagerOptions);
+  init(): Promise<PackageManagerResult>;
+  private loadPackages;
+  private loadDocumentModels;
+  private loadSubgraphs;
+  private loadProcessors;
+  private updateDocumentModelsForPackage;
+  private subscribePackages;
+  private getAllPackageNames;
+  private getPackageNamesFromConfigFile;
+  private initConfigFileWatcher;
+  private updatePackagesMap;
+  private updateSubgraphsMap;
+  private updateProcessorsMap;
+  onDocumentModelsChange(handler: (documentModels: Record<string, DocumentModelModule[]>) => void): void;
+  onSubgraphsChange(handler: (subgraphs: Map<string, SubgraphClass$1[]>) => void): void;
+  onProcessorsChange(handler: (processors: Map<string, Processor$1>) => void): void;
+}
+//#endregion
+//#region src/server.d.ts
+type Options = {
+  port?: number;
+  dbPath: string | undefined;
+  client?: PGlite | typeof Pool | undefined;
+  configFile?: string;
+  packages?: string[];
+  auth?: {
+    enabled: boolean;
+    admins: string[];
+  };
+  https?: {
+    keyPath: string;
+    certPath: string;
+  } | boolean | undefined;
+  packageLoaders?: IPackageLoader[];
+  processors?: Record<string, ProcessorInitializer[]>;
+  mcp?: boolean;
+  processorConfig?: Map<string, unknown>;
+  /**
+   * Document permission service instance.
+   * When provided, the Auth subgraph is registered and document permission
+   * checks are enforced on document operations.
+   * If not provided, can be auto-created by setting DOCUMENT_PERMISSIONS_ENABLED=true
+   * environment variable.
+   */
+  documentPermissionService?: DocumentPermissionService;
+  enableDocumentModelSubgraphs?: boolean;
+  logger?: ILogger;
+  /**
+   * Filesystem path for attachment binary storage.
+   * Defaults to a sibling "attachments" directory next to dbPath,
+   * or os.tmpdir() for in-memory DB deployments.
+   */
+  attachmentStoragePath?: string;
+};
+type ProcessorInitializer = ProcessorFactoryBuilder;
+/**
+ * Initializes and starts the API server using an initializer function.
+ * This function first loads packages to get document models, then calls the initializer function
+ * to create the reactor client module with the appropriate dependencies.
+ *
+ * @param clientInitializer - Initializer function that creates the reactor client module with document models.
+ * @param options - Additional options for server configuration.
+ *
+ * @returns The API server components along with the created client instances.
+ */
+declare function initializeAndStartAPI(clientInitializer: (documentModels: DocumentModelModule[]) => Promise<ReactorClientModule>, options: Options, processorApp: ProcessorApp): Promise<API & {
+  client: IReactorClient;
+  syncManager: ISyncManager;
+  documentModelRegistry: IDocumentModelRegistry;
+}>;
+//#endregion
+//#region src/tracing.d.ts
+declare function initTracing(): Promise<void>;
+declare function isTracingEnabled(): boolean;
+declare function trace<T>(_name: string, _options: any, fn: () => Promise<T>): Promise<T>;
+//#endregion
+//#region src/utils/create-schema.d.ts
+declare const buildSubgraphSchemaModule: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => GraphQLSchemaModule;
+declare const createSchema: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => graphql.GraphQLSchema;
+/**
+ * Create a merged GraphQL schema from multiple subgraph modules.
+ * Uses buildSubgraphSchema's array overload to combine type definitions
+ * and resolvers from multiple subgraphs into a single executable schema.
+ */
+declare const createMergedSchema: (modules: GraphQLSchemaModule[]) => graphql.GraphQLSchema;
+declare function getDocumentModelSchemaName(documentModel: DocumentModelGlobalState$1): string;
+declare const getDocumentModelTypeDefs: (documentModels: DocumentModelModule[], typeDefs: DocumentNode) => DocumentNode;
+/**
+ * Options for generating document model GraphQL schemas.
+ */
+interface DocumentModelSchemaOptions {
+  /**
+   * When true, generates new API patterns:
+   * - Mutations return full document objects (MutationResult type)
+   * - Adds createEmptyDocument mutation
+   * - Makes docId and input parameters required
+   * @default false
+   */
+  useNewApi?: boolean;
+}
+/**
+ * Generate a GraphQL schema for a document model.
+ *
+ * @param documentModel - The document model global state
+ * @param options - Schema generation options
+ * @returns GraphQL DocumentNode
+ */
+declare function generateDocumentModelSchema(documentModel: DocumentModelGlobalState$1, options?: DocumentModelSchemaOptions): DocumentNode;
+//#endregion
+export { ADMIN_USERS, API, Action, ActionContext, ActionContextInput, ActionContextInputSchema, ActionContextResolvers, ActionInput, ActionInputSchema, ActionResolvers, AddRelationshipDocument, AddRelationshipMutation, AddRelationshipMutationVariables, AnalyticsSubgraph, Attachment, AttachmentInput, AttachmentInputSchema, AttachmentResolvers, AuthConfig, AuthContext, AuthFetchMiddleware, AuthService, AuthSubgraph, BaseSubgraph, ChannelMeta, ChannelMetaInput, ChannelMetaInputSchema, ChannelMetaResolvers, Context, CreateDocumentDocument, CreateDocumentMutation, CreateDocumentMutationVariables, CreateEmptyDocumentDocument, CreateEmptyDocumentMutation, CreateEmptyDocumentMutationVariables, DateTimeScalarConfig, DeadLetterInfo, DeadLetterInfoResolvers, DeleteDocumentDocument, DeleteDocumentMutation, DeleteDocumentMutationVariables, DeleteDocumentsDocument, DeleteDocumentsMutation, DeleteDocumentsMutationVariables, DirectiveResolverFn, DocumentChangeContext, DocumentChangeContextResolvers, DocumentChangeEvent, DocumentChangeEventResolvers, DocumentChangeType, DocumentChangeTypeSchema, DocumentChangesDocument, DocumentChangesSubscription, DocumentChangesSubscriptionVariables, DocumentGroupPermissionEntry, DocumentGroupPermissionTable, DocumentModelGlobalState, DocumentModelGlobalStateResolvers, DocumentModelResultPage, DocumentModelResultPageResolvers, DocumentModelSchemaOptions, DocumentOperationsFilterInput, DocumentOperationsFilterInputSchema, DocumentPermissionConfig, DocumentPermissionDatabase, DocumentPermissionEntry, DocumentPermissionLevel, DocumentPermissionService, DocumentPermissionTable, DocumentProtectionTable, DocumentWithChildren, DocumentWithChildrenResolvers, Exact, FetchHandler, FindDocumentsDocument, FindDocumentsQuery, FindDocumentsQueryVariables, GatewayAdapterType, GatewayContextFactory, GetDocumentDocument, GetDocumentIncomingRelationshipsDocument, GetDocumentIncomingRelationshipsQuery, GetDocumentIncomingRelationshipsQueryVariables, GetDocumentModelsDocument, GetDocumentModelsQuery, GetDocumentModelsQueryVariables, GetDocumentOperationsDocument, GetDocumentOperationsQuery, GetDocumentOperationsQueryVariables, GetDocumentOutgoingRelationshipsDocument, GetDocumentOutgoingRelationshipsQuery, GetDocumentOutgoingRelationshipsQueryVariables, GetDocumentQuery, GetDocumentQueryVariables, GetDocumentWithOperationsDocument, GetDocumentWithOperationsQuery, GetDocumentWithOperationsQueryVariables, GetJobStatusDocument, GetJobStatusQuery, GetJobStatusQueryVariables, GetParentIdsFn, GqlDocument, GqlDriveDocument, GqlOperation, GqlOperationContext, GqlSigner, GqlSignerApp, GqlSignerUser, GraphQLManager, GraphqlManagerFeatureFlags, Group, GroupTable, HttpAdapterSetup, HttpAdapterType, HttpDocumentModelLoader, HttpPackageLoader, HttpPackageLoaderLogger, HttpPackageLoaderOptions, IGatewayAdapter, IHttpAdapter, type IPackageLoader, type IPackageLoaderOptions, IPackageStorage, ISubgraph, ImportPackageLoader, InMemoryPackageStorage, Incremental, InputMaybe, InstallPackageResult, InstalledPackageInfo, IsTypeOfResolverFn, JobChangeEvent, JobChangeEventResolvers, JobChangesDocument, JobChangesSubscription, JobChangesSubscriptionVariables, JobInfo, JobInfoResolvers, JsonObjectScalarConfig, MakeEmpty, MakeMaybe, MakeOptional, Maybe, MoveRelationshipDocument, MoveRelationshipMutation, MoveRelationshipMutationVariables, MoveRelationshipResult, MoveRelationshipResultResolvers, MutateDocumentAsyncDocument, MutateDocumentAsyncMutation, MutateDocumentAsyncMutationVariables, MutateDocumentDocument, MutateDocumentMutation, MutateDocumentMutationVariables, Mutation, MutationAddRelationshipArgs, MutationCreateDocumentArgs, MutationCreateEmptyDocumentArgs, MutationDeleteDocumentArgs, MutationDeleteDocumentsArgs, MutationMoveRelationshipArgs, MutationMutateDocumentArgs, MutationMutateDocumentAsyncArgs, MutationPushSyncEnvelopesArgs, MutationRemoveRelationshipArgs, MutationRenameDocumentArgs, MutationResolvers, MutationTouchChannelArgs, NextResolverFn, OperationContext, OperationContextInput, OperationContextInputSchema, OperationContextResolvers, OperationGroupPermissionEntry, OperationGroupPermissionTable, OperationInput, OperationInputSchema, OperationUserPermissionEntry, OperationUserPermissionTable, OperationWithContext, OperationWithContextInput, OperationWithContextInputSchema, OperationWithContextResolvers, OperationsFilterInput, OperationsFilterInputSchema, PackageManagementService, PackageManagementServiceOptions, PackageManager, PackagesSubgraph, type PackagesSubgraphArgs, PagingInput, PagingInputSchema, type ParsedDriveUrl, PhDocument, PhDocumentFieldsFragment, PhDocumentFieldsFragmentDoc, PhDocumentOperationsArgs, PhDocumentResolvers, PhDocumentResultPage, PhDocumentResultPageResolvers, PollSyncEnvelopesDocument, PollSyncEnvelopesQuery, PollSyncEnvelopesQueryVariables, PollSyncEnvelopesResult, PollSyncEnvelopesResultResolvers, Processor, ProcessorDriveFactory, ProcessorFactoryBuilder, PropagationMode, PropagationModeSchema, PushSyncEnvelopesDocument, PushSyncEnvelopesMutation, PushSyncEnvelopesMutationVariables, Query, QueryDocumentArgs, QueryDocumentIncomingRelationshipsArgs, QueryDocumentModelsArgs, QueryDocumentOperationsArgs, QueryDocumentOutgoingRelationshipsArgs, QueryFindDocumentsArgs, QueryJobStatusArgs, QueryPollSyncEnvelopesArgs, QueryResolvers, ReactorModule, ReactorOperation, ReactorOperationResolvers, ReactorOperationResultPage, ReactorOperationResultPageResolvers, ReactorSigner, ReactorSignerApp, ReactorSignerAppInput, ReactorSignerAppInputSchema, ReactorSignerAppResolvers, ReactorSignerInput, ReactorSignerInputSchema, ReactorSignerResolvers, ReactorSignerUser, ReactorSignerUserInput, ReactorSignerUserInputSchema, ReactorSignerUserResolvers, ReactorSubgraph, RemoteCursor, RemoteCursorInput, RemoteCursorInputSchema, RemoteCursorResolvers, RemoteFilterInput, RemoteFilterInputSchema, RemoveRelationshipDocument, RemoveRelationshipMutation, RemoveRelationshipMutationVariables, RenameDocumentDocument, RenameDocumentMutation, RenameDocumentMutationVariables, Requester, RequireFields, Resolver, ResolverFn, ResolverTypeWrapper, ResolverWithResolve, Resolvers, ResolversObject, ResolversParentTypes, ResolversTypes, Revision, RevisionResolvers, Scalars, Sdk, SearchFilterInput, SearchFilterInputSchema, SubgraphArgs, SubgraphClass, SubgraphDefinition, Subscription, SubscriptionDocumentChangesArgs, SubscriptionJobChangesArgs, SubscriptionObject, SubscriptionResolveFn, SubscriptionResolver, SubscriptionResolverObject, SubscriptionResolvers, SubscriptionSubscribeFn, SubscriptionSubscriberObject, SyncEnvelope, SyncEnvelopeInput, SyncEnvelopeInputSchema, SyncEnvelopeResolvers, SyncEnvelopeType, SyncEnvelopeTypeSchema, SystemSubgraph, TlsOptions, TouchChannelDocument, TouchChannelInput, TouchChannelInputSchema, TouchChannelMutation, TouchChannelMutationVariables, TouchChannelResult, TouchChannelResultResolvers, TypeResolveFn, User, UserGroupTable, ViewFilterInput, ViewFilterInputSchema, WithIndex, WsContextFactory, WsDisposer, buildGraphQlDocument, buildGraphQlDriveDocument, buildGraphqlOperation, buildGraphqlOperations, buildSubgraphSchemaModule, createAuthFetchMiddleware, createGatewayAdapter, createHttpAdapter, createMergedSchema, createReactorGraphQLClient, createSchema, definedNonNullAnySchema, driveIdFromUrl, generateDocumentModelSchema, getAuthContext, getDbClient, getDocumentModelSchemaName, getDocumentModelTypeDefs, getGitHash, getSdk, getUniqueDocumentModels, getVersion, initAnalyticsStoreSql, initTracing, initializeAndStartAPI, isDefinedNonNullAny, isSubgraphClass, isTracingEnabled, parseDriveUrl, renderGraphqlPlayground, trace };
+//# sourceMappingURL=index.d.mts.map