@powerhousedao/reactor-api 6.2.3-dev.34 → 6.2.3-dev.36

package/dist/index.d.mts

@@ -1,14 +1,14 @@
-import { a as IPackagePieceSource, c as PackageManagerResult, i as IPackageManagerOptions, l as PackagePiece, n as IPackageLoaderOptions, r as IPackageManager, t as IPackageLoader, u as PackagePieceEntry } from "./types-CuSz_zv6.mjs";
+import { a as IPackagePieceSource, c as PackageManagerResult, i as IPackageManagerOptions, l as PackagePiece, n as IPackageLoaderOptions, r as IPackageManager, t as IPackageLoader, u as PackagePieceEntry } from "./types-DlTiz6AA.mjs";
 import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
 import { AnalyticsModel } from "@powerhousedao/analytics-engine-graphql";
 import { DocumentNode, GraphQLError, GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig, GraphQLSchema } from "graphql";
 import { AttachmentRef, IDocumentModelLoader, IDocumentModelRegistry, IDriveClient, IReactorClient, IReactorProcessorHostModuleBase, IRelationalDb, ISyncManager, InProcessReactorClientModule, ParsedDriveUrl, ProcessorFactoryBuilder as ProcessorFactoryBuilder$1, SyncScopeGate, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
+import { AuthSubject, DocumentModelGlobalState as DocumentModelGlobalState$1, DocumentModelModule, Operation, PHDocument, UpgradeManifest } from "@powerhousedao/shared/document-model";
 import { ILogger } from "document-model";
 import { GraphQLResolverMap, GraphQLSchemaModule } from "@apollo/subgraph";
-import { AuthSubject, DocumentModelGlobalState as DocumentModelGlobalState$1, DocumentModelModule, Operation, PHDocument, UpgradeManifest } from "@powerhousedao/shared/document-model";
 import * as z$1 from "zod";
 import { DocumentDriveDocument, DocumentDriveGlobalState } from "@powerhousedao/shared/document-drive";
-import { AttachmentBuildResult, AttachmentReferenceIndexBuildResult, IAttachmentReferenceReader, IAttachmentReferenceWriter } from "@powerhousedao/reactor-attachments";
+import { AttachmentBuildResult, AttachmentDownloadOptions, AttachmentDownloadTarget, AttachmentDownloadTargetOptions, AttachmentHeader, AttachmentReferenceIndexBuildResult, AttachmentResponse, AttachmentStatOptions, IAttachmentReferenceReader, IAttachmentReferenceWriter, IAttachmentService, IAttachmentUpload, ReserveAttachmentOptions } from "@powerhousedao/reactor-attachments";
 import { IAttachmentClient } from "@powerhousedao/reactor-attachments/client";
 import { WebSocketServer } from "ws";
 import { AuthorizerResult, IHttpScope, IRelationalDb as IRelationalDb$1, IWebhookEndpoints, IWebhookScope, NodeRouteSpec, ProcessorApp, ProcessorFactory, RouteActor, RouteAuth, RouteAuthorizer, RouteBody, RouteContext, RouteHandler, RouteMethod, RouteOptions, RouteSpec, RouteTransport, RouteUser, RouteUser as RouteUser$1, ScopedRouteHandle, WebhookEndpointInfo, WebhookField, WebhookHashAlgorithm, WebhookPolicy, WebhookReply, WebhookRequest, WebhookScheme, WebhookSignatureEncoding, WebhookSpec, WebhookVerification } from "@powerhousedao/shared/processors";
@@ -146,7 +146,18 @@ export declare class DocumentPermissionService {
   /**
    * Delete all permissions for a document (used when deleting a document)
    */
-  deleteAllDocumentPermissions(documentId: string): Promise<void>;
+  deleteAllDocumentPermissions(documentId: string): Promise<{
+    DocumentPermission: number;
+    OperationUserPermission: number;
+  }>;
+  /** Delete a document's protection row, which names its owner. */
+  deleteDocumentProtection(documentId: string): Promise<number>;
+  /** Every row that names the address, for a subject access request. */
+  rowsForAddress(address: string): Promise<{
+    permissions: DocumentPermissionEntry[];
+    operationPermissions: OperationUserPermissionEntry[];
+    ownedDocumentIds: string[];
+  }>;
   /**
    * Grant a user permission to execute an operation on a document
    */
@@ -733,6 +744,192 @@ export declare function redactHeaders(headers: Record<string, string>, extra?: s
  * XML or CSV payload is still reachable downstream. */
 export declare function parseWebhookBody(raw: Buffer, contentType?: string): unknown;
 //#endregion
+//#region src/services/canonical-document-id.d.ts
+/**
+ * Raised when a caller-supplied identifier cannot be resolved to a canonical
+ * document id. Carries no detail on purpose: resolution failures must not act
+ * as a document-existence oracle, so consumers map this to their generic
+ * fail-closed response.
+ */
+export declare class CanonicalDocumentIdResolutionError extends Error {
+  constructor();
+}
+export type CanonicalDocumentIdResolver = (identifier: string) => Promise<CanonicalDocumentId>;
+/**
+ * The sanctioned string-to-CanonicalDocumentId cast: both the GraphQL layer
+ * and server routes must resolve caller identifiers through this helper so
+ * decision and data layers always agree on the subject document.
+ */
+export declare function createCanonicalDocumentIdResolver(client: Pick<IReactorClient, "resolveIdOrSlug">): CanonicalDocumentIdResolver;
+//#endregion
+//#region src/services/attachment-access.service.d.ts
+/**
+ * Whether the active Reactor composition hosts the attachment-reference
+ * projection. Reported by the client initializer: the built-in stack always
+ * registers it, while a caller-provided Reactor may lack the live
+ * registration capability. Consumers of reference evidence must fail closed
+ * when it is unavailable.
+ */
+export type AttachmentReferenceProjectionCapability = {
+  status: "available";
+} | {
+  status: "unavailable";
+  reason: "live-read-model-registration-unsupported" | "in-process-reactor-module-unavailable" | "initializer-did-not-report";
+};
+/**
+ * Outcome of an attachment read authorization. `denied` intentionally covers
+ * both an unreadable document and an absent document/ref relationship so the
+ * route layer cannot leak which check failed. `projection-unavailable` means
+ * the reference index is not being maintained in this composition; it is
+ * returned before any document-authorization or reference lookup runs.
+ */
+export type AttachmentAccessResult = {
+  kind: "allowed";
+  documentId: CanonicalDocumentId;
+  ref: AttachmentRef;
+} | {
+  kind: "denied";
+} | {
+  kind: "projection-unavailable";
+};
+export interface AttachmentAccessRequest {
+  documentId: string;
+  attachmentRef: string;
+  userAddress?: string;
+  /**
+   * The `did:key` of the app instance whose token authenticated the caller.
+   * A policy subject is an address AND a key — a grant can name either, and a
+   * document's creator is recorded by key — so a decision made from the address
+   * alone answers a narrower question than the one being asked.
+   */
+  appKey?: string;
+}
+/** The reactor's read gate, as the attachment facade consults it. */
+export type AttachmentReadGate = Pick<IReactorClient, "isServed" | "get">;
+/**
+ * Which scopes of a document a subject may read, asked by document id.
+ *
+ * Structural on purpose: the composition that has a policy model to enforce
+ * supplies `SyncScopeGate`, and one that does not supplies nothing at all.
+ */
+export interface IDocumentScopeGate {
+  scopePredicateById(documentId: string, subject: {
+    address?: string;
+    key?: string;
+  }, branch: string, signal?: AbortSignal): Promise<(scope: string) => boolean>;
+}
+export type AttachmentCallerResult = {
+  kind: "admitted";
+} | {
+  kind: "unauthenticated";
+};
+export interface AttachmentCallerRequest {
+  intent: "read" | "write";
+  userAddress?: string;
+  appKey?: string;
+}
+export interface IAttachmentAccessService {
+  canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
+  /** Whether this caller may use attachments at all, before any document decides. */
+  admitCaller(request: AttachmentCallerRequest): Promise<AttachmentCallerResult>;
+}
+export interface AttachmentAccessServiceOptions {
+  /** Refuse writes from a caller with no address. Default `true`. */
+  refuseAnonymousWrites?: boolean;
+  /** Refuse reads from a caller with no address. Default `false`. */
+  refuseAnonymousReads?: boolean;
+}
+/**
+ * Composes document authorization with the projected document/ref
+ * relationship. Order is fixed: validate ref, resolve the canonical document
+ * id, decide the read, check the reactor's read gate serves the document, then
+ * check the reference index and that the subject may read a scope whose
+ * operations reference the attachment. A denied document never reaches the
+ * reference reader, and the facade never touches attachment metadata, storage
+ * backends, or presigners.
+ *
+ * The named document decides alone: an attachment several documents reference
+ * is readable through each of them on that document's own terms.
+ *
+ * The read is decided by the document's own policy when this composition has a
+ * model to enforce it with, and by the host's permission tables when it does
+ * not. That is not a preference between two equivalent answers: a host running
+ * document policies keeps no rows in the permission tables, so asking them
+ * about such a document returns whatever the host-wide policy says — under
+ * `OPEN`, `true`, for everyone. Serving bytes on that answer hands the file to
+ * anyone who learns its hash, which the document's own state may well have told
+ * them. Both are kept because they are the two halves of one rule: an
+ * attachment is readable by whoever may read the document that references it,
+ * and each composition can only express that in its own terms. The caller
+ * decision mirrors the routes' `requireAuth`.
+ */
+export declare class AttachmentAccessService implements IAttachmentAccessService {
+  private readonly resolveCanonicalId;
+  private readonly authorization;
+  private readonly references;
+  private readonly projection;
+  private readonly readGate;
+  /**
+   * Absent below auth enforcement, where there is no policy model to
+   * evaluate; the host's permission tables decide alone, exactly as before.
+   */
+  private readonly scopeGate?;
+  private readonly options;
+  constructor(resolveCanonicalId: CanonicalDocumentIdResolver, authorization: IAuthorizationService, references: IAttachmentReferenceReader, projection: AttachmentReferenceProjectionCapability, readGate: AttachmentReadGate,
+  /**
+   * Absent below auth enforcement, where there is no policy model to
+   * evaluate; the host's permission tables decide alone, exactly as before.
+   */
+  scopeGate?: IDocumentScopeGate | undefined, options?: AttachmentAccessServiceOptions);
+  admitCaller(request: AttachmentCallerRequest): Promise<AttachmentCallerResult>;
+  canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
+  /**
+   * Whether the caller may read the state the reference lives in.
+   *
+   * A failure here is rethrown rather than turned into a denial. A read side
+   * that is down must not read as a policy: a denial nobody can distinguish
+   * from a refusal is one nobody investigates, and the route answers 500 for a
+   * reason.
+   */
+  private canReadDocument;
+}
+//#endregion
+//#region src/services/authorized-attachment.service.d.ts
+/** The reference index is not maintained in this composition. */
+export declare class AttachmentAccessUnavailable extends Error {
+  constructor();
+}
+/** The access decision itself failed; the cause is logged, not surfaced. */
+export declare class AttachmentAccessFailed extends Error {
+  constructor(cause: unknown);
+}
+/** An `IAttachmentService` whose reads and writes are decided for one subject. */
+export declare class AuthorizedAttachmentService implements IAttachmentService {
+  private readonly inner;
+  private readonly access;
+  private readonly subject;
+  private readonly logger;
+  constructor(inner: IAttachmentService, access: IAttachmentAccessService, subject: AuthSubject, logger: ILogger);
+  /** Hash-first only: an upload-first handle can send after it expires. */
+  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
+  stat(ref: AttachmentRef, options?: AttachmentStatOptions): Promise<AttachmentHeader>;
+  get(ref: AttachmentRef, options?: AbortSignal | AttachmentDownloadOptions): Promise<AttachmentResponse>;
+  getDownloadTarget(ref: AttachmentRef, options: AttachmentDownloadTargetOptions): Promise<AttachmentDownloadTarget>;
+  private decideRead;
+  private admit;
+  private accessFailed;
+}
+export interface IAttachmentClientProvider {
+  forSubject(subject: AuthSubject): IAttachmentClient;
+}
+export declare class AttachmentClientProvider implements IAttachmentClientProvider {
+  private readonly service;
+  private readonly access;
+  private readonly logger;
+  constructor(service: IAttachmentService, access: IAttachmentAccessService, logger: ILogger);
+  forSubject(subject: AuthSubject): IAttachmentClient;
+}
+//#endregion
 //#region src/graphql/types.d.ts
 export type SubgraphClass = typeof BaseSubgraph;
 export type Context = {
@@ -786,6 +983,11 @@ export type SubgraphArgs = {
    * to the host's permission tables alone.
    */
   syncServingGate?: SyncScopeGate;
+  /**
+   * Attachments as the request's caller may use them. Bind per request with
+   * `BaseSubgraph.attachmentsFor(ctx)`.
+   */
+  attachments?: IAttachmentClientProvider;
   /**
    * The host's base path, injected by the GraphQL manager when it constructs
    * a subgraph. Subgraph code may read it, but routing ignores it: every
@@ -872,6 +1074,12 @@ export declare class BaseSubgraph implements ISubgraph$1 {
   authorizationService: IAuthorizationService;
   syncServingGate?: SyncScopeGate;
   constructor(args: SubgraphArgs$1);
+  /**
+   * An attachment client bound to this request's caller, memoized per request.
+   *
+   * @throws Error when the host provides no attachment client to subgraphs.
+   */
+  attachmentsFor(ctx: Context): IAttachmentClient;
   onSetup(): Promise<void>;
   onDisconnect(): Promise<void>;
   /**
@@ -1032,6 +1240,10 @@ declare function transferDocumentOwnership(service: DocumentPermissionService, a
 }, userAddress: string | undefined): Promise<DocumentProtectionInfo>;
 //#endregion
 //#region src/graphql/auth/subgraph.d.ts
+type DocumentArgs = {
+  documentIdOrSlug?: string | null;
+  documentId?: string | null;
+};
 /**
  * Auth Subgraph - handles all document permission and authorization operations
  *
@@ -1042,6 +1254,7 @@ declare function transferDocumentOwnership(service: DocumentPermissionService, a
  * - Operation-level permissions (fine-grained operation control)
  */
 export declare class AuthSubgraph extends BaseSubgraph {
+  #private;
   private logger;
   constructor(args: SubgraphArgs);
   name: string;
@@ -1049,9 +1262,7 @@ export declare class AuthSubgraph extends BaseSubgraph {
   typeDefs: import("graphql").DocumentNode;
   resolvers: {
     Query: {
-      documentAccess: (_parent: unknown, args: {
-        documentId: string;
-      }, ctx: {
+      documentAccess: (_parent: unknown, args: DocumentArgs, ctx: {
         user?: {
           address: string;
         };
@@ -1068,49 +1279,42 @@ export declare class AuthSubgraph extends BaseSubgraph {
         createdAt: Date;
         updatedAt: Date;
       }[]>;
-      operationPermissions: (_parent: unknown, args: {
-        documentId: string;
+      operationPermissions: (_parent: unknown, args: DocumentArgs & {
         operationType: string;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<OperationPermissionsInfo>;
-      canExecuteOperation: (_parent: unknown, args: {
-        documentId: string;
+      canExecuteOperation: (_parent: unknown, args: DocumentArgs & {
         operationType: string;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<boolean>;
-      documentProtection: (_parent: unknown, args: {
-        documentId: string;
-      }, ctx: {
+      documentProtection: (_parent: unknown, args: DocumentArgs, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<DocumentProtectionInfo>;
     };
     Mutation: {
-      setDocumentProtection: (_parent: unknown, args: {
-        documentId: string;
+      setDocumentProtection: (_parent: unknown, args: DocumentArgs & {
         protected: boolean;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<DocumentProtectionInfo>;
-      transferDocumentOwnership: (_parent: unknown, args: {
-        documentId: string;
+      transferDocumentOwnership: (_parent: unknown, args: DocumentArgs & {
         newOwnerAddress: string;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<DocumentProtectionInfo>;
-      grantDocumentPermission: (_parent: unknown, args: {
-        documentId: string;
+      grantDocumentPermission: (_parent: unknown, args: DocumentArgs & {
         userAddress: string;
         permission: string;
       }, ctx: {
@@ -1125,16 +1329,14 @@ export declare class AuthSubgraph extends BaseSubgraph {
         createdAt: Date;
         updatedAt: Date;
       }>;
-      revokeDocumentPermission: (_parent: unknown, args: {
-        documentId: string;
+      revokeDocumentPermission: (_parent: unknown, args: DocumentArgs & {
         userAddress: string;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<boolean>;
-      grantOperationPermission: (_parent: unknown, args: {
-        documentId: string;
+      grantOperationPermission: (_parent: unknown, args: DocumentArgs & {
         operationType: string;
         userAddress: string;
       }, ctx: {
@@ -1142,8 +1344,7 @@ export declare class AuthSubgraph extends BaseSubgraph {
           address: string;
         };
       }) => Promise<OperationUserPermission>;
-      revokeOperationPermission: (_parent: unknown, args: {
-        documentId: string;
+      revokeOperationPermission: (_parent: unknown, args: DocumentArgs & {
         operationType: string;
         userAddress: string;
       }, ctx: {
@@ -1200,6 +1401,31 @@ type RequireAuthFetchMiddleware = (handler: FetchHandler) => FetchHandler;
 export type GraphqlManagerFeatureFlags = {
   enableDocumentModelSubgraphs?: boolean;
 };
+/** Dependencies and settings for a {@link GraphQLManager}. */
+export type GraphQLManagerOptions = {
+  path: string;
+  httpServer: http.Server;
+  wsServer: WebSocketServer;
+  reactorClient: IReactorClient;
+  relationalDb: IRelationalDb;
+  analyticsStore: IAnalyticsStore;
+  syncManager: ISyncManager;
+  logger: ILogger;
+  httpAdapter: IHttpAdapter;
+  gatewayAdapter: IGatewayAdapter<Context$1>;
+  authService?: AuthService;
+  documentPermissionService?: DocumentPermissionService;
+  /** Defaults to every flag on. */
+  featureFlags?: GraphqlManagerFeatureFlags;
+  /** Defaults to 4001. */
+  port?: number;
+  authorizationService: IAuthorizationService;
+  /** Resolvers dispatch to it for reactor-drive parents. */
+  reactorDriveClient?: IDriveClient;
+  syncServingGate?: SyncScopeGate;
+  httpRoutes?: HttpRouteService;
+  attachments?: IAttachmentClientProvider;
+};
 export declare function createWsAuthHandlers(opts: {
   authService?: AuthService;
   /** Whether anonymous callers are refused; read at call time, not at build time. */
@@ -1209,22 +1435,6 @@ export declare function createWsAuthHandlers(opts: {
 }): WsHandlers<Context$1>;
 export 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 authService?;
-  private readonly documentPermissionService?;
-  private readonly featureFlags;
-  private readonly port;
-  private readonly syncServingGate?;
-  private readonly httpRoutes?;
   private initialized;
   private coreSubgraphsMap;
   private contextFields;
@@ -1251,7 +1461,24 @@ export declare class GraphQLManager {
    */
   readonly reactorDriveClient?: IDriveClient;
   private readonly authorizationService;
-  constructor(path: string, httpServer: http.Server, wsServer: WebSocketServer, reactorClient: IReactorClient, relationalDb: IRelationalDb, analyticsStore: IAnalyticsStore, syncManager: ISyncManager, logger: ILogger, httpAdapter: IHttpAdapter, gatewayAdapter: IGatewayAdapter<Context$1>, authService?: AuthService | undefined, documentPermissionService?: DocumentPermissionService | undefined, featureFlags?: GraphqlManagerFeatureFlags, port?: number, authorizationService?: IAuthorizationService, reactorDriveClient?: IDriveClient, syncServingGate?: SyncScopeGate | undefined, httpRoutes?: HttpRouteService | undefined);
+  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 authService?;
+  private readonly documentPermissionService?;
+  private readonly featureFlags;
+  private readonly port;
+  private readonly syncServingGate?;
+  private readonly httpRoutes?;
+  private readonly attachments?;
+  constructor(options: GraphQLManagerOptions);
   init(coreSubgraphs: SubgraphClass$1[], authMiddleware?: AuthFetchMiddleware, requireAuthMiddleware?: RequireAuthFetchMiddleware): Promise<void>;
   /**
    * Regenerate document model subgraphs when models are dynamically loaded.
@@ -1341,135 +1568,6 @@ export declare class InMemoryPackageStorage implements IPackageStorage {
   has(name: string): Promise<boolean>;
 }
 //#endregion
-//#region src/services/canonical-document-id.d.ts
-/**
- * Raised when a caller-supplied identifier cannot be resolved to a canonical
- * document id. Carries no detail on purpose: resolution failures must not act
- * as a document-existence oracle, so consumers map this to their generic
- * fail-closed response.
- */
-export declare class CanonicalDocumentIdResolutionError extends Error {
-  constructor();
-}
-export type CanonicalDocumentIdResolver = (identifier: string) => Promise<CanonicalDocumentId>;
-/**
- * The sanctioned string-to-CanonicalDocumentId cast: both the GraphQL layer
- * and server routes must resolve caller identifiers through this helper so
- * decision and data layers always agree on the subject document.
- */
-export declare function createCanonicalDocumentIdResolver(client: Pick<IReactorClient, "resolveIdOrSlug">): CanonicalDocumentIdResolver;
-//#endregion
-//#region src/services/attachment-access.service.d.ts
-/**
- * Whether the active Reactor composition hosts the attachment-reference
- * projection. Reported by the client initializer: the built-in stack always
- * registers it, while a caller-provided Reactor may lack the live
- * registration capability. Consumers of reference evidence must fail closed
- * when it is unavailable.
- */
-export type AttachmentReferenceProjectionCapability = {
-  status: "available";
-} | {
-  status: "unavailable";
-  reason: "live-read-model-registration-unsupported" | "in-process-reactor-module-unavailable" | "initializer-did-not-report";
-};
-/**
- * Outcome of an attachment read authorization. `denied` intentionally covers
- * both an unreadable document and an absent document/ref relationship so the
- * route layer cannot leak which check failed. `projection-unavailable` means
- * the reference index is not being maintained in this composition; it is
- * returned before any document-authorization or reference lookup runs.
- */
-export type AttachmentAccessResult = {
-  kind: "allowed";
-  documentId: CanonicalDocumentId;
-  ref: AttachmentRef;
-} | {
-  kind: "denied";
-} | {
-  kind: "projection-unavailable";
-};
-export interface AttachmentAccessRequest {
-  documentId: string;
-  attachmentRef: string;
-  userAddress?: string;
-  /**
-   * The `did:key` of the app instance whose token authenticated the caller.
-   * A policy subject is an address AND a key — a grant can name either, and a
-   * document's creator is recorded by key — so a decision made from the address
-   * alone answers a narrower question than the one being asked.
-   */
-  appKey?: string;
-}
-/** The reactor's read gate, as the attachment facade consults it. */
-export type AttachmentReadGate = Pick<IReactorClient, "isServed" | "get">;
-/**
- * Which scopes of a document a subject may read, asked by document id.
- *
- * Structural on purpose: the composition that has a policy model to enforce
- * supplies `SyncScopeGate`, and one that does not supplies nothing at all.
- */
-export interface IDocumentScopeGate {
-  scopePredicateById(documentId: string, subject: {
-    address?: string;
-    key?: string;
-  }, branch: string, signal?: AbortSignal): Promise<(scope: string) => boolean>;
-}
-export interface IAttachmentAccessService {
-  canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
-}
-/**
- * Composes document authorization with the projected document/ref
- * relationship. Order is fixed: validate ref, resolve the canonical document
- * id, decide the read, check the reactor's read gate serves the document, then
- * check the reference index and that the subject may read a scope whose
- * operations reference the attachment. A denied document never reaches the
- * reference reader, and the facade never touches attachment metadata, storage
- * backends, or presigners.
- *
- * The named document decides alone: an attachment several documents reference
- * is readable through each of them on that document's own terms.
- *
- * The read is decided by the document's own policy when this composition has a
- * model to enforce it with, and by the host's permission tables when it does
- * not. That is not a preference between two equivalent answers: a host running
- * document policies keeps no rows in the permission tables, so asking them
- * about such a document returns whatever the host-wide policy says — under
- * `OPEN`, `true`, for everyone. Serving bytes on that answer hands the file to
- * anyone who learns its hash, which the document's own state may well have told
- * them. Both are kept because they are the two halves of one rule: an
- * attachment is readable by whoever may read the document that references it,
- * and each composition can only express that in its own terms.
- */
-export declare class AttachmentAccessService implements IAttachmentAccessService {
-  private readonly resolveCanonicalId;
-  private readonly authorization;
-  private readonly references;
-  private readonly projection;
-  private readonly readGate;
-  /**
-   * Absent below auth enforcement, where there is no policy model to
-   * evaluate; the host's permission tables decide alone, exactly as before.
-   */
-  private readonly scopeGate?;
-  constructor(resolveCanonicalId: CanonicalDocumentIdResolver, authorization: IAuthorizationService, references: IAttachmentReferenceReader, projection: AttachmentReferenceProjectionCapability, readGate: AttachmentReadGate,
-  /**
-   * Absent below auth enforcement, where there is no policy model to
-   * evaluate; the host's permission tables decide alone, exactly as before.
-   */
-  scopeGate?: IDocumentScopeGate | undefined);
-  canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
-  /**
-   * Whether the caller may read the state the reference lives in.
-   *
-   * A failure here is rethrown rather than turned into a denial. A read side
-   * that is down must not read as a policy: a denial nobody can distinguish
-   * from a refusal is one nobody investigates, and the route answers 500 for a
-   * reason.
-   */
-  private canReadDocument;
-}
-//#endregion
 //#region src/types.d.ts
 /**
  * Module hosts pass to processor factories: the reactor-level module plus the
@@ -1494,6 +1592,8 @@ export type API = {
   attachmentReferenceIndex: AttachmentReferenceIndexBuildResult;
   /** Document-authorized attachment read decisions; see AttachmentAccessService. */
   attachmentAccess: IAttachmentAccessService;
+  /** Caller-bound attachment clients for subgraphs the host constructs itself. */
+  attachmentClientProvider: IAttachmentClientProvider;
   authService: AuthService | undefined;
   /**
    * Whether this deployment refuses anonymous callers
@@ -1992,41 +2092,52 @@ export type MutationAddRelationshipArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
   metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
   relationshipType: Scalars["String"]["input"];
-  sourceIdentifier: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type MutationCreateDocumentArgs = {
   document: Scalars["JSONObject"]["input"];
+  parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
   parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type MutationCreateEmptyDocumentArgs = {
   documentType: Scalars["String"]["input"];
+  parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
   parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type MutationDeleteDocumentArgs = {
-  identifier: Scalars["String"]["input"];
+  idOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  identifier?: InputMaybe<Scalars["String"]["input"]>;
   propagate?: InputMaybe<PropagationMode>;
 };
 export type MutationDeleteDocumentsArgs = {
-  identifiers: ReadonlyArray<Scalars["String"]["input"]>;
+  identifiers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  idsOrSlugs?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   propagate?: InputMaybe<PropagationMode>;
 };
 export type MutationExecuteArgs = {
   actions: ReadonlyArray<ActionInput>;
   branch?: InputMaybe<Scalars["String"]["input"]>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type MutationExecuteAsyncArgs = {
   actions: ReadonlyArray<ActionInput>;
   branch?: InputMaybe<Scalars["String"]["input"]>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type MutationMoveRelationshipArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
   relationshipType: Scalars["String"]["input"];
-  sourceParentIdentifier: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
-  targetParentIdentifier: Scalars["String"]["input"];
+  sourceParentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceParentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetParentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetParentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type MutationMutateDocumentArgs = {
   actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
@@ -2045,17 +2156,21 @@ export type MutationPushSyncEnvelopesArgs = {
 export type MutationRemoveRelationshipArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
   relationshipType: Scalars["String"]["input"];
-  sourceIdentifier: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type MutationRenameDocumentArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   name: Scalars["String"]["input"];
 };
 export type MutationSetPreferredEditorArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   preferredEditor?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type MutationTouchChannelArgs = {
@@ -2065,8 +2180,10 @@ export type MutationUpdateRelationshipArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
   metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
   relationshipType: Scalars["String"]["input"];
-  sourceIdentifier: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type OperationContext = {
   readonly branch: Scalars["String"]["output"];
@@ -2103,7 +2220,9 @@ export type OperationWithContextInput = {
 export type OperationsFilterInput = {
   readonly actionTypes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   readonly branch?: InputMaybe<Scalars["String"]["input"]>;
-  readonly documentId: Scalars["String"]["input"];
+  /** @deprecated Use documentIdOrSlug. */
+  readonly documentId?: InputMaybe<Scalars["String"]["input"]>;
+  readonly documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
   readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   readonly sinceRevision?: InputMaybe<Scalars["Int"]["input"]>;
   readonly timestampFrom?: InputMaybe<Scalars["String"]["input"]>;
@@ -2218,19 +2337,22 @@ export type Query = {
   readonly syncHolds: ReadonlyArray<SyncHold>;
 };
 export type QueryDocumentArgs = {
-  identifier: Scalars["String"]["input"];
+  idOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  identifier?: InputMaybe<Scalars["String"]["input"]>;
   view?: InputMaybe<ViewFilterInput>;
 };
 export type QueryDocumentIncomingRelationshipEdgesArgs = {
   paging?: InputMaybe<PagingInput>;
   relationshipType?: InputMaybe<Scalars["String"]["input"]>;
-  targetIdentifier: Scalars["String"]["input"];
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   view?: InputMaybe<ViewFilterInput>;
 };
 export type QueryDocumentIncomingRelationshipsArgs = {
   paging?: InputMaybe<PagingInput>;
   relationshipType: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   view?: InputMaybe<ViewFilterInput>;
 };
 export type QueryDocumentModelsArgs = {
@@ -2244,19 +2366,22 @@ export type QueryDocumentOperationsArgs = {
 export type QueryDocumentOutgoingRelationshipEdgesArgs = {
   paging?: InputMaybe<PagingInput>;
   relationshipType?: InputMaybe<Scalars["String"]["input"]>;
-  sourceIdentifier: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   view?: InputMaybe<ViewFilterInput>;
 };
 export type QueryDocumentOutgoingRelationshipsArgs = {
   paging?: InputMaybe<PagingInput>;
   relationshipType: Scalars["String"]["input"];
-  sourceIdentifier: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   view?: InputMaybe<ViewFilterInput>;
 };
 export type QueryEvaluateActionsArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
   candidates: ReadonlyArray<ActionCandidateInput>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type QueryFindDocumentsArgs = {
   paging?: InputMaybe<PagingInput>;
@@ -2344,6 +2469,7 @@ export type Revision = {
   readonly scope: Scalars["String"]["output"];
 };
 export type SearchFilterInput = {
+  /** @deprecated Ignored. Filter by type or parentId. */
   readonly identifiers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   readonly parentId?: InputMaybe<Scalars["String"]["input"]>;
   readonly type?: InputMaybe<Scalars["String"]["input"]>;
@@ -2394,6 +2520,7 @@ export type SyncHoldReason = {
 export type SyncRefusalInput = {
   readonly branch: Scalars["String"]["input"];
   readonly documentId: Scalars["String"]["input"];
+  readonly kind?: InputMaybe<Scalars["String"]["input"]>;
 };
 export type TouchChannelInput = {
   readonly collectionId: Scalars["String"]["input"];
@@ -3335,22 +3462,22 @@ export type MoveRelationshipResultResolvers<ContextType = Context, ParentType ex
   target?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
 }>;
 export type MutationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Mutation"] = ResolversParentTypes["Mutation"]> = ResolversObject<{
-  addRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationAddRelationshipArgs, "relationshipType" | "sourceIdentifier" | "targetIdentifier">>;
+  addRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationAddRelationshipArgs, "relationshipType">>;
   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">>;
-  execute?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationExecuteArgs, "actions" | "documentIdentifier">>;
-  executeAsync?: Resolver<ResolversTypes["JobInfo"], ParentType, ContextType, RequireFields<MutationExecuteAsyncArgs, "actions" | "documentIdentifier">>;
-  moveRelationship?: Resolver<ResolversTypes["MoveRelationshipResult"], ParentType, ContextType, RequireFields<MutationMoveRelationshipArgs, "relationshipType" | "sourceParentIdentifier" | "targetIdentifier" | "targetParentIdentifier">>;
+  deleteDocument?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, Partial<MutationDeleteDocumentArgs>>;
+  deleteDocuments?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, Partial<MutationDeleteDocumentsArgs>>;
+  execute?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationExecuteArgs, "actions">>;
+  executeAsync?: Resolver<ResolversTypes["JobInfo"], ParentType, ContextType, RequireFields<MutationExecuteAsyncArgs, "actions">>;
+  moveRelationship?: Resolver<ResolversTypes["MoveRelationshipResult"], ParentType, ContextType, RequireFields<MutationMoveRelationshipArgs, "relationshipType">>;
   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">>;
-  setPreferredEditor?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationSetPreferredEditorArgs, "documentIdentifier">>;
+  removeRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRemoveRelationshipArgs, "relationshipType">>;
+  renameDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRenameDocumentArgs, "name">>;
+  setPreferredEditor?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, Partial<MutationSetPreferredEditorArgs>>;
   touchChannel?: Resolver<ResolversTypes["TouchChannelResult"], ParentType, ContextType, RequireFields<MutationTouchChannelArgs, "input">>;
-  updateRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationUpdateRelationshipArgs, "relationshipType" | "sourceIdentifier" | "targetIdentifier">>;
+  updateRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationUpdateRelationshipArgs, "relationshipType">>;
 }>;
 export type OperationContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationContext"] = ResolversParentTypes["OperationContext"]> = ResolversObject<{
   branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
@@ -3406,14 +3533,14 @@ export type PollSyncEnvelopesResultResolvers<ContextType = Context, ParentType e
   peerManifestRevision?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
 }>;
 export type QueryResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Query"] = ResolversParentTypes["Query"]> = ResolversObject<{
-  document?: Resolver<Maybe<ResolversTypes["DocumentWithChildren"]>, ParentType, ContextType, RequireFields<QueryDocumentArgs, "identifier">>;
-  documentIncomingRelationshipEdges?: Resolver<ResolversTypes["DocumentRelationshipResultPage"], ParentType, ContextType, RequireFields<QueryDocumentIncomingRelationshipEdgesArgs, "targetIdentifier">>;
-  documentIncomingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentIncomingRelationshipsArgs, "relationshipType" | "targetIdentifier">>;
+  document?: Resolver<Maybe<ResolversTypes["DocumentWithChildren"]>, ParentType, ContextType, Partial<QueryDocumentArgs>>;
+  documentIncomingRelationshipEdges?: Resolver<ResolversTypes["DocumentRelationshipResultPage"], ParentType, ContextType, Partial<QueryDocumentIncomingRelationshipEdgesArgs>>;
+  documentIncomingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentIncomingRelationshipsArgs, "relationshipType">>;
   documentModels?: Resolver<ResolversTypes["DocumentModelResultPage"], ParentType, ContextType, Partial<QueryDocumentModelsArgs>>;
   documentOperations?: Resolver<ResolversTypes["ReactorOperationResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOperationsArgs, "filter">>;
-  documentOutgoingRelationshipEdges?: Resolver<ResolversTypes["DocumentRelationshipResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOutgoingRelationshipEdgesArgs, "sourceIdentifier">>;
-  documentOutgoingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOutgoingRelationshipsArgs, "relationshipType" | "sourceIdentifier">>;
-  evaluateActions?: Resolver<ResolversTypes["ActionEvaluations"], ParentType, ContextType, RequireFields<QueryEvaluateActionsArgs, "candidates" | "documentIdentifier">>;
+  documentOutgoingRelationshipEdges?: Resolver<ResolversTypes["DocumentRelationshipResultPage"], ParentType, ContextType, Partial<QueryDocumentOutgoingRelationshipEdgesArgs>>;
+  documentOutgoingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOutgoingRelationshipsArgs, "relationshipType">>;
+  evaluateActions?: Resolver<ResolversTypes["ActionEvaluations"], ParentType, ContextType, RequireFields<QueryEvaluateActionsArgs, "candidates">>;
   findDocuments?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, Partial<QueryFindDocumentsArgs>>;
   jobStatus?: Resolver<Maybe<ResolversTypes["JobInfo"]>, ParentType, ContextType, RequireFields<QueryJobStatusArgs, "jobId">>;
   peerAgreement?: Resolver<ResolversTypes["PeerAgreement"], ParentType, ContextType, RequireFields<QueryPeerAgreementArgs, "collectionId">>;
@@ -3875,6 +4002,13 @@ export declare class AuthEvaluationUnsupportedError extends GraphQLError {
 export declare class MalformedStoredOperationError extends GraphQLError {
   constructor(detail: string);
 }
+/**
+ * The marker refusals a poll carried were not recorded, so the poll fails.
+ * The code is recoverable: the client keeps polling and reports them again.
+ */
+export declare class RefusalNotRecordedError extends GraphQLError {
+  constructor(cause: unknown);
+}
 //#endregion
 //#region src/packages/import-loader.d.ts
 /**
@@ -4119,6 +4253,8 @@ export declare function initializeAndStartAPI(clientInitializer: (documentModels
   readiness: ReadinessGate;
   attachmentReferenceProjection: AttachmentReferenceProjectionCapability;
   packageManager: PackageManager;
+  /** Set under DOCUMENT_PERMISSIONS; the privacy add-on erases through it. */
+  documentPermissionService: DocumentPermissionService | undefined;
 }>;
 //#endregion
 //#region src/services/renown-credential-verifier.d.ts
@@ -4128,6 +4264,25 @@ export interface RenownCredentialVerifierConfig {
 }
 export declare function createRenownCredentialVerifier(config?: RenownCredentialVerifierConfig): Promise<CredentialVerifier>;
 //#endregion
+//#region src/services/privacy-permissions.d.ts
+/** One permission row naming an address, as reactor-privacy discloses it. */
+export type PrivacyPermissionRow = {
+  table: string;
+  column: string;
+  documentId: string | null;
+  detail?: Record<string, unknown>;
+};
+/**
+ * reactor-privacy's permission lookup and eraser, over this host's
+ * DocumentPermissionService. Typed structurally on the privacy side.
+ */
+export declare class PrivacyPermissionAdapter {
+  private readonly service;
+  constructor(service: DocumentPermissionService);
+  rowsForAddress(address: string): Promise<PrivacyPermissionRow[]>;
+  erasePermissions(documentId: string): Promise<Record<string, number>>;
+}
+//#endregion
 //#region src/utils/create-schema.d.ts
 export declare const buildSubgraphSchemaModule: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => GraphQLSchemaModule;
 export declare const createSchema: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => import("graphql").GraphQLSchema;