@powerhousedao/reactor-api 6.2.3-dev.7 → 6.2.3-dev.70

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