@powerhousedao/reactor-api 6.2.3-dev.6 → 6.2.3-dev.61

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (55) hide show
  1. package/README.md +7 -2
  2. package/dist/{adapter-gateway-apollo-DowrX6E_.mjs → adapter-gateway-apollo-DTcAJpfN.mjs} +3 -3
  3. package/dist/{adapter-gateway-apollo-CxJNBVyD.mjs → adapter-gateway-apollo-DwAmdCYz.mjs} +17 -15
  4. package/dist/{adapter-gateway-apollo-CxJNBVyD.mjs.map → adapter-gateway-apollo-DwAmdCYz.mjs.map} +1 -1
  5. package/dist/{adapter-gateway-mercurius-CZVy88Za.mjs → adapter-gateway-mercurius-BhO0nwH_.mjs} +5 -5
  6. package/dist/{adapter-gateway-mercurius-CZVy88Za.mjs.map → adapter-gateway-mercurius-BhO0nwH_.mjs.map} +1 -1
  7. package/dist/adapter-gateway-stitching-969ZPot-.mjs +4 -0
  8. package/dist/{adapter-gateway-stitching-CaZjvRzx.mjs → adapter-gateway-stitching-ClVkjojb.mjs} +31 -14
  9. package/dist/adapter-gateway-stitching-ClVkjojb.mjs.map +1 -0
  10. package/dist/{adapter-http-express-B39rPhqH.mjs → adapter-http-express-P0t-mdMV.mjs} +10 -10
  11. package/dist/adapter-http-express-P0t-mdMV.mjs.map +1 -0
  12. package/dist/{adapter-http-fastify-BwXO6rqE.mjs → adapter-http-fastify-D0OP5q9K.mjs} +13 -12
  13. package/dist/adapter-http-fastify-D0OP5q9K.mjs.map +1 -0
  14. package/dist/base-document-models-69WRTSfH.mjs +1243 -0
  15. package/dist/base-document-models-69WRTSfH.mjs.map +1 -0
  16. package/dist/create-schema-DLTPkNpK.d.mts +138 -0
  17. package/dist/create-schema-DLTPkNpK.d.mts.map +1 -0
  18. package/dist/index.d.mts +2021 -732
  19. package/dist/index.d.mts.map +1 -1
  20. package/dist/index.mjs +3900 -1548
  21. package/dist/index.mjs.map +1 -1
  22. package/dist/pglite-node-Ow9i5Rb4.mjs +573 -0
  23. package/dist/pglite-node-Ow9i5Rb4.mjs.map +1 -0
  24. package/dist/rolldown-runtime-8H4AJuhK.mjs +16 -0
  25. package/dist/run-node-handler-CQjyjOuN.mjs +52 -0
  26. package/dist/run-node-handler-CQjyjOuN.mjs.map +1 -0
  27. package/dist/src/graphql/subgraph-types.d.mts +37 -0
  28. package/dist/src/graphql/subgraph-types.d.mts.map +1 -0
  29. package/dist/src/graphql/subgraph-types.mjs +105 -0
  30. package/dist/src/graphql/subgraph-types.mjs.map +1 -0
  31. package/dist/src/packages/https-hooks.d.mts +4 -4
  32. package/dist/src/packages/https-hooks.d.mts.map +1 -1
  33. package/dist/src/packages/https-hooks.mjs +2 -2
  34. package/dist/src/packages/https-hooks.mjs.map +1 -1
  35. package/dist/src/packages/vite-loader.d.mts +21 -10
  36. package/dist/src/packages/vite-loader.d.mts.map +1 -1
  37. package/dist/src/packages/vite-loader.mjs +121 -59
  38. package/dist/src/packages/vite-loader.mjs.map +1 -1
  39. package/dist/src/pglite/pglite-node.d.mts +130 -0
  40. package/dist/src/pglite/pglite-node.d.mts.map +1 -0
  41. package/dist/src/pglite/pglite-node.mjs +4 -0
  42. package/dist/{utils-XWVecaNn.mjs → subgraph-extraction-CcgWd0De.mjs} +540 -17
  43. package/dist/subgraph-extraction-CcgWd0De.mjs.map +1 -0
  44. package/dist/{types-DcYyNcHJ.d.mts → types-D3pD6fvQ.d.mts} +40 -5
  45. package/dist/types-D3pD6fvQ.d.mts.map +1 -0
  46. package/dist/{websocket-DncAB9XK.mjs → websocket-_SH5aBcy.mjs} +3 -3
  47. package/dist/{websocket-DncAB9XK.mjs.map → websocket-_SH5aBcy.mjs.map} +1 -1
  48. package/package.json +29 -19
  49. package/dist/adapter-gateway-stitching-CaZjvRzx.mjs.map +0 -1
  50. package/dist/adapter-http-express-B39rPhqH.mjs.map +0 -1
  51. package/dist/adapter-http-fastify-BwXO6rqE.mjs.map +0 -1
  52. package/dist/path-normalize-BOQwY9wR.mjs +0 -23
  53. package/dist/path-normalize-BOQwY9wR.mjs.map +0 -1
  54. package/dist/types-DcYyNcHJ.d.mts.map +0 -1
  55. package/dist/utils-XWVecaNn.mjs.map +0 -1
package/dist/index.d.mts CHANGED
@@ -1,18 +1,19 @@
1
- import { i as IPackageManagerOptions, n as IPackageLoaderOptions, r as IPackageManager, s as PackageManagerResult, t as IPackageLoader } from "./types-DcYyNcHJ.mjs";
1
+ import { a as IPackagePieceSource, c as PackageManagerResult, d as ReportError, f as RunDetachedOptions, i as IPackageManagerOptions, l as PackagePiece, m as runDetached, n as IPackageLoaderOptions, p as reportFailure, r as IPackageManager, t as IPackageLoader, u as PackagePieceEntry } from "./types-D3pD6fvQ.mjs";
2
+ import { C as reservedTypeNames, S as hasOperationSchemas, T as typeDefinitionNames, _ as generatedTypesOf, a as ReservedTypeNames, b as getDocumentModelTypeDefs, c as SubgraphTypeCollisionError, d as buildSubgraphSchemaModule, f as createMergedSchema, g as generateDocumentModelSchema, h as findSubgraphTypeCollisions, i as GeneratedDocumentModelTypes, l as assembleSubgraphTypeDefs, m as documentModelSubgraphTypes, n as DocumentModelSchemaCache, o as ResolvedDocumentModelSchema, p as createSchema, r as DocumentModelSchemaOptions, s as SubgraphSchemaOptions, t as DocumentModelSchema, u as buildDocumentModelSchema, v as getDocumentModelSchemaName, w as reservedTypeNamesTaken, x as getGeneratedDocumentModelTypes, y as getDocumentModelSubgraphName } from "./create-schema-DLTPkNpK.mjs";
2
3
  import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
3
4
  import { AnalyticsModel } from "@powerhousedao/analytics-engine-graphql";
4
- import * as graphql from "graphql";
5
- import { DocumentNode, GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig, GraphQLSchema } from "graphql";
6
- import { AttachmentRef, IDocumentModelLoader, IDocumentModelRegistry, IDriveClient, IReactorClient, IReactorProcessorHostModuleBase, IRelationalDb, ISyncManager, InProcessReactorClientModule, ParsedDriveUrl, ProcessorFactoryBuilder as ProcessorFactoryBuilder$1, SyncScopeGate, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
5
+ import { DocumentNode, GraphQLError, GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig, GraphQLSchema } from "graphql";
6
+ import { AttachmentRef, DocumentModelSource, IDocumentModelLoader, IDocumentModelRegistry, IDriveClient, IInspectableAttachmentStore, IInspector, IInspectorStorageHealthProvider, INSPECTOR_OPS, IReactorClient, IReactorFactsSink, IReactorProcessorHostModuleBase, IRelationalDb, ISyncInspector, ISyncManager, InProcessReactorClientModule, InProcessReactorModule, InspectorDocumentReader, InspectorReadOpKey, PagedResults, ParsedDriveUrl, ProcessorFactoryBuilder as ProcessorFactoryBuilder$1, Remote, SYNC_INSPECTION_OPS, SearchFilter, SyncInspectionReadOpKey, SyncScopeGate, ViewFilter, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
7
+ import { AuthSubject, DocumentModelModule, Operation, PHDocument, UpgradeManifest } from "@powerhousedao/shared/document-model";
7
8
  import { ILogger } from "document-model";
8
- import { GraphQLResolverMap, GraphQLSchemaModule } from "@apollo/subgraph";
9
- import { AuthSubject, DocumentModelGlobalState as DocumentModelGlobalState$1, DocumentModelModule, Operation, PHDocument, UpgradeManifest } from "@powerhousedao/shared/document-model";
9
+ import { GraphQLResolverMap } from "@apollo/subgraph";
10
10
  import * as z$1 from "zod";
11
11
  import { DocumentDriveDocument, DocumentDriveGlobalState } from "@powerhousedao/shared/document-drive";
12
- import { AttachmentBuildResult, AttachmentReferenceIndexBuildResult, IAttachmentReferenceReader, IAttachmentReferenceWriter } from "@powerhousedao/reactor-attachments";
12
+ import { AttachmentBuildResult, AttachmentDownloadOptions, AttachmentDownloadTarget, AttachmentDownloadTargetOptions, AttachmentHeader, AttachmentReferenceIndexBuildResult, AttachmentResponse, AttachmentStatOptions, IAttachmentReferenceReader, IAttachmentReferenceWriter, IAttachmentService, IAttachmentUpload, ReserveAttachmentOptions } from "@powerhousedao/reactor-attachments";
13
13
  import { IAttachmentClient } from "@powerhousedao/reactor-attachments/client";
14
14
  import { WebSocketServer } from "ws";
15
15
  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";
16
+ import { AttachmentReadGate, IDocumentScopeGate } from "@powerhousedao/reactor-attachments/replication";
16
17
  import { Generated, Kysely } from "kysely";
17
18
  import { PGlite } from "@electric-sql/pglite";
18
19
  import { Knex } from "knex";
@@ -22,7 +23,6 @@ import { Context as Context$1, GqlDocument as GqlDocument$1, GqlDriveDocument as
22
23
  import { IncomingHttpHeaders } from "http";
23
24
  import { Pool } from "pg";
24
25
  import { PHReactorRenown } from "@powerhousedao/shared/clis";
25
-
26
26
  //#region src/utils/db.d.ts
27
27
  /**
28
28
  * Permission levels for documents:
@@ -30,23 +30,23 @@ import { PHReactorRenown } from "@powerhousedao/shared/clis";
30
30
  * - WRITE: Can push updates and modify the document
31
31
  * - ADMIN: Can manage document permissions and settings
32
32
  */
33
- type DocumentPermissionLevel = "READ" | "WRITE" | "ADMIN";
33
+ export type DocumentPermissionLevel = "READ" | "WRITE" | "ADMIN";
34
34
  /**
35
35
  * Database schema for document permissions
36
36
  */
37
- interface DocumentProtectionTable {
37
+ export interface DocumentProtectionTable {
38
38
  documentId: string;
39
39
  protected: boolean;
40
40
  ownerAddress: string | null;
41
41
  createdAt: Date;
42
42
  updatedAt: Date;
43
43
  }
44
- interface DocumentPermissionDatabase {
44
+ export interface DocumentPermissionDatabase {
45
45
  DocumentPermission: DocumentPermissionTable;
46
46
  OperationUserPermission: OperationUserPermissionTable;
47
47
  DocumentProtection: DocumentProtectionTable;
48
48
  }
49
- interface DocumentPermissionTable {
49
+ export interface DocumentPermissionTable {
50
50
  id: Generated<number>;
51
51
  documentId: string;
52
52
  userAddress: string;
@@ -55,7 +55,7 @@ interface DocumentPermissionTable {
55
55
  createdAt: Date;
56
56
  updatedAt: Date;
57
57
  }
58
- interface OperationUserPermissionTable {
58
+ export interface OperationUserPermissionTable {
59
59
  id: Generated<number>;
60
60
  documentId: string;
61
61
  operationType: string;
@@ -64,26 +64,27 @@ interface OperationUserPermissionTable {
64
64
  createdAt: Date;
65
65
  }
66
66
  type Db = Kysely<any>;
67
- declare const PGLITE_UTC_PARSERS: {
67
+ export declare const PGLITE_UTC_PARSERS: {
68
68
  readonly 1114: (value: string) => Date;
69
69
  };
70
+ export declare function isPostgresConnectionString(connectionString: string): boolean;
70
71
  /**
71
72
  * Optional factory used by callers (e.g. Switchboard) to inject a
72
73
  * version-specific PGLite instance — e.g. `pglite-legacy-02` when an existing
73
74
  * data dir was created with an older PG major. Wire-compatible with the
74
75
  * current PGLite class for the surface knex-pglite uses.
75
76
  */
76
- type PgliteFactory = (connectionString: string | undefined) => PGlite;
77
- interface DbClient {
77
+ export type PgliteFactory = (connectionString: string | undefined) => PGlite;
78
+ export interface DbClient {
78
79
  db: Db;
79
80
  knex: Knex;
80
81
  pglite: PGlite | undefined;
81
82
  }
82
- declare function getDbClient(connectionString?: string | undefined, pgliteFactory?: PgliteFactory): DbClient;
83
- declare const initAnalyticsStoreSql: string[];
83
+ export declare function getDbClient(connectionString?: string | undefined, pgliteFactory?: PgliteFactory): DbClient;
84
+ export declare const initAnalyticsStoreSql: string[];
84
85
  //#endregion
85
86
  //#region src/services/document-permission.service.d.ts
86
- interface DocumentPermissionEntry {
87
+ export interface DocumentPermissionEntry {
87
88
  documentId: string;
88
89
  userAddress: string;
89
90
  permission: DocumentPermissionLevel;
@@ -91,7 +92,7 @@ interface DocumentPermissionEntry {
91
92
  createdAt: Date;
92
93
  updatedAt: Date;
93
94
  }
94
- interface OperationUserPermissionEntry {
95
+ export interface OperationUserPermissionEntry {
95
96
  documentId: string;
96
97
  operationType: string;
97
98
  userAddress: string;
@@ -102,11 +103,11 @@ interface OperationUserPermissionEntry {
102
103
  * Function type for getting parent document IDs
103
104
  * This is injected to avoid circular dependencies with the reactor client
104
105
  */
105
- type GetParentIdsFn = (documentId: string) => Promise<string[]>;
106
+ export type GetParentIdsFn = (documentId: string) => Promise<string[]>;
106
107
  /**
107
108
  * Configuration for the DocumentPermissionService
108
109
  */
109
- interface DocumentPermissionConfig {
110
+ export interface DocumentPermissionConfig {
110
111
  defaultProtection: boolean;
111
112
  }
112
113
  /**
@@ -120,7 +121,7 @@ interface DocumentPermissionConfig {
120
121
  * Operation permissions:
121
122
  * - Users can be granted permission to execute specific operations
122
123
  */
123
- declare class DocumentPermissionService {
124
+ export declare class DocumentPermissionService {
124
125
  private readonly db;
125
126
  readonly config: DocumentPermissionConfig;
126
127
  constructor(db: Kysely<DocumentPermissionDatabase>, config?: DocumentPermissionConfig);
@@ -148,7 +149,18 @@ declare class DocumentPermissionService {
148
149
  /**
149
150
  * Delete all permissions for a document (used when deleting a document)
150
151
  */
151
- deleteAllDocumentPermissions(documentId: string): Promise<void>;
152
+ deleteAllDocumentPermissions(documentId: string): Promise<{
153
+ DocumentPermission: number;
154
+ OperationUserPermission: number;
155
+ }>;
156
+ /** Delete a document's protection row, which names its owner. */
157
+ deleteDocumentProtection(documentId: string): Promise<number>;
158
+ /** Every row that names the address, for a subject access request. */
159
+ rowsForAddress(address: string): Promise<{
160
+ permissions: DocumentPermissionEntry[];
161
+ operationPermissions: OperationUserPermissionEntry[];
162
+ ownedDocumentIds: string[];
163
+ }>;
152
164
  /**
153
165
  * Grant a user permission to execute an operation on a document
154
166
  */
@@ -230,7 +242,7 @@ type CanonicalDocumentId = string & {
230
242
  * always safe for the data fetch: the canonical id when resolved, or the raw
231
243
  * identifier when the check was skipped for a policy-wide caller.
232
244
  */
233
- declare class AuthorizedDocumentHandle {
245
+ export declare class AuthorizedDocumentHandle {
234
246
  readonly fetchIdentifier: string;
235
247
  readonly isResolved: boolean;
236
248
  private constructor();
@@ -239,12 +251,12 @@ declare class AuthorizedDocumentHandle {
239
251
  /** The verified canonical id; throws when resolution was skipped. */
240
252
  canonicalId(): CanonicalDocumentId;
241
253
  }
242
- declare const AuthorizationPolicy: {
254
+ export declare const AuthorizationPolicy: {
243
255
  readonly OPEN: "OPEN";
244
256
  readonly ADMIN_ONLY: "ADMIN_ONLY";
245
257
  readonly DOCUMENT_PERMISSIONS: "DOCUMENT_PERMISSIONS";
246
258
  };
247
- type AuthorizationPolicy = (typeof AuthorizationPolicy)[keyof typeof AuthorizationPolicy];
259
+ export type AuthorizationPolicy = (typeof AuthorizationPolicy)[keyof typeof AuthorizationPolicy];
248
260
  interface AuthorizationConfig {
249
261
  admins: string[];
250
262
  defaultProtection: boolean;
@@ -287,33 +299,170 @@ interface IAuthorizationService {
287
299
  canMutate(documentId: CanonicalDocumentId, operationType: string, userAddress?: string): Promise<boolean>;
288
300
  }
289
301
  //#endregion
302
+ //#region src/services/auth.service.d.ts
303
+ export type CredentialVerifier = (params: {
304
+ address: string;
305
+ chainId: number;
306
+ appId: string;
307
+ }) => Promise<boolean>;
308
+ export interface AuthConfig {
309
+ /**
310
+ * Whether the authorization policy enforces anything: it selects `ADMIN_ONLY`
311
+ * over `OPEN`, and it is what `AuthContext.auth_enabled` reports to callers
312
+ * that gate on "is authentication being enforced" (the attachment routes do).
313
+ *
314
+ * It does NOT decide whether the bearer is read — see {@link resolveIdentity}.
315
+ */
316
+ enabled: boolean;
317
+ /**
318
+ * Whether the bearer is verified and `AuthContext.user` populated at all.
319
+ *
320
+ * Defaults to {@link enabled}, which is the behaviour every deployment had
321
+ * before this option existed. Setting it independently is what lets a server
322
+ * know who is calling while leaving the policy `OPEN` — resolving an identity
323
+ * and enforcing one are different concerns, and welding them together left
324
+ * consumers choosing between an unauthenticated caller and locking every
325
+ * non-admin out.
326
+ *
327
+ * It resolves an identity and enforces nothing: a request with no token is
328
+ * still admitted, with no user.
329
+ */
330
+ resolveIdentity?: boolean;
331
+ admins: string[];
332
+ skipCredentialVerification?: boolean;
333
+ credentialVerificationCacheTtlMs?: number;
334
+ verifyCredential?: CredentialVerifier;
335
+ }
336
+ /** What `invalidateCredential` was called with; `address` is lower-cased. */
337
+ export interface CredentialInvalidation {
338
+ address: string;
339
+ chainId?: number;
340
+ appDid?: string;
341
+ }
342
+ export type CredentialInvalidationListener = (invalidation: CredentialInvalidation) => void;
343
+ /**
344
+ * The slice of {@link AuthService} handed to packages (as
345
+ * `SubgraphArgs.credentials` / `BaseSubgraph.credentials`): a package that
346
+ * revokes a credential calls this so the host stops honouring it at once
347
+ * instead of after the credential cache TTL.
348
+ */
349
+ export interface ICredentialInvalidator {
350
+ /**
351
+ * Evict cached credential checks for `address` (case-insensitive), narrowed
352
+ * by `chainId` and the app DID (`did:key` of the app the credential
353
+ * delegates to) when given, and re-verify open WebSocket connections of that
354
+ * identity. Returns the number of cache entries evicted. Synchronous and
355
+ * local to this process: other replicas still honour their cache until
356
+ * their TTL lapses.
357
+ */
358
+ invalidateCredential(address: string, chainId?: number, appDid?: string): number;
359
+ }
360
+ /** The invalidator a subgraph receives: forwards to `authService`, or does
361
+ * nothing when the host runs without one. */
362
+ export declare function createCredentialInvalidator(authService: AuthService | undefined): ICredentialInvalidator;
363
+ /**
364
+ * The authenticated principal. The shape is declared once in
365
+ * `@powerhousedao/shared/processors` as `RouteUser`, so a route handler and a
366
+ * resolver agree on it without either package redeclaring it.
367
+ */
368
+ export type User = RouteUser$1;
369
+ export interface AuthContext {
370
+ user?: User;
371
+ admins: string[];
372
+ auth_enabled: boolean;
373
+ }
374
+ export declare class AuthService implements ICredentialInvalidator {
375
+ private readonly config;
376
+ private readonly credentialCache;
377
+ private readonly invalidationListeners;
378
+ constructor(config: AuthConfig);
379
+ /**
380
+ * Whether this service reads the bearer at all. Defaults to `enabled`, so a
381
+ * config written before `resolveIdentity` existed behaves exactly as it did.
382
+ */
383
+ private get resolvesIdentity();
384
+ /** The context an unresolved request gets: no user, and no admin list to match against. */
385
+ private anonymousContext;
386
+ authenticateRequest(request: globalThis.Request): Promise<AuthContext | globalThis.Response>;
387
+ /**
388
+ * Verify a Bearer token regardless of HTTP method. Use this from non-GraphQL
389
+ * middleware that must enforce authentication on every request.
390
+ */
391
+ verifyBearer(authorization: string | undefined): Promise<AuthContext | globalThis.Response>;
392
+ /** Throws only for a bearer that is present and unusable, as HTTP 401s it. */
393
+ authenticateWebSocketConnection(connectionParams: Record<string, unknown>): Promise<User | null>;
394
+ /** {@inheritDoc ICredentialInvalidator.invalidateCredential} */
395
+ invalidateCredential(address: string, chainId?: number, appDid?: string): number;
396
+ /** Called after every `invalidateCredential`; returns an unsubscribe. */
397
+ onCredentialInvalidated(listener: CredentialInvalidationListener): () => void;
398
+ /**
399
+ * Whether an already-authenticated principal's credential still holds, for
400
+ * re-checking long-lived connections. Goes through the same cache as
401
+ * admission, so it costs at most one verifier call per identity per TTL.
402
+ */
403
+ isCredentialValid(user: User): Promise<boolean>;
404
+ /**
405
+ * Verify the auth bearer token
406
+ */
407
+ private verifyToken;
408
+ /**
409
+ * Extract user information from verification result.
410
+ *
411
+ * The issuer is required along with the credential subject. A credential that
412
+ * verified must carry one -- resolving it is how the signature was checked --
413
+ * so this rejects a shape that cannot have come from verification rather than
414
+ * admitting a keyless principal.
415
+ */
416
+ private extractUserFromVerification;
417
+ /**
418
+ * Verify that the credential still exists on the Renown API.
419
+ *
420
+ * Results are cached per (address, chainId, issuer) for a short TTL so the
421
+ * blocking external round-trip is not paid on every request. Concurrent
422
+ * checks for the same key share a single in-flight request, and entries
423
+ * that resolve to false are evicted immediately so failed or revoked
424
+ * credentials are re-checked on the next request.
425
+ */
426
+ private verifyCredentialExists;
427
+ /**
428
+ * Enforce the cache size cap before inserting a new entry: drop expired
429
+ * entries first, then evict oldest-inserted entries (insertion order
430
+ * matches expiry order since the TTL is constant) until under the cap, so
431
+ * a flood of distinct keys cannot grow the map without bound.
432
+ */
433
+ private pruneCredentialCache;
434
+ private fetchCredentialExists;
435
+ }
436
+ //#endregion
290
437
  //#region src/graphql/gateway/types.d.ts
291
- type TlsOptions = {
438
+ export type TlsOptions = {
292
439
  keyPath: string;
293
440
  certPath: string;
294
441
  } | {
295
442
  cert: Buffer | string;
296
443
  key: Buffer | string;
297
444
  } | true;
298
- type GatewayContextFactory<TContext = unknown> = (request: Request) => Promise<TContext>;
445
+ export type GatewayContextFactory<TContext = unknown> = (request: Request) => Promise<TContext>;
299
446
  /** Under graphql-ws this is `ctx.extra`, created once per socket. */
300
- type WsConnection = object;
301
- type WsContextFactory<TContext = unknown> = (connectionParams: Record<string, unknown>, connection: WsConnection) => Promise<TContext>;
302
- type WsConnectHandler = (connectionParams: Record<string, unknown>, connection: WsConnection) => Promise<boolean>;
303
- type WsHandlers<TContext = unknown> = {
447
+ export type WsConnection = object;
448
+ export type WsContextFactory<TContext = unknown> = (connectionParams: Record<string, unknown>, connection: WsConnection) => Promise<TContext>;
449
+ export type WsConnectHandler = (connectionParams: Record<string, unknown>, connection: WsConnection) => Promise<boolean>;
450
+ export type WsHandlers<TContext = unknown> = {
304
451
  onConnect: WsConnectHandler;
305
452
  context: WsContextFactory<TContext>;
306
453
  };
307
454
  /** No authenticated caller resolved, and REQUIRE_AUTHENTICATED_CALLER wants one. */
308
- declare const WS_CLOSE_REASON_AUTHENTICATION_REQUIRED = "authentication-required";
455
+ export declare const WS_CLOSE_REASON_AUTHENTICATION_REQUIRED = "authentication-required";
309
456
  /** A bearer was sent and could not be verified. */
310
- declare const WS_CLOSE_REASON_BEARER_REJECTED = "bearer-rejected";
457
+ export declare const WS_CLOSE_REASON_BEARER_REJECTED = "bearer-rejected";
458
+ /** An admitted connection's credential was revoked or no longer verifies. */
459
+ export declare const WS_CLOSE_REASON_CREDENTIAL_REVOKED = "credential-revoked";
311
460
  /** Every reason a refusal closes with, for a client matching on the set. */
312
- declare const WS_AUTH_CLOSE_REASONS: readonly ["authentication-required", "bearer-rejected"];
313
- type WsDisposer = {
461
+ export declare const WS_AUTH_CLOSE_REASONS: readonly ["authentication-required", "bearer-rejected", "credential-revoked"];
462
+ export type WsDisposer = {
314
463
  dispose: () => void | Promise<void>;
315
464
  };
316
- type FetchHandler = (request: Request) => Promise<Response>;
465
+ export type FetchHandler = (request: Request) => Promise<Response>;
317
466
  /**
318
467
  * Handle to a route registered directly on the adapter. Packages hot-reload,
319
468
  * so every registration is reversible; disposing a route that is already gone
@@ -329,7 +478,7 @@ type FetchHandler = (request: Request) => Promise<Response>;
329
478
  * which also carries the public URL the route answers on — at this layer there
330
479
  * is no namespace to build one from and no knowledge of the host's origin.
331
480
  */
332
- interface AdapterRouteHandle {
481
+ export interface AdapterRouteHandle {
333
482
  dispose(): void;
334
483
  }
335
484
  /**
@@ -338,7 +487,7 @@ interface AdapterRouteHandle {
338
487
  * federation adapters treat it as a service to call over HTTP, while the
339
488
  * stitching adapter merges its typeDefs and resolvers in-process.
340
489
  */
341
- type SubgraphDefinition = {
490
+ export type SubgraphDefinition = {
342
491
  name: string;
343
492
  typeDefs: DocumentNode;
344
493
  url: string;
@@ -351,7 +500,7 @@ type SubgraphDefinition = {
351
500
  */
352
501
  resolvers?: Record<string, unknown>;
353
502
  };
354
- interface IGatewayAdapter<TContext = unknown> {
503
+ export interface IGatewayAdapter<TContext = unknown> {
355
504
  /** One-time startup. */
356
505
  start(httpServer: http.Server): Promise<void>;
357
506
  /**
@@ -381,8 +530,8 @@ interface IGatewayAdapter<TContext = unknown> {
381
530
  * Methods a node route may bind. OPTIONS is excluded: the framework's CORS
382
531
  * plugin owns preflight, and a duplicate registration conflicts at startup.
383
532
  */
384
- type HttpMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
385
- interface NodeRouteOptions {
533
+ export type HttpMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
534
+ export interface NodeRouteOptions {
386
535
  /** Serve sub-paths too, not just an exact path match. */
387
536
  prefix?: boolean;
388
537
  /**
@@ -398,7 +547,7 @@ interface NodeRouteOptions {
398
547
  */
399
548
  rawBody?: boolean;
400
549
  }
401
- interface IHttpAdapter {
550
+ export interface IHttpAdapter {
402
551
  /** Set up CORS and body-parser equivalent middleware. */
403
552
  setupMiddleware(config: {
404
553
  corsOptions?: CorsOptions;
@@ -413,7 +562,8 @@ interface IHttpAdapter {
413
562
  * replaces the previous one (last write wins).
414
563
  */
415
564
  mount(path: string, handler: FetchHandler, options?: {
416
- prefix?: boolean; /** @deprecated Misleading name: this always meant *prefix*, not exact. */
565
+ prefix?: boolean;
566
+ /** @deprecated Misleading name: this always meant *prefix*, not exact. */
417
567
  exact?: boolean;
418
568
  }): AdapterRouteHandle;
419
569
  /**
@@ -423,9 +573,10 @@ interface IHttpAdapter {
423
573
  getRoute(path: string, handler: (request: Request) => Response | Promise<Response>): AdapterRouteHandle;
424
574
  /**
425
575
  * Start listening on the given port. Returns the underlying http.Server
426
- * so callers can attach WebSocket servers.
576
+ * so callers can attach WebSocket servers. Without `host` it binds the
577
+ * wildcard address.
427
578
  */
428
- listen(port: number, tls?: TlsOptions): Promise<http.Server>;
579
+ listen(port: number, tls?: TlsOptions, host?: string): Promise<http.Server>;
429
580
  /**
430
581
  * Mount a raw Connect/Express-compatible middleware function (e.g. Vite dev
431
582
  * server middleware). The implementation is adapter-specific; for Express this
@@ -453,103 +604,6 @@ interface IHttpAdapter {
453
604
  readonly handle: unknown;
454
605
  }
455
606
  //#endregion
456
- //#region src/services/auth.service.d.ts
457
- type CredentialVerifier = (params: {
458
- address: string;
459
- chainId: number;
460
- appId: string;
461
- }) => Promise<boolean>;
462
- interface AuthConfig {
463
- /**
464
- * Whether the authorization policy enforces anything: it selects `ADMIN_ONLY`
465
- * over `OPEN`, and it is what `AuthContext.auth_enabled` reports to callers
466
- * that gate on "is authentication being enforced" (the attachment routes do).
467
- *
468
- * It does NOT decide whether the bearer is read — see {@link resolveIdentity}.
469
- */
470
- enabled: boolean;
471
- /**
472
- * Whether the bearer is verified and `AuthContext.user` populated at all.
473
- *
474
- * Defaults to {@link enabled}, which is the behaviour every deployment had
475
- * before this option existed. Setting it independently is what lets a server
476
- * know who is calling while leaving the policy `OPEN` — resolving an identity
477
- * and enforcing one are different concerns, and welding them together left
478
- * consumers choosing between an unauthenticated caller and locking every
479
- * non-admin out.
480
- *
481
- * It resolves an identity and enforces nothing: a request with no token is
482
- * still admitted, with no user.
483
- */
484
- resolveIdentity?: boolean;
485
- admins: string[];
486
- skipCredentialVerification?: boolean;
487
- credentialVerificationCacheTtlMs?: number;
488
- verifyCredential?: CredentialVerifier;
489
- }
490
- /**
491
- * The authenticated principal. The shape is declared once in
492
- * `@powerhousedao/shared/processors` as `RouteUser`, so a route handler and a
493
- * resolver agree on it without either package redeclaring it.
494
- */
495
- type User = RouteUser$1;
496
- interface AuthContext {
497
- user?: User;
498
- admins: string[];
499
- auth_enabled: boolean;
500
- }
501
- declare class AuthService {
502
- private readonly config;
503
- private readonly credentialCache;
504
- constructor(config: AuthConfig);
505
- /**
506
- * Whether this service reads the bearer at all. Defaults to `enabled`, so a
507
- * config written before `resolveIdentity` existed behaves exactly as it did.
508
- */
509
- private get resolvesIdentity();
510
- /** The context an unresolved request gets: no user, and no admin list to match against. */
511
- private anonymousContext;
512
- authenticateRequest(request: globalThis.Request): Promise<AuthContext | globalThis.Response>;
513
- /**
514
- * Verify a Bearer token regardless of HTTP method. Use this from non-GraphQL
515
- * middleware that must enforce authentication on every request.
516
- */
517
- verifyBearer(authorization: string | undefined): Promise<AuthContext | globalThis.Response>;
518
- /** Throws only for a bearer that is present and unusable, as HTTP 401s it. */
519
- authenticateWebSocketConnection(connectionParams: Record<string, unknown>): Promise<User | null>;
520
- /**
521
- * Verify the auth bearer token
522
- */
523
- private verifyToken;
524
- /**
525
- * Extract user information from verification result.
526
- *
527
- * The issuer is required along with the credential subject. A credential that
528
- * verified must carry one -- resolving it is how the signature was checked --
529
- * so this rejects a shape that cannot have come from verification rather than
530
- * admitting a keyless principal.
531
- */
532
- private extractUserFromVerification;
533
- /**
534
- * Verify that the credential still exists on the Renown API.
535
- *
536
- * Results are cached per (address, chainId, issuer) for a short TTL so the
537
- * blocking external round-trip is not paid on every request. Concurrent
538
- * checks for the same key share a single in-flight request, and entries
539
- * that resolve to false are evicted immediately so failed or revoked
540
- * credentials are re-checked on the next request.
541
- */
542
- private verifyCredentialExists;
543
- /**
544
- * Enforce the cache size cap before inserting a new entry: drop expired
545
- * entries first, then evict oldest-inserted entries (insertion order
546
- * matches expiry order since the TTL is constant) until under the cap, so
547
- * a flood of distinct keys cannot grow the map without bound.
548
- */
549
- private pruneCredentialCache;
550
- private fetchCredentialExists;
551
- }
552
- //#endregion
553
607
  //#region src/http/webhook-store.d.ts
554
608
  /**
555
609
  * Where webhook tokens live. Core-owned and relational rather than per-host, so
@@ -575,11 +629,13 @@ interface IWebhookStore {
575
629
  revoke(namespace: string, endpoint: string, ownerKey: string): Promise<void>;
576
630
  /** True when this delivery has been seen before, within the TTL. */
577
631
  seen(token: string, key: string, ttlSeconds: number): Promise<boolean>;
632
+ /** Drops a delivery recorded by seen(), so a retry of it is delivered. */
633
+ forget(token: string, key: string): Promise<void>;
578
634
  }
579
635
  /** Opaque and unguessable: the URL is a bearer capability held by a third party. */
580
- declare function newWebhookToken(): string;
636
+ export declare function newWebhookToken(): string;
581
637
  /** Relational implementation, over the reactor's own database. */
582
- declare class RelationalWebhookStore implements IWebhookStore {
638
+ export declare class RelationalWebhookStore implements IWebhookStore {
583
639
  #private;
584
640
  private readonly relationalDb;
585
641
  constructor(relationalDb: IRelationalDb$1);
@@ -588,14 +644,16 @@ declare class RelationalWebhookStore implements IWebhookStore {
588
644
  find(token: string): Promise<WebhookEndpointRow | undefined>;
589
645
  list(namespace: string, endpoint?: string): Promise<WebhookEndpointRow[]>;
590
646
  revoke(namespace: string, endpoint: string, ownerKey: string): Promise<void>;
647
+ forget(token: string, key: string): Promise<void>;
591
648
  seen(token: string, key: string, ttlSeconds: number): Promise<boolean>;
592
649
  }
593
650
  /** In-memory store, for hosts with no relational database and for tests. */
594
- declare class MemoryWebhookStore implements IWebhookStore {
651
+ export declare class MemoryWebhookStore implements IWebhookStore {
595
652
  #private;
596
653
  init(): Promise<void>;
597
654
  ensure(namespace: string, endpoint: string, ownerKey: string): Promise<WebhookEndpointRow>;
598
655
  find(token: string): Promise<WebhookEndpointRow | undefined>;
656
+ forget(token: string, key: string): Promise<void>;
599
657
  list(namespace: string, endpoint?: string): Promise<WebhookEndpointRow[]>;
600
658
  revoke(namespace: string, endpoint: string, ownerKey: string): Promise<void>;
601
659
  seen(token: string, key: string, ttlSeconds: number): Promise<boolean>;
@@ -603,7 +661,7 @@ declare class MemoryWebhookStore implements IWebhookStore {
603
661
  //#endregion
604
662
  //#region src/http/webhook-service.d.ts
605
663
  /** The flat, token-addressed path family. */
606
- declare const WEBHOOK_SEGMENT = "webhooks";
664
+ export declare const WEBHOOK_SEGMENT = "webhooks";
607
665
  interface WebhookServiceOptions {
608
666
  store: IWebhookStore;
609
667
  basePath?: string;
@@ -612,13 +670,9 @@ interface WebhookServiceOptions {
612
670
  }
613
671
  /** One host route for `/webhooks/:token`, dispatching by token. The flat path leaks
614
672
  * neither package nor document; the namespace lives in the token record, which is also what stops one package's token reaching another's handler. */
615
- declare class WebhookService {
673
+ export declare class WebhookService {
616
674
  #private;
617
- constructor({
618
- store,
619
- basePath,
620
- publicUrl
621
- }: WebhookServiceOptions);
675
+ constructor({ store, basePath, publicUrl }: WebhookServiceOptions);
622
676
  /** The scope the endpoint family serves from, handed over once the route service exists;
623
677
  * separate from the constructor only because that service takes this one as an option. */
624
678
  attach(scope: IHttpScope): void;
@@ -637,9 +691,9 @@ declare class WebhookService {
637
691
  //#endregion
638
692
  //#region src/http/route-service.d.ts
639
693
  /** The segment package routes live under, inside the host's base path. */
640
- declare const PACKAGE_ROUTE_SEGMENT = "api";
694
+ export declare const PACKAGE_ROUTE_SEGMENT = "api";
641
695
  /** The namespace core's own subgraphs and services register under. */
642
- declare const CORE_PACKAGE_NAME = "@powerhousedao/reactor-api";
696
+ export declare const CORE_PACKAGE_NAME = "@powerhousedao/reactor-api";
643
697
  interface HttpRouteServiceOptions {
644
698
  httpAdapter: IHttpAdapter;
645
699
  /** Absent on a host with no webhook store; `scope.webhooks` then refuses. */
@@ -656,16 +710,9 @@ interface HttpRouteServiceOptions {
656
710
  }
657
711
  /** Owns the URL space packages serve from, handing each a scope bound to its own namespace. The prefix nests inside
658
712
  * the host's base path (`<basePath>/api`), so core collisions are prevented by URL shape, not a reserved-name list. */
659
- declare class HttpRouteService {
713
+ export declare class HttpRouteService {
660
714
  #private;
661
- constructor({
662
- httpAdapter,
663
- basePath,
664
- authService,
665
- webhooks,
666
- publicUrl,
667
- trustProxy
668
- }: HttpRouteServiceOptions);
715
+ constructor({ httpAdapter, basePath, authService, webhooks, publicUrl, trustProxy }: HttpRouteServiceOptions);
669
716
  /** The absolute path packages are mounted under. */
670
717
  get prefix(): string;
671
718
  /** The scope for a package; idempotent per name, so a reload cannot accumulate namespaces. Throws when two packages
@@ -683,18 +730,18 @@ declare class HttpRouteService {
683
730
  }
684
731
  //#endregion
685
732
  //#region src/http/namespace.d.ts
686
- declare class InvalidNamespaceError extends Error {}
733
+ export declare class InvalidNamespaceError extends Error {}
687
734
  /**
688
735
  * Turns a package name into the path segments it occupies.
689
736
  * `@powerhousedao/workflow` → ["@powerhousedao", "workflow"]
690
737
  * `document-model` → ["document-model"]
691
738
  */
692
- declare function namespaceSegments(packageName: string): string[];
739
+ export declare function namespaceSegments(packageName: string): string[];
693
740
  /**
694
741
  * The path a package's routes hang off, relative to the package prefix.
695
742
  * Scoped names occupy two segments — the addressing unpkg and jsdelivr use.
696
743
  */
697
- declare function namespacePath(packageName: string): string;
744
+ export declare function namespacePath(packageName: string): string;
698
745
  /**
699
746
  * Resolves the npm name a package is routed under from the key the package
700
747
  * manager holds it by. That key is the specifier as configured, which is not
@@ -707,7 +754,7 @@ declare function namespacePath(packageName: string): string;
707
754
  * Deriving a URL segment straight from the key would give a developer's home
708
755
  * directory a route namespace, so the path form is resolved rather than slugged.
709
756
  */
710
- declare function resolvePackageName(key: string, readPackageJsonName?: (dir: string) => string | undefined): string;
757
+ export declare function resolvePackageName(key: string, readPackageJsonName?: (dir: string) => string | undefined): string;
711
758
  /**
712
759
  * A mount path the host named for one of its own route groups.
713
760
  *
@@ -722,7 +769,7 @@ declare function resolvePackageName(key: string, readPackageJsonName?: (dir: str
722
769
  * routes unpredictable relative to each other. Returns the normalized path,
723
770
  * with a leading and no trailing slash.
724
771
  */
725
- declare function assertHostMountPath(path: string): string;
772
+ export declare function assertHostMountPath(path: string): string;
726
773
  //#endregion
727
774
  //#region src/http/webhook-verify.d.ts
728
775
  type VerifyResult = {
@@ -733,20 +780,230 @@ type VerifyResult = {
733
780
  };
734
781
  /** Verifies a delivery against the configured scheme; `raw` must be the exact bytes
735
782
  * received. The reason is for the log only: callers answer a fixed 401, so a probing sender learns nothing from the body. */
736
- declare function verifyWebhook(options: {
783
+ export declare function verifyWebhook(options: {
737
784
  verification: WebhookVerification;
738
785
  headers: Record<string, string>;
739
786
  raw: Buffer;
740
787
  now?: Date;
741
788
  }): VerifyResult;
742
- declare function redactHeaders(headers: Record<string, string>, extra?: string): Record<string, string>;
789
+ export declare function redactHeaders(headers: Record<string, string>, extra?: string): Record<string, string>;
743
790
  /** JSON and form bodies become objects; anything else stays decoded text, so a verified
744
791
  * XML or CSV payload is still reachable downstream. */
745
- declare function parseWebhookBody(raw: Buffer, contentType?: string): unknown;
792
+ export declare function parseWebhookBody(raw: Buffer, contentType?: string): unknown;
793
+ //#endregion
794
+ //#region src/services/canonical-document-id.d.ts
795
+ /**
796
+ * Raised when a caller-supplied identifier cannot be resolved to a canonical
797
+ * document id. Carries no detail on purpose: resolution failures must not act
798
+ * as a document-existence oracle, so consumers map this to their generic
799
+ * fail-closed response.
800
+ */
801
+ export declare class CanonicalDocumentIdResolutionError extends Error {
802
+ constructor();
803
+ }
804
+ export type CanonicalDocumentIdResolver = (identifier: string) => Promise<CanonicalDocumentId>;
805
+ /**
806
+ * The sanctioned string-to-CanonicalDocumentId cast: both the GraphQL layer
807
+ * and server routes must resolve caller identifiers through this helper so
808
+ * decision and data layers always agree on the subject document.
809
+ */
810
+ export declare function createCanonicalDocumentIdResolver(client: Pick<IReactorClient, "resolveIdOrSlug">): CanonicalDocumentIdResolver;
811
+ //#endregion
812
+ //#region src/services/attachment-access.service.d.ts
813
+ /**
814
+ * Whether the active Reactor composition hosts the attachment-reference
815
+ * projection. Reported by the client initializer: the built-in stack always
816
+ * registers it, while a caller-provided Reactor may lack the live
817
+ * registration capability. Consumers of reference evidence must fail closed
818
+ * when it is unavailable.
819
+ */
820
+ export type AttachmentReferenceProjectionCapability = {
821
+ status: "available";
822
+ } | {
823
+ status: "unavailable";
824
+ reason: "live-read-model-registration-unsupported" | "in-process-reactor-module-unavailable" | "initializer-did-not-report";
825
+ };
826
+ /**
827
+ * Outcome of an attachment read authorization. `denied` intentionally covers
828
+ * both an unreadable document and an absent document/ref relationship so the
829
+ * route layer cannot leak which check failed. `projection-unavailable` means
830
+ * the reference index is not being maintained in this composition; it is
831
+ * returned before any document-authorization or reference lookup runs.
832
+ */
833
+ export type AttachmentAccessResult = {
834
+ kind: "allowed";
835
+ documentId: CanonicalDocumentId;
836
+ ref: AttachmentRef;
837
+ } | {
838
+ kind: "denied";
839
+ } | {
840
+ kind: "projection-unavailable";
841
+ };
842
+ export interface AttachmentAccessRequest {
843
+ documentId: string;
844
+ attachmentRef: string;
845
+ userAddress?: string;
846
+ /**
847
+ * The `did:key` of the app instance whose token authenticated the caller.
848
+ * A policy subject is an address AND a key — a grant can name either, and a
849
+ * document's creator is recorded by key — so a decision made from the address
850
+ * alone answers a narrower question than the one being asked.
851
+ */
852
+ appKey?: string;
853
+ }
854
+ export type AttachmentCallerResult = {
855
+ kind: "admitted";
856
+ } | {
857
+ kind: "unauthenticated";
858
+ };
859
+ export interface AttachmentCallerRequest {
860
+ intent: "read" | "write";
861
+ userAddress?: string;
862
+ appKey?: string;
863
+ }
864
+ export interface IAttachmentAccessService {
865
+ canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
866
+ /** Whether this caller may use attachments at all, before any document decides. */
867
+ admitCaller(request: AttachmentCallerRequest): Promise<AttachmentCallerResult>;
868
+ }
869
+ export interface AttachmentAccessServiceOptions {
870
+ /** Refuse writes from a caller with no address. Default `true`. */
871
+ refuseAnonymousWrites?: boolean;
872
+ /** Refuse reads from a caller with no address. Default `false`. */
873
+ refuseAnonymousReads?: boolean;
874
+ }
875
+ /**
876
+ * Composes document authorization with the projected document/ref
877
+ * relationship. Order is fixed: validate ref, resolve the canonical document
878
+ * id, decide the read, check the reactor's read gate serves the document, then
879
+ * check the reference index and that the subject may read a scope whose
880
+ * operations reference the attachment. A denied document never reaches the
881
+ * reference reader, and the facade never touches attachment metadata, storage
882
+ * backends, or presigners.
883
+ *
884
+ * The named document decides alone: an attachment several documents reference
885
+ * is readable through each of them on that document's own terms.
886
+ *
887
+ * The read is decided by the document's own policy when this composition has a
888
+ * model to enforce it with, and by the host's permission tables when it does
889
+ * not. That is not a preference between two equivalent answers: a host running
890
+ * document policies keeps no rows in the permission tables, so asking them
891
+ * about such a document returns whatever the host-wide policy says — under
892
+ * `OPEN`, `true`, for everyone. Serving bytes on that answer hands the file to
893
+ * anyone who learns its hash, which the document's own state may well have told
894
+ * them. Both are kept because they are the two halves of one rule: an
895
+ * attachment is readable by whoever may read the document that references it,
896
+ * and each composition can only express that in its own terms. The caller
897
+ * decision mirrors the routes' `requireAuth`.
898
+ */
899
+ export declare class AttachmentAccessService implements IAttachmentAccessService {
900
+ private readonly resolveCanonicalId;
901
+ private readonly authorization;
902
+ private readonly references;
903
+ private readonly projection;
904
+ private readonly readGate;
905
+ /**
906
+ * Absent below auth enforcement, where there is no policy model to
907
+ * evaluate; the host's permission tables decide alone, exactly as before.
908
+ */
909
+ private readonly scopeGate?;
910
+ private readonly options;
911
+ constructor(resolveCanonicalId: CanonicalDocumentIdResolver, authorization: IAuthorizationService, references: IAttachmentReferenceReader, projection: AttachmentReferenceProjectionCapability, readGate: AttachmentReadGate,
912
+ /**
913
+ * Absent below auth enforcement, where there is no policy model to
914
+ * evaluate; the host's permission tables decide alone, exactly as before.
915
+ */
916
+ scopeGate?: IDocumentScopeGate | undefined, options?: AttachmentAccessServiceOptions);
917
+ admitCaller(request: AttachmentCallerRequest): Promise<AttachmentCallerResult>;
918
+ canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
919
+ /**
920
+ * Whether the caller may read the state the reference lives in.
921
+ *
922
+ * A failure here is rethrown rather than turned into a denial. A read side
923
+ * that is down must not read as a policy: a denial nobody can distinguish
924
+ * from a refusal is one nobody investigates, and the route answers 500 for a
925
+ * reason.
926
+ */
927
+ private canReadDocument;
928
+ }
929
+ //#endregion
930
+ //#region src/services/authorized-attachment.service.d.ts
931
+ /** The reference index is not maintained in this composition. */
932
+ export declare class AttachmentAccessUnavailable extends Error {
933
+ constructor();
934
+ }
935
+ /** The access decision itself failed; the cause is logged, not surfaced. */
936
+ export declare class AttachmentAccessFailed extends Error {
937
+ constructor(cause: unknown);
938
+ }
939
+ /** An `IAttachmentService` whose reads and writes are decided for one subject. */
940
+ export declare class AuthorizedAttachmentService implements IAttachmentService {
941
+ private readonly inner;
942
+ private readonly access;
943
+ private readonly subject;
944
+ private readonly logger;
945
+ constructor(inner: IAttachmentService, access: IAttachmentAccessService, subject: AuthSubject, logger: ILogger);
946
+ /** Hash-first only: an upload-first handle can send after it expires. */
947
+ reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
948
+ stat(ref: AttachmentRef, options?: AttachmentStatOptions): Promise<AttachmentHeader>;
949
+ get(ref: AttachmentRef, options?: AbortSignal | AttachmentDownloadOptions): Promise<AttachmentResponse>;
950
+ getDownloadTarget(ref: AttachmentRef, options: AttachmentDownloadTargetOptions): Promise<AttachmentDownloadTarget>;
951
+ private decideRead;
952
+ private admit;
953
+ private accessFailed;
954
+ }
955
+ export interface IAttachmentClientProvider {
956
+ forSubject(subject: AuthSubject): IAttachmentClient;
957
+ }
958
+ export declare class AttachmentClientProvider implements IAttachmentClientProvider {
959
+ private readonly service;
960
+ private readonly access;
961
+ private readonly logger;
962
+ constructor(service: IAttachmentService, access: IAttachmentAccessService, logger: ILogger);
963
+ forSubject(subject: AuthSubject): IAttachmentClient;
964
+ }
965
+ //#endregion
966
+ //#region src/graphql/inspection/throttle.d.ts
967
+ type InspectionThrottleConfig = {
968
+ /** Per caller, also the burst; admins exempt (PH_INSPECTION_CALLS_PER_MINUTE). */
969
+ callsPerMinute: number;
970
+ };
971
+ export declare const DEFAULT_INSPECTION_THROTTLE: InspectionThrottleConfig;
972
+ export declare class InspectionThrottledError extends GraphQLError {
973
+ constructor(retryAfterMs: number);
974
+ }
975
+ export declare class InspectionThrottle {
976
+ #private;
977
+ constructor(config?: Partial<InspectionThrottleConfig>);
978
+ /** Callers with a bucket, at most the 10,000 most recently seen. */
979
+ get trackedCallers(): number;
980
+ /** Spends one of the caller's calls; throws when none is left. */
981
+ charge(caller: string): void;
982
+ }
983
+ //#endregion
984
+ //#region src/graphql/inspection/source.d.ts
985
+ /** What the inspection subgraph serves. Only reads cross GraphQL. */
986
+ interface IReactorInspectionSource {
987
+ /** Reads as the host; drive and document reads are re-made as the caller. */
988
+ readonly inspector: IInspector;
989
+ readonly syncInspector: ISyncInspector | undefined;
990
+ readonly documentModelRegistry: IDocumentModelRegistry;
991
+ /** Facts the host learns after boot, e.g. a composed workflow runtime. */
992
+ readonly facts: IReactorFactsSink;
993
+ readonly throttle: InspectionThrottle;
994
+ }
995
+ type ReactorInspectionOptions = {
996
+ /** Absent: a group-commit store's own health, else `tracked: false`. */
997
+ storageHealth?: IInspectorStorageHealthProvider;
998
+ attachmentStore?: IInspectableAttachmentStore;
999
+ workflows?: boolean;
1000
+ throttle?: Partial<InspectionThrottleConfig>;
1001
+ };
1002
+ export declare function createReactorInspectionSource(module: InProcessReactorModule, options?: ReactorInspectionOptions): IReactorInspectionSource;
746
1003
  //#endregion
747
1004
  //#region src/graphql/types.d.ts
748
- type SubgraphClass = typeof BaseSubgraph;
749
- type Context = {
1005
+ export type SubgraphClass = typeof BaseSubgraph;
1006
+ export type Context = {
750
1007
  driveId?: string;
751
1008
  document?: PHDocument;
752
1009
  headers: IncomingHttpHeaders;
@@ -754,11 +1011,12 @@ type Context = {
754
1011
  user?: {
755
1012
  address: string;
756
1013
  chainId: number;
757
- networkId: string; /** The did:key of the app instance that issued this request's token. */
1014
+ networkId: string;
1015
+ /** The did:key of the app instance that issued this request's token. */
758
1016
  appKey: string;
759
1017
  };
760
1018
  };
761
- type ISubgraph = {
1019
+ export type ISubgraph = {
762
1020
  name: string;
763
1021
  /**
764
1022
  * @deprecated The GraphQL manager mounts every subgraph under its own base
@@ -776,7 +1034,7 @@ type ISubgraph = {
776
1034
  onSetup?: () => Promise<void>;
777
1035
  onDisconnect?: () => Promise<void>;
778
1036
  };
779
- type SubgraphArgs = {
1037
+ export type SubgraphArgs = {
780
1038
  reactorClient: IReactorClient;
781
1039
  /**
782
1040
  * The subgraph's package's slice of the HTTP surface, for serving REST
@@ -796,6 +1054,20 @@ type SubgraphArgs = {
796
1054
  * to the host's permission tables alone.
797
1055
  */
798
1056
  syncServingGate?: SyncScopeGate;
1057
+ /**
1058
+ * Attachments as the request's caller may use them. Bind per request with
1059
+ * `BaseSubgraph.attachmentsFor(ctx)`.
1060
+ */
1061
+ attachments?: IAttachmentClientProvider;
1062
+ /** Read only by `InspectionSubgraph`, registered only when this is set. */
1063
+ inspection?: IReactorInspectionSource;
1064
+ /**
1065
+ * Evicts the host's cached credential checks, e.g. from a package's
1066
+ * credential-revoke mutation, so a revoked credential is refused on the
1067
+ * next request rather than after the cache TTL. Read it through
1068
+ * `BaseSubgraph.credentials`, which is a no-op when the host passes none.
1069
+ */
1070
+ credentials?: ICredentialInvalidator;
799
1071
  /**
800
1072
  * The host's base path, injected by the GraphQL manager when it constructs
801
1073
  * a subgraph. Subgraph code may read it, but routing ignores it: every
@@ -803,7 +1075,7 @@ type SubgraphArgs = {
803
1075
  */
804
1076
  path?: string;
805
1077
  };
806
- type GqlSigner = {
1078
+ export type GqlSigner = {
807
1079
  user: {
808
1080
  address: string;
809
1081
  networkId: string;
@@ -815,19 +1087,19 @@ type GqlSigner = {
815
1087
  };
816
1088
  signatures: string[];
817
1089
  };
818
- type GqlOperationContext = {
1090
+ export type GqlOperationContext = {
819
1091
  signer: GqlSigner | undefined;
820
1092
  };
821
- type GqlSignerUser = {
1093
+ export type GqlSignerUser = {
822
1094
  address: string;
823
1095
  networkId: string;
824
1096
  chainId: number;
825
1097
  };
826
- type GqlSignerApp = {
1098
+ export type GqlSignerApp = {
827
1099
  name: string;
828
1100
  key: string;
829
1101
  };
830
- type GqlOperation = {
1102
+ export type GqlOperation = {
831
1103
  id: string;
832
1104
  type: string;
833
1105
  index: number;
@@ -838,7 +1110,7 @@ type GqlOperation = {
838
1110
  error: string | undefined;
839
1111
  context: GqlOperationContext;
840
1112
  };
841
- type GqlDocument = {
1113
+ export type GqlDocument = {
842
1114
  __typename?: string;
843
1115
  id: string;
844
1116
  name: string;
@@ -851,7 +1123,7 @@ type GqlDocument = {
851
1123
  state: unknown;
852
1124
  initialState: unknown;
853
1125
  };
854
- type GqlDriveDocument = GqlDocument & {
1126
+ export type GqlDriveDocument = GqlDocument & {
855
1127
  meta: {
856
1128
  preferredEditor?: string;
857
1129
  };
@@ -861,7 +1133,12 @@ type GqlDriveDocument = GqlDocument & {
861
1133
  };
862
1134
  //#endregion
863
1135
  //#region src/graphql/base-subgraph.d.ts
864
- declare class BaseSubgraph implements ISubgraph$1 {
1136
+ /**
1137
+ * The subject a request reads as: its address and the app key its token
1138
+ * carries. Anonymous is an empty subject, never the host's signer.
1139
+ */
1140
+ export declare function callerSubject(user: Context["user"]): AuthSubject;
1141
+ export declare class BaseSubgraph implements ISubgraph$1 {
865
1142
  #private;
866
1143
  name: string;
867
1144
  path: string;
@@ -876,7 +1153,21 @@ declare class BaseSubgraph implements ISubgraph$1 {
876
1153
  documentPermissionService?: DocumentPermissionService;
877
1154
  authorizationService: IAuthorizationService;
878
1155
  syncServingGate?: SyncScopeGate;
1156
+ /**
1157
+ * The host's credential cache, for a package that revokes credentials:
1158
+ * call `this.credentials.invalidateCredential(address, chainId?, appDid?)`
1159
+ * right after the revocation is stored, so this host refuses the credential
1160
+ * on the next request and closes WebSocket connections that rely on it.
1161
+ * A no-op on a host without authentication.
1162
+ */
1163
+ readonly credentials: ICredentialInvalidator;
879
1164
  constructor(args: SubgraphArgs$1);
1165
+ /**
1166
+ * An attachment client bound to this request's caller, memoized per request.
1167
+ *
1168
+ * @throws Error when the host provides no attachment client to subgraphs.
1169
+ */
1170
+ attachmentsFor(ctx: Context): IAttachmentClient;
880
1171
  onSetup(): Promise<void>;
881
1172
  onDisconnect(): Promise<void>;
882
1173
  /**
@@ -902,6 +1193,10 @@ declare class BaseSubgraph implements ISubgraph$1 {
902
1193
  * layer, such as a fetched document's id). Performs no slug resolution.
903
1194
  */
904
1195
  canReadDocument(documentId: CanonicalDocumentId, ctx: Context): Promise<boolean>;
1196
+ /** Drops the items the host's own ACL refuses the caller. */
1197
+ readableByHost<T extends {
1198
+ id: string;
1199
+ }>(items: readonly T[], ctx: Context): Promise<T[]>;
905
1200
  /**
906
1201
  * The principal a request decides as: the authenticated caller's address, and
907
1202
  * the did:key of the app instance whose token authenticated it.
@@ -913,6 +1208,16 @@ declare class BaseSubgraph implements ISubgraph$1 {
913
1208
  * carries the same key. Anonymous callers supply neither.
914
1209
  */
915
1210
  protected viewSubject(ctx: Context): AuthSubject;
1211
+ /** Whether a listing would serve the document to the caller; fails closed. */
1212
+ protected servesDocument(documentId: string, ctx: Context): Promise<boolean>;
1213
+ /** {@link servesDocument}, but a reactor that cannot answer throws. */
1214
+ protected servesDocumentOrThrows(identifier: string, ctx: Context, view?: Pick<ViewFilter, "branch" | "scopes">): Promise<boolean>;
1215
+ /**
1216
+ * Whether a listing would serve the document to the caller: the reactor read
1217
+ * gate, then the host's legacy layer, as `findDocuments` applies them. Absent
1218
+ * or withheld is `false`; a failure to decide throws.
1219
+ */
1220
+ protected listsDocument(identifier: string, ctx: Context, view?: Pick<ViewFilter, "branch" | "scopes">): Promise<boolean>;
916
1221
  /**
917
1222
  * Asserts read access, resolving a slug first. Returns a handle whose
918
1223
  * `fetchIdentifier` the caller reuses for the data fetch; a denial throws.
@@ -931,16 +1236,24 @@ declare class BaseSubgraph implements ISubgraph$1 {
931
1236
  }
932
1237
  //#endregion
933
1238
  //#region src/graphql/analytics-subgraph.d.ts
934
- declare class AnalyticsSubgraph extends BaseSubgraph {
1239
+ export declare class AnalyticsSubgraph extends BaseSubgraph {
1240
+ #private;
935
1241
  analyticsStore: IAnalyticsStore;
936
1242
  analyticsModel: AnalyticsModel;
937
1243
  name: string;
938
- typeDefs: graphql.DocumentNode;
1244
+ typeDefs: import("graphql").DocumentNode;
1245
+ /**
1246
+ * Every analytics field hangs off `Query.analytics`, so gating it gates them
1247
+ * all. Series are aggregates a processor built from many documents and carry
1248
+ * no document to decide on, so only a caller with policy-wide read (anyone
1249
+ * under OPEN, an admin otherwise) may read them.
1250
+ */
939
1251
  resolvers: GraphQLResolverMap<Context$1>;
940
1252
  constructor(args: SubgraphArgs$1);
941
1253
  }
942
- //#endregion
943
- //#region src/graphql/auth/resolvers.d.ts
1254
+ declare namespace resolvers_d_exports {
1255
+ export { DocumentAccessInfo, DocumentProtectionInfo, OperationPermissionsInfo, OperationUserPermission, canExecuteOperation, documentAccess, documentProtection, grantDocumentPermission, grantOperationPermission, operationPermissions, revokeDocumentPermission, revokeOperationPermission, setDocumentProtection, transferDocumentOwnership, userDocumentPermissions };
1256
+ }
944
1257
  type DocumentAccessInfo = {
945
1258
  documentId: string;
946
1259
  permissions: Array<{
@@ -952,6 +1265,33 @@ type DocumentAccessInfo = {
952
1265
  updatedAt: Date;
953
1266
  }>;
954
1267
  };
1268
+ declare function documentAccess(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1269
+ documentId: CanonicalDocumentId;
1270
+ }, userAddress: string | undefined): Promise<DocumentAccessInfo>;
1271
+ declare function userDocumentPermissions(service: DocumentPermissionService, userAddress: string): Promise<Array<{
1272
+ documentId: string;
1273
+ userAddress: string;
1274
+ permission: DocumentPermissionLevel;
1275
+ grantedBy: string;
1276
+ createdAt: Date;
1277
+ updatedAt: Date;
1278
+ }>>;
1279
+ declare function grantDocumentPermission(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1280
+ documentId: CanonicalDocumentId;
1281
+ userAddress: string;
1282
+ permission: DocumentPermissionLevel;
1283
+ }, grantedByAddress: string | undefined): Promise<{
1284
+ documentId: string;
1285
+ userAddress: string;
1286
+ permission: DocumentPermissionLevel;
1287
+ grantedBy: string;
1288
+ createdAt: Date;
1289
+ updatedAt: Date;
1290
+ }>;
1291
+ declare function revokeDocumentPermission(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1292
+ documentId: CanonicalDocumentId;
1293
+ userAddress: string;
1294
+ }, revokedByAddress: string | undefined): Promise<boolean>;
955
1295
  type OperationUserPermission = {
956
1296
  documentId: string;
957
1297
  operationType: string;
@@ -964,13 +1304,46 @@ type OperationPermissionsInfo = {
964
1304
  operationType: string;
965
1305
  userPermissions: OperationUserPermission[];
966
1306
  };
1307
+ declare function operationPermissions(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1308
+ documentId: CanonicalDocumentId;
1309
+ operationType: string;
1310
+ }, userAddress: string | undefined): Promise<OperationPermissionsInfo>;
1311
+ declare function canExecuteOperation(authorizationService: IAuthorizationService, args: {
1312
+ documentId: CanonicalDocumentId;
1313
+ operationType: string;
1314
+ }, userAddress: string | undefined): Promise<boolean>;
1315
+ declare function grantOperationPermission(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1316
+ documentId: CanonicalDocumentId;
1317
+ operationType: string;
1318
+ userAddress: string;
1319
+ }, grantedByAddress: string | undefined): Promise<OperationUserPermission>;
1320
+ declare function revokeOperationPermission(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1321
+ documentId: CanonicalDocumentId;
1322
+ operationType: string;
1323
+ userAddress: string;
1324
+ }, revokedByAddress: string | undefined): Promise<boolean>;
967
1325
  type DocumentProtectionInfo = {
968
1326
  documentId: string;
969
1327
  protected: boolean;
970
1328
  ownerAddress: string | null;
971
1329
  };
1330
+ declare function documentProtection(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1331
+ documentId: CanonicalDocumentId;
1332
+ }, userAddress: string | undefined): Promise<DocumentProtectionInfo>;
1333
+ declare function setDocumentProtection(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1334
+ documentId: CanonicalDocumentId;
1335
+ protected: boolean;
1336
+ }, userAddress: string | undefined): Promise<DocumentProtectionInfo>;
1337
+ declare function transferDocumentOwnership(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
1338
+ documentId: CanonicalDocumentId;
1339
+ newOwnerAddress: string;
1340
+ }, userAddress: string | undefined): Promise<DocumentProtectionInfo>;
972
1341
  //#endregion
973
1342
  //#region src/graphql/auth/subgraph.d.ts
1343
+ type DocumentArgs = {
1344
+ documentIdOrSlug?: string | null;
1345
+ documentId?: string | null;
1346
+ };
974
1347
  /**
975
1348
  * Auth Subgraph - handles all document permission and authorization operations
976
1349
  *
@@ -980,17 +1353,16 @@ type DocumentProtectionInfo = {
980
1353
  * - Document protection and ownership
981
1354
  * - Operation-level permissions (fine-grained operation control)
982
1355
  */
983
- declare class AuthSubgraph extends BaseSubgraph {
1356
+ export declare class AuthSubgraph extends BaseSubgraph {
1357
+ #private;
984
1358
  private logger;
985
1359
  constructor(args: SubgraphArgs);
986
1360
  name: string;
987
1361
  hasSubscriptions: boolean;
988
- typeDefs: graphql.DocumentNode;
1362
+ typeDefs: import("graphql").DocumentNode;
989
1363
  resolvers: {
990
1364
  Query: {
991
- documentAccess: (_parent: unknown, args: {
992
- documentId: string;
993
- }, ctx: {
1365
+ documentAccess: (_parent: unknown, args: DocumentArgs, ctx: {
994
1366
  user?: {
995
1367
  address: string;
996
1368
  };
@@ -1007,49 +1379,42 @@ declare class AuthSubgraph extends BaseSubgraph {
1007
1379
  createdAt: Date;
1008
1380
  updatedAt: Date;
1009
1381
  }[]>;
1010
- operationPermissions: (_parent: unknown, args: {
1011
- documentId: string;
1382
+ operationPermissions: (_parent: unknown, args: DocumentArgs & {
1012
1383
  operationType: string;
1013
1384
  }, ctx: {
1014
1385
  user?: {
1015
1386
  address: string;
1016
1387
  };
1017
1388
  }) => Promise<OperationPermissionsInfo>;
1018
- canExecuteOperation: (_parent: unknown, args: {
1019
- documentId: string;
1389
+ canExecuteOperation: (_parent: unknown, args: DocumentArgs & {
1020
1390
  operationType: string;
1021
1391
  }, ctx: {
1022
1392
  user?: {
1023
1393
  address: string;
1024
1394
  };
1025
1395
  }) => Promise<boolean>;
1026
- documentProtection: (_parent: unknown, args: {
1027
- documentId: string;
1028
- }, ctx: {
1396
+ documentProtection: (_parent: unknown, args: DocumentArgs, ctx: {
1029
1397
  user?: {
1030
1398
  address: string;
1031
1399
  };
1032
1400
  }) => Promise<DocumentProtectionInfo>;
1033
1401
  };
1034
1402
  Mutation: {
1035
- setDocumentProtection: (_parent: unknown, args: {
1036
- documentId: string;
1403
+ setDocumentProtection: (_parent: unknown, args: DocumentArgs & {
1037
1404
  protected: boolean;
1038
1405
  }, ctx: {
1039
1406
  user?: {
1040
1407
  address: string;
1041
1408
  };
1042
1409
  }) => Promise<DocumentProtectionInfo>;
1043
- transferDocumentOwnership: (_parent: unknown, args: {
1044
- documentId: string;
1410
+ transferDocumentOwnership: (_parent: unknown, args: DocumentArgs & {
1045
1411
  newOwnerAddress: string;
1046
1412
  }, ctx: {
1047
1413
  user?: {
1048
1414
  address: string;
1049
1415
  };
1050
1416
  }) => Promise<DocumentProtectionInfo>;
1051
- grantDocumentPermission: (_parent: unknown, args: {
1052
- documentId: string;
1417
+ grantDocumentPermission: (_parent: unknown, args: DocumentArgs & {
1053
1418
  userAddress: string;
1054
1419
  permission: string;
1055
1420
  }, ctx: {
@@ -1064,16 +1429,14 @@ declare class AuthSubgraph extends BaseSubgraph {
1064
1429
  createdAt: Date;
1065
1430
  updatedAt: Date;
1066
1431
  }>;
1067
- revokeDocumentPermission: (_parent: unknown, args: {
1068
- documentId: string;
1432
+ revokeDocumentPermission: (_parent: unknown, args: DocumentArgs & {
1069
1433
  userAddress: string;
1070
1434
  }, ctx: {
1071
1435
  user?: {
1072
1436
  address: string;
1073
1437
  };
1074
1438
  }) => Promise<boolean>;
1075
- grantOperationPermission: (_parent: unknown, args: {
1076
- documentId: string;
1439
+ grantOperationPermission: (_parent: unknown, args: DocumentArgs & {
1077
1440
  operationType: string;
1078
1441
  userAddress: string;
1079
1442
  }, ctx: {
@@ -1081,8 +1444,7 @@ declare class AuthSubgraph extends BaseSubgraph {
1081
1444
  address: string;
1082
1445
  };
1083
1446
  }) => Promise<OperationUserPermission>;
1084
- revokeOperationPermission: (_parent: unknown, args: {
1085
- documentId: string;
1447
+ revokeOperationPermission: (_parent: unknown, args: DocumentArgs & {
1086
1448
  operationType: string;
1087
1449
  userAddress: string;
1088
1450
  }, ctx: {
@@ -1096,21 +1458,29 @@ declare class AuthSubgraph extends BaseSubgraph {
1096
1458
  }
1097
1459
  //#endregion
1098
1460
  //#region src/graphql/gateway/auth-middleware.d.ts
1099
- type AuthFetchMiddleware = (handler: FetchHandler) => FetchHandler;
1461
+ export type AuthFetchMiddleware = (handler: FetchHandler) => FetchHandler;
1100
1462
  /** Internal — only `graphql-manager.ts` should call this. */
1101
- declare function getAuthContext(request: globalThis.Request): AuthContext | undefined;
1102
- declare function createAuthFetchMiddleware(authService: AuthService): AuthFetchMiddleware;
1463
+ export declare function getAuthContext(request: globalThis.Request): AuthContext | undefined;
1464
+ export declare function createAuthFetchMiddleware(authService: AuthService): AuthFetchMiddleware;
1103
1465
  //#endregion
1104
1466
  //#region src/graphql/gateway/factory.d.ts
1105
- type GatewayAdapterType = "apollo" | "mercurius" | "stitching";
1106
- type HttpAdapterType = "express" | "fastify";
1107
- declare function createGatewayAdapter(type: GatewayAdapterType, logger: ILogger): Promise<IGatewayAdapter<Context>>;
1108
- type HttpAdapterSetup = {
1467
+ export type GatewayAdapterType = "apollo" | "mercurius" | "stitching";
1468
+ export type HttpAdapterType = "express" | "fastify";
1469
+ export declare function createGatewayAdapter(type: GatewayAdapterType, logger: ILogger): Promise<IGatewayAdapter<Context>>;
1470
+ export type HttpAdapterSetup = {
1109
1471
  adapter: IHttpAdapter;
1110
1472
  };
1111
- declare function createHttpAdapter(type: HttpAdapterType): Promise<HttpAdapterSetup>;
1473
+ export declare function createHttpAdapter(type: HttpAdapterType): Promise<HttpAdapterSetup>;
1112
1474
  //#endregion
1113
1475
  //#region src/graphql/gateway/drive-ownership-cache.d.ts
1476
+ /**
1477
+ * Where drives are looked up: the raw reactor, past the read gate. Ownership
1478
+ * is a storage fact that serves no content, so a policy that withholds a drive
1479
+ * from the host's key must not make the host deny holding it.
1480
+ */
1481
+ type DriveStore = {
1482
+ find(search: SearchFilter): Promise<PagedResults<PHDocument>>;
1483
+ };
1114
1484
  /**
1115
1485
  * In-memory record of which drives this switchboard instance owns.
1116
1486
  *
@@ -1122,11 +1492,17 @@ declare function createHttpAdapter(type: HttpAdapterType): Promise<HttpAdapterSe
1122
1492
  * 421 response.
1123
1493
  */
1124
1494
  declare class DriveOwnershipCache {
1125
- private readonly reactorClient;
1495
+ private readonly store;
1126
1496
  private readonly drives;
1127
- constructor(reactorClient: IReactorClient);
1497
+ constructor(store: DriveStore);
1128
1498
  init(): Promise<void>;
1129
1499
  has(driveId: string): boolean;
1500
+ /**
1501
+ * Whether this host holds the drive, asking the reactor on a miss: drives
1502
+ * also arrive by sync and by writes that bypass the create resolvers. A
1503
+ * positive answer is cached; a failure to ask throws.
1504
+ */
1505
+ holds(driveId: string): Promise<boolean>;
1130
1506
  add(driveId: string): void;
1131
1507
  remove(driveId: string): void;
1132
1508
  size(): number;
@@ -1135,34 +1511,97 @@ declare class DriveOwnershipCache {
1135
1511
  //#region src/graphql/gateway/require-auth-middleware.d.ts
1136
1512
  type RequireAuthFetchMiddleware = (handler: FetchHandler) => FetchHandler;
1137
1513
  //#endregion
1514
+ //#region src/graphql/ws-credential-monitor.d.ts
1515
+ type WsCredentialMonitorOptions = {
1516
+ authService: Pick<AuthService, "isCredentialValid" | "onCredentialInvalidated">;
1517
+ /** Re-check interval; `0` disables the periodic sweep (invalidations still re-check). */
1518
+ intervalMs: number;
1519
+ logger: ILogger;
1520
+ };
1521
+ /**
1522
+ * Re-verifies the credentials of authenticated WebSocket connections.
1523
+ *
1524
+ * A WebSocket is authenticated once, at `ConnectionInit`, so a credential
1525
+ * revoked afterwards would otherwise keep every subscription it opened alive
1526
+ * for as long as the socket stays up. The monitor re-checks each tracked
1527
+ * connection on an interval and, at once, the connections of an identity whose
1528
+ * credential a package invalidated; a connection whose credential no longer
1529
+ * verifies is closed 4403 with {@link WS_CLOSE_REASON_CREDENTIAL_REVOKED}.
1530
+ *
1531
+ * A check that throws (a verifier outage) leaves the connection open: admission
1532
+ * fails closed on the next connect, but an outage should not drop every live
1533
+ * subscription at once.
1534
+ */
1535
+ declare class WsCredentialMonitor {
1536
+ #private;
1537
+ constructor(options: WsCredentialMonitorOptions);
1538
+ get size(): number;
1539
+ /** Begin the periodic sweep and listen for invalidations. Idempotent. */
1540
+ start(): void;
1541
+ dispose(): void;
1542
+ /** Track an admitted, authenticated connection until its socket closes. */
1543
+ track(connection: object, user: User): void;
1544
+ /**
1545
+ * Re-verify tracked connections (those matching `filter`, or all) and close
1546
+ * the ones whose credential no longer holds. Resolves to the number closed.
1547
+ */
1548
+ recheck(filter?: CredentialInvalidation): Promise<number>;
1549
+ }
1550
+ //#endregion
1138
1551
  //#region src/graphql/graphql-manager.d.ts
1139
- type GraphqlManagerFeatureFlags = {
1552
+ export type GraphqlManagerFeatureFlags = {
1140
1553
  enableDocumentModelSubgraphs?: boolean;
1141
1554
  };
1142
- declare function createWsAuthHandlers(opts: {
1143
- authService?: AuthService; /** Whether anonymous callers are refused; read at call time, not at build time. */
1555
+ /** Dependencies and settings for a {@link GraphQLManager}. */
1556
+ export type GraphQLManagerOptions = {
1557
+ path: string;
1558
+ httpServer: http.Server;
1559
+ wsServer: WebSocketServer;
1560
+ reactorClient: IReactorClient;
1561
+ relationalDb: IRelationalDb;
1562
+ analyticsStore: IAnalyticsStore;
1563
+ syncManager: ISyncManager;
1564
+ logger: ILogger;
1565
+ httpAdapter: IHttpAdapter;
1566
+ gatewayAdapter: IGatewayAdapter<Context$1>;
1567
+ authService?: AuthService;
1568
+ documentPermissionService?: DocumentPermissionService;
1569
+ /** Defaults to every flag on. */
1570
+ featureFlags?: GraphqlManagerFeatureFlags;
1571
+ /** Defaults to 4001. */
1572
+ port?: number;
1573
+ authorizationService: IAuthorizationService;
1574
+ /** Resolvers dispatch to it for reactor-drive parents. */
1575
+ reactorDriveClient?: IDriveClient;
1576
+ syncServingGate?: SyncScopeGate;
1577
+ httpRoutes?: HttpRouteService;
1578
+ attachments?: IAttachmentClientProvider;
1579
+ inspection?: IReactorInspectionSource;
1580
+ /**
1581
+ * Where drive ownership is looked up, past the read gate. Defaults to the
1582
+ * reactor client, which withholds a drive the host's own key may not read.
1583
+ */
1584
+ driveStore?: DriveStore;
1585
+ reportError?: ReportError;
1586
+ /**
1587
+ * How often the credentials of authenticated WebSocket connections are
1588
+ * re-verified; a connection whose credential no longer holds is closed.
1589
+ * Defaults to {@link DEFAULT_WS_CREDENTIAL_RECHECK_INTERVAL_MS}; `0` turns the
1590
+ * periodic sweep off, leaving only the re-check on invalidation.
1591
+ */
1592
+ wsCredentialRecheckIntervalMs?: number;
1593
+ };
1594
+ export declare function createWsAuthHandlers(opts: {
1595
+ authService?: AuthService;
1596
+ /** Re-verifies admitted connections and closes revoked ones. */
1597
+ credentialMonitor?: WsCredentialMonitor;
1598
+ /** Whether anonymous callers are refused; read at call time, not at build time. */
1144
1599
  requireAuthenticatedCaller: () => boolean;
1145
1600
  logger: ILogger;
1146
1601
  buildContext: (connectionParams: Record<string, unknown>, user?: User) => Context$1;
1147
1602
  }): WsHandlers<Context$1>;
1148
- declare class GraphQLManager {
1603
+ export declare class GraphQLManager {
1149
1604
  #private;
1150
- private readonly path;
1151
- private readonly httpServer;
1152
- private readonly wsServer;
1153
- private readonly reactorClient;
1154
- private readonly relationalDb;
1155
- private readonly analyticsStore;
1156
- private readonly syncManager;
1157
- private readonly logger;
1158
- private readonly httpAdapter;
1159
- private readonly gatewayAdapter;
1160
- private readonly authService?;
1161
- private readonly documentPermissionService?;
1162
- private readonly featureFlags;
1163
- private readonly port;
1164
- private readonly syncServingGate?;
1165
- private readonly httpRoutes?;
1166
1605
  private initialized;
1167
1606
  private coreSubgraphsMap;
1168
1607
  private contextFields;
@@ -1174,12 +1613,13 @@ declare class GraphQLManager {
1174
1613
  private readonly subgraphHandlerCache;
1175
1614
  /** subgraphPath → the http adapter handle of its mounted route. */
1176
1615
  private readonly subgraphRouteHandles;
1177
- /** Handle of the currently mounted supergraph SSE route, if any. */
1178
- private sseRouteHandle;
1616
+ /** Mounted SSE routes, keyed by path: the supergraph's and each subgraph's. */
1617
+ private readonly sseRouteHandles;
1179
1618
  /**
1180
- * Package name → the subgraph instances registered from it, keyed by
1181
- * subgraph name. Tracks the package association so that removed packages
1182
- * can be torn down (see unregisterPackage / prunePackageSubgraphs).
1619
+ * Origin → the subgraph instances registered from it. Core and host
1620
+ * subgraphs are not tracked. Tracks the package association so that
1621
+ * removed packages can be torn down (see unregisterPackage /
1622
+ * prunePackageSubgraphs).
1183
1623
  */
1184
1624
  private readonly packageSubgraphs;
1185
1625
  /**
@@ -1189,7 +1629,25 @@ declare class GraphQLManager {
1189
1629
  */
1190
1630
  readonly reactorDriveClient?: IDriveClient;
1191
1631
  private readonly authorizationService;
1192
- 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);
1632
+ private readonly path;
1633
+ private readonly httpServer;
1634
+ private readonly wsServer;
1635
+ private readonly reactorClient;
1636
+ private readonly relationalDb;
1637
+ private readonly analyticsStore;
1638
+ private readonly syncManager;
1639
+ private readonly logger;
1640
+ private readonly httpAdapter;
1641
+ private readonly gatewayAdapter;
1642
+ private readonly authService?;
1643
+ private readonly documentPermissionService?;
1644
+ private readonly featureFlags;
1645
+ private readonly port;
1646
+ private readonly syncServingGate?;
1647
+ private readonly httpRoutes?;
1648
+ private readonly attachments?;
1649
+ private readonly inspection?;
1650
+ constructor(options: GraphQLManagerOptions);
1193
1651
  init(coreSubgraphs: SubgraphClass$1[], authMiddleware?: AuthFetchMiddleware, requireAuthMiddleware?: RequireAuthFetchMiddleware): Promise<void>;
1194
1652
  /**
1195
1653
  * Regenerate document model subgraphs when models are dynamically loaded.
@@ -1225,6 +1683,13 @@ declare class GraphQLManager {
1225
1683
  * webhooks live under.
1226
1684
  */
1227
1685
  registerSubgraph(subgraph: SubgraphClass$1, supergraph?: string, core?: boolean, packageName?: string): Promise<ISubgraph$1 | undefined>;
1686
+ /**
1687
+ * Apply a package change: `packaged` holds every loaded package's subgraph
1688
+ * classes. Removals run before additions, so a name one package gives up
1689
+ * can be taken by another in the same change. Changes apply one at a time;
1690
+ * the router refresh is scheduled, not awaited.
1691
+ */
1692
+ applyPackageSubgraphs(packaged: ReadonlyMap<string, readonly SubgraphClass$1[]>, supergraph?: string): Promise<void>;
1228
1693
  /**
1229
1694
  * Tear down every subgraph instance registered from `packageName`:
1230
1695
  * disconnects the instances, unmounts their routes, disposes their
@@ -1251,104 +1716,78 @@ declare class GraphQLManager {
1251
1716
  private _updateRouter;
1252
1717
  getAdditionalContextFields: () => Record<string, any>;
1253
1718
  setAdditionalContextFields(fields: Record<string, any>): void;
1719
+ /** Replace the subgraphs of `supergraph` with `subgraphs`, under the same
1720
+ * name and type guards as any registration. */
1254
1721
  setSupergraph(supergraph: string, subgraphs: ISubgraph$1[]): Promise<void>;
1255
1722
  shutdown(): Promise<void>;
1256
1723
  }
1257
1724
  //#endregion
1725
+ //#region src/graphql/inspection/resolvers.d.ts
1726
+ /** How the subgraph decides for one request's caller. */
1727
+ interface InspectionCallerGate {
1728
+ /** One of the host's listed admins, whatever the policy. */
1729
+ isOperator(ctx: Context): boolean;
1730
+ /** The reactor client, reading as the caller. */
1731
+ readerFor(ctx: Context): InspectorDocumentReader;
1732
+ /** The host's own read check on one document; throws when refused. */
1733
+ assertCanRead(identifier: string, ctx: Context): Promise<string>;
1734
+ /** The host's own read check over a listing. */
1735
+ readableIds(ids: readonly string[], ctx: Context): Promise<Set<string>>;
1736
+ /** The document's id and the scopes the caller is served, or undefined. */
1737
+ servedDocument(identifier: string, branch: string | undefined, ctx: Context): Promise<{
1738
+ id: string;
1739
+ scopes: ReadonlySet<string>;
1740
+ } | undefined>;
1741
+ }
1742
+ type GqlOf<T, K extends keyof T> = T[K] extends {
1743
+ readonly gql: infer G extends string;
1744
+ } ? G : never;
1745
+ /** Exactly the GraphQL fields of the read rows of both op tables. */
1746
+ type InspectionReadField = GqlOf<typeof INSPECTOR_OPS, InspectorReadOpKey> | GqlOf<typeof SYNC_INSPECTION_OPS, SyncInspectionReadOpKey>;
1747
+ /** The read half of the inspection surface; no lever has a field here. */
1748
+ export declare function createInspectionResolvers(source: IReactorInspectionSource, sync: {
1749
+ list(): Remote[];
1750
+ }, gate: InspectionCallerGate): Record<string, unknown>;
1751
+ //#endregion
1752
+ //#region src/graphql/inspection/schema.d.ts
1753
+ export declare const inspectionTypeDefs: import("graphql").DocumentNode;
1754
+ //#endregion
1755
+ //#region src/graphql/inspection/subgraph.d.ts
1756
+ export declare function isListedAdmin(config: AuthorizationConfig, address: string | undefined): boolean;
1757
+ /** The read half of the reactor's inspection surface. */
1758
+ export declare class InspectionSubgraph extends BaseSubgraph {
1759
+ name: string;
1760
+ hasSubscriptions: boolean;
1761
+ typeDefs: DocumentNode;
1762
+ resolvers: Record<string, any>;
1763
+ constructor(args: SubgraphArgs);
1764
+ private callerGate;
1765
+ private readerFor;
1766
+ private servedDocument;
1767
+ }
1768
+ //#endregion
1258
1769
  //#region src/services/package-storage.d.ts
1259
- interface InstalledPackageInfo {
1770
+ export interface InstalledPackageInfo {
1260
1771
  name: string;
1261
1772
  version?: string;
1262
1773
  registryUrl: string;
1263
1774
  installedAt: Date;
1264
1775
  documentTypes: string[];
1265
1776
  }
1266
- interface IPackageStorage {
1777
+ export interface IPackageStorage {
1267
1778
  get(name: string): Promise<InstalledPackageInfo | undefined>;
1268
1779
  getAll(): Promise<InstalledPackageInfo[]>;
1269
1780
  set(name: string, info: InstalledPackageInfo): Promise<void>;
1270
1781
  delete(name: string): Promise<boolean>;
1271
1782
  has(name: string): Promise<boolean>;
1272
1783
  }
1273
- declare class InMemoryPackageStorage implements IPackageStorage {
1784
+ export declare class InMemoryPackageStorage implements IPackageStorage {
1274
1785
  private packages;
1275
- get(name: string): Promise<InstalledPackageInfo | undefined>;
1276
- getAll(): Promise<InstalledPackageInfo[]>;
1277
- set(name: string, info: InstalledPackageInfo): Promise<void>;
1278
- delete(name: string): Promise<boolean>;
1279
- has(name: string): Promise<boolean>;
1280
- }
1281
- //#endregion
1282
- //#region src/services/canonical-document-id.d.ts
1283
- /**
1284
- * Raised when a caller-supplied identifier cannot be resolved to a canonical
1285
- * document id. Carries no detail on purpose: resolution failures must not act
1286
- * as a document-existence oracle, so consumers map this to their generic
1287
- * fail-closed response.
1288
- */
1289
- declare class CanonicalDocumentIdResolutionError extends Error {
1290
- constructor();
1291
- }
1292
- type CanonicalDocumentIdResolver = (identifier: string) => Promise<CanonicalDocumentId>;
1293
- /**
1294
- * The sanctioned string-to-CanonicalDocumentId cast: both the GraphQL layer
1295
- * and server routes must resolve caller identifiers through this helper so
1296
- * decision and data layers always agree on the subject document.
1297
- */
1298
- declare function createCanonicalDocumentIdResolver(client: Pick<IReactorClient, "resolveIdOrSlug">): CanonicalDocumentIdResolver;
1299
- //#endregion
1300
- //#region src/services/attachment-access.service.d.ts
1301
- /**
1302
- * Whether the active Reactor composition hosts the attachment-reference
1303
- * projection. Reported by the client initializer: the built-in stack always
1304
- * registers it, while a caller-provided Reactor may lack the live
1305
- * registration capability. Consumers of reference evidence must fail closed
1306
- * when it is unavailable.
1307
- */
1308
- type AttachmentReferenceProjectionCapability = {
1309
- status: "available";
1310
- } | {
1311
- status: "unavailable";
1312
- reason: "live-read-model-registration-unsupported" | "in-process-reactor-module-unavailable" | "initializer-did-not-report";
1313
- };
1314
- /**
1315
- * Outcome of an attachment read authorization. `denied` intentionally covers
1316
- * both an unreadable document and an absent document/ref relationship so the
1317
- * route layer cannot leak which check failed. `projection-unavailable` means
1318
- * the reference index is not being maintained in this composition; it is
1319
- * returned before any document-authorization or reference lookup runs.
1320
- */
1321
- type AttachmentAccessResult = {
1322
- kind: "allowed";
1323
- documentId: CanonicalDocumentId;
1324
- ref: AttachmentRef;
1325
- } | {
1326
- kind: "denied";
1327
- } | {
1328
- kind: "projection-unavailable";
1329
- };
1330
- interface AttachmentAccessRequest {
1331
- documentId: string;
1332
- attachmentRef: string;
1333
- userAddress?: string;
1334
- }
1335
- interface IAttachmentAccessService {
1336
- canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
1337
- }
1338
- /**
1339
- * Composes document authorization with the projected document/ref
1340
- * relationship. Order is fixed: validate ref, resolve the canonical document
1341
- * id, check `canRead`, then check the reference index. A denied document
1342
- * never reaches the reference reader, and the facade never touches
1343
- * attachment metadata, storage backends, or presigners.
1344
- */
1345
- declare class AttachmentAccessService implements IAttachmentAccessService {
1346
- private readonly resolveCanonicalId;
1347
- private readonly authorization;
1348
- private readonly references;
1349
- private readonly projection;
1350
- constructor(resolveCanonicalId: CanonicalDocumentIdResolver, authorization: IAuthorizationService, references: IAttachmentReferenceReader, projection: AttachmentReferenceProjectionCapability);
1351
- canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
1786
+ get(name: string): Promise<InstalledPackageInfo | undefined>;
1787
+ getAll(): Promise<InstalledPackageInfo[]>;
1788
+ set(name: string, info: InstalledPackageInfo): Promise<void>;
1789
+ delete(name: string): Promise<boolean>;
1790
+ has(name: string): Promise<boolean>;
1352
1791
  }
1353
1792
  //#endregion
1354
1793
  //#region src/types.d.ts
@@ -1356,24 +1795,45 @@ declare class AttachmentAccessService implements IAttachmentAccessService {
1356
1795
  * Module hosts pass to processor factories: the reactor-level module plus the
1357
1796
  * attachment client, which shared and reactor cannot name.
1358
1797
  */
1359
- interface IProcessorHostModule extends IReactorProcessorHostModuleBase {
1798
+ export interface IProcessorHostModule extends IReactorProcessorHostModuleBase {
1360
1799
  attachments: IAttachmentClient;
1361
1800
  }
1362
1801
  /** @deprecated Use `IProcessorHostModule`. */
1363
- type IReactorProcessorHostModule = IProcessorHostModule;
1364
- type ReadinessGate = {
1802
+ export type IReactorProcessorHostModule = IProcessorHostModule;
1803
+ export type ReadinessGate = {
1365
1804
  isReady: () => boolean;
1366
1805
  markReady: () => void;
1367
1806
  };
1368
- type API = {
1369
- httpAdapter: IHttpAdapter; /** Hands each package a namespaced slice of the HTTP surface. */
1807
+ export type API = {
1808
+ httpAdapter: IHttpAdapter;
1809
+ /** Hands each package a namespaced slice of the HTTP surface. */
1370
1810
  httpRoutes: HttpRouteService;
1371
1811
  graphqlManager: GraphQLManager$1;
1372
1812
  packages: IPackageManager;
1373
1813
  attachments: AttachmentBuildResult;
1374
- attachmentReferenceIndex: AttachmentReferenceIndexBuildResult; /** Document-authorized attachment read decisions; see AttachmentAccessService. */
1814
+ attachmentReferenceIndex: AttachmentReferenceIndexBuildResult;
1815
+ /** Document-authorized attachment read decisions; see AttachmentAccessService. */
1375
1816
  attachmentAccess: IAttachmentAccessService;
1817
+ /** Caller-bound attachment clients for subgraphs the host constructs itself. */
1818
+ attachmentClientProvider: IAttachmentClientProvider;
1376
1819
  authService: AuthService | undefined;
1820
+ /**
1821
+ * Whether this deployment refuses anonymous callers
1822
+ * (`REQUIRE_AUTHENTICATED_CALLER`). Carried here because routes mounted
1823
+ * straight on the HTTP adapter never pass the GraphQL fetch chain, so its
1824
+ * require-auth middleware cannot reach them: a host-composed route reads the
1825
+ * resolved value from the API rather than the environment, so one variable
1826
+ * cannot end up half applied.
1827
+ */
1828
+ requireAuthenticatedCaller: boolean;
1829
+ /** The service the subgraphs decide with, for a component the host composes
1830
+ * after boot: it must authorize with this one, not one of its own. */
1831
+ authorizationService: IAuthorizationService;
1832
+ /** The read-model relational store, for the same host-composed component:
1833
+ * its tables belong in this database and nothing else hands one over. */
1834
+ relationalDb: IRelationalDb$1;
1835
+ /** Present when the host serves inspection; `facts` takes late-bound facts. */
1836
+ inspection?: IReactorInspectionSource;
1377
1837
  /**
1378
1838
  * Releases resources owned by the API: shuts down the GraphQL gateway,
1379
1839
  * closes WebSocket and HTTP servers, destroys knex pools, and closes any
@@ -1383,25 +1843,82 @@ type API = {
1383
1843
  */
1384
1844
  dispose: () => Promise<void>;
1385
1845
  };
1386
- type ReactorModule = {
1846
+ export type ReactorModule = {
1387
1847
  analyticsStore: IAnalyticsStore;
1388
1848
  relationalDb: IRelationalDb$1;
1389
1849
  };
1390
1850
  /** @deprecated Use `ProcessorFactory`. */
1391
- type ProcessorDriveFactory = ProcessorFactory;
1851
+ export type ProcessorDriveFactory = ProcessorFactory;
1392
1852
  /** Builds a per-drive factory from the host module (e.g. vetra `processorFactory`). */
1393
- type ProcessorFactoryBuilder = ProcessorFactoryBuilder$1<IProcessorHostModule>;
1853
+ export type ProcessorFactoryBuilder = ProcessorFactoryBuilder$1<IProcessorHostModule>;
1394
1854
  /** Multiple initializers per package name (e.g. Switchboard `processors` option). */
1395
- type Processor = ProcessorFactoryBuilder[];
1855
+ export type Processor = ProcessorFactoryBuilder[];
1856
+ //#endregion
1857
+ //#region src/packages/registry-cache.d.ts
1858
+ /** Entry files a registry package's node build is served from, CDN-relative. */
1859
+ declare const PACKAGE_ENTRIES: {
1860
+ readonly documentModels: "node/document-models/index.mjs";
1861
+ readonly subgraphs: "node/subgraphs/index.mjs";
1862
+ readonly processors: "node/processors/index.mjs";
1863
+ };
1864
+ type PackageEntryKind = keyof typeof PACKAGE_ENTRIES;
1865
+ type CachedRegistryPackage = {
1866
+ name: string;
1867
+ version: string;
1868
+ dir: string;
1869
+ /** Absolute entry files inside `dir`, for the entries the package serves. */
1870
+ entries: Partial<Record<PackageEntryKind, string>>;
1871
+ source: "cache" | "download";
1872
+ /** External packages the package manifest lists, name -> version. */
1873
+ externalDependencies: Record<string, string>;
1874
+ /** The external packages that resolve from neither the project nor reactor-api. */
1875
+ missingExternalDependencies: string[];
1876
+ };
1877
+ type RegistryPackageCacheOptions = {
1878
+ registryUrl: string;
1879
+ cacheDir?: string;
1880
+ logger?: ILogger;
1881
+ fetchTimeoutMs?: number;
1882
+ };
1883
+ declare class RegistryPackageCache {
1884
+ readonly cacheDir: string;
1885
+ private readonly registryUrl;
1886
+ private readonly logger;
1887
+ private readonly fetchTimeoutMs;
1888
+ private readonly inFlight;
1889
+ private readonly verified;
1890
+ constructor(options: RegistryPackageCacheOptions);
1891
+ /** Base URL every file of `name@version` is fetched under. */
1892
+ baseUrl(name: string, version: string): string;
1893
+ entryDir(name: string, version: string): string;
1894
+ /** Complete cached versions of `name`, newest-agnostic. */
1895
+ cachedVersions(name: string): Promise<string[]>;
1896
+ ensurePackage(name: string, version: string): Promise<CachedRegistryPackage>;
1897
+ private resolveEntry;
1898
+ /** The manifest when every listed file is present and hashes to it. */
1899
+ private verify;
1900
+ private discard;
1901
+ private fill;
1902
+ private download;
1903
+ private dependenciesOf;
1904
+ private fetchBounded;
1905
+ private outsideUrl;
1906
+ /** Whether `specifier` resolves from the project or from reactor-api. */
1907
+ resolvesForCachedPackages(specifier: string, pkg: string): boolean;
1908
+ private linkBareImports;
1909
+ }
1396
1910
  //#endregion
1397
1911
  //#region src/packages/http-loader.d.ts
1398
- interface HttpPackageLoaderOptions {
1912
+ export interface HttpPackageLoaderOptions {
1399
1913
  registryUrl: string;
1914
+ /** Where document-model graphs are cached; `<cwd>/.ph/registry-packages` by default. */
1915
+ cacheDir?: string;
1400
1916
  }
1401
- interface HttpPackageLoaderLogger {
1917
+ export interface HttpPackageLoaderLogger {
1402
1918
  info: (msg: string) => void;
1403
1919
  error: (msg: string, err: unknown) => void;
1404
1920
  }
1921
+ export declare function piecesBaseUrl(registryUrl: string, packageName: string, version: string): string;
1405
1922
  type SubgraphsExport = Record<string, SubgraphClass$1>;
1406
1923
  /**
1407
1924
  * Extract subgraph classes from the imported subgraphs/index.mjs module shape.
@@ -1409,11 +1926,13 @@ type SubgraphsExport = Record<string, SubgraphClass$1>;
1409
1926
  * The published bundle uses `export * as Foo from "./file"`, which Node turns
1410
1927
  * into `{ Foo: <namespace>, … }`. The inner namespace's keys come from the
1411
1928
  * source file's named exports — typically `Subgraph` / `default` / the class
1412
- * name itself — so the shape varies. Flatten one level and keep callables.
1929
+ * name itself — so the shape varies.
1413
1930
  *
1414
- * Exported for direct unit testing against synthetic module shapes.
1931
+ * Delegates to the unified acceptance rule every package loader shares
1932
+ * (`extractSubgraphs`), kept as an export because it is part of the package's
1933
+ * public API and is unit-tested directly against synthetic module shapes.
1415
1934
  */
1416
- declare function extractSubgraphsFromModule(module: Record<string, SubgraphsExport>): SubgraphClass$1[];
1935
+ export declare function extractSubgraphsFromModule(module: Record<string, SubgraphsExport>): SubgraphClass$1[];
1417
1936
  /**
1418
1937
  * Loads document models, subgraphs, and processors from an HTTP registry.
1419
1938
  * Uses Node.js module loader hooks to import directly from HTTP URLs.
@@ -1422,11 +1941,14 @@ declare function extractSubgraphsFromModule(module: Record<string, SubgraphsExpo
1422
1941
  * import { register } from "node:module";
1423
1942
  * register("@powerhousedao/reactor-api/https-hooks", import.meta.url);
1424
1943
  */
1425
- declare class HttpPackageLoader implements IPackageLoader {
1944
+ export declare class HttpPackageLoader implements IPackageLoader {
1426
1945
  private readonly registryUrl;
1427
1946
  private readonly logger;
1428
1947
  readonly name = "HttpPackageLoader";
1429
1948
  readonly documentModelLoader: HttpDocumentModelLoader;
1949
+ readonly cache: RegistryPackageCache;
1950
+ private readonly versions;
1951
+ private readonly reportedExternal;
1430
1952
  constructor(options: HttpPackageLoaderOptions);
1431
1953
  /**
1432
1954
  * Load document models from a package in the HTTP registry.
@@ -1436,33 +1958,43 @@ declare class HttpPackageLoader implements IPackageLoader {
1436
1958
  * Parse a package specifier like "@scope/pkg@tag" into name and optional tag.
1437
1959
  */
1438
1960
  private parsePackageSpec;
1961
+ resolveVersion(packageSpec: string): Promise<string | undefined>;
1962
+ private lookUpVersion;
1963
+ /** Caches the pinned version of `packageSpec` on disk. */
1964
+ cachePackage(packageSpec: string): Promise<CachedRegistryPackage>;
1965
+ /** One entry module of the package, plus the cached file it came from. */
1966
+ importEntry(packageSpec: string, kind: PackageEntryKind): Promise<{
1967
+ module: Record<string, unknown>;
1968
+ filePath?: string;
1969
+ }>;
1970
+ private assertExternalDependencies;
1971
+ importDocumentModels(packageSpec: string): Promise<{
1972
+ module: Record<string, unknown>;
1973
+ filePath?: string;
1974
+ }>;
1439
1975
  loadDocumentModels(packageSpec: string): Promise<DocumentModelModule[]>;
1440
1976
  loadUpgradeManifests(packageSpec: string): Promise<UpgradeManifest<readonly number[]>[]>;
1441
1977
  loadSubgraphs(packageSpec: string): Promise<SubgraphClass$1[]>;
1442
1978
  loadProcessors(packageSpec: string): Promise<ProcessorFactoryBuilder | null>;
1979
+ loadPieces(packageSpec: string): Promise<PackagePieceEntry[]>;
1443
1980
  /**
1444
1981
  * Load document models from multiple packages.
1445
1982
  * Continues loading even if some packages fail.
1446
1983
  */
1447
1984
  loadPackages(packageNames: string[], logger?: HttpPackageLoaderLogger): Promise<DocumentModelModule[]>;
1448
- private isValidPackageName;
1985
+ packageVersion(packageSpec: string): Promise<string | undefined>;
1449
1986
  }
1450
- /**
1451
- * Returns live modules (host-only sources): dynamically loaded models are
1452
- * registered on the host registry but never reach executor worker threads.
1453
- * Making them worker-executable means returning an importable source here
1454
- * (the CDN URL as a package specifier, given process-wide https hooks).
1455
- */
1456
- declare class HttpDocumentModelLoader implements IDocumentModelLoader {
1987
+ export declare class HttpDocumentModelLoader implements IDocumentModelLoader {
1457
1988
  private readonly loader;
1458
1989
  private readonly logger;
1459
1990
  private readonly documentTypeCache;
1460
1991
  private readonly packageModulesCache;
1992
+ private readonly packageFileCache;
1461
1993
  private onModelLoaded?;
1462
1994
  constructor(loader: HttpPackageLoader);
1463
1995
  setOnModelLoaded(callback: (model: DocumentModelModule) => void): void;
1464
1996
  clearCache(): void;
1465
- load(documentType: string): Promise<DocumentModelModule>;
1997
+ load(documentType: string): Promise<DocumentModelSource>;
1466
1998
  private findPackageByDocumentType;
1467
1999
  getLoadedPackages(): string[];
1468
2000
  getPackageModules(packageName: string): DocumentModelModule[] | undefined;
@@ -1470,18 +2002,18 @@ declare class HttpDocumentModelLoader implements IDocumentModelLoader {
1470
2002
  }
1471
2003
  //#endregion
1472
2004
  //#region src/services/package-management.service.d.ts
1473
- interface InstallPackageResult {
2005
+ export interface InstallPackageResult {
1474
2006
  package: InstalledPackageInfo;
1475
2007
  documentModelsLoaded: number;
1476
2008
  }
1477
- interface PackageManagementServiceOptions {
2009
+ export interface PackageManagementServiceOptions {
1478
2010
  storage?: IPackageStorage;
1479
2011
  defaultRegistryUrl?: string;
1480
2012
  httpLoader?: HttpPackageLoader;
1481
2013
  documentModelRegistry?: IDocumentModelRegistry;
1482
2014
  packageManager?: IPackageManager;
1483
2015
  }
1484
- declare class PackageManagementService {
2016
+ export declare class PackageManagementService {
1485
2017
  private readonly storage;
1486
2018
  private readonly defaultRegistryUrl?;
1487
2019
  private readonly httpLoader?;
@@ -1504,13 +2036,13 @@ declare class PackageManagementService {
1504
2036
  interface PackagesSubgraphArgs extends SubgraphArgs {
1505
2037
  packageManagementService: PackageManagementService;
1506
2038
  }
1507
- declare class PackagesSubgraph extends BaseSubgraph {
2039
+ export declare class PackagesSubgraph extends BaseSubgraph {
1508
2040
  private logger;
1509
2041
  private packageManagementService;
1510
2042
  constructor(args: PackagesSubgraphArgs);
1511
2043
  name: string;
1512
2044
  hasSubscriptions: boolean;
1513
- typeDefs: graphql.DocumentNode;
2045
+ typeDefs: import("graphql").DocumentNode;
1514
2046
  resolvers: {
1515
2047
  Query: {
1516
2048
  Packages: () => {};
@@ -1566,7 +2098,7 @@ declare class PackagesSubgraph extends BaseSubgraph {
1566
2098
  * `{ document, variables, headers? }` with `variables` and `headers`
1567
2099
  * already JSON-stringified.
1568
2100
  */
1569
- interface ExplorerUrlState {
2101
+ export interface ExplorerUrlState {
1570
2102
  /** The GraphQL query to prefill in GraphiQL. */
1571
2103
  query: string;
1572
2104
  /** JSON-stringified variables, as stored in the payload. */
@@ -1578,24 +2110,24 @@ interface ExplorerUrlState {
1578
2110
  * Decodes an `explorerURLState` URL parameter. Returns `null` for anything
1579
2111
  * that is not a valid lz-compressed payload with a non-empty `document`.
1580
2112
  */
1581
- declare function decodeExplorerUrlState(encoded: string): ExplorerUrlState | null;
1582
- declare function renderGraphqlPlayground(url: string, query?: string, headers?: Record<string, string>, variables?: string): string;
2113
+ export declare function decodeExplorerUrlState(encoded: string): ExplorerUrlState | null;
2114
+ export declare function renderGraphqlPlayground(url: string, query?: string, headers?: Record<string, string>, variables?: string): string;
1583
2115
  //#endregion
1584
2116
  //#region src/graphql/reactor/gen/graphql.d.ts
1585
- type Maybe<T> = T | null | undefined;
1586
- type InputMaybe<T> = T | null | undefined;
1587
- type Exact<T extends {
2117
+ export type Maybe<T> = T | null | undefined;
2118
+ export type InputMaybe<T> = T | null | undefined;
2119
+ export type Exact<T extends {
1588
2120
  [key: string]: unknown;
1589
- }> = { [K in keyof T]: T[K] };
1590
- type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
1591
- type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
1592
- type MakeEmpty<T extends {
2121
+ }> = { [K in keyof T]: T[K]; };
2122
+ export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]>; };
2123
+ export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]>; };
2124
+ export type MakeEmpty<T extends {
1593
2125
  [key: string]: unknown;
1594
- }, K extends keyof T> = { [_ in K]?: never };
1595
- type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never };
1596
- type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
2126
+ }, K extends keyof T> = { [_ in K]?: never; };
2127
+ export type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never; };
2128
+ export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]>; };
1597
2129
  /** All built-in and custom scalars, mapped to their actual values */
1598
- type Scalars = {
2130
+ export type Scalars = {
1599
2131
  ID: {
1600
2132
  input: string;
1601
2133
  output: string;
@@ -1625,7 +2157,7 @@ type Scalars = {
1625
2157
  output: NonNullable<unknown>;
1626
2158
  };
1627
2159
  };
1628
- type Action = {
2160
+ export type Action = {
1629
2161
  readonly context?: Maybe<ActionContext>;
1630
2162
  readonly id: Scalars["String"]["output"];
1631
2163
  readonly input: Scalars["JSONObject"]["output"];
@@ -1640,12 +2172,12 @@ type Action = {
1640
2172
  * filled-in form carries that form's input. Omitting it predicts the verdict an
1641
2173
  * empty input earns, not the verdict the filled-in form will get.
1642
2174
  */
1643
- type ActionCandidateInput = {
2175
+ export type ActionCandidateInput = {
1644
2176
  readonly input?: InputMaybe<Scalars["JSONObject"]["input"]>;
1645
2177
  readonly scope: Scalars["String"]["input"];
1646
2178
  readonly type: Scalars["String"]["input"];
1647
2179
  };
1648
- type ActionContext = {
2180
+ export type ActionContext = {
1649
2181
  readonly signer?: Maybe<ReactorSigner>;
1650
2182
  };
1651
2183
  /**
@@ -1660,9 +2192,12 @@ type ActionContext = {
1660
2192
  * against. They are recorded rather than enforced; a signature is verified from
1661
2193
  * the params carried in its own tuple, which do not include them.
1662
2194
  */
1663
- type ActionContextInput = {
1664
- /** Covers replay of an operation that would otherwise be a no-op. */readonly nonce?: InputMaybe<Scalars["String"]["input"]>; /** The hash of the state the action applies to. */
1665
- readonly prevOpHash?: InputMaybe<Scalars["String"]["input"]>; /** The index of the last operation in the scope the action applies to. */
2195
+ export type ActionContextInput = {
2196
+ /** Covers replay of an operation that would otherwise be a no-op. */
2197
+ readonly nonce?: InputMaybe<Scalars["String"]["input"]>;
2198
+ /** The hash of the state the action applies to. */
2199
+ readonly prevOpHash?: InputMaybe<Scalars["String"]["input"]>;
2200
+ /** The index of the last operation in the scope the action applies to. */
1666
2201
  readonly prevOpIndex?: InputMaybe<Scalars["Int"]["input"]>;
1667
2202
  readonly signer?: InputMaybe<ReactorSignerInput>;
1668
2203
  };
@@ -1670,7 +2205,7 @@ type ActionContextInput = {
1670
2205
  * One candidate's predicted verdict. `reason` carries the refusal a DENY is
1671
2206
  * recorded with, and is null on an ALLOW.
1672
2207
  */
1673
- type ActionEvaluation = {
2208
+ export type ActionEvaluation = {
1674
2209
  readonly decision: AuthDecision;
1675
2210
  readonly reason?: Maybe<Scalars["String"]["output"]>;
1676
2211
  };
@@ -1683,14 +2218,14 @@ type ActionEvaluation = {
1683
2218
  * another. Over no candidates every aggregate is false: nothing is allowed and
1684
2219
  * nothing is denied.
1685
2220
  */
1686
- type ActionEvaluations = {
2221
+ export type ActionEvaluations = {
1687
2222
  readonly allAllowed: Scalars["Boolean"]["output"];
1688
2223
  readonly allDenied: Scalars["Boolean"]["output"];
1689
2224
  readonly anyAllowed: Scalars["Boolean"]["output"];
1690
2225
  readonly anyDenied: Scalars["Boolean"]["output"];
1691
2226
  readonly evaluations: ReadonlyArray<ActionEvaluation>;
1692
2227
  };
1693
- type ActionInput = {
2228
+ export type ActionInput = {
1694
2229
  readonly context?: InputMaybe<ActionContextInput>;
1695
2230
  readonly id: Scalars["String"]["input"];
1696
2231
  readonly input: Scalars["JSONObject"]["input"];
@@ -1698,17 +2233,56 @@ type ActionInput = {
1698
2233
  readonly timestampUtcMs: Scalars["String"]["input"];
1699
2234
  readonly type: Scalars["String"]["input"];
1700
2235
  };
1701
- declare enum AuthDecision {
2236
+ export declare enum AuthDecision {
1702
2237
  Allow = "ALLOW",
1703
2238
  Deny = "DENY"
1704
2239
  }
1705
- type ChannelMeta = {
2240
+ /**
2241
+ * The outcome of a batch mutation, one entry per job the request named. The wire
2242
+ * shape of `BatchExecutionResult` (`{ jobs }`), keyed on each entry by the plan
2243
+ * key rather than by position so the client can rebuild the record. The batch is
2244
+ * not atomic: each job commits on its own and a failed job releases its
2245
+ * dependents, so each entry's status says what happened to that job, and
2246
+ * re-submitting re-applies the jobs that succeeded.
2247
+ */
2248
+ export type BatchExecutionResult = {
2249
+ readonly jobs: ReadonlyArray<BatchJobResult>;
2250
+ };
2251
+ /**
2252
+ * One job's outcome within a batch, pairing the plan key the caller gave with the
2253
+ * job that applied it. Mirrors one entry of the `Record<string, JobInfo>` that
2254
+ * `IReactor.executeBatch` returns (packages/reactor/src/core/types.ts).
2255
+ */
2256
+ export type BatchJobResult = {
2257
+ readonly job: JobInfo;
2258
+ readonly key: Scalars["String"]["output"];
2259
+ };
2260
+ export type ChannelMeta = {
1706
2261
  readonly id: Scalars["String"]["output"];
1707
2262
  };
1708
- type ChannelMetaInput = {
2263
+ export type ChannelMetaInput = {
1709
2264
  readonly id: Scalars["String"]["input"];
1710
2265
  };
1711
- type DeadLetterInfo = {
2266
+ export type ConsistencyCoordinate = {
2267
+ readonly branch: Scalars["String"]["output"];
2268
+ readonly documentId: Scalars["String"]["output"];
2269
+ readonly operationIndex: Scalars["Int"]["output"];
2270
+ readonly scope: Scalars["String"]["output"];
2271
+ };
2272
+ /**
2273
+ * The write positions a job reached, for read-after-write. Only meaningful once
2274
+ * the job has completed.
2275
+ */
2276
+ export type ConsistencyToken = {
2277
+ readonly coordinates: ReadonlyArray<ConsistencyCoordinate>;
2278
+ readonly createdAtUtcIso: Scalars["String"]["output"];
2279
+ readonly version: Scalars["Int"]["output"];
2280
+ };
2281
+ export type CreateDefaults = {
2282
+ readonly protocolVersions: Scalars["JSONObject"]["output"];
2283
+ readonly signaturePolicy: Scalars["String"]["output"];
2284
+ };
2285
+ export type DeadLetterInfo = {
1712
2286
  readonly branch: Scalars["String"]["output"];
1713
2287
  readonly documentId: Scalars["String"]["output"];
1714
2288
  readonly error: Scalars["String"]["output"];
@@ -1722,16 +2296,16 @@ type DeadLetterInfo = {
1722
2296
  readonly operationCount: Scalars["Int"]["output"];
1723
2297
  readonly scopes: ReadonlyArray<Scalars["String"]["output"]>;
1724
2298
  };
1725
- type DocumentChangeContext = {
2299
+ export type DocumentChangeContext = {
1726
2300
  readonly childId?: Maybe<Scalars["String"]["output"]>;
1727
2301
  readonly parentId?: Maybe<Scalars["String"]["output"]>;
1728
2302
  };
1729
- type DocumentChangeEvent = {
2303
+ export type DocumentChangeEvent = {
1730
2304
  readonly context?: Maybe<DocumentChangeContext>;
1731
2305
  readonly documents: ReadonlyArray<PhDocument>;
1732
2306
  readonly type: DocumentChangeType;
1733
2307
  };
1734
- declare enum DocumentChangeType {
2308
+ export declare enum DocumentChangeType {
1735
2309
  ChildAdded = "CHILD_ADDED",
1736
2310
  ChildRemoved = "CHILD_REMOVED",
1737
2311
  Created = "CREATED",
@@ -1740,21 +2314,20 @@ declare enum DocumentChangeType {
1740
2314
  ParentRemoved = "PARENT_REMOVED",
1741
2315
  Updated = "UPDATED"
1742
2316
  }
1743
- type DocumentModelGlobalState = {
2317
+ export type DocumentModelGlobalState = {
1744
2318
  readonly id: Scalars["String"]["output"];
1745
2319
  readonly name: Scalars["String"]["output"];
1746
2320
  readonly namespace?: Maybe<Scalars["String"]["output"]>;
1747
2321
  readonly specification: Scalars["JSONObject"]["output"];
1748
2322
  readonly version?: Maybe<Scalars["String"]["output"]>;
1749
2323
  };
1750
- type DocumentModelResultPage = {
2324
+ export type DocumentModelResultPage = {
1751
2325
  readonly cursor?: Maybe<Scalars["String"]["output"]>;
1752
2326
  readonly hasNextPage: Scalars["Boolean"]["output"];
1753
2327
  readonly hasPreviousPage: Scalars["Boolean"]["output"];
1754
2328
  readonly items: ReadonlyArray<DocumentModelGlobalState>;
1755
- readonly totalCount: Scalars["Int"]["output"];
1756
2329
  };
1757
- type DocumentOperationsFilterInput = {
2330
+ export type DocumentOperationsFilterInput = {
1758
2331
  readonly actionTypes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
1759
2332
  readonly branch?: InputMaybe<Scalars["String"]["input"]>;
1760
2333
  readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
@@ -1762,21 +2335,75 @@ type DocumentOperationsFilterInput = {
1762
2335
  readonly timestampFrom?: InputMaybe<Scalars["String"]["input"]>;
1763
2336
  readonly timestampTo?: InputMaybe<Scalars["String"]["input"]>;
1764
2337
  };
1765
- type DocumentWithChildren = {
2338
+ export type DocumentRelationship = {
2339
+ readonly createdAt: Scalars["DateTime"]["output"];
2340
+ readonly metadata?: Maybe<Scalars["JSONObject"]["output"]>;
2341
+ readonly relationshipType: Scalars["String"]["output"];
2342
+ readonly sourceId: Scalars["String"]["output"];
2343
+ readonly targetId: Scalars["String"]["output"];
2344
+ readonly updatedAt: Scalars["DateTime"]["output"];
2345
+ };
2346
+ export type DocumentRelationshipResultPage = {
2347
+ readonly cursor?: Maybe<Scalars["String"]["output"]>;
2348
+ readonly hasNextPage: Scalars["Boolean"]["output"];
2349
+ readonly hasPreviousPage: Scalars["Boolean"]["output"];
2350
+ readonly items: ReadonlyArray<DocumentRelationship>;
2351
+ };
2352
+ export type DocumentWithChildren = {
1766
2353
  readonly childIds: ReadonlyArray<Scalars["String"]["output"]>;
1767
2354
  readonly document: PhDocument;
1768
2355
  };
1769
- type JobChangeEvent = {
2356
+ /**
2357
+ * One mutation job of a batch, mirroring the reactor's `ExecutionJobPlan`
2358
+ * (packages/reactor/src/core/types.ts). The batch runs its jobs in dependency
2359
+ * order only, not atomically: each job commits on its own with no batch rollback,
2360
+ * and a failed job still releases its dependents.
2361
+ *
2362
+ * `documentIdOrSlug` is the document the job's actions apply to -- an id that does
2363
+ * not yet exist when the job's actions create it. `actions` are coerced against
2364
+ * `ActionInput` and passed through exactly as `execute` does, so a client-signed
2365
+ * action keeps its signature. `scope` is the single scope every action in the job
2366
+ * shares, and `dependsOn` names the plan keys this job is ordered after. `branch`
2367
+ * defaults to `main`.
2368
+ */
2369
+ export type ExecutionJobInput = {
2370
+ readonly actions: ReadonlyArray<ActionInput>;
2371
+ readonly branch?: InputMaybe<Scalars["String"]["input"]>;
2372
+ readonly dependsOn: ReadonlyArray<Scalars["String"]["input"]>;
2373
+ readonly documentIdOrSlug: Scalars["String"]["input"];
2374
+ readonly key: Scalars["String"]["input"];
2375
+ readonly scope: Scalars["String"]["input"];
2376
+ };
2377
+ /** The batch a job was submitted in. */
2378
+ export type JobBatchMeta = {
2379
+ readonly batchId: Scalars["String"]["output"];
2380
+ readonly batchJobIds: ReadonlyArray<Scalars["String"]["output"]>;
2381
+ };
2382
+ export type JobChangeEvent = {
1770
2383
  readonly error?: Maybe<Scalars["String"]["output"]>;
1771
2384
  readonly jobId: Scalars["String"]["output"];
1772
- readonly result: Scalars["JSONObject"]["output"];
2385
+ /**
2386
+ * What the job produced, once it has produced anything. Nullable for the same
2387
+ * reason as `JobInfo.result`: a job that has not written yet has produced
2388
+ * nothing, and an empty object would claim otherwise.
2389
+ */
2390
+ readonly result?: Maybe<Scalars["JSONObject"]["output"]>;
1773
2391
  readonly status: Scalars["String"]["output"];
1774
2392
  };
1775
- type JobInfo = {
2393
+ export type JobInfo = {
1776
2394
  readonly completedAt?: Maybe<Scalars["DateTime"]["output"]>;
2395
+ readonly consistencyToken: ConsistencyToken;
1777
2396
  readonly createdAt: Scalars["DateTime"]["output"];
2397
+ /**
2398
+ * The document the job operates on. Empty for a job this server does not know,
2399
+ * which then comes back FAILED with "Job not found".
2400
+ */
2401
+ readonly documentId: Scalars["String"]["output"];
1778
2402
  readonly error?: Maybe<Scalars["String"]["output"]>;
2403
+ /** The error's class name, such as `DocumentAlreadyExistsError`, when it failed. */
2404
+ readonly errorName?: Maybe<Scalars["String"]["output"]>;
1779
2405
  readonly id: Scalars["String"]["output"];
2406
+ readonly meta: JobBatchMeta;
1780
2407
  /**
1781
2408
  * What the job produced, once it has produced anything. Null until then, which
1782
2409
  * is the state every job is in when it is handed back from a submission.
@@ -1784,11 +2411,11 @@ type JobInfo = {
1784
2411
  readonly result?: Maybe<Scalars["JSONObject"]["output"]>;
1785
2412
  readonly status: Scalars["String"]["output"];
1786
2413
  };
1787
- type MoveRelationshipResult = {
2414
+ export type MoveRelationshipResult = {
1788
2415
  readonly source: PhDocument;
1789
2416
  readonly target: PhDocument;
1790
2417
  };
1791
- type Mutation = {
2418
+ export type Mutation = {
1792
2419
  readonly addRelationship: PhDocument;
1793
2420
  readonly createDocument: PhDocument;
1794
2421
  readonly createEmptyDocument: PhDocument;
@@ -1816,101 +2443,154 @@ type Mutation = {
1816
2443
  * ask for; `result` is null until the job produces one.
1817
2444
  */
1818
2445
  readonly executeAsync: JobInfo;
1819
- readonly moveRelationship: MoveRelationshipResult; /** @deprecated Use execute. Actions here are untyped, so a malformed one is refused by a hand-written check rather than by the schema, and `view.scopes` is accepted but ignored. */
1820
- readonly mutateDocument: PhDocument; /** @deprecated Use executeAsync, which is typed and returns the job rather than only its id. */
2446
+ /**
2447
+ * Applies multiple mutation jobs in dependency order and waits for all of them,
2448
+ * the wire form of `IReactorClient.executeBatch`. Each job's actions are coerced
2449
+ * against `ActionInput` exactly as `execute` is, so client-signed actions pass
2450
+ * through unchanged, and `dependsOn` orders the jobs. It is synchronous: the jobs
2451
+ * are applied and awaited before the result returns, so every returned `JobInfo`
2452
+ * is a completed one rather than the pending receipt the in-process reactor hands
2453
+ * back. A batch is ordering, not a transaction: each job commits on its own, and
2454
+ * a failed job still releases the jobs that depend on it, so any job, before or
2455
+ * after a failure, may have committed. A failed job is therefore returned as a
2456
+ * FAILED entry with its `error` and `errorName`, beside the final state of every
2457
+ * other job, rather than failing the mutation. The mutation itself fails only
2458
+ * when no job state can be reported.
2459
+ *
2460
+ * A job carrying `CREATE_DOCUMENT` must be the batch's only job, with the create
2461
+ * as its first action naming the job's document. Its other actions may only be
2462
+ * an `UPGRADE_DOCUMENT` of the new document and `ADD_RELATIONSHIP`s targeting
2463
+ * it. It is authorized like `createDocument`: write on every source of those
2464
+ * relationships, or the right to create when there is none.
2465
+ */
2466
+ readonly executeBatch: BatchExecutionResult;
2467
+ readonly moveRelationship: MoveRelationshipResult;
2468
+ /** @deprecated Use execute. Actions here are untyped, so a malformed one is refused by a hand-written check rather than by the schema, and `view.scopes` is accepted but ignored. */
2469
+ readonly mutateDocument: PhDocument;
2470
+ /** @deprecated Use executeAsync, which is typed and returns the job rather than only its id. */
1821
2471
  readonly mutateDocumentAsync: Scalars["String"]["output"];
1822
2472
  readonly pushSyncEnvelopes: Scalars["Boolean"]["output"];
1823
2473
  readonly removeRelationship: PhDocument;
1824
2474
  readonly renameDocument: PhDocument;
1825
2475
  readonly setPreferredEditor: PhDocument;
1826
2476
  readonly touchChannel: TouchChannelResult;
2477
+ readonly updateRelationship: PhDocument;
1827
2478
  };
1828
- type MutationAddRelationshipArgs = {
2479
+ export type MutationAddRelationshipArgs = {
1829
2480
  branch?: InputMaybe<Scalars["String"]["input"]>;
2481
+ metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
1830
2482
  relationshipType: Scalars["String"]["input"];
1831
- sourceIdentifier: Scalars["String"]["input"];
1832
- targetIdentifier: Scalars["String"]["input"];
2483
+ sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2484
+ sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2485
+ targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2486
+ targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
1833
2487
  };
1834
- type MutationCreateDocumentArgs = {
2488
+ export type MutationCreateDocumentArgs = {
1835
2489
  document: Scalars["JSONObject"]["input"];
2490
+ parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
1836
2491
  parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
1837
2492
  };
1838
- type MutationCreateEmptyDocumentArgs = {
2493
+ export type MutationCreateEmptyDocumentArgs = {
1839
2494
  documentType: Scalars["String"]["input"];
2495
+ parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
1840
2496
  parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
1841
2497
  };
1842
- type MutationDeleteDocumentArgs = {
1843
- identifier: Scalars["String"]["input"];
2498
+ export type MutationDeleteDocumentArgs = {
2499
+ idOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2500
+ identifier?: InputMaybe<Scalars["String"]["input"]>;
1844
2501
  propagate?: InputMaybe<PropagationMode>;
1845
2502
  };
1846
- type MutationDeleteDocumentsArgs = {
1847
- identifiers: ReadonlyArray<Scalars["String"]["input"]>;
2503
+ export type MutationDeleteDocumentsArgs = {
2504
+ identifiers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
2505
+ idsOrSlugs?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
1848
2506
  propagate?: InputMaybe<PropagationMode>;
1849
2507
  };
1850
- type MutationExecuteArgs = {
2508
+ export type MutationExecuteArgs = {
1851
2509
  actions: ReadonlyArray<ActionInput>;
1852
2510
  branch?: InputMaybe<Scalars["String"]["input"]>;
1853
- documentIdentifier: Scalars["String"]["input"];
2511
+ documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2512
+ documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
1854
2513
  };
1855
- type MutationExecuteAsyncArgs = {
2514
+ export type MutationExecuteAsyncArgs = {
1856
2515
  actions: ReadonlyArray<ActionInput>;
1857
2516
  branch?: InputMaybe<Scalars["String"]["input"]>;
1858
- documentIdentifier: Scalars["String"]["input"];
2517
+ documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2518
+ documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
1859
2519
  };
1860
- type MutationMoveRelationshipArgs = {
2520
+ export type MutationExecuteBatchArgs = {
2521
+ jobs: ReadonlyArray<ExecutionJobInput>;
2522
+ };
2523
+ export type MutationMoveRelationshipArgs = {
1861
2524
  branch?: InputMaybe<Scalars["String"]["input"]>;
1862
2525
  relationshipType: Scalars["String"]["input"];
1863
- sourceParentIdentifier: Scalars["String"]["input"];
1864
- targetIdentifier: Scalars["String"]["input"];
1865
- targetParentIdentifier: Scalars["String"]["input"];
1866
- };
1867
- type MutationMutateDocumentArgs = {
2526
+ sourceParentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2527
+ sourceParentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2528
+ targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2529
+ targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2530
+ targetParentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2531
+ targetParentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2532
+ };
2533
+ export type MutationMutateDocumentArgs = {
1868
2534
  actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
1869
2535
  documentIdentifier: Scalars["String"]["input"];
1870
2536
  view?: InputMaybe<ViewFilterInput>;
1871
2537
  };
1872
- type MutationMutateDocumentAsyncArgs = {
2538
+ export type MutationMutateDocumentAsyncArgs = {
1873
2539
  actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
1874
2540
  documentIdentifier: Scalars["String"]["input"];
1875
2541
  view?: InputMaybe<ViewFilterInput>;
1876
2542
  };
1877
- type MutationPushSyncEnvelopesArgs = {
2543
+ export type MutationPushSyncEnvelopesArgs = {
1878
2544
  envelopes: ReadonlyArray<SyncEnvelopeInput>;
2545
+ peerManifestRevision?: InputMaybe<Scalars["String"]["input"]>;
1879
2546
  };
1880
- type MutationRemoveRelationshipArgs = {
2547
+ export type MutationRemoveRelationshipArgs = {
1881
2548
  branch?: InputMaybe<Scalars["String"]["input"]>;
1882
2549
  relationshipType: Scalars["String"]["input"];
1883
- sourceIdentifier: Scalars["String"]["input"];
1884
- targetIdentifier: Scalars["String"]["input"];
2550
+ sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2551
+ sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2552
+ targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2553
+ targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
1885
2554
  };
1886
- type MutationRenameDocumentArgs = {
2555
+ export type MutationRenameDocumentArgs = {
1887
2556
  branch?: InputMaybe<Scalars["String"]["input"]>;
1888
- documentIdentifier: Scalars["String"]["input"];
2557
+ documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2558
+ documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
1889
2559
  name: Scalars["String"]["input"];
1890
2560
  };
1891
- type MutationSetPreferredEditorArgs = {
2561
+ export type MutationSetPreferredEditorArgs = {
1892
2562
  branch?: InputMaybe<Scalars["String"]["input"]>;
1893
- documentIdentifier: Scalars["String"]["input"];
2563
+ documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2564
+ documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
1894
2565
  preferredEditor?: InputMaybe<Scalars["String"]["input"]>;
1895
2566
  };
1896
- type MutationTouchChannelArgs = {
2567
+ export type MutationTouchChannelArgs = {
1897
2568
  input: TouchChannelInput;
1898
2569
  };
1899
- type OperationContext = {
2570
+ export type MutationUpdateRelationshipArgs = {
2571
+ branch?: InputMaybe<Scalars["String"]["input"]>;
2572
+ metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
2573
+ relationshipType: Scalars["String"]["input"];
2574
+ sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2575
+ sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2576
+ targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2577
+ targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2578
+ };
2579
+ export type OperationContext = {
1900
2580
  readonly branch: Scalars["String"]["output"];
1901
2581
  readonly documentId: Scalars["String"]["output"];
1902
2582
  readonly documentType: Scalars["String"]["output"];
1903
2583
  readonly ordinal: Scalars["Int"]["output"];
1904
2584
  readonly scope: Scalars["String"]["output"];
1905
2585
  };
1906
- type OperationContextInput = {
2586
+ export type OperationContextInput = {
1907
2587
  readonly branch: Scalars["String"]["input"];
1908
2588
  readonly documentId: Scalars["String"]["input"];
1909
2589
  readonly documentType: Scalars["String"]["input"];
1910
2590
  readonly ordinal: Scalars["Int"]["input"];
1911
2591
  readonly scope: Scalars["String"]["input"];
1912
2592
  };
1913
- type OperationInput = {
2593
+ export type OperationInput = {
1914
2594
  readonly action: ActionInput;
1915
2595
  readonly deniedReason?: InputMaybe<Scalars["String"]["input"]>;
1916
2596
  readonly error?: InputMaybe<Scalars["String"]["input"]>;
@@ -1920,67 +2600,92 @@ type OperationInput = {
1920
2600
  readonly skip: Scalars["Int"]["input"];
1921
2601
  readonly timestampUtcMs: Scalars["String"]["input"];
1922
2602
  };
1923
- type OperationWithContext = {
2603
+ export type OperationWithContext = {
1924
2604
  readonly context: OperationContext;
1925
2605
  readonly operation: ReactorOperation;
1926
2606
  };
1927
- type OperationWithContextInput = {
2607
+ export type OperationWithContextInput = {
1928
2608
  readonly context: OperationContextInput;
1929
2609
  readonly operation: OperationInput;
1930
2610
  };
1931
- type OperationsFilterInput = {
2611
+ export type OperationsFilterInput = {
1932
2612
  readonly actionTypes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
1933
2613
  readonly branch?: InputMaybe<Scalars["String"]["input"]>;
1934
- readonly documentId: Scalars["String"]["input"];
2614
+ /** @deprecated Use documentIdOrSlug. */
2615
+ readonly documentId?: InputMaybe<Scalars["String"]["input"]>;
2616
+ readonly documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
1935
2617
  readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
1936
2618
  readonly sinceRevision?: InputMaybe<Scalars["Int"]["input"]>;
1937
2619
  readonly timestampFrom?: InputMaybe<Scalars["String"]["input"]>;
1938
2620
  readonly timestampTo?: InputMaybe<Scalars["String"]["input"]>;
1939
2621
  };
1940
- type PhDocument = {
2622
+ export type PhDocument = {
1941
2623
  readonly createdAtUtcIso: Scalars["DateTime"]["output"];
1942
2624
  readonly documentType: Scalars["String"]["output"];
1943
2625
  readonly id: Scalars["String"]["output"];
1944
2626
  readonly lastModifiedAtUtcIso: Scalars["DateTime"]["output"];
2627
+ readonly meta?: Maybe<Scalars["JSONObject"]["output"]>;
1945
2628
  readonly name: Scalars["String"]["output"];
1946
2629
  readonly operations?: Maybe<ReactorOperationResultPage>;
1947
2630
  readonly preferredEditor?: Maybe<Scalars["String"]["output"]>;
2631
+ readonly protocolVersions?: Maybe<Scalars["JSONObject"]["output"]>;
1948
2632
  readonly revisionsList: ReadonlyArray<Revision>;
1949
2633
  readonly slug?: Maybe<Scalars["String"]["output"]>;
1950
2634
  readonly state: Scalars["JSONObject"]["output"];
1951
2635
  };
1952
- type PhDocumentOperationsArgs = {
2636
+ export type PhDocumentOperationsArgs = {
1953
2637
  filter?: InputMaybe<DocumentOperationsFilterInput>;
1954
2638
  paging?: InputMaybe<PagingInput>;
1955
2639
  };
1956
- type PhDocumentResultPage = {
2640
+ export type PhDocumentResultPage = {
1957
2641
  readonly cursor?: Maybe<Scalars["String"]["output"]>;
1958
2642
  readonly hasNextPage: Scalars["Boolean"]["output"];
1959
2643
  readonly hasPreviousPage: Scalars["Boolean"]["output"];
1960
2644
  readonly items: ReadonlyArray<PhDocument>;
1961
- readonly totalCount: Scalars["Int"]["output"];
1962
2645
  };
1963
- type PagingInput = {
2646
+ export type PagingInput = {
1964
2647
  readonly cursor?: InputMaybe<Scalars["String"]["input"]>;
1965
2648
  readonly limit?: InputMaybe<Scalars["Int"]["input"]>;
1966
2649
  readonly offset?: InputMaybe<Scalars["Int"]["input"]>;
1967
2650
  };
1968
- type PollSyncEnvelopesResult = {
2651
+ export type PeerAgreement = {
2652
+ readonly collectionId: Scalars["String"]["output"];
2653
+ readonly limitedBy: ReadonlyArray<PeerAgreementLimit>;
2654
+ readonly local: Scalars["JSONObject"]["output"];
2655
+ readonly members: ReadonlyArray<PeerAgreementMember>;
2656
+ };
2657
+ export type PeerAgreementLimit = {
2658
+ readonly protocol: Scalars["String"]["output"];
2659
+ readonly remoteNames: ReadonlyArray<Scalars["String"]["output"]>;
2660
+ };
2661
+ export type PeerAgreementMember = {
2662
+ readonly announced: Scalars["Boolean"]["output"];
2663
+ readonly features: Scalars["JSONObject"]["output"];
2664
+ readonly protocols: Scalars["JSONObject"]["output"];
2665
+ readonly remoteName: Scalars["String"]["output"];
2666
+ };
2667
+ export type PollSyncEnvelopesResult = {
1969
2668
  readonly ackOrdinal: Scalars["Int"]["output"];
1970
2669
  readonly deadLetters: ReadonlyArray<DeadLetterInfo>;
1971
2670
  readonly envelopes: ReadonlyArray<SyncEnvelope>;
1972
2671
  readonly hasMore: Scalars["Boolean"]["output"];
2672
+ readonly manifestRevision?: Maybe<Scalars["String"]["output"]>;
2673
+ readonly peerManifestRevision?: Maybe<Scalars["String"]["output"]>;
1973
2674
  };
1974
- declare enum PropagationMode {
2675
+ export declare enum PropagationMode {
1975
2676
  Cascade = "CASCADE",
1976
2677
  Orphan = "ORPHAN"
1977
2678
  }
1978
- type Query = {
2679
+ export type Query = {
2680
+ readonly createDefaults: CreateDefaults;
1979
2681
  readonly document?: Maybe<DocumentWithChildren>;
2682
+ readonly documentIncomingRelationshipEdges: DocumentRelationshipResultPage;
1980
2683
  readonly documentIncomingRelationships: PhDocumentResultPage;
1981
2684
  readonly documentModels: DocumentModelResultPage;
1982
2685
  readonly documentOperations: ReactorOperationResultPage;
2686
+ readonly documentOutgoingRelationshipEdges: DocumentRelationshipResultPage;
1983
2687
  readonly documentOutgoingRelationships: PhDocumentResultPage;
2688
+ readonly documentServed: Scalars["Boolean"]["output"];
1984
2689
  /**
1985
2690
  * Predicts whether the calling subject would be admitted to execute each of a
1986
2691
  * set of candidate operations, without submitting any of them. A UI asks this to
@@ -2011,6 +2716,7 @@ type Query = {
2011
2716
  readonly evaluateActions: ActionEvaluations;
2012
2717
  readonly findDocuments: PhDocumentResultPage;
2013
2718
  readonly jobStatus?: Maybe<JobInfo>;
2719
+ readonly peerAgreement: PeerAgreement;
2014
2720
  /**
2015
2721
  * Polls for sync envelopes from a channel.
2016
2722
  *
@@ -2023,50 +2729,85 @@ type Query = {
2023
2729
  * would stop receiving those too.
2024
2730
  */
2025
2731
  readonly pollSyncEnvelopes: PollSyncEnvelopesResult;
2732
+ readonly syncHolds: ReadonlyArray<SyncHold>;
2026
2733
  };
2027
- type QueryDocumentArgs = {
2028
- identifier: Scalars["String"]["input"];
2734
+ export type QueryCreateDefaultsArgs = {
2735
+ parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2736
+ };
2737
+ export type QueryDocumentArgs = {
2738
+ idOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2739
+ identifier?: InputMaybe<Scalars["String"]["input"]>;
2740
+ view?: InputMaybe<ViewFilterInput>;
2741
+ };
2742
+ export type QueryDocumentIncomingRelationshipEdgesArgs = {
2743
+ paging?: InputMaybe<PagingInput>;
2744
+ relationshipType?: InputMaybe<Scalars["String"]["input"]>;
2745
+ targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2746
+ targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2029
2747
  view?: InputMaybe<ViewFilterInput>;
2030
2748
  };
2031
- type QueryDocumentIncomingRelationshipsArgs = {
2749
+ export type QueryDocumentIncomingRelationshipsArgs = {
2032
2750
  paging?: InputMaybe<PagingInput>;
2033
2751
  relationshipType: Scalars["String"]["input"];
2034
- targetIdentifier: Scalars["String"]["input"];
2752
+ targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2753
+ targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2035
2754
  view?: InputMaybe<ViewFilterInput>;
2036
2755
  };
2037
- type QueryDocumentModelsArgs = {
2756
+ export type QueryDocumentModelsArgs = {
2038
2757
  namespace?: InputMaybe<Scalars["String"]["input"]>;
2039
2758
  paging?: InputMaybe<PagingInput>;
2040
2759
  };
2041
- type QueryDocumentOperationsArgs = {
2760
+ export type QueryDocumentOperationsArgs = {
2042
2761
  filter: OperationsFilterInput;
2043
2762
  paging?: InputMaybe<PagingInput>;
2044
2763
  };
2045
- type QueryDocumentOutgoingRelationshipsArgs = {
2764
+ export type QueryDocumentOutgoingRelationshipEdgesArgs = {
2765
+ paging?: InputMaybe<PagingInput>;
2766
+ relationshipType?: InputMaybe<Scalars["String"]["input"]>;
2767
+ sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2768
+ sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2769
+ view?: InputMaybe<ViewFilterInput>;
2770
+ };
2771
+ export type QueryDocumentOutgoingRelationshipsArgs = {
2046
2772
  paging?: InputMaybe<PagingInput>;
2047
2773
  relationshipType: Scalars["String"]["input"];
2048
- sourceIdentifier: Scalars["String"]["input"];
2774
+ sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2775
+ sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2776
+ view?: InputMaybe<ViewFilterInput>;
2777
+ };
2778
+ export type QueryDocumentServedArgs = {
2779
+ idOrSlug: Scalars["String"]["input"];
2049
2780
  view?: InputMaybe<ViewFilterInput>;
2050
2781
  };
2051
- type QueryEvaluateActionsArgs = {
2782
+ export type QueryEvaluateActionsArgs = {
2052
2783
  branch?: InputMaybe<Scalars["String"]["input"]>;
2053
2784
  candidates: ReadonlyArray<ActionCandidateInput>;
2054
- documentIdentifier: Scalars["String"]["input"];
2785
+ documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
2786
+ documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2055
2787
  };
2056
- type QueryFindDocumentsArgs = {
2788
+ export type QueryFindDocumentsArgs = {
2057
2789
  paging?: InputMaybe<PagingInput>;
2058
2790
  search?: InputMaybe<SearchFilterInput>;
2059
2791
  view?: InputMaybe<ViewFilterInput>;
2060
2792
  };
2061
- type QueryJobStatusArgs = {
2793
+ export type QueryJobStatusArgs = {
2062
2794
  jobId: Scalars["String"]["input"];
2063
2795
  };
2064
- type QueryPollSyncEnvelopesArgs = {
2796
+ export type QueryPeerAgreementArgs = {
2797
+ collectionId: Scalars["String"]["input"];
2798
+ };
2799
+ export type QueryPollSyncEnvelopesArgs = {
2065
2800
  channelId: Scalars["String"]["input"];
2801
+ manifestRevision?: InputMaybe<Scalars["String"]["input"]>;
2066
2802
  outboxAck: Scalars["Int"]["input"];
2067
2803
  outboxLatest: Scalars["Int"]["input"];
2804
+ refusals?: InputMaybe<ReadonlyArray<SyncRefusalInput>>;
2805
+ };
2806
+ export type QuerySyncHoldsArgs = {
2807
+ documentId?: InputMaybe<Scalars["String"]["input"]>;
2808
+ remoteName?: InputMaybe<Scalars["String"]["input"]>;
2068
2809
  };
2069
- type ReactorOperation = {
2810
+ export type ReactorOperation = {
2070
2811
  readonly action: Action;
2071
2812
  readonly deniedReason?: Maybe<Scalars["String"]["output"]>;
2072
2813
  readonly error?: Maybe<Scalars["String"]["output"]>;
@@ -2076,77 +2817,77 @@ type ReactorOperation = {
2076
2817
  readonly skip: Scalars["Int"]["output"];
2077
2818
  readonly timestampUtcMs: Scalars["String"]["output"];
2078
2819
  };
2079
- type ReactorOperationResultPage = {
2820
+ export type ReactorOperationResultPage = {
2080
2821
  readonly cursor?: Maybe<Scalars["String"]["output"]>;
2081
2822
  readonly hasNextPage: Scalars["Boolean"]["output"];
2082
2823
  readonly hasPreviousPage: Scalars["Boolean"]["output"];
2083
2824
  readonly items: ReadonlyArray<ReactorOperation>;
2084
- readonly totalCount: Scalars["Int"]["output"];
2085
2825
  };
2086
- type ReactorSigner = {
2826
+ export type ReactorSigner = {
2087
2827
  readonly app?: Maybe<ReactorSignerApp>;
2088
2828
  readonly signatures: ReadonlyArray<Scalars["String"]["output"]>;
2089
2829
  readonly user?: Maybe<ReactorSignerUser>;
2090
2830
  };
2091
- type ReactorSignerApp = {
2831
+ export type ReactorSignerApp = {
2092
2832
  readonly key: Scalars["String"]["output"];
2093
2833
  readonly name: Scalars["String"]["output"];
2094
2834
  };
2095
- type ReactorSignerAppInput = {
2835
+ export type ReactorSignerAppInput = {
2096
2836
  readonly key: Scalars["String"]["input"];
2097
2837
  readonly name: Scalars["String"]["input"];
2098
2838
  };
2099
- type ReactorSignerInput = {
2839
+ export type ReactorSignerInput = {
2100
2840
  readonly app?: InputMaybe<ReactorSignerAppInput>;
2101
2841
  readonly signatures: ReadonlyArray<Scalars["String"]["input"]>;
2102
2842
  readonly user?: InputMaybe<ReactorSignerUserInput>;
2103
2843
  };
2104
- type ReactorSignerUser = {
2844
+ export type ReactorSignerUser = {
2105
2845
  readonly address: Scalars["String"]["output"];
2106
2846
  readonly chainId: Scalars["Int"]["output"];
2107
2847
  readonly networkId: Scalars["String"]["output"];
2108
2848
  };
2109
- type ReactorSignerUserInput = {
2849
+ export type ReactorSignerUserInput = {
2110
2850
  readonly address: Scalars["String"]["input"];
2111
2851
  readonly chainId: Scalars["Int"]["input"];
2112
2852
  readonly networkId: Scalars["String"]["input"];
2113
2853
  };
2114
- type RemoteCursor = {
2854
+ export type RemoteCursor = {
2115
2855
  readonly cursorOrdinal: Scalars["Int"]["output"];
2116
2856
  readonly lastSyncedAtUtcMs?: Maybe<Scalars["String"]["output"]>;
2117
2857
  readonly remoteName: Scalars["String"]["output"];
2118
2858
  };
2119
- type RemoteCursorInput = {
2859
+ export type RemoteCursorInput = {
2120
2860
  readonly cursorOrdinal: Scalars["Int"]["input"];
2121
2861
  readonly lastSyncedAtUtcMs?: InputMaybe<Scalars["String"]["input"]>;
2122
2862
  readonly remoteName: Scalars["String"]["input"];
2123
2863
  };
2124
- type RemoteFilterInput = {
2864
+ export type RemoteFilterInput = {
2125
2865
  readonly branch: Scalars["String"]["input"];
2126
2866
  readonly documentId: ReadonlyArray<Scalars["String"]["input"]>;
2127
2867
  readonly scope: ReadonlyArray<Scalars["String"]["input"]>;
2128
2868
  };
2129
- type Revision = {
2869
+ export type Revision = {
2130
2870
  readonly revision: Scalars["Int"]["output"];
2131
2871
  readonly scope: Scalars["String"]["output"];
2132
2872
  };
2133
- type SearchFilterInput = {
2873
+ export type SearchFilterInput = {
2874
+ /** @deprecated Ignored. Filter by type or parentId. */
2134
2875
  readonly identifiers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
2135
2876
  readonly parentId?: InputMaybe<Scalars["String"]["input"]>;
2136
2877
  readonly type?: InputMaybe<Scalars["String"]["input"]>;
2137
2878
  };
2138
- type Subscription = {
2879
+ export type Subscription = {
2139
2880
  readonly documentChanges: DocumentChangeEvent;
2140
2881
  readonly jobChanges: JobChangeEvent;
2141
2882
  };
2142
- type SubscriptionDocumentChangesArgs = {
2883
+ export type SubscriptionDocumentChangesArgs = {
2143
2884
  search?: InputMaybe<SearchFilterInput>;
2144
2885
  view?: InputMaybe<ViewFilterInput>;
2145
2886
  };
2146
- type SubscriptionJobChangesArgs = {
2887
+ export type SubscriptionJobChangesArgs = {
2147
2888
  jobId: Scalars["String"]["input"];
2148
2889
  };
2149
- type SyncEnvelope = {
2890
+ export type SyncEnvelope = {
2150
2891
  readonly channelMeta: ChannelMeta;
2151
2892
  readonly cursor?: Maybe<RemoteCursor>;
2152
2893
  readonly dependsOn?: Maybe<ReadonlyArray<Scalars["String"]["output"]>>;
@@ -2154,7 +2895,7 @@ type SyncEnvelope = {
2154
2895
  readonly operations?: Maybe<ReadonlyArray<OperationWithContext>>;
2155
2896
  readonly type: SyncEnvelopeType;
2156
2897
  };
2157
- type SyncEnvelopeInput = {
2898
+ export type SyncEnvelopeInput = {
2158
2899
  readonly channelMeta: ChannelMetaInput;
2159
2900
  readonly cursor?: InputMaybe<RemoteCursorInput>;
2160
2901
  readonly dependsOn?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
@@ -2162,30 +2903,51 @@ type SyncEnvelopeInput = {
2162
2903
  readonly operations?: InputMaybe<ReadonlyArray<OperationWithContextInput>>;
2163
2904
  readonly type: SyncEnvelopeType;
2164
2905
  };
2165
- declare enum SyncEnvelopeType {
2906
+ export declare enum SyncEnvelopeType {
2166
2907
  Ack = "ACK",
2167
2908
  Operations = "OPERATIONS"
2168
2909
  }
2169
- type TouchChannelInput = {
2910
+ export type SyncHold = {
2911
+ readonly branch: Scalars["String"]["output"];
2912
+ readonly documentId: Scalars["String"]["output"];
2913
+ readonly heldAtUtcMs: Scalars["String"]["output"];
2914
+ readonly reason: SyncHoldReason;
2915
+ readonly remoteName: Scalars["String"]["output"];
2916
+ };
2917
+ export type SyncHoldReason = {
2918
+ readonly peerSupports: ReadonlyArray<Scalars["Int"]["output"]>;
2919
+ readonly protocol: Scalars["String"]["output"];
2920
+ readonly version: Scalars["Int"]["output"];
2921
+ };
2922
+ export type SyncRefusalInput = {
2923
+ readonly branch: Scalars["String"]["input"];
2924
+ readonly documentId: Scalars["String"]["input"];
2925
+ readonly kind?: InputMaybe<Scalars["String"]["input"]>;
2926
+ };
2927
+ export type TouchChannelInput = {
2170
2928
  readonly collectionId: Scalars["String"]["input"];
2171
2929
  readonly filter: RemoteFilterInput;
2172
2930
  readonly id: Scalars["String"]["input"];
2931
+ readonly manifest?: InputMaybe<Scalars["JSONObject"]["input"]>;
2173
2932
  readonly name: Scalars["String"]["input"];
2174
2933
  readonly sinceTimestampUtcMs: Scalars["String"]["input"];
2175
2934
  };
2176
- type TouchChannelResult = {
2935
+ export type TouchChannelResult = {
2177
2936
  readonly ackOrdinal: Scalars["Int"]["output"];
2937
+ readonly manifest?: Maybe<Scalars["JSONObject"]["output"]>;
2178
2938
  readonly success: Scalars["Boolean"]["output"];
2179
2939
  };
2180
- type ViewFilterInput = {
2940
+ export type ViewFilterInput = {
2181
2941
  readonly branch?: InputMaybe<Scalars["String"]["input"]>;
2182
2942
  readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
2183
2943
  };
2184
- type PhDocumentFieldsFragment = {
2944
+ export type PhDocumentFieldsFragment = {
2185
2945
  readonly id: string;
2186
2946
  readonly slug?: string | null | undefined;
2187
2947
  readonly name: string;
2188
2948
  readonly documentType: string;
2949
+ readonly meta?: NonNullable<unknown> | null | undefined;
2950
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2189
2951
  readonly state: NonNullable<unknown>;
2190
2952
  readonly createdAtUtcIso: string | Date;
2191
2953
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2194,13 +2956,20 @@ type PhDocumentFieldsFragment = {
2194
2956
  readonly revision: number;
2195
2957
  }>;
2196
2958
  };
2197
- type GetDocumentModelsQueryVariables = Exact<{
2959
+ export type DocumentRelationshipFieldsFragment = {
2960
+ readonly sourceId: string;
2961
+ readonly targetId: string;
2962
+ readonly relationshipType: string;
2963
+ readonly metadata?: NonNullable<unknown> | null | undefined;
2964
+ readonly createdAt: string | Date;
2965
+ readonly updatedAt: string | Date;
2966
+ };
2967
+ export type GetDocumentModelsQueryVariables = Exact<{
2198
2968
  namespace?: InputMaybe<Scalars["String"]["input"]>;
2199
2969
  paging?: InputMaybe<PagingInput>;
2200
2970
  }>;
2201
- type GetDocumentModelsQuery = {
2971
+ export type GetDocumentModelsQuery = {
2202
2972
  readonly documentModels: {
2203
- readonly totalCount: number;
2204
2973
  readonly hasNextPage: boolean;
2205
2974
  readonly hasPreviousPage: boolean;
2206
2975
  readonly cursor?: string | null | undefined;
@@ -2213,11 +2982,11 @@ type GetDocumentModelsQuery = {
2213
2982
  }>;
2214
2983
  };
2215
2984
  };
2216
- type GetDocumentQueryVariables = Exact<{
2985
+ export type GetDocumentQueryVariables = Exact<{
2217
2986
  identifier: Scalars["String"]["input"];
2218
2987
  view?: InputMaybe<ViewFilterInput>;
2219
2988
  }>;
2220
- type GetDocumentQuery = {
2989
+ export type GetDocumentQuery = {
2221
2990
  readonly document?: {
2222
2991
  readonly childIds: ReadonlyArray<string>;
2223
2992
  readonly document: {
@@ -2225,6 +2994,8 @@ type GetDocumentQuery = {
2225
2994
  readonly slug?: string | null | undefined;
2226
2995
  readonly name: string;
2227
2996
  readonly documentType: string;
2997
+ readonly meta?: NonNullable<unknown> | null | undefined;
2998
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2228
2999
  readonly state: NonNullable<unknown>;
2229
3000
  readonly createdAtUtcIso: string | Date;
2230
3001
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2235,13 +3006,13 @@ type GetDocumentQuery = {
2235
3006
  };
2236
3007
  } | null | undefined;
2237
3008
  };
2238
- type GetDocumentWithOperationsQueryVariables = Exact<{
3009
+ export type GetDocumentWithOperationsQueryVariables = Exact<{
2239
3010
  identifier: Scalars["String"]["input"];
2240
3011
  view?: InputMaybe<ViewFilterInput>;
2241
3012
  operationsFilter?: InputMaybe<DocumentOperationsFilterInput>;
2242
3013
  operationsPaging?: InputMaybe<PagingInput>;
2243
3014
  }>;
2244
- type GetDocumentWithOperationsQuery = {
3015
+ export type GetDocumentWithOperationsQuery = {
2245
3016
  readonly document?: {
2246
3017
  readonly childIds: ReadonlyArray<string>;
2247
3018
  readonly document: {
@@ -2249,11 +3020,12 @@ type GetDocumentWithOperationsQuery = {
2249
3020
  readonly slug?: string | null | undefined;
2250
3021
  readonly name: string;
2251
3022
  readonly documentType: string;
3023
+ readonly meta?: NonNullable<unknown> | null | undefined;
3024
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2252
3025
  readonly state: NonNullable<unknown>;
2253
3026
  readonly createdAtUtcIso: string | Date;
2254
3027
  readonly lastModifiedAtUtcIso: string | Date;
2255
3028
  readonly operations?: {
2256
- readonly totalCount: number;
2257
3029
  readonly hasNextPage: boolean;
2258
3030
  readonly hasPreviousPage: boolean;
2259
3031
  readonly cursor?: string | null | undefined;
@@ -2295,15 +3067,14 @@ type GetDocumentWithOperationsQuery = {
2295
3067
  };
2296
3068
  } | null | undefined;
2297
3069
  };
2298
- type GetDocumentOutgoingRelationshipsQueryVariables = Exact<{
3070
+ export type GetDocumentOutgoingRelationshipsQueryVariables = Exact<{
2299
3071
  sourceIdentifier: Scalars["String"]["input"];
2300
3072
  relationshipType: Scalars["String"]["input"];
2301
3073
  view?: InputMaybe<ViewFilterInput>;
2302
3074
  paging?: InputMaybe<PagingInput>;
2303
3075
  }>;
2304
- type GetDocumentOutgoingRelationshipsQuery = {
3076
+ export type GetDocumentOutgoingRelationshipsQuery = {
2305
3077
  readonly documentOutgoingRelationships: {
2306
- readonly totalCount: number;
2307
3078
  readonly hasNextPage: boolean;
2308
3079
  readonly hasPreviousPage: boolean;
2309
3080
  readonly cursor?: string | null | undefined;
@@ -2312,6 +3083,8 @@ type GetDocumentOutgoingRelationshipsQuery = {
2312
3083
  readonly slug?: string | null | undefined;
2313
3084
  readonly name: string;
2314
3085
  readonly documentType: string;
3086
+ readonly meta?: NonNullable<unknown> | null | undefined;
3087
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2315
3088
  readonly state: NonNullable<unknown>;
2316
3089
  readonly createdAtUtcIso: string | Date;
2317
3090
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2322,15 +3095,14 @@ type GetDocumentOutgoingRelationshipsQuery = {
2322
3095
  }>;
2323
3096
  };
2324
3097
  };
2325
- type GetDocumentIncomingRelationshipsQueryVariables = Exact<{
3098
+ export type GetDocumentIncomingRelationshipsQueryVariables = Exact<{
2326
3099
  targetIdentifier: Scalars["String"]["input"];
2327
3100
  relationshipType: Scalars["String"]["input"];
2328
3101
  view?: InputMaybe<ViewFilterInput>;
2329
3102
  paging?: InputMaybe<PagingInput>;
2330
3103
  }>;
2331
- type GetDocumentIncomingRelationshipsQuery = {
3104
+ export type GetDocumentIncomingRelationshipsQuery = {
2332
3105
  readonly documentIncomingRelationships: {
2333
- readonly totalCount: number;
2334
3106
  readonly hasNextPage: boolean;
2335
3107
  readonly hasPreviousPage: boolean;
2336
3108
  readonly cursor?: string | null | undefined;
@@ -2339,6 +3111,8 @@ type GetDocumentIncomingRelationshipsQuery = {
2339
3111
  readonly slug?: string | null | undefined;
2340
3112
  readonly name: string;
2341
3113
  readonly documentType: string;
3114
+ readonly meta?: NonNullable<unknown> | null | undefined;
3115
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2342
3116
  readonly state: NonNullable<unknown>;
2343
3117
  readonly createdAtUtcIso: string | Date;
2344
3118
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2349,14 +3123,55 @@ type GetDocumentIncomingRelationshipsQuery = {
2349
3123
  }>;
2350
3124
  };
2351
3125
  };
2352
- type FindDocumentsQueryVariables = Exact<{
3126
+ export type GetDocumentOutgoingRelationshipEdgesQueryVariables = Exact<{
3127
+ sourceIdentifier: Scalars["String"]["input"];
3128
+ relationshipType?: InputMaybe<Scalars["String"]["input"]>;
3129
+ view?: InputMaybe<ViewFilterInput>;
3130
+ paging?: InputMaybe<PagingInput>;
3131
+ }>;
3132
+ export type GetDocumentOutgoingRelationshipEdgesQuery = {
3133
+ readonly documentOutgoingRelationshipEdges: {
3134
+ readonly hasNextPage: boolean;
3135
+ readonly hasPreviousPage: boolean;
3136
+ readonly cursor?: string | null | undefined;
3137
+ readonly items: ReadonlyArray<{
3138
+ readonly sourceId: string;
3139
+ readonly targetId: string;
3140
+ readonly relationshipType: string;
3141
+ readonly metadata?: NonNullable<unknown> | null | undefined;
3142
+ readonly createdAt: string | Date;
3143
+ readonly updatedAt: string | Date;
3144
+ }>;
3145
+ };
3146
+ };
3147
+ export type GetDocumentIncomingRelationshipEdgesQueryVariables = Exact<{
3148
+ targetIdentifier: Scalars["String"]["input"];
3149
+ relationshipType?: InputMaybe<Scalars["String"]["input"]>;
3150
+ view?: InputMaybe<ViewFilterInput>;
3151
+ paging?: InputMaybe<PagingInput>;
3152
+ }>;
3153
+ export type GetDocumentIncomingRelationshipEdgesQuery = {
3154
+ readonly documentIncomingRelationshipEdges: {
3155
+ readonly hasNextPage: boolean;
3156
+ readonly hasPreviousPage: boolean;
3157
+ readonly cursor?: string | null | undefined;
3158
+ readonly items: ReadonlyArray<{
3159
+ readonly sourceId: string;
3160
+ readonly targetId: string;
3161
+ readonly relationshipType: string;
3162
+ readonly metadata?: NonNullable<unknown> | null | undefined;
3163
+ readonly createdAt: string | Date;
3164
+ readonly updatedAt: string | Date;
3165
+ }>;
3166
+ };
3167
+ };
3168
+ export type FindDocumentsQueryVariables = Exact<{
2353
3169
  search?: InputMaybe<SearchFilterInput>;
2354
3170
  view?: InputMaybe<ViewFilterInput>;
2355
3171
  paging?: InputMaybe<PagingInput>;
2356
3172
  }>;
2357
- type FindDocumentsQuery = {
3173
+ export type FindDocumentsQuery = {
2358
3174
  readonly findDocuments: {
2359
- readonly totalCount: number;
2360
3175
  readonly hasNextPage: boolean;
2361
3176
  readonly hasPreviousPage: boolean;
2362
3177
  readonly cursor?: string | null | undefined;
@@ -2365,6 +3180,8 @@ type FindDocumentsQuery = {
2365
3180
  readonly slug?: string | null | undefined;
2366
3181
  readonly name: string;
2367
3182
  readonly documentType: string;
3183
+ readonly meta?: NonNullable<unknown> | null | undefined;
3184
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2368
3185
  readonly state: NonNullable<unknown>;
2369
3186
  readonly createdAtUtcIso: string | Date;
2370
3187
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2375,13 +3192,12 @@ type FindDocumentsQuery = {
2375
3192
  }>;
2376
3193
  };
2377
3194
  };
2378
- type GetDocumentOperationsQueryVariables = Exact<{
3195
+ export type GetDocumentOperationsQueryVariables = Exact<{
2379
3196
  filter: OperationsFilterInput;
2380
3197
  paging?: InputMaybe<PagingInput>;
2381
3198
  }>;
2382
- type GetDocumentOperationsQuery = {
3199
+ export type GetDocumentOperationsQuery = {
2383
3200
  readonly documentOperations: {
2384
- readonly totalCount: number;
2385
3201
  readonly hasNextPage: boolean;
2386
3202
  readonly hasPreviousPage: boolean;
2387
3203
  readonly cursor?: string | null | undefined;
@@ -2417,25 +3233,81 @@ type GetDocumentOperationsQuery = {
2417
3233
  }>;
2418
3234
  };
2419
3235
  };
2420
- type GetJobStatusQueryVariables = Exact<{
3236
+ export type JobInfoFieldsFragment = {
3237
+ readonly id: string;
3238
+ readonly documentId: string;
3239
+ readonly status: string;
3240
+ readonly result?: NonNullable<unknown> | null | undefined;
3241
+ readonly error?: string | null | undefined;
3242
+ readonly errorName?: string | null | undefined;
3243
+ readonly createdAt: string | Date;
3244
+ readonly completedAt?: string | Date | null | undefined;
3245
+ readonly consistencyToken: {
3246
+ readonly version: number;
3247
+ readonly createdAtUtcIso: string;
3248
+ readonly coordinates: ReadonlyArray<{
3249
+ readonly documentId: string;
3250
+ readonly scope: string;
3251
+ readonly branch: string;
3252
+ readonly operationIndex: number;
3253
+ }>;
3254
+ };
3255
+ readonly meta: {
3256
+ readonly batchId: string;
3257
+ readonly batchJobIds: ReadonlyArray<string>;
3258
+ };
3259
+ };
3260
+ export type GetJobStatusQueryVariables = Exact<{
2421
3261
  jobId: Scalars["String"]["input"];
2422
3262
  }>;
2423
- type GetJobStatusQuery = {
3263
+ export type GetJobStatusQuery = {
2424
3264
  readonly jobStatus?: {
2425
3265
  readonly id: string;
3266
+ readonly documentId: string;
2426
3267
  readonly status: string;
2427
3268
  readonly result?: NonNullable<unknown> | null | undefined;
2428
3269
  readonly error?: string | null | undefined;
3270
+ readonly errorName?: string | null | undefined;
2429
3271
  readonly createdAt: string | Date;
2430
3272
  readonly completedAt?: string | Date | null | undefined;
3273
+ readonly consistencyToken: {
3274
+ readonly version: number;
3275
+ readonly createdAtUtcIso: string;
3276
+ readonly coordinates: ReadonlyArray<{
3277
+ readonly documentId: string;
3278
+ readonly scope: string;
3279
+ readonly branch: string;
3280
+ readonly operationIndex: number;
3281
+ }>;
3282
+ };
3283
+ readonly meta: {
3284
+ readonly batchId: string;
3285
+ readonly batchJobIds: ReadonlyArray<string>;
3286
+ };
2431
3287
  } | null | undefined;
2432
3288
  };
2433
- type EvaluateActionsQueryVariables = Exact<{
3289
+ export type GetDocumentServedQueryVariables = Exact<{
3290
+ idOrSlug: Scalars["String"]["input"];
3291
+ view?: InputMaybe<ViewFilterInput>;
3292
+ }>;
3293
+ export type GetDocumentServedQuery = {
3294
+ readonly documentServed: boolean;
3295
+ };
3296
+ export type GetCreateDefaultsQueryVariables = Exact<{
3297
+ parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
3298
+ }>;
3299
+ export type GetCreateDefaultsQuery = {
3300
+ readonly createDefaults: {
3301
+ readonly signaturePolicy: string;
3302
+ readonly protocolVersions: NonNullable<unknown>;
3303
+ };
3304
+ };
3305
+ export type EvaluateActionsQueryVariables = Exact<{
2434
3306
  documentIdentifier: Scalars["String"]["input"];
2435
3307
  branch?: InputMaybe<Scalars["String"]["input"]>;
2436
3308
  candidates: ReadonlyArray<ActionCandidateInput>;
2437
3309
  }>;
2438
- type EvaluateActionsQuery = {
3310
+ export type EvaluateActionsQuery = {
2439
3311
  readonly evaluateActions: {
2440
3312
  readonly allAllowed: boolean;
2441
3313
  readonly anyAllowed: boolean;
@@ -2447,16 +3319,18 @@ type EvaluateActionsQuery = {
2447
3319
  }>;
2448
3320
  };
2449
3321
  };
2450
- type CreateDocumentMutationVariables = Exact<{
3322
+ export type CreateDocumentMutationVariables = Exact<{
2451
3323
  document: Scalars["JSONObject"]["input"];
2452
3324
  parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2453
3325
  }>;
2454
- type CreateDocumentMutation = {
3326
+ export type CreateDocumentMutation = {
2455
3327
  readonly createDocument: {
2456
3328
  readonly id: string;
2457
3329
  readonly slug?: string | null | undefined;
2458
3330
  readonly name: string;
2459
3331
  readonly documentType: string;
3332
+ readonly meta?: NonNullable<unknown> | null | undefined;
3333
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2460
3334
  readonly state: NonNullable<unknown>;
2461
3335
  readonly createdAtUtcIso: string | Date;
2462
3336
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2466,16 +3340,18 @@ type CreateDocumentMutation = {
2466
3340
  }>;
2467
3341
  };
2468
3342
  };
2469
- type CreateEmptyDocumentMutationVariables = Exact<{
3343
+ export type CreateEmptyDocumentMutationVariables = Exact<{
2470
3344
  documentType: Scalars["String"]["input"];
2471
3345
  parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
2472
3346
  }>;
2473
- type CreateEmptyDocumentMutation = {
3347
+ export type CreateEmptyDocumentMutation = {
2474
3348
  readonly createEmptyDocument: {
2475
3349
  readonly id: string;
2476
3350
  readonly slug?: string | null | undefined;
2477
3351
  readonly name: string;
2478
3352
  readonly documentType: string;
3353
+ readonly meta?: NonNullable<unknown> | null | undefined;
3354
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2479
3355
  readonly state: NonNullable<unknown>;
2480
3356
  readonly createdAtUtcIso: string | Date;
2481
3357
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2485,17 +3361,19 @@ type CreateEmptyDocumentMutation = {
2485
3361
  }>;
2486
3362
  };
2487
3363
  };
2488
- type MutateDocumentMutationVariables = Exact<{
3364
+ export type MutateDocumentMutationVariables = Exact<{
2489
3365
  documentIdentifier: Scalars["String"]["input"];
2490
3366
  actions: ReadonlyArray<ActionInput>;
2491
3367
  branch?: InputMaybe<Scalars["String"]["input"]>;
2492
3368
  }>;
2493
- type MutateDocumentMutation = {
3369
+ export type MutateDocumentMutation = {
2494
3370
  readonly mutateDocument: {
2495
3371
  readonly id: string;
2496
3372
  readonly slug?: string | null | undefined;
2497
3373
  readonly name: string;
2498
3374
  readonly documentType: string;
3375
+ readonly meta?: NonNullable<unknown> | null | undefined;
3376
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2499
3377
  readonly state: NonNullable<unknown>;
2500
3378
  readonly createdAtUtcIso: string | Date;
2501
3379
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2505,32 +3383,84 @@ type MutateDocumentMutation = {
2505
3383
  }>;
2506
3384
  };
2507
3385
  };
2508
- type MutateDocumentAsyncMutationVariables = Exact<{
3386
+ export type MutateDocumentAsyncMutationVariables = Exact<{
2509
3387
  documentIdentifier: Scalars["String"]["input"];
2510
3388
  actions: ReadonlyArray<ActionInput>;
2511
3389
  branch?: InputMaybe<Scalars["String"]["input"]>;
2512
3390
  }>;
2513
- type MutateDocumentAsyncMutation = {
3391
+ export type MutateDocumentAsyncMutation = {
2514
3392
  readonly mutateDocumentAsync: {
2515
3393
  readonly id: string;
3394
+ readonly documentId: string;
2516
3395
  readonly status: string;
2517
3396
  readonly result?: NonNullable<unknown> | null | undefined;
2518
3397
  readonly error?: string | null | undefined;
3398
+ readonly errorName?: string | null | undefined;
2519
3399
  readonly createdAt: string | Date;
2520
3400
  readonly completedAt?: string | Date | null | undefined;
3401
+ readonly consistencyToken: {
3402
+ readonly version: number;
3403
+ readonly createdAtUtcIso: string;
3404
+ readonly coordinates: ReadonlyArray<{
3405
+ readonly documentId: string;
3406
+ readonly scope: string;
3407
+ readonly branch: string;
3408
+ readonly operationIndex: number;
3409
+ }>;
3410
+ };
3411
+ readonly meta: {
3412
+ readonly batchId: string;
3413
+ readonly batchJobIds: ReadonlyArray<string>;
3414
+ };
3415
+ };
3416
+ };
3417
+ export type ExecuteBatchMutationVariables = Exact<{
3418
+ jobs: ReadonlyArray<ExecutionJobInput>;
3419
+ }>;
3420
+ export type ExecuteBatchMutation = {
3421
+ readonly executeBatch: {
3422
+ readonly jobs: ReadonlyArray<{
3423
+ readonly key: string;
3424
+ readonly job: {
3425
+ readonly id: string;
3426
+ readonly documentId: string;
3427
+ readonly status: string;
3428
+ readonly result?: NonNullable<unknown> | null | undefined;
3429
+ readonly error?: string | null | undefined;
3430
+ readonly errorName?: string | null | undefined;
3431
+ readonly createdAt: string | Date;
3432
+ readonly completedAt?: string | Date | null | undefined;
3433
+ readonly consistencyToken: {
3434
+ readonly version: number;
3435
+ readonly createdAtUtcIso: string;
3436
+ readonly coordinates: ReadonlyArray<{
3437
+ readonly documentId: string;
3438
+ readonly scope: string;
3439
+ readonly branch: string;
3440
+ readonly operationIndex: number;
3441
+ }>;
3442
+ };
3443
+ readonly meta: {
3444
+ readonly batchId: string;
3445
+ readonly batchJobIds: ReadonlyArray<string>;
3446
+ };
3447
+ };
3448
+ }>;
2521
3449
  };
2522
3450
  };
2523
- type RenameDocumentMutationVariables = Exact<{
3451
+ export type RenameDocumentMutationVariables = Exact<{
2524
3452
  documentIdentifier: Scalars["String"]["input"];
2525
3453
  name: Scalars["String"]["input"];
2526
3454
  branch?: InputMaybe<Scalars["String"]["input"]>;
2527
3455
  }>;
2528
- type RenameDocumentMutation = {
3456
+ export type RenameDocumentMutation = {
2529
3457
  readonly renameDocument: {
2530
3458
  readonly id: string;
2531
3459
  readonly slug?: string | null | undefined;
2532
3460
  readonly name: string;
2533
3461
  readonly documentType: string;
3462
+ readonly meta?: NonNullable<unknown> | null | undefined;
3463
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2534
3464
  readonly state: NonNullable<unknown>;
2535
3465
  readonly createdAtUtcIso: string | Date;
2536
3466
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2540,17 +3470,19 @@ type RenameDocumentMutation = {
2540
3470
  }>;
2541
3471
  };
2542
3472
  };
2543
- type SetPreferredEditorMutationVariables = Exact<{
3473
+ export type SetPreferredEditorMutationVariables = Exact<{
2544
3474
  documentIdentifier: Scalars["String"]["input"];
2545
3475
  preferredEditor?: InputMaybe<Scalars["String"]["input"]>;
2546
3476
  branch?: InputMaybe<Scalars["String"]["input"]>;
2547
3477
  }>;
2548
- type SetPreferredEditorMutation = {
3478
+ export type SetPreferredEditorMutation = {
2549
3479
  readonly setPreferredEditor: {
2550
3480
  readonly id: string;
2551
3481
  readonly slug?: string | null | undefined;
2552
3482
  readonly name: string;
2553
3483
  readonly documentType: string;
3484
+ readonly meta?: NonNullable<unknown> | null | undefined;
3485
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2554
3486
  readonly state: NonNullable<unknown>;
2555
3487
  readonly createdAtUtcIso: string | Date;
2556
3488
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2560,18 +3492,45 @@ type SetPreferredEditorMutation = {
2560
3492
  }>;
2561
3493
  };
2562
3494
  };
2563
- type AddRelationshipMutationVariables = Exact<{
3495
+ export type AddRelationshipMutationVariables = Exact<{
2564
3496
  sourceIdentifier: Scalars["String"]["input"];
2565
3497
  targetIdentifier: Scalars["String"]["input"];
2566
3498
  relationshipType: Scalars["String"]["input"];
3499
+ metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
2567
3500
  branch?: InputMaybe<Scalars["String"]["input"]>;
2568
3501
  }>;
2569
- type AddRelationshipMutation = {
3502
+ export type AddRelationshipMutation = {
2570
3503
  readonly addRelationship: {
2571
3504
  readonly id: string;
2572
3505
  readonly slug?: string | null | undefined;
2573
3506
  readonly name: string;
2574
3507
  readonly documentType: string;
3508
+ readonly meta?: NonNullable<unknown> | null | undefined;
3509
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
3510
+ readonly state: NonNullable<unknown>;
3511
+ readonly createdAtUtcIso: string | Date;
3512
+ readonly lastModifiedAtUtcIso: string | Date;
3513
+ readonly revisionsList: ReadonlyArray<{
3514
+ readonly scope: string;
3515
+ readonly revision: number;
3516
+ }>;
3517
+ };
3518
+ };
3519
+ export type UpdateRelationshipMutationVariables = Exact<{
3520
+ sourceIdentifier: Scalars["String"]["input"];
3521
+ targetIdentifier: Scalars["String"]["input"];
3522
+ relationshipType: Scalars["String"]["input"];
3523
+ metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
3524
+ branch?: InputMaybe<Scalars["String"]["input"]>;
3525
+ }>;
3526
+ export type UpdateRelationshipMutation = {
3527
+ readonly updateRelationship: {
3528
+ readonly id: string;
3529
+ readonly slug?: string | null | undefined;
3530
+ readonly name: string;
3531
+ readonly documentType: string;
3532
+ readonly meta?: NonNullable<unknown> | null | undefined;
3533
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2575
3534
  readonly state: NonNullable<unknown>;
2576
3535
  readonly createdAtUtcIso: string | Date;
2577
3536
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2581,18 +3540,20 @@ type AddRelationshipMutation = {
2581
3540
  }>;
2582
3541
  };
2583
3542
  };
2584
- type RemoveRelationshipMutationVariables = Exact<{
3543
+ export type RemoveRelationshipMutationVariables = Exact<{
2585
3544
  sourceIdentifier: Scalars["String"]["input"];
2586
3545
  targetIdentifier: Scalars["String"]["input"];
2587
3546
  relationshipType: Scalars["String"]["input"];
2588
3547
  branch?: InputMaybe<Scalars["String"]["input"]>;
2589
3548
  }>;
2590
- type RemoveRelationshipMutation = {
3549
+ export type RemoveRelationshipMutation = {
2591
3550
  readonly removeRelationship: {
2592
3551
  readonly id: string;
2593
3552
  readonly slug?: string | null | undefined;
2594
3553
  readonly name: string;
2595
3554
  readonly documentType: string;
3555
+ readonly meta?: NonNullable<unknown> | null | undefined;
3556
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2596
3557
  readonly state: NonNullable<unknown>;
2597
3558
  readonly createdAtUtcIso: string | Date;
2598
3559
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2602,20 +3563,22 @@ type RemoveRelationshipMutation = {
2602
3563
  }>;
2603
3564
  };
2604
3565
  };
2605
- type MoveRelationshipMutationVariables = Exact<{
3566
+ export type MoveRelationshipMutationVariables = Exact<{
2606
3567
  sourceParentIdentifier: Scalars["String"]["input"];
2607
3568
  targetParentIdentifier: Scalars["String"]["input"];
2608
3569
  targetIdentifier: Scalars["String"]["input"];
2609
3570
  relationshipType: Scalars["String"]["input"];
2610
3571
  branch?: InputMaybe<Scalars["String"]["input"]>;
2611
3572
  }>;
2612
- type MoveRelationshipMutation = {
3573
+ export type MoveRelationshipMutation = {
2613
3574
  readonly moveRelationship: {
2614
3575
  readonly source: {
2615
3576
  readonly id: string;
2616
3577
  readonly slug?: string | null | undefined;
2617
3578
  readonly name: string;
2618
3579
  readonly documentType: string;
3580
+ readonly meta?: NonNullable<unknown> | null | undefined;
3581
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2619
3582
  readonly state: NonNullable<unknown>;
2620
3583
  readonly createdAtUtcIso: string | Date;
2621
3584
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2629,6 +3592,8 @@ type MoveRelationshipMutation = {
2629
3592
  readonly slug?: string | null | undefined;
2630
3593
  readonly name: string;
2631
3594
  readonly documentType: string;
3595
+ readonly meta?: NonNullable<unknown> | null | undefined;
3596
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2632
3597
  readonly state: NonNullable<unknown>;
2633
3598
  readonly createdAtUtcIso: string | Date;
2634
3599
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2639,25 +3604,25 @@ type MoveRelationshipMutation = {
2639
3604
  };
2640
3605
  };
2641
3606
  };
2642
- type DeleteDocumentMutationVariables = Exact<{
3607
+ export type DeleteDocumentMutationVariables = Exact<{
2643
3608
  identifier: Scalars["String"]["input"];
2644
3609
  propagate?: InputMaybe<PropagationMode>;
2645
3610
  }>;
2646
- type DeleteDocumentMutation = {
3611
+ export type DeleteDocumentMutation = {
2647
3612
  readonly deleteDocument: boolean;
2648
3613
  };
2649
- type DeleteDocumentsMutationVariables = Exact<{
3614
+ export type DeleteDocumentsMutationVariables = Exact<{
2650
3615
  identifiers: ReadonlyArray<Scalars["String"]["input"]>;
2651
3616
  propagate?: InputMaybe<PropagationMode>;
2652
3617
  }>;
2653
- type DeleteDocumentsMutation = {
3618
+ export type DeleteDocumentsMutation = {
2654
3619
  readonly deleteDocuments: boolean;
2655
3620
  };
2656
- type DocumentChangesSubscriptionVariables = Exact<{
3621
+ export type DocumentChangesSubscriptionVariables = Exact<{
2657
3622
  search?: InputMaybe<SearchFilterInput>;
2658
3623
  view?: InputMaybe<ViewFilterInput>;
2659
3624
  }>;
2660
- type DocumentChangesSubscription = {
3625
+ export type DocumentChangesSubscription = {
2661
3626
  readonly documentChanges: {
2662
3627
  readonly type: DocumentChangeType;
2663
3628
  readonly documents: ReadonlyArray<{
@@ -2665,6 +3630,8 @@ type DocumentChangesSubscription = {
2665
3630
  readonly slug?: string | null | undefined;
2666
3631
  readonly name: string;
2667
3632
  readonly documentType: string;
3633
+ readonly meta?: NonNullable<unknown> | null | undefined;
3634
+ readonly protocolVersions?: NonNullable<unknown> | null | undefined;
2668
3635
  readonly state: NonNullable<unknown>;
2669
3636
  readonly createdAtUtcIso: string | Date;
2670
3637
  readonly lastModifiedAtUtcIso: string | Date;
@@ -2679,26 +3646,30 @@ type DocumentChangesSubscription = {
2679
3646
  } | null | undefined;
2680
3647
  };
2681
3648
  };
2682
- type JobChangesSubscriptionVariables = Exact<{
3649
+ export type JobChangesSubscriptionVariables = Exact<{
2683
3650
  jobId: Scalars["String"]["input"];
2684
3651
  }>;
2685
- type JobChangesSubscription = {
3652
+ export type JobChangesSubscription = {
2686
3653
  readonly jobChanges: {
2687
3654
  readonly jobId: string;
2688
3655
  readonly status: string;
2689
- readonly result: NonNullable<unknown>;
3656
+ readonly result?: NonNullable<unknown> | null | undefined;
2690
3657
  readonly error?: string | null | undefined;
2691
3658
  };
2692
3659
  };
2693
- type PollSyncEnvelopesQueryVariables = Exact<{
3660
+ export type PollSyncEnvelopesQueryVariables = Exact<{
2694
3661
  channelId: Scalars["String"]["input"];
2695
3662
  outboxAck: Scalars["Int"]["input"];
2696
3663
  outboxLatest: Scalars["Int"]["input"];
3664
+ manifestRevision?: InputMaybe<Scalars["String"]["input"]>;
3665
+ refusals?: InputMaybe<ReadonlyArray<SyncRefusalInput>>;
2697
3666
  }>;
2698
- type PollSyncEnvelopesQuery = {
3667
+ export type PollSyncEnvelopesQuery = {
2699
3668
  readonly pollSyncEnvelopes: {
2700
3669
  readonly ackOrdinal: number;
2701
3670
  readonly hasMore: boolean;
3671
+ readonly manifestRevision?: string | null | undefined;
3672
+ readonly peerManifestRevision?: string | null | undefined;
2702
3673
  readonly envelopes: ReadonlyArray<{
2703
3674
  readonly type: SyncEnvelopeType;
2704
3675
  readonly key?: string | null | undefined;
@@ -2757,47 +3728,49 @@ type PollSyncEnvelopesQuery = {
2757
3728
  }>;
2758
3729
  };
2759
3730
  };
2760
- type TouchChannelMutationVariables = Exact<{
3731
+ export type TouchChannelMutationVariables = Exact<{
2761
3732
  input: TouchChannelInput;
2762
3733
  }>;
2763
- type TouchChannelMutation = {
3734
+ export type TouchChannelMutation = {
2764
3735
  readonly touchChannel: {
2765
3736
  readonly success: boolean;
2766
3737
  readonly ackOrdinal: number;
3738
+ readonly manifest?: NonNullable<unknown> | null | undefined;
2767
3739
  };
2768
3740
  };
2769
- type PushSyncEnvelopesMutationVariables = Exact<{
3741
+ export type PushSyncEnvelopesMutationVariables = Exact<{
2770
3742
  envelopes: ReadonlyArray<SyncEnvelopeInput>;
3743
+ peerManifestRevision?: InputMaybe<Scalars["String"]["input"]>;
2771
3744
  }>;
2772
- type PushSyncEnvelopesMutation = {
3745
+ export type PushSyncEnvelopesMutation = {
2773
3746
  readonly pushSyncEnvelopes: boolean;
2774
3747
  };
2775
- type WithIndex<TObject> = TObject & Record<string, any>;
2776
- type ResolversObject<TObject> = WithIndex<TObject>;
2777
- type ResolverTypeWrapper<T> = Promise<T> | T;
2778
- type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
3748
+ export type WithIndex<TObject> = TObject & Record<string, any>;
3749
+ export type ResolversObject<TObject> = WithIndex<TObject>;
3750
+ export type ResolverTypeWrapper<T> = Promise<T> | T;
3751
+ export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
2779
3752
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
2780
3753
  };
2781
- 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>;
2782
- type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
2783
- type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
2784
- type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
2785
- interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
2786
- subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
2787
- resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
3754
+ export 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>;
3755
+ export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
3756
+ export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
3757
+ export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
3758
+ export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
3759
+ subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult; }, TParent, TContext, TArgs>;
3760
+ resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult; }, TContext, TArgs>;
2788
3761
  }
2789
- interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
3762
+ export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
2790
3763
  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
2791
3764
  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
2792
3765
  }
2793
- type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
2794
- 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>;
2795
- type TypeResolveFn<TTypes, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
2796
- type IsTypeOfResolverFn<T = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
2797
- type NextResolverFn<T> = () => Promise<T>;
2798
- 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>;
3766
+ export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
3767
+ export 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>;
3768
+ export type TypeResolveFn<TTypes, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
3769
+ export type IsTypeOfResolverFn<T = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
3770
+ export type NextResolverFn<T> = () => Promise<T>;
3771
+ export 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>;
2799
3772
  /** Mapping between all available schema types and the resolvers types */
2800
- type ResolversTypes = ResolversObject<{
3773
+ export type ResolversTypes = ResolversObject<{
2801
3774
  Action: ResolverTypeWrapper<Action>;
2802
3775
  ActionCandidateInput: ActionCandidateInput;
2803
3776
  ActionContext: ResolverTypeWrapper<ActionContext>;
@@ -2806,9 +3779,14 @@ type ResolversTypes = ResolversObject<{
2806
3779
  ActionEvaluations: ResolverTypeWrapper<ActionEvaluations>;
2807
3780
  ActionInput: ActionInput;
2808
3781
  AuthDecision: AuthDecision;
3782
+ BatchExecutionResult: ResolverTypeWrapper<BatchExecutionResult>;
3783
+ BatchJobResult: ResolverTypeWrapper<BatchJobResult>;
2809
3784
  Boolean: ResolverTypeWrapper<Scalars["Boolean"]["output"]>;
2810
3785
  ChannelMeta: ResolverTypeWrapper<ChannelMeta>;
2811
3786
  ChannelMetaInput: ChannelMetaInput;
3787
+ ConsistencyCoordinate: ResolverTypeWrapper<ConsistencyCoordinate>;
3788
+ ConsistencyToken: ResolverTypeWrapper<ConsistencyToken>;
3789
+ CreateDefaults: ResolverTypeWrapper<CreateDefaults>;
2812
3790
  DateTime: ResolverTypeWrapper<Scalars["DateTime"]["output"]>;
2813
3791
  DeadLetterInfo: ResolverTypeWrapper<DeadLetterInfo>;
2814
3792
  DocumentChangeContext: ResolverTypeWrapper<DocumentChangeContext>;
@@ -2817,9 +3795,13 @@ type ResolversTypes = ResolversObject<{
2817
3795
  DocumentModelGlobalState: ResolverTypeWrapper<DocumentModelGlobalState>;
2818
3796
  DocumentModelResultPage: ResolverTypeWrapper<DocumentModelResultPage>;
2819
3797
  DocumentOperationsFilterInput: DocumentOperationsFilterInput;
3798
+ DocumentRelationship: ResolverTypeWrapper<DocumentRelationship>;
3799
+ DocumentRelationshipResultPage: ResolverTypeWrapper<DocumentRelationshipResultPage>;
2820
3800
  DocumentWithChildren: ResolverTypeWrapper<DocumentWithChildren>;
3801
+ ExecutionJobInput: ExecutionJobInput;
2821
3802
  Int: ResolverTypeWrapper<Scalars["Int"]["output"]>;
2822
3803
  JSONObject: ResolverTypeWrapper<Scalars["JSONObject"]["output"]>;
3804
+ JobBatchMeta: ResolverTypeWrapper<JobBatchMeta>;
2823
3805
  JobChangeEvent: ResolverTypeWrapper<JobChangeEvent>;
2824
3806
  JobInfo: ResolverTypeWrapper<JobInfo>;
2825
3807
  MoveRelationshipResult: ResolverTypeWrapper<MoveRelationshipResult>;
@@ -2833,6 +3815,9 @@ type ResolversTypes = ResolversObject<{
2833
3815
  PHDocument: ResolverTypeWrapper<PhDocument>;
2834
3816
  PHDocumentResultPage: ResolverTypeWrapper<PhDocumentResultPage>;
2835
3817
  PagingInput: PagingInput;
3818
+ PeerAgreement: ResolverTypeWrapper<PeerAgreement>;
3819
+ PeerAgreementLimit: ResolverTypeWrapper<PeerAgreementLimit>;
3820
+ PeerAgreementMember: ResolverTypeWrapper<PeerAgreementMember>;
2836
3821
  PollSyncEnvelopesResult: ResolverTypeWrapper<PollSyncEnvelopesResult>;
2837
3822
  PropagationMode: PropagationMode;
2838
3823
  Query: ResolverTypeWrapper<Record<PropertyKey, never>>;
@@ -2854,12 +3839,15 @@ type ResolversTypes = ResolversObject<{
2854
3839
  SyncEnvelope: ResolverTypeWrapper<SyncEnvelope>;
2855
3840
  SyncEnvelopeInput: SyncEnvelopeInput;
2856
3841
  SyncEnvelopeType: SyncEnvelopeType;
3842
+ SyncHold: ResolverTypeWrapper<SyncHold>;
3843
+ SyncHoldReason: ResolverTypeWrapper<SyncHoldReason>;
3844
+ SyncRefusalInput: SyncRefusalInput;
2857
3845
  TouchChannelInput: TouchChannelInput;
2858
3846
  TouchChannelResult: ResolverTypeWrapper<TouchChannelResult>;
2859
3847
  ViewFilterInput: ViewFilterInput;
2860
3848
  }>;
2861
3849
  /** Mapping between all available schema types and the resolvers parents */
2862
- type ResolversParentTypes = ResolversObject<{
3850
+ export type ResolversParentTypes = ResolversObject<{
2863
3851
  Action: Action;
2864
3852
  ActionCandidateInput: ActionCandidateInput;
2865
3853
  ActionContext: ActionContext;
@@ -2867,9 +3855,14 @@ type ResolversParentTypes = ResolversObject<{
2867
3855
  ActionEvaluation: ActionEvaluation;
2868
3856
  ActionEvaluations: ActionEvaluations;
2869
3857
  ActionInput: ActionInput;
3858
+ BatchExecutionResult: BatchExecutionResult;
3859
+ BatchJobResult: BatchJobResult;
2870
3860
  Boolean: Scalars["Boolean"]["output"];
2871
3861
  ChannelMeta: ChannelMeta;
2872
3862
  ChannelMetaInput: ChannelMetaInput;
3863
+ ConsistencyCoordinate: ConsistencyCoordinate;
3864
+ ConsistencyToken: ConsistencyToken;
3865
+ CreateDefaults: CreateDefaults;
2873
3866
  DateTime: Scalars["DateTime"]["output"];
2874
3867
  DeadLetterInfo: DeadLetterInfo;
2875
3868
  DocumentChangeContext: DocumentChangeContext;
@@ -2877,9 +3870,13 @@ type ResolversParentTypes = ResolversObject<{
2877
3870
  DocumentModelGlobalState: DocumentModelGlobalState;
2878
3871
  DocumentModelResultPage: DocumentModelResultPage;
2879
3872
  DocumentOperationsFilterInput: DocumentOperationsFilterInput;
3873
+ DocumentRelationship: DocumentRelationship;
3874
+ DocumentRelationshipResultPage: DocumentRelationshipResultPage;
2880
3875
  DocumentWithChildren: DocumentWithChildren;
3876
+ ExecutionJobInput: ExecutionJobInput;
2881
3877
  Int: Scalars["Int"]["output"];
2882
3878
  JSONObject: Scalars["JSONObject"]["output"];
3879
+ JobBatchMeta: JobBatchMeta;
2883
3880
  JobChangeEvent: JobChangeEvent;
2884
3881
  JobInfo: JobInfo;
2885
3882
  MoveRelationshipResult: MoveRelationshipResult;
@@ -2893,6 +3890,9 @@ type ResolversParentTypes = ResolversObject<{
2893
3890
  PHDocument: PhDocument;
2894
3891
  PHDocumentResultPage: PhDocumentResultPage;
2895
3892
  PagingInput: PagingInput;
3893
+ PeerAgreement: PeerAgreement;
3894
+ PeerAgreementLimit: PeerAgreementLimit;
3895
+ PeerAgreementMember: PeerAgreementMember;
2896
3896
  PollSyncEnvelopesResult: PollSyncEnvelopesResult;
2897
3897
  Query: Record<PropertyKey, never>;
2898
3898
  ReactorOperation: ReactorOperation;
@@ -2912,11 +3912,14 @@ type ResolversParentTypes = ResolversObject<{
2912
3912
  Subscription: Record<PropertyKey, never>;
2913
3913
  SyncEnvelope: SyncEnvelope;
2914
3914
  SyncEnvelopeInput: SyncEnvelopeInput;
3915
+ SyncHold: SyncHold;
3916
+ SyncHoldReason: SyncHoldReason;
3917
+ SyncRefusalInput: SyncRefusalInput;
2915
3918
  TouchChannelInput: TouchChannelInput;
2916
3919
  TouchChannelResult: TouchChannelResult;
2917
3920
  ViewFilterInput: ViewFilterInput;
2918
3921
  }>;
2919
- type ActionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Action"] = ResolversParentTypes["Action"]> = ResolversObject<{
3922
+ export type ActionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Action"] = ResolversParentTypes["Action"]> = ResolversObject<{
2920
3923
  context?: Resolver<Maybe<ResolversTypes["ActionContext"]>, ParentType, ContextType>;
2921
3924
  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2922
3925
  input?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
@@ -2924,27 +3927,49 @@ type ActionResolvers<ContextType = Context, ParentType extends ResolversParentTy
2924
3927
  timestampUtcMs?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2925
3928
  type?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2926
3929
  }>;
2927
- type ActionContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionContext"] = ResolversParentTypes["ActionContext"]> = ResolversObject<{
3930
+ export type ActionContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionContext"] = ResolversParentTypes["ActionContext"]> = ResolversObject<{
2928
3931
  signer?: Resolver<Maybe<ResolversTypes["ReactorSigner"]>, ParentType, ContextType>;
2929
3932
  }>;
2930
- type ActionEvaluationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionEvaluation"] = ResolversParentTypes["ActionEvaluation"]> = ResolversObject<{
3933
+ export type ActionEvaluationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionEvaluation"] = ResolversParentTypes["ActionEvaluation"]> = ResolversObject<{
2931
3934
  decision?: Resolver<ResolversTypes["AuthDecision"], ParentType, ContextType>;
2932
3935
  reason?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
2933
3936
  }>;
2934
- type ActionEvaluationsResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionEvaluations"] = ResolversParentTypes["ActionEvaluations"]> = ResolversObject<{
3937
+ export type ActionEvaluationsResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionEvaluations"] = ResolversParentTypes["ActionEvaluations"]> = ResolversObject<{
2935
3938
  allAllowed?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
2936
3939
  allDenied?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
2937
3940
  anyAllowed?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
2938
3941
  anyDenied?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
2939
3942
  evaluations?: Resolver<ReadonlyArray<ResolversTypes["ActionEvaluation"]>, ParentType, ContextType>;
2940
3943
  }>;
2941
- type ChannelMetaResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ChannelMeta"] = ResolversParentTypes["ChannelMeta"]> = ResolversObject<{
3944
+ export type BatchExecutionResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["BatchExecutionResult"] = ResolversParentTypes["BatchExecutionResult"]> = ResolversObject<{
3945
+ jobs?: Resolver<ReadonlyArray<ResolversTypes["BatchJobResult"]>, ParentType, ContextType>;
3946
+ }>;
3947
+ export type BatchJobResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["BatchJobResult"] = ResolversParentTypes["BatchJobResult"]> = ResolversObject<{
3948
+ job?: Resolver<ResolversTypes["JobInfo"], ParentType, ContextType>;
3949
+ key?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3950
+ }>;
3951
+ export type ChannelMetaResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ChannelMeta"] = ResolversParentTypes["ChannelMeta"]> = ResolversObject<{
2942
3952
  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2943
3953
  }>;
2944
- interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["DateTime"], any> {
3954
+ export type ConsistencyCoordinateResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ConsistencyCoordinate"] = ResolversParentTypes["ConsistencyCoordinate"]> = ResolversObject<{
3955
+ branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3956
+ documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3957
+ operationIndex?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3958
+ scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3959
+ }>;
3960
+ export type ConsistencyTokenResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ConsistencyToken"] = ResolversParentTypes["ConsistencyToken"]> = ResolversObject<{
3961
+ coordinates?: Resolver<ReadonlyArray<ResolversTypes["ConsistencyCoordinate"]>, ParentType, ContextType>;
3962
+ createdAtUtcIso?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3963
+ version?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3964
+ }>;
3965
+ export type CreateDefaultsResolvers<ContextType = Context, ParentType extends ResolversParentTypes["CreateDefaults"] = ResolversParentTypes["CreateDefaults"]> = ResolversObject<{
3966
+ protocolVersions?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
3967
+ signaturePolicy?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3968
+ }>;
3969
+ export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["DateTime"], any> {
2945
3970
  name: "DateTime";
2946
3971
  }
2947
- type DeadLetterInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DeadLetterInfo"] = ResolversParentTypes["DeadLetterInfo"]> = ResolversObject<{
3972
+ export type DeadLetterInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DeadLetterInfo"] = ResolversParentTypes["DeadLetterInfo"]> = ResolversObject<{
2948
3973
  branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2949
3974
  documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2950
3975
  error?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
@@ -2953,119 +3978,167 @@ type DeadLetterInfoResolvers<ContextType = Context, ParentType extends Resolvers
2953
3978
  operationCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
2954
3979
  scopes?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
2955
3980
  }>;
2956
- type DocumentChangeContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeContext"] = ResolversParentTypes["DocumentChangeContext"]> = ResolversObject<{
3981
+ export type DocumentChangeContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeContext"] = ResolversParentTypes["DocumentChangeContext"]> = ResolversObject<{
2957
3982
  childId?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
2958
3983
  parentId?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
2959
3984
  }>;
2960
- type DocumentChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeEvent"] = ResolversParentTypes["DocumentChangeEvent"]> = ResolversObject<{
3985
+ export type DocumentChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeEvent"] = ResolversParentTypes["DocumentChangeEvent"]> = ResolversObject<{
2961
3986
  context?: Resolver<Maybe<ResolversTypes["DocumentChangeContext"]>, ParentType, ContextType>;
2962
3987
  documents?: Resolver<ReadonlyArray<ResolversTypes["PHDocument"]>, ParentType, ContextType>;
2963
3988
  type?: Resolver<ResolversTypes["DocumentChangeType"], ParentType, ContextType>;
2964
3989
  }>;
2965
- type DocumentModelGlobalStateResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelGlobalState"] = ResolversParentTypes["DocumentModelGlobalState"]> = ResolversObject<{
3990
+ export type DocumentModelGlobalStateResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelGlobalState"] = ResolversParentTypes["DocumentModelGlobalState"]> = ResolversObject<{
2966
3991
  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2967
3992
  name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2968
3993
  namespace?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
2969
3994
  specification?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
2970
3995
  version?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
2971
3996
  }>;
2972
- type DocumentModelResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelResultPage"] = ResolversParentTypes["DocumentModelResultPage"]> = ResolversObject<{
3997
+ export type DocumentModelResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelResultPage"] = ResolversParentTypes["DocumentModelResultPage"]> = ResolversObject<{
2973
3998
  cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
2974
3999
  hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
2975
4000
  hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
2976
4001
  items?: Resolver<ReadonlyArray<ResolversTypes["DocumentModelGlobalState"]>, ParentType, ContextType>;
2977
- totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
2978
4002
  }>;
2979
- type DocumentWithChildrenResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentWithChildren"] = ResolversParentTypes["DocumentWithChildren"]> = ResolversObject<{
4003
+ export type DocumentRelationshipResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentRelationship"] = ResolversParentTypes["DocumentRelationship"]> = ResolversObject<{
4004
+ createdAt?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
4005
+ metadata?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
4006
+ relationshipType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4007
+ sourceId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4008
+ targetId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4009
+ updatedAt?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
4010
+ }>;
4011
+ export type DocumentRelationshipResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentRelationshipResultPage"] = ResolversParentTypes["DocumentRelationshipResultPage"]> = ResolversObject<{
4012
+ cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
4013
+ hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
4014
+ hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
4015
+ items?: Resolver<ReadonlyArray<ResolversTypes["DocumentRelationship"]>, ParentType, ContextType>;
4016
+ }>;
4017
+ export type DocumentWithChildrenResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentWithChildren"] = ResolversParentTypes["DocumentWithChildren"]> = ResolversObject<{
2980
4018
  childIds?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
2981
4019
  document?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
2982
4020
  }>;
2983
- interface JsonObjectScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["JSONObject"], any> {
4021
+ export interface JsonObjectScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["JSONObject"], any> {
2984
4022
  name: "JSONObject";
2985
4023
  }
2986
- type JobChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobChangeEvent"] = ResolversParentTypes["JobChangeEvent"]> = ResolversObject<{
4024
+ export type JobBatchMetaResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobBatchMeta"] = ResolversParentTypes["JobBatchMeta"]> = ResolversObject<{
4025
+ batchId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4026
+ batchJobIds?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
4027
+ }>;
4028
+ export type JobChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobChangeEvent"] = ResolversParentTypes["JobChangeEvent"]> = ResolversObject<{
2987
4029
  error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
2988
4030
  jobId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2989
- result?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
4031
+ result?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
2990
4032
  status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2991
4033
  }>;
2992
- type JobInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobInfo"] = ResolversParentTypes["JobInfo"]> = ResolversObject<{
4034
+ export type JobInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobInfo"] = ResolversParentTypes["JobInfo"]> = ResolversObject<{
2993
4035
  completedAt?: Resolver<Maybe<ResolversTypes["DateTime"]>, ParentType, ContextType>;
4036
+ consistencyToken?: Resolver<ResolversTypes["ConsistencyToken"], ParentType, ContextType>;
2994
4037
  createdAt?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
4038
+ documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2995
4039
  error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
4040
+ errorName?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
2996
4041
  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4042
+ meta?: Resolver<ResolversTypes["JobBatchMeta"], ParentType, ContextType>;
2997
4043
  result?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
2998
4044
  status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
2999
4045
  }>;
3000
- type MoveRelationshipResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["MoveRelationshipResult"] = ResolversParentTypes["MoveRelationshipResult"]> = ResolversObject<{
4046
+ export type MoveRelationshipResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["MoveRelationshipResult"] = ResolversParentTypes["MoveRelationshipResult"]> = ResolversObject<{
3001
4047
  source?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
3002
4048
  target?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
3003
4049
  }>;
3004
- type MutationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Mutation"] = ResolversParentTypes["Mutation"]> = ResolversObject<{
3005
- addRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationAddRelationshipArgs, "relationshipType" | "sourceIdentifier" | "targetIdentifier">>;
4050
+ export type MutationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Mutation"] = ResolversParentTypes["Mutation"]> = ResolversObject<{
4051
+ addRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationAddRelationshipArgs, "relationshipType">>;
3006
4052
  createDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationCreateDocumentArgs, "document">>;
3007
4053
  createEmptyDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationCreateEmptyDocumentArgs, "documentType">>;
3008
- deleteDocument?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationDeleteDocumentArgs, "identifier">>;
3009
- deleteDocuments?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationDeleteDocumentsArgs, "identifiers">>;
3010
- execute?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationExecuteArgs, "actions" | "documentIdentifier">>;
3011
- executeAsync?: Resolver<ResolversTypes["JobInfo"], ParentType, ContextType, RequireFields<MutationExecuteAsyncArgs, "actions" | "documentIdentifier">>;
3012
- moveRelationship?: Resolver<ResolversTypes["MoveRelationshipResult"], ParentType, ContextType, RequireFields<MutationMoveRelationshipArgs, "relationshipType" | "sourceParentIdentifier" | "targetIdentifier" | "targetParentIdentifier">>;
4054
+ deleteDocument?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, Partial<MutationDeleteDocumentArgs>>;
4055
+ deleteDocuments?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, Partial<MutationDeleteDocumentsArgs>>;
4056
+ execute?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationExecuteArgs, "actions">>;
4057
+ executeAsync?: Resolver<ResolversTypes["JobInfo"], ParentType, ContextType, RequireFields<MutationExecuteAsyncArgs, "actions">>;
4058
+ executeBatch?: Resolver<ResolversTypes["BatchExecutionResult"], ParentType, ContextType, RequireFields<MutationExecuteBatchArgs, "jobs">>;
4059
+ moveRelationship?: Resolver<ResolversTypes["MoveRelationshipResult"], ParentType, ContextType, RequireFields<MutationMoveRelationshipArgs, "relationshipType">>;
3013
4060
  mutateDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationMutateDocumentArgs, "actions" | "documentIdentifier">>;
3014
4061
  mutateDocumentAsync?: Resolver<ResolversTypes["String"], ParentType, ContextType, RequireFields<MutationMutateDocumentAsyncArgs, "actions" | "documentIdentifier">>;
3015
4062
  pushSyncEnvelopes?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationPushSyncEnvelopesArgs, "envelopes">>;
3016
- removeRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRemoveRelationshipArgs, "relationshipType" | "sourceIdentifier" | "targetIdentifier">>;
3017
- renameDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRenameDocumentArgs, "documentIdentifier" | "name">>;
3018
- setPreferredEditor?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationSetPreferredEditorArgs, "documentIdentifier">>;
4063
+ removeRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRemoveRelationshipArgs, "relationshipType">>;
4064
+ renameDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRenameDocumentArgs, "name">>;
4065
+ setPreferredEditor?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, Partial<MutationSetPreferredEditorArgs>>;
3019
4066
  touchChannel?: Resolver<ResolversTypes["TouchChannelResult"], ParentType, ContextType, RequireFields<MutationTouchChannelArgs, "input">>;
4067
+ updateRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationUpdateRelationshipArgs, "relationshipType">>;
3020
4068
  }>;
3021
- type OperationContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationContext"] = ResolversParentTypes["OperationContext"]> = ResolversObject<{
4069
+ export type OperationContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationContext"] = ResolversParentTypes["OperationContext"]> = ResolversObject<{
3022
4070
  branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3023
4071
  documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3024
4072
  documentType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3025
4073
  ordinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3026
4074
  scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3027
4075
  }>;
3028
- type OperationWithContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationWithContext"] = ResolversParentTypes["OperationWithContext"]> = ResolversObject<{
4076
+ export type OperationWithContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationWithContext"] = ResolversParentTypes["OperationWithContext"]> = ResolversObject<{
3029
4077
  context?: Resolver<ResolversTypes["OperationContext"], ParentType, ContextType>;
3030
4078
  operation?: Resolver<ResolversTypes["ReactorOperation"], ParentType, ContextType>;
3031
4079
  }>;
3032
- type PhDocumentResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocument"] = ResolversParentTypes["PHDocument"]> = ResolversObject<{
4080
+ export type PhDocumentResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocument"] = ResolversParentTypes["PHDocument"]> = ResolversObject<{
3033
4081
  createdAtUtcIso?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
3034
4082
  documentType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3035
4083
  id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3036
4084
  lastModifiedAtUtcIso?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
4085
+ meta?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
3037
4086
  name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3038
4087
  operations?: Resolver<Maybe<ResolversTypes["ReactorOperationResultPage"]>, ParentType, ContextType, Partial<PhDocumentOperationsArgs>>;
3039
4088
  preferredEditor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
4089
+ protocolVersions?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
3040
4090
  revisionsList?: Resolver<ReadonlyArray<ResolversTypes["Revision"]>, ParentType, ContextType>;
3041
4091
  slug?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
3042
4092
  state?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
3043
4093
  }>;
3044
- type PhDocumentResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocumentResultPage"] = ResolversParentTypes["PHDocumentResultPage"]> = ResolversObject<{
4094
+ export type PhDocumentResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocumentResultPage"] = ResolversParentTypes["PHDocumentResultPage"]> = ResolversObject<{
3045
4095
  cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
3046
4096
  hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
3047
4097
  hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
3048
4098
  items?: Resolver<ReadonlyArray<ResolversTypes["PHDocument"]>, ParentType, ContextType>;
3049
- totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3050
4099
  }>;
3051
- type PollSyncEnvelopesResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PollSyncEnvelopesResult"] = ResolversParentTypes["PollSyncEnvelopesResult"]> = ResolversObject<{
4100
+ export type PeerAgreementResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PeerAgreement"] = ResolversParentTypes["PeerAgreement"]> = ResolversObject<{
4101
+ collectionId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4102
+ limitedBy?: Resolver<ReadonlyArray<ResolversTypes["PeerAgreementLimit"]>, ParentType, ContextType>;
4103
+ local?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
4104
+ members?: Resolver<ReadonlyArray<ResolversTypes["PeerAgreementMember"]>, ParentType, ContextType>;
4105
+ }>;
4106
+ export type PeerAgreementLimitResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PeerAgreementLimit"] = ResolversParentTypes["PeerAgreementLimit"]> = ResolversObject<{
4107
+ protocol?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4108
+ remoteNames?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
4109
+ }>;
4110
+ export type PeerAgreementMemberResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PeerAgreementMember"] = ResolversParentTypes["PeerAgreementMember"]> = ResolversObject<{
4111
+ announced?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
4112
+ features?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
4113
+ protocols?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
4114
+ remoteName?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4115
+ }>;
4116
+ export type PollSyncEnvelopesResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PollSyncEnvelopesResult"] = ResolversParentTypes["PollSyncEnvelopesResult"]> = ResolversObject<{
3052
4117
  ackOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3053
4118
  deadLetters?: Resolver<ReadonlyArray<ResolversTypes["DeadLetterInfo"]>, ParentType, ContextType>;
3054
4119
  envelopes?: Resolver<ReadonlyArray<ResolversTypes["SyncEnvelope"]>, ParentType, ContextType>;
3055
4120
  hasMore?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
4121
+ manifestRevision?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
4122
+ peerManifestRevision?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
3056
4123
  }>;
3057
- type QueryResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Query"] = ResolversParentTypes["Query"]> = ResolversObject<{
3058
- document?: Resolver<Maybe<ResolversTypes["DocumentWithChildren"]>, ParentType, ContextType, RequireFields<QueryDocumentArgs, "identifier">>;
3059
- documentIncomingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentIncomingRelationshipsArgs, "relationshipType" | "targetIdentifier">>;
4124
+ export type QueryResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Query"] = ResolversParentTypes["Query"]> = ResolversObject<{
4125
+ createDefaults?: Resolver<ResolversTypes["CreateDefaults"], ParentType, ContextType, Partial<QueryCreateDefaultsArgs>>;
4126
+ document?: Resolver<Maybe<ResolversTypes["DocumentWithChildren"]>, ParentType, ContextType, Partial<QueryDocumentArgs>>;
4127
+ documentIncomingRelationshipEdges?: Resolver<ResolversTypes["DocumentRelationshipResultPage"], ParentType, ContextType, Partial<QueryDocumentIncomingRelationshipEdgesArgs>>;
4128
+ documentIncomingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentIncomingRelationshipsArgs, "relationshipType">>;
3060
4129
  documentModels?: Resolver<ResolversTypes["DocumentModelResultPage"], ParentType, ContextType, Partial<QueryDocumentModelsArgs>>;
3061
4130
  documentOperations?: Resolver<ResolversTypes["ReactorOperationResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOperationsArgs, "filter">>;
3062
- documentOutgoingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOutgoingRelationshipsArgs, "relationshipType" | "sourceIdentifier">>;
3063
- evaluateActions?: Resolver<ResolversTypes["ActionEvaluations"], ParentType, ContextType, RequireFields<QueryEvaluateActionsArgs, "candidates" | "documentIdentifier">>;
4131
+ documentOutgoingRelationshipEdges?: Resolver<ResolversTypes["DocumentRelationshipResultPage"], ParentType, ContextType, Partial<QueryDocumentOutgoingRelationshipEdgesArgs>>;
4132
+ documentOutgoingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOutgoingRelationshipsArgs, "relationshipType">>;
4133
+ documentServed?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<QueryDocumentServedArgs, "idOrSlug">>;
4134
+ evaluateActions?: Resolver<ResolversTypes["ActionEvaluations"], ParentType, ContextType, RequireFields<QueryEvaluateActionsArgs, "candidates">>;
3064
4135
  findDocuments?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, Partial<QueryFindDocumentsArgs>>;
3065
4136
  jobStatus?: Resolver<Maybe<ResolversTypes["JobInfo"]>, ParentType, ContextType, RequireFields<QueryJobStatusArgs, "jobId">>;
4137
+ peerAgreement?: Resolver<ResolversTypes["PeerAgreement"], ParentType, ContextType, RequireFields<QueryPeerAgreementArgs, "collectionId">>;
3066
4138
  pollSyncEnvelopes?: Resolver<ResolversTypes["PollSyncEnvelopesResult"], ParentType, ContextType, RequireFields<QueryPollSyncEnvelopesArgs, "channelId" | "outboxAck" | "outboxLatest">>;
4139
+ syncHolds?: Resolver<ReadonlyArray<ResolversTypes["SyncHold"]>, ParentType, ContextType, Partial<QuerySyncHoldsArgs>>;
3067
4140
  }>;
3068
- type ReactorOperationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperation"] = ResolversParentTypes["ReactorOperation"]> = ResolversObject<{
4141
+ export type ReactorOperationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperation"] = ResolversParentTypes["ReactorOperation"]> = ResolversObject<{
3069
4142
  action?: Resolver<ResolversTypes["Action"], ParentType, ContextType>;
3070
4143
  deniedReason?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
3071
4144
  error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
@@ -3075,41 +4148,40 @@ type ReactorOperationResolvers<ContextType = Context, ParentType extends Resolve
3075
4148
  skip?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3076
4149
  timestampUtcMs?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3077
4150
  }>;
3078
- type ReactorOperationResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperationResultPage"] = ResolversParentTypes["ReactorOperationResultPage"]> = ResolversObject<{
4151
+ export type ReactorOperationResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperationResultPage"] = ResolversParentTypes["ReactorOperationResultPage"]> = ResolversObject<{
3079
4152
  cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
3080
4153
  hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
3081
4154
  hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
3082
4155
  items?: Resolver<ReadonlyArray<ResolversTypes["ReactorOperation"]>, ParentType, ContextType>;
3083
- totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3084
4156
  }>;
3085
- type ReactorSignerResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSigner"] = ResolversParentTypes["ReactorSigner"]> = ResolversObject<{
4157
+ export type ReactorSignerResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSigner"] = ResolversParentTypes["ReactorSigner"]> = ResolversObject<{
3086
4158
  app?: Resolver<Maybe<ResolversTypes["ReactorSignerApp"]>, ParentType, ContextType>;
3087
4159
  signatures?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
3088
4160
  user?: Resolver<Maybe<ResolversTypes["ReactorSignerUser"]>, ParentType, ContextType>;
3089
4161
  }>;
3090
- type ReactorSignerAppResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerApp"] = ResolversParentTypes["ReactorSignerApp"]> = ResolversObject<{
4162
+ export type ReactorSignerAppResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerApp"] = ResolversParentTypes["ReactorSignerApp"]> = ResolversObject<{
3091
4163
  key?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3092
4164
  name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3093
4165
  }>;
3094
- type ReactorSignerUserResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerUser"] = ResolversParentTypes["ReactorSignerUser"]> = ResolversObject<{
4166
+ export type ReactorSignerUserResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerUser"] = ResolversParentTypes["ReactorSignerUser"]> = ResolversObject<{
3095
4167
  address?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3096
4168
  chainId?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3097
4169
  networkId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3098
4170
  }>;
3099
- type RemoteCursorResolvers<ContextType = Context, ParentType extends ResolversParentTypes["RemoteCursor"] = ResolversParentTypes["RemoteCursor"]> = ResolversObject<{
4171
+ export type RemoteCursorResolvers<ContextType = Context, ParentType extends ResolversParentTypes["RemoteCursor"] = ResolversParentTypes["RemoteCursor"]> = ResolversObject<{
3100
4172
  cursorOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3101
4173
  lastSyncedAtUtcMs?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
3102
4174
  remoteName?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3103
4175
  }>;
3104
- type RevisionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Revision"] = ResolversParentTypes["Revision"]> = ResolversObject<{
4176
+ export type RevisionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Revision"] = ResolversParentTypes["Revision"]> = ResolversObject<{
3105
4177
  revision?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
3106
4178
  scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
3107
4179
  }>;
3108
- type SubscriptionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Subscription"] = ResolversParentTypes["Subscription"]> = ResolversObject<{
4180
+ export type SubscriptionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Subscription"] = ResolversParentTypes["Subscription"]> = ResolversObject<{
3109
4181
  documentChanges?: SubscriptionResolver<ResolversTypes["DocumentChangeEvent"], "documentChanges", ParentType, ContextType, Partial<SubscriptionDocumentChangesArgs>>;
3110
4182
  jobChanges?: SubscriptionResolver<ResolversTypes["JobChangeEvent"], "jobChanges", ParentType, ContextType, RequireFields<SubscriptionJobChangesArgs, "jobId">>;
3111
4183
  }>;
3112
- type SyncEnvelopeResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncEnvelope"] = ResolversParentTypes["SyncEnvelope"]> = ResolversObject<{
4184
+ export type SyncEnvelopeResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncEnvelope"] = ResolversParentTypes["SyncEnvelope"]> = ResolversObject<{
3113
4185
  channelMeta?: Resolver<ResolversTypes["ChannelMeta"], ParentType, ContextType>;
3114
4186
  cursor?: Resolver<Maybe<ResolversTypes["RemoteCursor"]>, ParentType, ContextType>;
3115
4187
  dependsOn?: Resolver<Maybe<ReadonlyArray<ResolversTypes["String"]>>, ParentType, ContextType>;
@@ -3117,24 +4189,45 @@ type SyncEnvelopeResolvers<ContextType = Context, ParentType extends ResolversPa
3117
4189
  operations?: Resolver<Maybe<ReadonlyArray<ResolversTypes["OperationWithContext"]>>, ParentType, ContextType>;
3118
4190
  type?: Resolver<ResolversTypes["SyncEnvelopeType"], ParentType, ContextType>;
3119
4191
  }>;
3120
- type TouchChannelResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["TouchChannelResult"] = ResolversParentTypes["TouchChannelResult"]> = ResolversObject<{
4192
+ export type SyncHoldResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncHold"] = ResolversParentTypes["SyncHold"]> = ResolversObject<{
4193
+ branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4194
+ documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4195
+ heldAtUtcMs?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4196
+ reason?: Resolver<ResolversTypes["SyncHoldReason"], ParentType, ContextType>;
4197
+ remoteName?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4198
+ }>;
4199
+ export type SyncHoldReasonResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncHoldReason"] = ResolversParentTypes["SyncHoldReason"]> = ResolversObject<{
4200
+ peerSupports?: Resolver<ReadonlyArray<ResolversTypes["Int"]>, ParentType, ContextType>;
4201
+ protocol?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
4202
+ version?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
4203
+ }>;
4204
+ export type TouchChannelResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["TouchChannelResult"] = ResolversParentTypes["TouchChannelResult"]> = ResolversObject<{
3121
4205
  ackOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
4206
+ manifest?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
3122
4207
  success?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
3123
4208
  }>;
3124
- type Resolvers<ContextType = Context> = ResolversObject<{
4209
+ export type Resolvers<ContextType = Context> = ResolversObject<{
3125
4210
  Action?: ActionResolvers<ContextType>;
3126
4211
  ActionContext?: ActionContextResolvers<ContextType>;
3127
4212
  ActionEvaluation?: ActionEvaluationResolvers<ContextType>;
3128
4213
  ActionEvaluations?: ActionEvaluationsResolvers<ContextType>;
4214
+ BatchExecutionResult?: BatchExecutionResultResolvers<ContextType>;
4215
+ BatchJobResult?: BatchJobResultResolvers<ContextType>;
3129
4216
  ChannelMeta?: ChannelMetaResolvers<ContextType>;
4217
+ ConsistencyCoordinate?: ConsistencyCoordinateResolvers<ContextType>;
4218
+ ConsistencyToken?: ConsistencyTokenResolvers<ContextType>;
4219
+ CreateDefaults?: CreateDefaultsResolvers<ContextType>;
3130
4220
  DateTime?: GraphQLScalarType;
3131
4221
  DeadLetterInfo?: DeadLetterInfoResolvers<ContextType>;
3132
4222
  DocumentChangeContext?: DocumentChangeContextResolvers<ContextType>;
3133
4223
  DocumentChangeEvent?: DocumentChangeEventResolvers<ContextType>;
3134
4224
  DocumentModelGlobalState?: DocumentModelGlobalStateResolvers<ContextType>;
3135
4225
  DocumentModelResultPage?: DocumentModelResultPageResolvers<ContextType>;
4226
+ DocumentRelationship?: DocumentRelationshipResolvers<ContextType>;
4227
+ DocumentRelationshipResultPage?: DocumentRelationshipResultPageResolvers<ContextType>;
3136
4228
  DocumentWithChildren?: DocumentWithChildrenResolvers<ContextType>;
3137
4229
  JSONObject?: GraphQLScalarType;
4230
+ JobBatchMeta?: JobBatchMetaResolvers<ContextType>;
3138
4231
  JobChangeEvent?: JobChangeEventResolvers<ContextType>;
3139
4232
  JobInfo?: JobInfoResolvers<ContextType>;
3140
4233
  MoveRelationshipResult?: MoveRelationshipResultResolvers<ContextType>;
@@ -3143,6 +4236,9 @@ type Resolvers<ContextType = Context> = ResolversObject<{
3143
4236
  OperationWithContext?: OperationWithContextResolvers<ContextType>;
3144
4237
  PHDocument?: PhDocumentResolvers<ContextType>;
3145
4238
  PHDocumentResultPage?: PhDocumentResultPageResolvers<ContextType>;
4239
+ PeerAgreement?: PeerAgreementResolvers<ContextType>;
4240
+ PeerAgreementLimit?: PeerAgreementLimitResolvers<ContextType>;
4241
+ PeerAgreementMember?: PeerAgreementMemberResolvers<ContextType>;
3146
4242
  PollSyncEnvelopesResult?: PollSyncEnvelopesResultResolvers<ContextType>;
3147
4243
  Query?: QueryResolvers<ContextType>;
3148
4244
  ReactorOperation?: ReactorOperationResolvers<ContextType>;
@@ -3154,79 +4250,97 @@ type Resolvers<ContextType = Context> = ResolversObject<{
3154
4250
  Revision?: RevisionResolvers<ContextType>;
3155
4251
  Subscription?: SubscriptionResolvers<ContextType>;
3156
4252
  SyncEnvelope?: SyncEnvelopeResolvers<ContextType>;
4253
+ SyncHold?: SyncHoldResolvers<ContextType>;
4254
+ SyncHoldReason?: SyncHoldReasonResolvers<ContextType>;
3157
4255
  TouchChannelResult?: TouchChannelResultResolvers<ContextType>;
3158
4256
  }>;
3159
- type Properties<T> = Required<{ [K in keyof T]: z$1.ZodType<T[K]> }>;
4257
+ type Properties<T> = Required<{ [K in keyof T]: z$1.ZodType<T[K]>; }>;
3160
4258
  type definedNonNullAny = {};
3161
- declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
3162
- declare const definedNonNullAnySchema: z$1.ZodAny & z$1.ZodType<definedNonNullAny, any, z$1.core.$ZodTypeInternals<definedNonNullAny, any>>;
3163
- declare const AuthDecisionSchema: z$1.ZodEnum<typeof AuthDecision>;
3164
- declare const DocumentChangeTypeSchema: z$1.ZodEnum<typeof DocumentChangeType>;
3165
- declare const PropagationModeSchema: z$1.ZodEnum<typeof PropagationMode>;
3166
- declare const SyncEnvelopeTypeSchema: z$1.ZodEnum<typeof SyncEnvelopeType>;
3167
- declare function ActionCandidateInputSchema(): z$1.ZodObject<Properties<ActionCandidateInput>>;
3168
- declare function ActionContextInputSchema(): z$1.ZodObject<Properties<ActionContextInput>>;
3169
- declare function ActionInputSchema(): z$1.ZodObject<Properties<ActionInput>>;
3170
- declare function ChannelMetaInputSchema(): z$1.ZodObject<Properties<ChannelMetaInput>>;
3171
- declare function DocumentOperationsFilterInputSchema(): z$1.ZodObject<Properties<DocumentOperationsFilterInput>>;
3172
- declare function OperationContextInputSchema(): z$1.ZodObject<Properties<OperationContextInput>>;
3173
- declare function OperationInputSchema(): z$1.ZodObject<Properties<OperationInput>>;
3174
- declare function OperationWithContextInputSchema(): z$1.ZodObject<Properties<OperationWithContextInput>>;
3175
- declare function OperationsFilterInputSchema(): z$1.ZodObject<Properties<OperationsFilterInput>>;
3176
- declare function PagingInputSchema(): z$1.ZodObject<Properties<PagingInput>>;
3177
- declare function ReactorSignerAppInputSchema(): z$1.ZodObject<Properties<ReactorSignerAppInput>>;
3178
- declare function ReactorSignerInputSchema(): z$1.ZodObject<Properties<ReactorSignerInput>>;
3179
- declare function ReactorSignerUserInputSchema(): z$1.ZodObject<Properties<ReactorSignerUserInput>>;
3180
- declare function RemoteCursorInputSchema(): z$1.ZodObject<Properties<RemoteCursorInput>>;
3181
- declare function RemoteFilterInputSchema(): z$1.ZodObject<Properties<RemoteFilterInput>>;
3182
- declare function SearchFilterInputSchema(): z$1.ZodObject<Properties<SearchFilterInput>>;
3183
- declare function SyncEnvelopeInputSchema(): z$1.ZodObject<Properties<SyncEnvelopeInput>>;
3184
- declare function TouchChannelInputSchema(): z$1.ZodObject<Properties<TouchChannelInput>>;
3185
- declare function ViewFilterInputSchema(): z$1.ZodObject<Properties<ViewFilterInput>>;
3186
- declare const PhDocumentFieldsFragmentDoc: DocumentNode;
3187
- declare const GetDocumentModelsDocument: DocumentNode;
3188
- declare const GetDocumentDocument: DocumentNode;
3189
- declare const GetDocumentWithOperationsDocument: DocumentNode;
3190
- declare const GetDocumentOutgoingRelationshipsDocument: DocumentNode;
3191
- declare const GetDocumentIncomingRelationshipsDocument: DocumentNode;
3192
- declare const FindDocumentsDocument: DocumentNode;
3193
- declare const GetDocumentOperationsDocument: DocumentNode;
3194
- declare const GetJobStatusDocument: DocumentNode;
3195
- declare const EvaluateActionsDocument: DocumentNode;
3196
- declare const CreateDocumentDocument: DocumentNode;
3197
- declare const CreateEmptyDocumentDocument: DocumentNode;
3198
- declare const MutateDocumentDocument: DocumentNode;
3199
- declare const MutateDocumentAsyncDocument: DocumentNode;
3200
- declare const RenameDocumentDocument: DocumentNode;
3201
- declare const SetPreferredEditorDocument: DocumentNode;
3202
- declare const AddRelationshipDocument: DocumentNode;
3203
- declare const RemoveRelationshipDocument: DocumentNode;
3204
- declare const MoveRelationshipDocument: DocumentNode;
3205
- declare const DeleteDocumentDocument: DocumentNode;
3206
- declare const DeleteDocumentsDocument: DocumentNode;
3207
- declare const DocumentChangesDocument: DocumentNode;
3208
- declare const JobChangesDocument: DocumentNode;
3209
- declare const PollSyncEnvelopesDocument: DocumentNode;
3210
- declare const TouchChannelDocument: DocumentNode;
3211
- declare const PushSyncEnvelopesDocument: DocumentNode;
3212
- type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
3213
- declare function getSdk<C>(requester: Requester<C>): {
4259
+ export declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
4260
+ export declare const definedNonNullAnySchema: z$1.ZodAny & z$1.ZodType<definedNonNullAny, any, z$1.core.$ZodTypeInternals<definedNonNullAny, any>>;
4261
+ export declare const AuthDecisionSchema: z$1.ZodEnum<typeof AuthDecision>;
4262
+ export declare const DocumentChangeTypeSchema: z$1.ZodEnum<typeof DocumentChangeType>;
4263
+ export declare const PropagationModeSchema: z$1.ZodEnum<typeof PropagationMode>;
4264
+ export declare const SyncEnvelopeTypeSchema: z$1.ZodEnum<typeof SyncEnvelopeType>;
4265
+ export declare function ActionCandidateInputSchema(): z$1.ZodObject<Properties<ActionCandidateInput>>;
4266
+ export declare function ActionContextInputSchema(): z$1.ZodObject<Properties<ActionContextInput>>;
4267
+ export declare function ActionInputSchema(): z$1.ZodObject<Properties<ActionInput>>;
4268
+ export declare function ChannelMetaInputSchema(): z$1.ZodObject<Properties<ChannelMetaInput>>;
4269
+ export declare function DocumentOperationsFilterInputSchema(): z$1.ZodObject<Properties<DocumentOperationsFilterInput>>;
4270
+ export declare function ExecutionJobInputSchema(): z$1.ZodObject<Properties<ExecutionJobInput>>;
4271
+ export declare function OperationContextInputSchema(): z$1.ZodObject<Properties<OperationContextInput>>;
4272
+ export declare function OperationInputSchema(): z$1.ZodObject<Properties<OperationInput>>;
4273
+ export declare function OperationWithContextInputSchema(): z$1.ZodObject<Properties<OperationWithContextInput>>;
4274
+ export declare function OperationsFilterInputSchema(): z$1.ZodObject<Properties<OperationsFilterInput>>;
4275
+ export declare function PagingInputSchema(): z$1.ZodObject<Properties<PagingInput>>;
4276
+ export declare function ReactorSignerAppInputSchema(): z$1.ZodObject<Properties<ReactorSignerAppInput>>;
4277
+ export declare function ReactorSignerInputSchema(): z$1.ZodObject<Properties<ReactorSignerInput>>;
4278
+ export declare function ReactorSignerUserInputSchema(): z$1.ZodObject<Properties<ReactorSignerUserInput>>;
4279
+ export declare function RemoteCursorInputSchema(): z$1.ZodObject<Properties<RemoteCursorInput>>;
4280
+ export declare function RemoteFilterInputSchema(): z$1.ZodObject<Properties<RemoteFilterInput>>;
4281
+ export declare function SearchFilterInputSchema(): z$1.ZodObject<Properties<SearchFilterInput>>;
4282
+ export declare function SyncEnvelopeInputSchema(): z$1.ZodObject<Properties<SyncEnvelopeInput>>;
4283
+ export declare function SyncRefusalInputSchema(): z$1.ZodObject<Properties<SyncRefusalInput>>;
4284
+ export declare function TouchChannelInputSchema(): z$1.ZodObject<Properties<TouchChannelInput>>;
4285
+ export declare function ViewFilterInputSchema(): z$1.ZodObject<Properties<ViewFilterInput>>;
4286
+ export declare const PhDocumentFieldsFragmentDoc: DocumentNode;
4287
+ export declare const DocumentRelationshipFieldsFragmentDoc: DocumentNode;
4288
+ export declare const JobInfoFieldsFragmentDoc: DocumentNode;
4289
+ export declare const GetDocumentModelsDocument: DocumentNode;
4290
+ export declare const GetDocumentDocument: DocumentNode;
4291
+ export declare const GetDocumentWithOperationsDocument: DocumentNode;
4292
+ export declare const GetDocumentOutgoingRelationshipsDocument: DocumentNode;
4293
+ export declare const GetDocumentIncomingRelationshipsDocument: DocumentNode;
4294
+ export declare const GetDocumentOutgoingRelationshipEdgesDocument: DocumentNode;
4295
+ export declare const GetDocumentIncomingRelationshipEdgesDocument: DocumentNode;
4296
+ export declare const FindDocumentsDocument: DocumentNode;
4297
+ export declare const GetDocumentOperationsDocument: DocumentNode;
4298
+ export declare const GetJobStatusDocument: DocumentNode;
4299
+ export declare const GetDocumentServedDocument: DocumentNode;
4300
+ export declare const GetCreateDefaultsDocument: DocumentNode;
4301
+ export declare const EvaluateActionsDocument: DocumentNode;
4302
+ export declare const CreateDocumentDocument: DocumentNode;
4303
+ export declare const CreateEmptyDocumentDocument: DocumentNode;
4304
+ export declare const MutateDocumentDocument: DocumentNode;
4305
+ export declare const MutateDocumentAsyncDocument: DocumentNode;
4306
+ export declare const ExecuteBatchDocument: DocumentNode;
4307
+ export declare const RenameDocumentDocument: DocumentNode;
4308
+ export declare const SetPreferredEditorDocument: DocumentNode;
4309
+ export declare const AddRelationshipDocument: DocumentNode;
4310
+ export declare const UpdateRelationshipDocument: DocumentNode;
4311
+ export declare const RemoveRelationshipDocument: DocumentNode;
4312
+ export declare const MoveRelationshipDocument: DocumentNode;
4313
+ export declare const DeleteDocumentDocument: DocumentNode;
4314
+ export declare const DeleteDocumentsDocument: DocumentNode;
4315
+ export declare const DocumentChangesDocument: DocumentNode;
4316
+ export declare const JobChangesDocument: DocumentNode;
4317
+ export declare const PollSyncEnvelopesDocument: DocumentNode;
4318
+ export declare const TouchChannelDocument: DocumentNode;
4319
+ export declare const PushSyncEnvelopesDocument: DocumentNode;
4320
+ export type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
4321
+ export declare function getSdk<C>(requester: Requester<C>): {
3214
4322
  GetDocumentModels(variables?: GetDocumentModelsQueryVariables, options?: C): Promise<GetDocumentModelsQuery>;
3215
4323
  GetDocument(variables: GetDocumentQueryVariables, options?: C): Promise<GetDocumentQuery>;
3216
4324
  GetDocumentWithOperations(variables: GetDocumentWithOperationsQueryVariables, options?: C): Promise<GetDocumentWithOperationsQuery>;
3217
4325
  GetDocumentOutgoingRelationships(variables: GetDocumentOutgoingRelationshipsQueryVariables, options?: C): Promise<GetDocumentOutgoingRelationshipsQuery>;
3218
4326
  GetDocumentIncomingRelationships(variables: GetDocumentIncomingRelationshipsQueryVariables, options?: C): Promise<GetDocumentIncomingRelationshipsQuery>;
4327
+ GetDocumentOutgoingRelationshipEdges(variables: GetDocumentOutgoingRelationshipEdgesQueryVariables, options?: C): Promise<GetDocumentOutgoingRelationshipEdgesQuery>;
4328
+ GetDocumentIncomingRelationshipEdges(variables: GetDocumentIncomingRelationshipEdgesQueryVariables, options?: C): Promise<GetDocumentIncomingRelationshipEdgesQuery>;
3219
4329
  FindDocuments(variables?: FindDocumentsQueryVariables, options?: C): Promise<FindDocumentsQuery>;
3220
4330
  GetDocumentOperations(variables: GetDocumentOperationsQueryVariables, options?: C): Promise<GetDocumentOperationsQuery>;
3221
4331
  GetJobStatus(variables: GetJobStatusQueryVariables, options?: C): Promise<GetJobStatusQuery>;
4332
+ GetDocumentServed(variables: GetDocumentServedQueryVariables, options?: C): Promise<GetDocumentServedQuery>;
4333
+ GetCreateDefaults(variables?: GetCreateDefaultsQueryVariables, options?: C): Promise<GetCreateDefaultsQuery>;
3222
4334
  EvaluateActions(variables: EvaluateActionsQueryVariables, options?: C): Promise<EvaluateActionsQuery>;
3223
4335
  CreateDocument(variables: CreateDocumentMutationVariables, options?: C): Promise<CreateDocumentMutation>;
3224
4336
  CreateEmptyDocument(variables: CreateEmptyDocumentMutationVariables, options?: C): Promise<CreateEmptyDocumentMutation>;
3225
4337
  MutateDocument(variables: MutateDocumentMutationVariables, options?: C): Promise<MutateDocumentMutation>;
3226
4338
  MutateDocumentAsync(variables: MutateDocumentAsyncMutationVariables, options?: C): Promise<MutateDocumentAsyncMutation>;
4339
+ ExecuteBatch(variables: ExecuteBatchMutationVariables, options?: C): Promise<ExecuteBatchMutation>;
3227
4340
  RenameDocument(variables: RenameDocumentMutationVariables, options?: C): Promise<RenameDocumentMutation>;
3228
4341
  SetPreferredEditor(variables: SetPreferredEditorMutationVariables, options?: C): Promise<SetPreferredEditorMutation>;
3229
4342
  AddRelationship(variables: AddRelationshipMutationVariables, options?: C): Promise<AddRelationshipMutation>;
4343
+ UpdateRelationship(variables: UpdateRelationshipMutationVariables, options?: C): Promise<UpdateRelationshipMutation>;
3230
4344
  RemoveRelationship(variables: RemoveRelationshipMutationVariables, options?: C): Promise<RemoveRelationshipMutation>;
3231
4345
  MoveRelationship(variables: MoveRelationshipMutationVariables, options?: C): Promise<MoveRelationshipMutation>;
3232
4346
  DeleteDocument(variables: DeleteDocumentMutationVariables, options?: C): Promise<DeleteDocumentMutation>;
@@ -3237,13 +4351,13 @@ declare function getSdk<C>(requester: Requester<C>): {
3237
4351
  TouchChannel(variables: TouchChannelMutationVariables, options?: C): Promise<TouchChannelMutation>;
3238
4352
  PushSyncEnvelopes(variables: PushSyncEnvelopesMutationVariables, options?: C): Promise<PushSyncEnvelopesMutation>;
3239
4353
  };
3240
- type Sdk = ReturnType<typeof getSdk>;
4354
+ export type Sdk = ReturnType<typeof getSdk>;
3241
4355
  //#endregion
3242
4356
  //#region src/graphql/reactor/requester.d.ts
3243
4357
  type FetchLike = (input: URL | string, init: RequestInit) => Promise<Response>;
3244
4358
  //#endregion
3245
4359
  //#region src/graphql/reactor/factory.d.ts
3246
- declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike, headers?: Record<string, string>): {
4360
+ export declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike, headers?: Record<string, string>): {
3247
4361
  GetDocumentModels(variables?: Exact<{
3248
4362
  namespace?: InputMaybe<Scalars["String"]["input"]>;
3249
4363
  paging?: InputMaybe<PagingInput>;
@@ -3270,6 +4384,18 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
3270
4384
  view?: InputMaybe<ViewFilterInput>;
3271
4385
  paging?: InputMaybe<PagingInput>;
3272
4386
  }>, options?: {} | undefined): Promise<GetDocumentIncomingRelationshipsQuery>;
4387
+ GetDocumentOutgoingRelationshipEdges(variables: Exact<{
4388
+ sourceIdentifier: Scalars["String"]["input"];
4389
+ relationshipType?: InputMaybe<Scalars["String"]["input"]>;
4390
+ view?: InputMaybe<ViewFilterInput>;
4391
+ paging?: InputMaybe<PagingInput>;
4392
+ }>, options?: {} | undefined): Promise<GetDocumentOutgoingRelationshipEdgesQuery>;
4393
+ GetDocumentIncomingRelationshipEdges(variables: Exact<{
4394
+ targetIdentifier: Scalars["String"]["input"];
4395
+ relationshipType?: InputMaybe<Scalars["String"]["input"]>;
4396
+ view?: InputMaybe<ViewFilterInput>;
4397
+ paging?: InputMaybe<PagingInput>;
4398
+ }>, options?: {} | undefined): Promise<GetDocumentIncomingRelationshipEdgesQuery>;
3273
4399
  FindDocuments(variables?: Exact<{
3274
4400
  search?: InputMaybe<SearchFilterInput>;
3275
4401
  view?: InputMaybe<ViewFilterInput>;
@@ -3282,6 +4408,13 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
3282
4408
  GetJobStatus(variables: Exact<{
3283
4409
  jobId: Scalars["String"]["input"];
3284
4410
  }>, options?: {} | undefined): Promise<GetJobStatusQuery>;
4411
+ GetDocumentServed(variables: Exact<{
4412
+ idOrSlug: Scalars["String"]["input"];
4413
+ view?: InputMaybe<ViewFilterInput>;
4414
+ }>, options?: {} | undefined): Promise<GetDocumentServedQuery>;
4415
+ GetCreateDefaults(variables?: Exact<{
4416
+ parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
4417
+ }> | undefined, options?: {} | undefined): Promise<GetCreateDefaultsQuery>;
3285
4418
  EvaluateActions(variables: Exact<{
3286
4419
  documentIdentifier: Scalars["String"]["input"];
3287
4420
  branch?: InputMaybe<Scalars["String"]["input"]>;
@@ -3305,6 +4438,9 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
3305
4438
  actions: ReadonlyArray<ActionInput>;
3306
4439
  branch?: InputMaybe<Scalars["String"]["input"]>;
3307
4440
  }>, options?: {} | undefined): Promise<MutateDocumentAsyncMutation>;
4441
+ ExecuteBatch(variables: Exact<{
4442
+ jobs: ReadonlyArray<ExecutionJobInput>;
4443
+ }>, options?: {} | undefined): Promise<ExecuteBatchMutation>;
3308
4444
  RenameDocument(variables: Exact<{
3309
4445
  documentIdentifier: Scalars["String"]["input"];
3310
4446
  name: Scalars["String"]["input"];
@@ -3319,8 +4455,16 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
3319
4455
  sourceIdentifier: Scalars["String"]["input"];
3320
4456
  targetIdentifier: Scalars["String"]["input"];
3321
4457
  relationshipType: Scalars["String"]["input"];
4458
+ metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
3322
4459
  branch?: InputMaybe<Scalars["String"]["input"]>;
3323
4460
  }>, options?: {} | undefined): Promise<AddRelationshipMutation>;
4461
+ UpdateRelationship(variables: Exact<{
4462
+ sourceIdentifier: Scalars["String"]["input"];
4463
+ targetIdentifier: Scalars["String"]["input"];
4464
+ relationshipType: Scalars["String"]["input"];
4465
+ metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
4466
+ branch?: InputMaybe<Scalars["String"]["input"]>;
4467
+ }>, options?: {} | undefined): Promise<UpdateRelationshipMutation>;
3324
4468
  RemoveRelationship(variables: Exact<{
3325
4469
  sourceIdentifier: Scalars["String"]["input"];
3326
4470
  targetIdentifier: Scalars["String"]["input"];
@@ -3353,40 +4497,59 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
3353
4497
  channelId: Scalars["String"]["input"];
3354
4498
  outboxAck: Scalars["Int"]["input"];
3355
4499
  outboxLatest: Scalars["Int"]["input"];
4500
+ manifestRevision?: InputMaybe<Scalars["String"]["input"]>;
4501
+ refusals?: InputMaybe<ReadonlyArray<SyncRefusalInput>>;
3356
4502
  }>, options?: {} | undefined): Promise<PollSyncEnvelopesQuery>;
3357
4503
  TouchChannel(variables: Exact<{
3358
4504
  input: TouchChannelInput;
3359
4505
  }>, options?: {} | undefined): Promise<TouchChannelMutation>;
3360
4506
  PushSyncEnvelopes(variables: Exact<{
3361
4507
  envelopes: ReadonlyArray<SyncEnvelopeInput>;
4508
+ peerManifestRevision?: InputMaybe<Scalars["String"]["input"]>;
3362
4509
  }>, options?: {} | undefined): Promise<PushSyncEnvelopesMutation>;
3363
4510
  };
3364
4511
  //#endregion
3365
4512
  //#region src/graphql/reactor/subgraph.d.ts
3366
- declare class ReactorSubgraph extends BaseSubgraph {
4513
+ export declare class ReactorSubgraph extends BaseSubgraph {
3367
4514
  #private;
3368
4515
  private logger;
3369
4516
  constructor(args: SubgraphArgs);
3370
4517
  name: string;
3371
4518
  hasSubscriptions: boolean;
4519
+ private get documentChanges();
3372
4520
  /**
3373
4521
  * Check operation-level permissions for an array of actions.
3374
4522
  * Delegates to base assertCanExecuteOperation for each action.
3375
4523
  */
3376
4524
  private assertCanExecuteOperations;
3377
- typeDefs: graphql.DocumentNode;
4525
+ /**
4526
+ * Drops the relationship edges whose far-end document the caller cannot read.
4527
+ *
4528
+ * An edge names two documents, so returning it discloses the far end's id. The
4529
+ * document-shaped relationship queries already withhold far-end documents the
4530
+ * caller cannot read; the edge-shaped queries have to withhold the same ones,
4531
+ * or they become a way to enumerate around that check. Supreme admins read
4532
+ * everything, so the per-edge check is skipped for them.
4533
+ *
4534
+ * The cursor describes where to resume in the underlying unfiltered stream,
4535
+ * so it is left as it came. A filtered page is therefore often shorter than
4536
+ * the requested limit, and that is the stream continuing rather than a sign
4537
+ * it ended.
4538
+ */
4539
+ private filterRelationshipEdges;
4540
+ typeDefs: import("graphql").DocumentNode;
3378
4541
  resolvers: Resolvers;
3379
4542
  onSetup(): Promise<void>;
3380
4543
  }
3381
4544
  //#endregion
3382
4545
  //#region src/graphql/system/env/index.d.ts
3383
- declare const ADMIN_USERS: string[];
4546
+ export declare const ADMIN_USERS: string[];
3384
4547
  //#endregion
3385
4548
  //#region src/graphql/system/subgraph.d.ts
3386
- declare class SystemSubgraph extends BaseSubgraph {
4549
+ export declare class SystemSubgraph extends BaseSubgraph {
3387
4550
  name: string;
3388
4551
  hasSubscriptions: boolean;
3389
- typeDefs: graphql.DocumentNode;
4552
+ typeDefs: import("graphql").DocumentNode;
3390
4553
  resolvers: {
3391
4554
  Query: {
3392
4555
  system: () => {
@@ -3399,28 +4562,89 @@ declare class SystemSubgraph extends BaseSubgraph {
3399
4562
  }
3400
4563
  //#endregion
3401
4564
  //#region src/graphql/system/version.d.ts
3402
- declare function getVersion(): string;
3403
- declare function getGitHash(): string;
3404
- declare function getGitUrl(): string | null;
4565
+ export declare function getVersion(): string;
4566
+ export declare function getGitHash(): string;
4567
+ export declare function getGitUrl(): string | null;
3405
4568
  //#endregion
3406
4569
  //#region src/graphql/utils.d.ts
3407
- declare function isSubgraphClass(candidate: unknown): candidate is SubgraphClass$1;
3408
- declare function buildGraphqlOperations(operations: Operation[], skip: number, first: number): GqlOperation$1[];
3409
- declare function buildGraphqlOperation(operation: Operation): GqlOperation$1;
3410
- declare function buildGraphQlDocument(doc: PHDocument): GqlDocument$1;
3411
- declare function buildGraphQlDriveDocument(doc: DocumentDriveDocument): GqlDriveDocument$1;
4570
+ export declare function isSubgraphClass(candidate: unknown): candidate is SubgraphClass$1;
4571
+ export declare function buildGraphqlOperations(operations: Operation[], skip: number, first: number): GqlOperation$1[];
4572
+ export declare function buildGraphqlOperation(operation: Operation): GqlOperation$1;
4573
+ export declare function buildGraphQlDocument(doc: PHDocument): GqlDocument$1;
4574
+ export declare function buildGraphQlDriveDocument(doc: DocumentDriveDocument): GqlDriveDocument$1;
4575
+ //#endregion
4576
+ //#region src/graphql/errors.d.ts
4577
+ /** Caller (authenticated or anonymous) lacks permission for the document. */
4578
+ export declare class ForbiddenError extends GraphQLError {
4579
+ constructor(detail?: string);
4580
+ }
4581
+ /** Anonymous caller on an action that requires logging in. */
4582
+ export declare class AuthenticationRequiredError extends GraphQLError {
4583
+ constructor(detail?: string);
4584
+ }
4585
+ /**
4586
+ * The reactor holds no decision model, so no authorization preflight can be
4587
+ * answered.
4588
+ *
4589
+ * Distinct from a denial, and deliberately so: a caller that cannot get a
4590
+ * prediction should render its controls as it did before it asked and let the
4591
+ * submit path refuse. Reading this as a denial would disable every control on a
4592
+ * switchboard running without authEnforcement. The code is what a client
4593
+ * branches on, since the message is not a contract.
4594
+ */
4595
+ export declare class AuthEvaluationUnsupportedError extends GraphQLError {
4596
+ constructor();
4597
+ }
4598
+ /**
4599
+ * A stored operation cannot be represented in the schema, so it is reported
4600
+ * rather than served.
4601
+ *
4602
+ * The schema declares an action's id, type, timestamp, input and scope
4603
+ * non-null; an operation written before the API rejected an action without an
4604
+ * id violates that. Left to the executor, the missing value nullifies the
4605
+ * action, which bubbles up through the non-null chain until it nullifies the
4606
+ * envelope's whole operation list, and the caller receives a partial response
4607
+ * beside "Cannot return null for non-nullable field Action.id" - which says
4608
+ * nothing about which operation, and which a sync client can only read as a
4609
+ * permanent GraphQL rejection, stopping its poll timer for good.
4610
+ *
4611
+ * Thrown instead, with a code that says the failure is worth polling through:
4612
+ * the document holding the operation needs repairing, but the channel serves
4613
+ * every other document, and a peer that stopped polling would stop receiving
4614
+ * those too. The code is what a client branches on, since the message is not a
4615
+ * contract.
4616
+ */
4617
+ export declare class MalformedStoredOperationError extends GraphQLError {
4618
+ constructor(detail: string);
4619
+ }
4620
+ /**
4621
+ * The marker refusals a poll carried were not recorded, so the poll fails.
4622
+ * The code is recoverable: the client keeps polling and reports them again.
4623
+ */
4624
+ export declare class RefusalNotRecordedError extends GraphQLError {
4625
+ constructor(cause: unknown);
4626
+ }
4627
+ //#endregion
4628
+ //#region src/packages/base-document-models.d.ts
4629
+ /** The models every host loads before any package's, by source package. */
4630
+ export declare const baseDocumentModels: ReadonlyArray<readonly [string, DocumentModelModule]>;
3412
4631
  //#endregion
3413
4632
  //#region src/packages/import-loader.d.ts
3414
4633
  /**
3415
4634
  * This class is used to load packages using the import keyword.
3416
4635
  */
3417
- declare class ImportPackageLoader implements IPackageLoader {
4636
+ export declare class ImportPackageLoader implements IPackageLoader {
4637
+ private readonly hostDir;
3418
4638
  private readonly logger;
3419
4639
  readonly name = "ImportPackageLoader";
4640
+ constructor(hostDir?: string);
4641
+ private readonly reportedUnbuilt;
3420
4642
  loadDocumentModels(identifier: string): Promise<DocumentModelModule[]>;
3421
4643
  loadUpgradeManifests(identifier: string): Promise<UpgradeManifest<readonly number[]>[]>;
3422
4644
  loadSubgraphs(identifier: string): Promise<SubgraphClass$1[]>;
3423
4645
  loadProcessors(identifier: string): Promise<ProcessorFactoryBuilder | null>;
4646
+ loadPieces(identifier: string): Promise<PackagePieceEntry[]>;
4647
+ private reportUnbuilt;
3424
4648
  }
3425
4649
  //#endregion
3426
4650
  //#region src/packages/package-manager.d.ts
@@ -3436,10 +4660,10 @@ declare class ImportPackageLoader implements IPackageLoader {
3436
4660
  * either bare (`'pkg'`) or as a subpath (`'pkg/subgraphs'`), since loaders
3437
4661
  * import sub-entries like `${pkg}/subgraphs` / `${pkg}/document-models`.
3438
4662
  */
3439
- declare function isExpectedLoaderMiss(error: unknown, pkg: string): boolean;
3440
- declare function getUniqueDocumentModels(...documentModels: readonly (readonly DocumentModelModule<any>[])[]): DocumentModelModule[];
3441
- declare function getUniqueUpgradeManifests(...upgradeManifests: readonly (readonly UpgradeManifest<readonly number[]>[])[]): UpgradeManifest<readonly number[]>[];
3442
- declare class PackageManager implements IPackageManager {
4663
+ export declare function isExpectedLoaderMiss(error: unknown, pkg: string, subPath?: string): boolean;
4664
+ export declare function getUniqueDocumentModels(...documentModels: readonly (readonly DocumentModelModule<any>[])[]): DocumentModelModule[];
4665
+ export declare function getUniqueUpgradeManifests(...upgradeManifests: readonly (readonly UpgradeManifest<readonly number[]>[])[]): UpgradeManifest<readonly number[]>[];
4666
+ export declare class PackageManager implements IPackageManager {
3443
4667
  protected options: IPackageManagerOptions;
3444
4668
  private readonly logger;
3445
4669
  private loaders;
@@ -3447,9 +4671,13 @@ declare class PackageManager implements IPackageManager {
3447
4671
  private upgradeManifestsMap;
3448
4672
  private subgraphsMap;
3449
4673
  private processorMap;
4674
+ private piecesMap;
3450
4675
  private configWatcher;
4676
+ private unsubscribePackages;
4677
+ private subscribedPackages;
3451
4678
  private debouncedUpdateCallbacks;
3452
4679
  private eventEmitter;
4680
+ private get detached();
3453
4681
  constructor(loaders: IPackageLoader[], options: IPackageManagerOptions);
3454
4682
  init(): Promise<PackageManagerResult>;
3455
4683
  private loadPackages;
@@ -3459,10 +4687,12 @@ declare class PackageManager implements IPackageManager {
3459
4687
  private loadUpgradeManifests;
3460
4688
  private loadSubgraphs;
3461
4689
  private loadProcessors;
4690
+ private loadPieces;
3462
4691
  private maybeWarnAllLoadersFailed;
3463
4692
  private updateDocumentModelsForPackage;
3464
4693
  private updateSubgraphsForPackage;
3465
4694
  private updateProcessorsForPackage;
4695
+ private updatePiecesForPackage;
3466
4696
  /** Debounced per key so repeated subscribePackages calls reuse one timer. */
3467
4697
  private getDebouncedUpdateCallback;
3468
4698
  private subscribePackages;
@@ -3472,6 +4702,11 @@ declare class PackageManager implements IPackageManager {
3472
4702
  private updatePackagesMap;
3473
4703
  private updateSubgraphsMap;
3474
4704
  private updateProcessorsMap;
4705
+ private updatePiecesMap;
4706
+ /** The document models every loaded package ships, keyed by the package. */
4707
+ getDocumentModels(): Map<string, DocumentModelModule[]>;
4708
+ /** The pieces every loaded package ships, keyed by the package. */
4709
+ getPieces(): Map<string, PackagePieceEntry[]>;
3475
4710
  /**
3476
4711
  * Remove `pkg` from all package maps and emit the change events, tearing
3477
4712
  * down everything the package registered (subgraphs, processors, document
@@ -3479,31 +4714,70 @@ declare class PackageManager implements IPackageManager {
3479
4714
  * nothing can re-add it.
3480
4715
  */
3481
4716
  removePackage(pkg: string): void;
3482
- onDocumentModelsChange(handler: (documentModels: Record<string, DocumentModelModule[]>) => void): void;
3483
- onSubgraphsChange(handler: (subgraphs: Map<string, SubgraphClass$1[]>) => void): void;
3484
- onProcessorsChange(handler: (processors: Map<string, Processor$1>) => void): void;
4717
+ onDocumentModelsChange(handler: (documentModels: Record<string, DocumentModelModule[]>) => unknown): void;
4718
+ onSubgraphsChange(handler: (subgraphs: Map<string, SubgraphClass$1[]>) => unknown): void;
4719
+ onProcessorsChange(handler: (processors: Map<string, Processor$1>) => unknown): void;
4720
+ onPiecesChange(handler: (pieces: Map<string, PackagePieceEntry[]>) => unknown): void;
3485
4721
  }
3486
4722
  //#endregion
4723
+ //#region src/packages/subgraph-extraction.d.ts
4724
+ /**
4725
+ * The one acceptance rule for a package's `subgraphs` module.
4726
+ *
4727
+ * All three package loaders (vite, import, http) consume the same generated
4728
+ * `subgraphs/index` file, and each used to apply its own rule — the vite
4729
+ * loader required a namespace whose alias equalled the class name inside it,
4730
+ * the http loader took any function one level deep, and the import loader
4731
+ * took every nested value. An export that registered under one loader could
4732
+ * silently vanish under another (the codegen-does-not-register-subgraphs
4733
+ * report). This is now the single rule they all share:
4734
+ *
4735
+ * - an export that is itself a subgraph class is accepted (named or default
4736
+ * export of the class);
4737
+ * - any subgraph class among the values of an exported object is accepted
4738
+ * (a `export * as Alias from ...` namespace under any alias, or a
4739
+ * default-exported object of classes);
4740
+ * - everything else — constants, configs, functions and classes that do not
4741
+ * extend BaseSubgraph — is dropped.
4742
+ *
4743
+ * Codegen emits `export * as <ClassName> from "./<dir>/index.js"`
4744
+ * (makeSubgraphsIndexFile in packages/codegen), which the namespace branch
4745
+ * accepts regardless of the alias; hand-written packages may re-export a
4746
+ * class directly, which the direct branch accepts. A class reached through
4747
+ * both branches is returned once.
4748
+ */
4749
+ export declare function extractSubgraphs(namespace: Record<string, unknown>): SubgraphClass$1[];
4750
+ //#endregion
3487
4751
  //#region src/services/renown-config.d.ts
3488
4752
  /** Where the credential check reads from: a remote Renown or Switchboard
3489
4753
  * instance, or this switchboard's own renown read model. */
3490
- type RenownSource = NonNullable<PHReactorRenown["source"]>;
4754
+ export type RenownSource = NonNullable<PHReactorRenown["source"]>;
3491
4755
  /** The `auth.renown` config block: which Renown instance to authenticate
3492
4756
  * against, before env overrides are applied. */
3493
- type RenownConfig = PHReactorRenown;
4757
+ export type RenownConfig = PHReactorRenown;
3494
4758
  /** Resolved renown coordinates. `url` also drives this reactor's own identity,
3495
4759
  * so it stays meaningful when `source` is "self". */
3496
- type ResolvedRenownConfig = {
4760
+ export type ResolvedRenownConfig = {
3497
4761
  source: RenownSource;
3498
4762
  url: string | undefined;
3499
4763
  switchboardUrl: string | undefined;
3500
4764
  };
3501
4765
  /** Reading credentials from this reactor's own read model needs a host-supplied
3502
4766
  * verifier: core has no idea which subgraph serves that read model. */
3503
- declare function assertCredentialVerifierForSource(source: RenownSource, hasVerifier: boolean): void;
4767
+ export declare function assertCredentialVerifierForSource(source: RenownSource, hasVerifier: boolean): void;
3504
4768
  /** Resolve `auth.renown`; RENOWN_SOURCE / RENOWN_URL / SWITCHBOARD_URL win
3505
4769
  * over the config file, which wins over the SDK defaults. */
3506
- declare function resolveRenownConfig(configured: RenownConfig | undefined, env: NodeJS.ProcessEnv, logger: ILogger): ResolvedRenownConfig;
4770
+ export declare function resolveRenownConfig(configured: RenownConfig | undefined, env: NodeJS.ProcessEnv, logger: ILogger): ResolvedRenownConfig;
4771
+ /**
4772
+ * The credential-verification cache TTL for `AuthService`.
4773
+ *
4774
+ * `CREDENTIAL_VERIFICATION_CACHE_TTL_MS` wins when it is a non-negative number.
4775
+ * Otherwise the default depends on the source: with `"self"` the check is an
4776
+ * in-process read-model query, so caching buys little and only delays a
4777
+ * revocation — it defaults to `0` (no cache). A `"remote"` source returns
4778
+ * `undefined`, leaving AuthService's own default TTL in place.
4779
+ */
4780
+ export declare function resolveCredentialCacheTtlMs(raw: string | undefined, source: RenownSource, logger: ILogger): number | undefined;
3507
4781
  //#endregion
3508
4782
  //#region src/server.d.ts
3509
4783
  type Options = {
@@ -3529,6 +4803,19 @@ type Options = {
3529
4803
  * request. Off by default; `REQUIRE_AUTHENTICATED_CALLER` overrides.
3530
4804
  * Requires identity resolution to be on — refused at boot without it. */
3531
4805
  requireAuthenticatedCaller?: boolean;
4806
+ /** Mounted paths that stay reachable anonymously while
4807
+ * `requireAuthenticatedCaller` is on, for a flow that runs before
4808
+ * sign-in. Matched against the request's pathname in full, never as a
4809
+ * prefix. `REQUIRE_AUTHENTICATED_CALLER_EXEMPT_PATHS` overrides, as a
4810
+ * comma-separated list. Each entry is a hole in the floor: only ever name
4811
+ * a path serving operations that are safe without a caller. */
4812
+ requireAuthenticatedCallerExemptPaths?: string[];
4813
+ /** Decide an attachment read with the referencing document's own policy
4814
+ * instead of the host permission tables. Off by default;
4815
+ * `ATTACHMENT_READS_FOLLOW_DOCUMENT_POLICY` overrides. Requires auth
4816
+ * enforcement, which is what supplies the model — refused at boot
4817
+ * without it. */
4818
+ attachmentReadsFollowDocumentPolicy?: boolean;
3532
4819
  };
3533
4820
  /** Renown coordinates the host already resolved, used verbatim instead of
3534
4821
  * resolving `auth.renown` and the env again (which would warn twice). */
@@ -3554,25 +4841,30 @@ type Options = {
3554
4841
  documentPermissionService?: DocumentPermissionService;
3555
4842
  enableDocumentModelSubgraphs?: boolean;
3556
4843
  logger?: ILogger;
4844
+ /** Receives failures in background work that is logged and skipped. */
4845
+ reportError?: ReportError;
3557
4846
  /**
3558
4847
  * Filesystem path for attachment binary storage.
3559
4848
  * Defaults to a sibling "attachments" directory next to dbPath,
3560
4849
  * or os.tmpdir() for in-memory DB deployments.
3561
4850
  */
3562
4851
  attachmentStoragePath?: string;
4852
+ /** Storage health and workflow facts for the inspection subgraph; `false`
4853
+ * leaves it unmounted and `api.inspection` undefined. On by default. */
4854
+ inspection?: ReactorInspectionOptions | false;
3563
4855
  };
3564
4856
  type ProcessorInitializer = ProcessorFactoryBuilder;
3565
4857
  /**
3566
4858
  * Doc-perms require auth: with auth off no `user` is ever resolved, so every
3567
4859
  * authorization check fails closed. Refuse to boot rather than run broken.
3568
4860
  */
3569
- declare function assertAuthRequiredForDocumentPermissions(authEnabled: boolean, documentPermissionsRequested: boolean): void;
4861
+ export declare function assertAuthRequiredForDocumentPermissions(authEnabled: boolean, documentPermissionsRequested: boolean): void;
3570
4862
  /**
3571
4863
  * Refuses SKIP_CREDENTIAL_VERIFICATION at boot outside tests or an explicit
3572
4864
  * opt-in: it removes the only binding between a token's claimed address and its
3573
4865
  * signing key. Fail-closed — unset NODE_ENV counts as production.
3574
4866
  */
3575
- declare function assertSkipCredentialVerificationAllowed(resolvesCallerIdentity: boolean, skipCredentialVerification: boolean, env: NodeJS.ProcessEnv): void;
4867
+ export declare function assertSkipCredentialVerificationAllowed(resolvesCallerIdentity: boolean, skipCredentialVerification: boolean, env: NodeJS.ProcessEnv): void;
3576
4868
  /**
3577
4869
  * Requiring an authenticated caller requires identity resolution to exist at
3578
4870
  * all: with neither AUTH_ENABLED nor RESOLVE_CALLER_IDENTITY the middleware
@@ -3580,14 +4872,22 @@ declare function assertSkipCredentialVerificationAllowed(resolvesCallerIdentity:
3580
4872
  * require-authenticated-caller middleware would reject every caller —
3581
4873
  * authenticated ones included. Refuse to boot rather than run broken.
3582
4874
  */
3583
- declare function assertRequireAuthenticatedCallerAllowed(requireAuthenticatedCaller: boolean, resolvesCallerIdentity: boolean): void;
4875
+ export declare function assertRequireAuthenticatedCallerAllowed(requireAuthenticatedCaller: boolean, resolvesCallerIdentity: boolean, exemptPaths?: readonly string[]): void;
4876
+ /**
4877
+ * Deciding an attachment read by the document's policy needs a policy model to
4878
+ * decide with, and that is what auth enforcement supplies. Without one there is
4879
+ * nothing to consult, so the setting would silently leave the permission tables
4880
+ * in charge — configuration that describes a protection the server is not
4881
+ * applying, which is worse than no configuration at all. Refuse instead.
4882
+ */
4883
+ export declare function assertAttachmentPolicyReadsAllowed(attachmentReadsFollowDocumentPolicy: boolean, hasDecisionModel: boolean): void;
3584
4884
  /**
3585
4885
  * The GraphiQL explorer page's mount prefix. `path.posix.join` normalizes the
3586
4886
  * join with `basePath` — a naive template literal would produce `//explorer`
3587
4887
  * for the default `/` basePath, which express compiles into a route that only
3588
4888
  * matches `//explorer`, leaving `GET /explorer` a 404.
3589
4889
  */
3590
- declare function getExplorerPrefix(basePath: string): string;
4890
+ export declare function getExplorerPrefix(basePath: string): string;
3591
4891
  /**
3592
4892
  * Initializes and starts the API server using an initializer function.
3593
4893
  * This function first loads packages to get document models, then calls the initializer function
@@ -3603,64 +4903,53 @@ declare function getExplorerPrefix(basePath: string): string;
3603
4903
  * alongside the reactor module so resolvers can dispatch reactor-drive parent
3604
4904
  * ops to it; legacy switchboards omit it.
3605
4905
  */
3606
- interface ClientInitializerResult {
4906
+ export interface ClientInitializerResult {
3607
4907
  module: InProcessReactorClientModule;
3608
4908
  reactorDriveClient?: IDriveClient;
3609
4909
  attachmentReferenceProjection?: AttachmentReferenceProjectionCapability;
3610
4910
  }
3611
- interface ClientInitializerDependencies {
4911
+ export interface ClientInitializerDependencies {
3612
4912
  attachmentReferenceWriter: IAttachmentReferenceWriter;
3613
4913
  /** Upgrade manifests exported by the loaded packages, one per type. */
3614
4914
  upgradeManifests: UpgradeManifest<readonly number[]>[];
3615
4915
  }
3616
- declare function initializeAndStartAPI(clientInitializer: (documentModels: DocumentModelModule[], dependencies: ClientInitializerDependencies) => Promise<ClientInitializerResult>, options: Options, processorApp: ProcessorApp): Promise<API & {
4916
+ export declare function initializeAndStartAPI(clientInitializer: (documentModels: DocumentModelModule[], dependencies: ClientInitializerDependencies) => Promise<ClientInitializerResult>, options: Options, processorApp: ProcessorApp): Promise<API & {
3617
4917
  client: IReactorClient;
3618
4918
  syncManager: ISyncManager;
3619
4919
  documentModelRegistry: IDocumentModelRegistry;
3620
4920
  readiness: ReadinessGate;
3621
4921
  attachmentReferenceProjection: AttachmentReferenceProjectionCapability;
3622
4922
  packageManager: PackageManager;
4923
+ /** Set under DOCUMENT_PERMISSIONS; the privacy add-on erases through it. */
4924
+ documentPermissionService: DocumentPermissionService | undefined;
3623
4925
  }>;
3624
4926
  //#endregion
3625
4927
  //#region src/services/renown-credential-verifier.d.ts
3626
- interface RenownCredentialVerifierConfig {
4928
+ export interface RenownCredentialVerifierConfig {
3627
4929
  renownUrl?: string;
3628
4930
  switchboardUrl?: string;
3629
4931
  }
3630
- declare function createRenownCredentialVerifier(config?: RenownCredentialVerifierConfig): Promise<CredentialVerifier>;
4932
+ export declare function createRenownCredentialVerifier(config?: RenownCredentialVerifierConfig): Promise<CredentialVerifier>;
3631
4933
  //#endregion
3632
- //#region src/utils/create-schema.d.ts
3633
- declare const buildSubgraphSchemaModule: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => GraphQLSchemaModule;
3634
- declare const createSchema: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => graphql.GraphQLSchema;
3635
- /**
3636
- * Create a merged GraphQL schema from multiple subgraph modules.
3637
- * Uses buildSubgraphSchema's array overload to combine type definitions
3638
- * and resolvers from multiple subgraphs into a single executable schema.
3639
- */
3640
- declare const createMergedSchema: (modules: GraphQLSchemaModule[]) => graphql.GraphQLSchema;
3641
- declare function getDocumentModelSchemaName(documentModel: DocumentModelGlobalState$1): string;
3642
- declare const getDocumentModelTypeDefs: (documentModels: DocumentModelModule[], typeDefs: DocumentNode) => DocumentNode;
4934
+ //#region src/services/privacy-permissions.d.ts
4935
+ /** One permission row naming an address, as reactor-privacy discloses it. */
4936
+ export type PrivacyPermissionRow = {
4937
+ table: string;
4938
+ column: string;
4939
+ documentId: string | null;
4940
+ detail?: Record<string, unknown>;
4941
+ };
3643
4942
  /**
3644
- * Options for generating document model GraphQL schemas.
4943
+ * reactor-privacy's permission lookup and eraser, over this host's
4944
+ * DocumentPermissionService. Typed structurally on the privacy side.
3645
4945
  */
3646
- interface DocumentModelSchemaOptions {
3647
- /**
3648
- * When true, generates new API patterns:
3649
- * - Mutations return full document objects (MutationResult type)
3650
- * - Adds createEmptyDocument mutation
3651
- * - Makes docId and input parameters required
3652
- * @default false
3653
- */
3654
- useNewApi?: boolean;
4946
+ export declare class PrivacyPermissionAdapter {
4947
+ private readonly service;
4948
+ constructor(service: DocumentPermissionService);
4949
+ rowsForAddress(address: string): Promise<PrivacyPermissionRow[]>;
4950
+ erasePermissions(documentId: string): Promise<Record<string, number>>;
3655
4951
  }
3656
- /**
3657
- * Generate a GraphQL schema for a document model.
3658
- *
3659
- * @param documentModel - The document model global state
3660
- * @param options - Schema generation options
3661
- * @returns GraphQL DocumentNode
3662
- */
3663
- declare function generateDocumentModelSchema(documentModel: DocumentModelGlobalState$1, options?: DocumentModelSchemaOptions): DocumentNode;
3664
4952
  //#endregion
3665
- export { ADMIN_USERS, API, Action, ActionCandidateInput, ActionCandidateInputSchema, ActionContext, ActionContextInput, ActionContextInputSchema, ActionContextResolvers, ActionEvaluation, ActionEvaluationResolvers, ActionEvaluations, ActionEvaluationsResolvers, ActionInput, ActionInputSchema, ActionResolvers, AdapterRouteHandle, AddRelationshipDocument, AddRelationshipMutation, AddRelationshipMutationVariables, AnalyticsSubgraph, AttachmentAccessRequest, AttachmentAccessResult, AttachmentAccessService, type AttachmentReferenceProjectionCapability, AuthConfig, AuthContext, AuthDecision, AuthDecisionSchema, AuthFetchMiddleware, AuthService, AuthSubgraph, type AuthorizationConfig, AuthorizationPolicy, AuthorizedDocumentHandle, type AuthorizerResult, BaseSubgraph, CORE_PACKAGE_NAME, type CanonicalDocumentId, CanonicalDocumentIdResolutionError, CanonicalDocumentIdResolver, ChannelMeta, ChannelMetaInput, ChannelMetaInputSchema, ChannelMetaResolvers, ClientInitializerDependencies, ClientInitializerResult, Context, CreateDocumentDocument, CreateDocumentMutation, CreateDocumentMutationVariables, CreateEmptyDocumentDocument, CreateEmptyDocumentMutation, CreateEmptyDocumentMutationVariables, CredentialVerifier, DateTimeScalarConfig, DbClient, DeadLetterInfo, DeadLetterInfoResolvers, DeleteDocumentDocument, DeleteDocumentMutation, DeleteDocumentMutationVariables, DeleteDocumentsDocument, DeleteDocumentsMutation, DeleteDocumentsMutationVariables, DirectiveResolverFn, DocumentChangeContext, DocumentChangeContextResolvers, DocumentChangeEvent, DocumentChangeEventResolvers, DocumentChangeType, DocumentChangeTypeSchema, DocumentChangesDocument, DocumentChangesSubscription, DocumentChangesSubscriptionVariables, DocumentModelGlobalState, DocumentModelGlobalStateResolvers, DocumentModelResultPage, DocumentModelResultPageResolvers, DocumentModelSchemaOptions, DocumentOperationsFilterInput, DocumentOperationsFilterInputSchema, DocumentPermissionConfig, DocumentPermissionDatabase, DocumentPermissionEntry, DocumentPermissionLevel, DocumentPermissionService, DocumentPermissionTable, DocumentProtectionTable, DocumentWithChildren, DocumentWithChildrenResolvers, EvaluateActionsDocument, EvaluateActionsQuery, EvaluateActionsQueryVariables, Exact, ExplorerUrlState, 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, HttpAdapterSetup, HttpAdapterType, HttpDocumentModelLoader, HttpMethod, HttpPackageLoader, HttpPackageLoaderLogger, HttpPackageLoaderOptions, HttpRouteService, type HttpRouteServiceOptions, IAttachmentAccessService, type IAuthorizationService, IGatewayAdapter, IHttpAdapter, type IHttpScope, type IPackageLoader, type IPackageLoaderOptions, IPackageStorage, IProcessorHostModule, IReactorProcessorHostModule, ISubgraph, type IWebhookEndpoints, type IWebhookScope, type IWebhookStore, ImportPackageLoader, InMemoryPackageStorage, Incremental, InputMaybe, InstallPackageResult, InstalledPackageInfo, InvalidNamespaceError, IsTypeOfResolverFn, JobChangeEvent, JobChangeEventResolvers, JobChangesDocument, JobChangesSubscription, JobChangesSubscriptionVariables, JobInfo, JobInfoResolvers, JsonObjectScalarConfig, MakeEmpty, MakeMaybe, MakeOptional, Maybe, MemoryWebhookStore, MoveRelationshipDocument, MoveRelationshipMutation, MoveRelationshipMutationVariables, MoveRelationshipResult, MoveRelationshipResultResolvers, MutateDocumentAsyncDocument, MutateDocumentAsyncMutation, MutateDocumentAsyncMutationVariables, MutateDocumentDocument, MutateDocumentMutation, MutateDocumentMutationVariables, Mutation, MutationAddRelationshipArgs, MutationCreateDocumentArgs, MutationCreateEmptyDocumentArgs, MutationDeleteDocumentArgs, MutationDeleteDocumentsArgs, MutationExecuteArgs, MutationExecuteAsyncArgs, MutationMoveRelationshipArgs, MutationMutateDocumentArgs, MutationMutateDocumentAsyncArgs, MutationPushSyncEnvelopesArgs, MutationRemoveRelationshipArgs, MutationRenameDocumentArgs, MutationResolvers, MutationSetPreferredEditorArgs, MutationTouchChannelArgs, NextResolverFn, NodeRouteOptions, type NodeRouteSpec, OperationContext, OperationContextInput, OperationContextInputSchema, OperationContextResolvers, OperationInput, OperationInputSchema, OperationUserPermissionEntry, OperationUserPermissionTable, OperationWithContext, OperationWithContextInput, OperationWithContextInputSchema, OperationWithContextResolvers, OperationsFilterInput, OperationsFilterInputSchema, PACKAGE_ROUTE_SEGMENT, PGLITE_UTC_PARSERS, PackageManagementService, PackageManagementServiceOptions, PackageManager, PackagesSubgraph, type PackagesSubgraphArgs, PagingInput, PagingInputSchema, type ParsedDriveUrl, PgliteFactory, 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, QueryEvaluateActionsArgs, QueryFindDocumentsArgs, QueryJobStatusArgs, QueryPollSyncEnvelopesArgs, QueryResolvers, ReactorModule, ReactorOperation, ReactorOperationResolvers, ReactorOperationResultPage, ReactorOperationResultPageResolvers, ReactorSigner, ReactorSignerApp, ReactorSignerAppInput, ReactorSignerAppInputSchema, ReactorSignerAppResolvers, ReactorSignerInput, ReactorSignerInputSchema, ReactorSignerResolvers, ReactorSignerUser, ReactorSignerUserInput, ReactorSignerUserInputSchema, ReactorSignerUserResolvers, ReactorSubgraph, ReadinessGate, RelationalWebhookStore, RemoteCursor, RemoteCursorInput, RemoteCursorInputSchema, RemoteCursorResolvers, RemoteFilterInput, RemoteFilterInputSchema, RemoveRelationshipDocument, RemoveRelationshipMutation, RemoveRelationshipMutationVariables, RenameDocumentDocument, RenameDocumentMutation, RenameDocumentMutationVariables, RenownConfig, RenownCredentialVerifierConfig, RenownSource, Requester, RequireFields, ResolvedRenownConfig, Resolver, ResolverFn, ResolverTypeWrapper, ResolverWithResolve, Resolvers, ResolversObject, ResolversParentTypes, ResolversTypes, Revision, RevisionResolvers, type RouteActor, type RouteAuth, type RouteAuthorizer, type RouteBody, type RouteContext, type RouteHandler, type RouteMethod, type RouteOptions, type RouteSpec, type RouteTransport, type RouteUser, Scalars, type ScopedRouteHandle, Sdk, SearchFilterInput, SearchFilterInputSchema, SetPreferredEditorDocument, SetPreferredEditorMutation, SetPreferredEditorMutationVariables, 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, ViewFilterInput, ViewFilterInputSchema, WEBHOOK_SEGMENT, WS_AUTH_CLOSE_REASONS, WS_CLOSE_REASON_AUTHENTICATION_REQUIRED, WS_CLOSE_REASON_BEARER_REJECTED, type WebhookEndpointInfo, type WebhookEndpointRow, type WebhookField, type WebhookHashAlgorithm, type WebhookPolicy, type WebhookReply, type WebhookRequest, type WebhookScheme, WebhookService, type WebhookSignatureEncoding, type WebhookSpec, type WebhookVerification, WithIndex, WsConnectHandler, WsConnection, WsContextFactory, WsDisposer, WsHandlers, assertAuthRequiredForDocumentPermissions, assertCredentialVerifierForSource, assertHostMountPath, assertRequireAuthenticatedCallerAllowed, assertSkipCredentialVerificationAllowed, buildGraphQlDocument, buildGraphQlDriveDocument, buildGraphqlOperation, buildGraphqlOperations, buildSubgraphSchemaModule, createAuthFetchMiddleware, createCanonicalDocumentIdResolver, createGatewayAdapter, createHttpAdapter, createMergedSchema, createReactorGraphQLClient, createRenownCredentialVerifier, createSchema, createWsAuthHandlers, decodeExplorerUrlState, definedNonNullAnySchema, driveIdFromUrl, extractSubgraphsFromModule, generateDocumentModelSchema, getAuthContext, getDbClient, getDocumentModelSchemaName, getDocumentModelTypeDefs, getExplorerPrefix, getGitHash, getGitUrl, getSdk, getUniqueDocumentModels, getUniqueUpgradeManifests, getVersion, initAnalyticsStoreSql, initializeAndStartAPI, isDefinedNonNullAny, isExpectedLoaderMiss, isSubgraphClass, namespacePath, namespaceSegments, newWebhookToken, parseDriveUrl, parseWebhookBody, redactHeaders, renderGraphqlPlayground, resolvePackageName, resolveRenownConfig, verifyWebhook };
4953
+ export { type AttachmentReadGate, type AuthorizationConfig, type AuthorizerResult, type CanonicalDocumentId, DocumentModelSchema, DocumentModelSchemaCache, DocumentModelSchemaOptions, GeneratedDocumentModelTypes, type HttpRouteServiceOptions, type IAuthorizationService, type IDocumentScopeGate, type IHttpScope, type IPackageLoader, type IPackageLoaderOptions, type IPackagePieceSource, type IReactorInspectionSource, type IWebhookEndpoints, type IWebhookScope, type IWebhookStore, type InspectionCallerGate, type InspectionReadField, type InspectionThrottleConfig, type NodeRouteSpec, type PackagePiece, type PackagePieceEntry, type PackagesSubgraphArgs, type ParsedDriveUrl, type ReactorInspectionOptions, ReportError, ReservedTypeNames, ResolvedDocumentModelSchema, type RouteActor, type RouteAuth, type RouteAuthorizer, type RouteBody, type RouteContext, type RouteHandler, type RouteMethod, type RouteOptions, type RouteSpec, type RouteTransport, type RouteUser, RunDetachedOptions, type ScopedRouteHandle, SubgraphSchemaOptions, SubgraphTypeCollisionError, type WebhookEndpointInfo, type WebhookEndpointRow, type WebhookField, type WebhookHashAlgorithm, type WebhookPolicy, type WebhookReply, type WebhookRequest, type WebhookScheme, type WebhookSignatureEncoding, type WebhookSpec, type WebhookVerification, assembleSubgraphTypeDefs, buildDocumentModelSchema, buildSubgraphSchemaModule, createMergedSchema, createSchema, documentModelSubgraphTypes, driveIdFromUrl, findSubgraphTypeCollisions, generateDocumentModelSchema, generatedTypesOf, getDocumentModelSchemaName, getDocumentModelSubgraphName, getDocumentModelTypeDefs, getGeneratedDocumentModelTypes, hasOperationSchemas, parseDriveUrl, reportFailure, reservedTypeNames, reservedTypeNamesTaken, runDetached, typeDefinitionNames };
4954
+ export {};
3666
4955
  //# sourceMappingURL=index.d.mts.map