process-graph 1.0.6 → 1.1.1

package/dist/graphql-C1j5wQFz.d.ts

@@ -0,0 +1,631 @@
+import { K as OpenIds, a as Overlay, g as Model } from "./index-CmZOswkx.js";
+import { z } from "zod";
+import { ContractRouterClient, InitialInputSchema, ProcedureContract, RouterContract, eventIterator } from "@orpc/contract";
+import { ContractedRouter, DefaultInitialContext } from "@orpc/server";
+//#region ../../core/graph/source-contract/dist/schema.d.ts
+/** A participant as the model declares it: an organisation, a repository, a person. */
+declare const participantSchema: z.ZodReadonly<z.ZodObject<{
+  id: z.ZodString;
+  label: z.ZodString;
+  kind: z.ZodEnum<{
+    role: "role";
+    system: "system";
+    entity: "entity";
+  }>;
+}, z.core.$strict>>;
+/** A transition as the model declares it. A source emits one per dependency, from the prerequisite to the work that waits on it. */
+declare const transitionSchema: z.ZodReadonly<z.ZodObject<{
+  id: z.ZodString;
+  source: z.ZodString;
+  target: z.ZodString;
+  trigger: z.ZodExactOptional<z.ZodString>;
+  guard: z.ZodExactOptional<z.ZodString>;
+  condition: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"not">;
+    operand: typeof import("trilean").PredicateNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"and">;
+    left: typeof import("trilean").PredicateNodeSchema;
+    right: typeof import("trilean").PredicateNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"or">;
+    left: typeof import("trilean").PredicateNodeSchema;
+    right: typeof import("trilean").PredicateNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"allOf">;
+    operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"anyOf">;
+    operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"compare">;
+    op: z.ZodEnum<{
+      gt: "gt";
+      gte: "gte";
+      lt: "lt";
+      lte: "lte";
+      eq: "eq";
+      neq: "neq";
+    }>;
+    left: typeof import("trilean").ExpressionNodeSchema;
+    right: typeof import("trilean").ExpressionNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"textCompare">;
+    op: z.ZodEnum<{
+      equals: "equals";
+      notEquals: "notEquals";
+      matches: "matches";
+      notMatches: "notMatches";
+      portableMatches: "portableMatches";
+      portableNotMatches: "portableNotMatches";
+    }>;
+    left: typeof import("trilean").ExpressionNodeSchema;
+    right: typeof import("trilean").ExpressionNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"memberOf">;
+    op: z.ZodEnum<{
+      in: "in";
+      notIn: "notIn";
+    }>;
+    operand: typeof import("trilean").ExpressionNodeSchema;
+    candidates: z.ZodArray<typeof import("trilean").ExpressionNodeSchema>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"exists">;
+    operand: typeof import("trilean").ExpressionNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"some">;
+    collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+    item: typeof import("trilean").PredicateNodeSchema;
+    filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"every">;
+    collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+    item: typeof import("trilean").PredicateNodeSchema;
+    filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"treeReference">;
+    key: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+  }, z.core.$strip>], "kind">>;
+  effect: z.ZodExactOptional<z.ZodString>;
+}, z.core.$strict>>;
+/**
+ * An activity bound to the external record it stands for. `source` is required here, where the model leaves it optional, and it equals `id`: the source-qualified identifier (`github:org/repo#12`) is the element's identity, so the same record synced twice, or reached from two places, is the same element.
+ */
+declare const boundActivitySchema: z.ZodReadonly<z.ZodObject<{
+  kind: z.ZodLiteral<"activity">;
+  id: z.ZodString;
+  extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+  label: z.ZodString;
+  actor: z.ZodExactOptional<z.ZodString>;
+  action: z.ZodExactOptional<z.ZodString>;
+  affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  source: z.ZodString;
+}, z.core.$strict>>;
+/** The relation kinds a source reports beside the model's transitions. */
+declare const relationKinds: readonly ["child-of", "assigned-to", "part-of"];
+/**
+ * A structural link between two identifiers that the model has no field for: `child-of` from a sub-task activity to its parent activity, `assigned-to` from an activity to a person participant, `part-of` from one participant to the participant that contains it (a repository to its organisation). Relations carry no ordering, so a consumer decides whether a parent waits on its children.
+ */
+declare const relationSchema: z.ZodReadonly<z.ZodObject<{
+  kind: z.ZodEnum<{
+    "child-of": "child-of";
+    "assigned-to": "assigned-to";
+    "part-of": "part-of";
+  }>;
+  from: z.ZodString;
+  to: z.ZodString;
+}, z.core.$strict>>;
+/** Why part of a requested scope is missing from a sync. */
+declare const gapReasons: readonly ["not-found", "forbidden"];
+/**
+ * A part of the requested scope that the source could not read, reported as data so the rest of the sync still arrives. `target` is the source-qualified identifier of what is missing: a scope, a record, or one of a record's connections.
+ */
+declare const gapSchema: z.ZodReadonly<z.ZodObject<{
+  target: z.ZodString;
+  reason: z.ZodEnum<{
+    "not-found": "not-found";
+    forbidden: "forbidden";
+  }>;
+  message: z.ZodString;
+}, z.core.$strict>>;
+/**
+ * One page of a sync: bound activities, the participants they name, the transitions between them, their relations, their run state, and any gaps. A page is a partial view; `assembleSync` merges a whole sync into one model.
+ *
+ * `next` is the cursor to resume after this page. It is absent on the last page.
+ */
+declare const syncPageSchema: z.ZodReadonly<z.ZodObject<{
+  participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+      role: "role";
+      system: "system";
+      entity: "entity";
+    }>;
+  }, z.core.$strict>>>>;
+  activities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"activity">;
+    id: z.ZodString;
+    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+    label: z.ZodString;
+    actor: z.ZodExactOptional<z.ZodString>;
+    action: z.ZodExactOptional<z.ZodString>;
+    affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    source: z.ZodString;
+  }, z.core.$strict>>>>;
+  transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+    trigger: z.ZodExactOptional<z.ZodString>;
+    guard: z.ZodExactOptional<z.ZodString>;
+    condition: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"not">;
+      operand: typeof import("trilean").PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"and">;
+      left: typeof import("trilean").PredicateNodeSchema;
+      right: typeof import("trilean").PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"or">;
+      left: typeof import("trilean").PredicateNodeSchema;
+      right: typeof import("trilean").PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"allOf">;
+      operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"anyOf">;
+      operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"compare">;
+      op: z.ZodEnum<{
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        eq: "eq";
+        neq: "neq";
+      }>;
+      left: typeof import("trilean").ExpressionNodeSchema;
+      right: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"textCompare">;
+      op: z.ZodEnum<{
+        equals: "equals";
+        notEquals: "notEquals";
+        matches: "matches";
+        notMatches: "notMatches";
+        portableMatches: "portableMatches";
+        portableNotMatches: "portableNotMatches";
+      }>;
+      left: typeof import("trilean").ExpressionNodeSchema;
+      right: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"memberOf">;
+      op: z.ZodEnum<{
+        in: "in";
+        notIn: "notIn";
+      }>;
+      operand: typeof import("trilean").ExpressionNodeSchema;
+      candidates: z.ZodArray<typeof import("trilean").ExpressionNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"exists">;
+      operand: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"some">;
+      collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+      item: typeof import("trilean").PredicateNodeSchema;
+      filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"every">;
+      collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+      item: typeof import("trilean").PredicateNodeSchema;
+      filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"treeReference">;
+      key: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+    }, z.core.$strip>], "kind">>;
+    effect: z.ZodExactOptional<z.ZodString>;
+  }, z.core.$strict>>>>;
+  relations: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodEnum<{
+      "child-of": "child-of";
+      "assigned-to": "assigned-to";
+      "part-of": "part-of";
+    }>;
+    from: z.ZodString;
+    to: z.ZodString;
+  }, z.core.$strict>>>>;
+  overlay: z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodEnum<{
+    done: "done";
+    open: "open";
+    unknown: "unknown";
+  }>>>;
+  gaps: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    target: z.ZodString;
+    reason: z.ZodEnum<{
+      "not-found": "not-found";
+      forbidden: "forbidden";
+    }>;
+    message: z.ZodString;
+  }, z.core.$strict>>>>;
+  next: z.ZodExactOptional<z.ZodString>;
+}, z.core.$strict>>;
+/** The run states a sync filter can select by: whether the work is still open or done. */
+declare const filterStates: readonly ["open", "done"];
+/** What a sync filter can order the listed records by: when they were created, when they last changed, or how much discussion they have. */
+declare const orderFields: readonly ["created", "updated", "comments"];
+/** Which way a sync filter orders the listed records. */
+declare const orderDirections: readonly ["ascending", "descending"];
+/**
+ * Narrows and orders the records each scope lists, applied on the source's side where the source supports it. Every field is optional, and an absent field does not narrow.
+ *
+ * - `states` keeps records whose run state is one of those given.
+ * - `labels` keeps records carrying at least one of the labels given.
+ * - `order` is the order the records are listed in; absent, the source's own stable order.
+ *
+ * A filter narrows what a scope lists, not what the listed records reach: a blocker of a listed record is read whatever its own state or labels, because it is a dependency of work the filter kept.
+ */
+declare const syncFilterSchema: z.ZodReadonly<z.ZodObject<{
+  states: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+    open: "open";
+    done: "done";
+  }>>>>;
+  labels: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  order: z.ZodExactOptional<z.ZodReadonly<z.ZodObject<{
+    field: z.ZodEnum<{
+      created: "created";
+      updated: "updated";
+      comments: "comments";
+    }>;
+    direction: z.ZodEnum<{
+      ascending: "ascending";
+      descending: "descending";
+    }>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>>;
+/**
+ * What to sync and where to resume. `scope` names what to read as source-qualified scope identifiers (for GitHub, `github:org` for every repository an owner has, or `github:org/repo`), read in the order given. `after` is a cursor from an earlier page's `next`: the sync continues with the page that followed it. A cursor is valid only with the scope list and the filter it was issued for.
+ *
+ * `filter` narrows and orders what each scope lists (see `syncFilterSchema`).
+ */
+declare const syncInputSchema: z.ZodReadonly<z.ZodObject<{
+  scope: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  after: z.ZodExactOptional<z.ZodString>;
+  filter: z.ZodExactOptional<z.ZodReadonly<z.ZodObject<{
+    states: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+      open: "open";
+      done: "done";
+    }>>>>;
+    labels: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    order: z.ZodExactOptional<z.ZodReadonly<z.ZodObject<{
+      field: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+        comments: "comments";
+      }>;
+      direction: z.ZodEnum<{
+        ascending: "ascending";
+        descending: "descending";
+      }>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>>;
+/**
+ * A scope a person can choose to sync, as a picker lists it. `scope` is the scope identifier to pass to `sync` (for GitHub, `github:org` for an organisation, `github:org/repo` for a repository), `label` its display name, `description` the source's own description when it has one, `url` where it lives in the source's own interface, and `archived` whether the source has archived it.
+ */
+declare const scopeEntrySchema: z.ZodReadonly<z.ZodObject<{
+  scope: z.ZodString;
+  label: z.ZodString;
+  description: z.ZodExactOptional<z.ZodString>;
+  url: z.ZodExactOptional<z.ZodURL>;
+  archived: z.ZodBoolean;
+}, z.core.$strict>>;
+/**
+ * One page of a scope listing. `entries` are in the source's stable listing order, `gaps` name a parent the source could not read (it does not exist, or the credentials cannot see it), and `next` is the cursor to resume after this page, absent on the last.
+ */
+declare const scopeListingSchema: z.ZodReadonly<z.ZodObject<{
+  entries: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    scope: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodExactOptional<z.ZodString>;
+    url: z.ZodExactOptional<z.ZodURL>;
+    archived: z.ZodBoolean;
+  }, z.core.$strict>>>>;
+  gaps: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    target: z.ZodString;
+    reason: z.ZodEnum<{
+      "not-found": "not-found";
+      forbidden: "forbidden";
+    }>;
+    message: z.ZodString;
+  }, z.core.$strict>>>>;
+  next: z.ZodExactOptional<z.ZodString>;
+}, z.core.$strict>>;
+/** Where a listing of the top-level scopes resumes: a cursor from an earlier page's `next`. */
+declare const scopeRootsInputSchema: z.ZodReadonly<z.ZodObject<{
+  after: z.ZodExactOptional<z.ZodString>;
+}, z.core.$strict>>;
+/** The scope whose child scopes to list (for GitHub, the repositories of `github:owner`), and where to resume. A cursor is valid only for the parent it was issued for. */
+declare const scopeChildrenInputSchema: z.ZodReadonly<z.ZodObject<{
+  scope: z.ZodString;
+  after: z.ZodExactOptional<z.ZodString>;
+}, z.core.$strict>>;
+/** What a source says about itself. `source` is the prefix of every identifier it emits, before the colon. */
+declare const sourceDescriptionSchema: z.ZodReadonly<z.ZodObject<{
+  source: z.ZodString;
+}, z.core.$strict>>;
+/** Why a request was rejected as malformed. */
+declare const badRequestReasons: readonly ["invalid-cursor", "invalid-scope"];
+type BoundActivity = z.infer<typeof boundActivitySchema>;
+type SourceParticipant = z.infer<typeof participantSchema>;
+type SourceTransition = z.infer<typeof transitionSchema>;
+type Relation = z.infer<typeof relationSchema>;
+type RelationKind = (typeof relationKinds)[number];
+type Gap = z.infer<typeof gapSchema>;
+type GapReason = (typeof gapReasons)[number];
+type SyncPage = z.output<typeof syncPageSchema>;
+/** A page as an implementation supplies it, before parsing. */
+type SyncPageInput = z.input<typeof syncPageSchema>;
+type SyncInput = z.infer<typeof syncInputSchema>;
+type SyncFilter = z.infer<typeof syncFilterSchema>;
+type FilterState = (typeof filterStates)[number];
+type OrderField = (typeof orderFields)[number];
+type OrderDirection = (typeof orderDirections)[number];
+type ScopeEntry = z.infer<typeof scopeEntrySchema>;
+type ScopeListing = z.output<typeof scopeListingSchema>;
+/** A listing page as an implementation supplies it, before parsing. */
+type ScopeListingInput = z.input<typeof scopeListingSchema>;
+type ScopeRootsInput = z.infer<typeof scopeRootsInputSchema>;
+type ScopeChildrenInput = z.infer<typeof scopeChildrenInputSchema>;
+type SourceDescription = z.infer<typeof sourceDescriptionSchema>;
+type BadRequestReason = (typeof badRequestReasons)[number];
+//#endregion
+//#region ../../core/graph/source-contract/dist/contract.d.ts
+/**
+ * The typed errors every procedure can end with, each carrying its detail as data. The codes are oRPC's common codes, so an HTTP transport answers with the matching status (401, 429, 400) without any per-transport mapping.
+ */
+declare const graphSourceErrors: {
+  UNAUTHORIZED: {
+    message: string;
+    data: z.ZodObject<{}, z.core.$strict>;
+  };
+  TOO_MANY_REQUESTS: {
+    message: string;
+    data: z.ZodObject<{
+      resetAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>;
+  };
+  BAD_REQUEST: {
+    message: string;
+    data: z.ZodObject<{
+      reason: z.ZodEnum<{
+        "invalid-cursor": "invalid-cursor";
+        "invalid-scope": "invalid-scope";
+      }>;
+      value: z.ZodString;
+    }, z.core.$strict>;
+  };
+};
+type GraphSourceErrors = typeof graphSourceErrors;
+/**
+ * The scope listings' errors: every procedure's, and `NOT_IMPLEMENTED` for a source that offers no listing, which oRPC's common code answers with HTTP 501 over HTTP.
+ */
+declare const scopeListingErrors: {
+  NOT_IMPLEMENTED: {
+    message: string;
+    data: z.ZodObject<{}, z.core.$strict>;
+  };
+  UNAUTHORIZED: {
+    message: string;
+    data: z.ZodObject<{}, z.core.$strict>;
+  };
+  TOO_MANY_REQUESTS: {
+    message: string;
+    data: z.ZodObject<{
+      resetAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>;
+  };
+  BAD_REQUEST: {
+    message: string;
+    data: z.ZodObject<{
+      reason: z.ZodEnum<{
+        "invalid-cursor": "invalid-cursor";
+        "invalid-scope": "invalid-scope";
+      }>;
+      value: z.ZodString;
+    }, z.core.$strict>;
+  };
+};
+type ScopeListingErrors = typeof scopeListingErrors;
+/** The event iterator of pages `sync.stream` returns, typed by name so declarations stay small. */
+declare const syncPageEvents: ReturnType<typeof eventIterator<SyncPageInput, SyncPage>>;
+/**
+ * The shape of version 1, stated so the published declarations name the page and input schemas rather than expanding them into every procedure.
+ */
+interface GraphSourceV1Contract {
+  /** Present so the contract is assignable to oRPC's `RouterContract`, which is an index-signature type. */
+  readonly [key: string]: RouterContract;
+  readonly describe: ProcedureContract<InitialInputSchema, typeof sourceDescriptionSchema, GraphSourceErrors>;
+  readonly sync: {
+    readonly page: ProcedureContract<typeof syncInputSchema, typeof syncPageSchema, GraphSourceErrors>;
+    readonly stream: ProcedureContract<typeof syncInputSchema, typeof syncPageEvents, GraphSourceErrors>;
+  };
+  readonly scopes: {
+    readonly roots: ProcedureContract<typeof scopeRootsInputSchema, typeof scopeListingSchema, ScopeListingErrors>;
+    readonly children: ProcedureContract<typeof scopeChildrenInputSchema, typeof scopeListingSchema, ScopeListingErrors>;
+  };
+}
+/** The `GraphSource` port: an oRPC router contract, keyed by version. */
+declare const graphSourceContract: {
+  readonly v1: GraphSourceV1Contract;
+};
+/** A client for the `GraphSource` port over any transport: an in-process router client or one built on an oRPC link. */
+type GraphSourceClient = ContractRouterClient<typeof graphSourceContract>;
+//#endregion
+//#region ../../core/graph/source-contract/dist/errors.d.ts
+/**
+ * The failures that end a sync call, as a closed union a caller can switch on exhaustively. What a source can still partly read is not a failure: it arrives as a `Gap` in the page.
+ *
+ * - `unauthorised`: the source rejected the credentials outright.
+ * - `rate-limited`: the source refused the request until `resetAt` (an ISO 8601 instant) when it said so. Resume from the last page's `next` after that.
+ * - `bad-request`: the cursor or a scope identifier is not one this source issued or understands.
+ */
+type GraphSourceFailure = {
+  readonly kind: "unauthorised";
+  readonly message: string;
+} | {
+  readonly kind: "rate-limited";
+  readonly message: string;
+  readonly resetAt: string | undefined;
+} | {
+  readonly kind: "bad-request";
+  readonly message: string;
+  readonly reason: BadRequestReason;
+  readonly value: string;
+};
+/**
+ * Thrown by a `GraphSourcePager` to end a call with a typed failure. `createGraphSourceRouter` turns it into the contract's matching oRPC error, so it reaches a client over any transport as `UNAUTHORIZED`, `TOO_MANY_REQUESTS` or `BAD_REQUEST` with its data.
+ */
+declare class GraphSourceError extends Error {
+  /** The failure, with the detail a caller branches on. */
+  readonly failure: GraphSourceFailure;
+  /**
+   * @param failure - The failure this error carries; its `message` becomes the error's message.
+   * @param options - Standard error options: `cause` is the underlying error, when there is one.
+   */
+  constructor(failure: GraphSourceFailure, options?: ErrorOptions);
+}
+//#endregion
+//#region ../../core/graph/source-contract/dist/router.d.ts
+/** One request for a page, as a pager receives it. */
+interface PageRequest {
+  /** The scope identifiers to read, in order. */
+  readonly scope: SyncInput["scope"];
+  /** Where to start: the `next` of the page before, or `undefined` for the first page. */
+  readonly cursor: string | undefined;
+  /** The caller's abort signal. A pager passes it to every request it makes and stops when it fires. */
+  readonly signal: AbortSignal | undefined;
+  /** What narrows and orders each scope's listing; absent or `undefined`, nothing narrows it. A cursor issued under one filter is not valid under another. */
+  readonly filter?: SyncFilter | undefined;
+}
+/** One request for a page of a scope listing. */
+interface ListingRequest {
+  /** Where to start: the `next` of the page before, or `undefined` for the first page. */
+  readonly cursor: string | undefined;
+  /** The caller's abort signal, passed to every request the listing makes. */
+  readonly signal: AbortSignal | undefined;
+}
+/** One request for a page of the scopes inside a scope. */
+interface ChildrenRequest extends ListingRequest {
+  /** The scope identifier whose child scopes to list. */
+  readonly scope: string;
+}
+/**
+ * How a source lists the scopes a person can choose to sync, one page at a time. Cursors follow the pager's rules: stable, holding no in-memory state, and valid only for the listing (and parent) that issued them, so a foreign one throws `GraphSourceError` with `bad-request` and `invalid-cursor`.
+ */
+interface GraphSourceScopes {
+  /**
+   * Lists the top-level scopes the credentials reach.
+   * @param request - The cursor to start after, and the abort signal.
+   * @returns One page of entries, with `next` absent on the last.
+   * @throws GraphSourceError for a failure that ends the call.
+   */
+  readonly roots: (request: ListingRequest) => Promise<ScopeListing>;
+  /**
+   * Lists the scopes inside one scope. A parent that does not exist, or that the credentials cannot see, is a gap on an empty page; a scope with nothing inside it is an empty page; a parent that is not a scope identifier of this source throws `bad-request` with `invalid-scope`.
+   * @param request - The parent scope, the cursor to start after, and the abort signal.
+   * @returns One page of entries, with `next` absent on the last.
+   * @throws GraphSourceError for a failure that ends the call.
+   */
+  readonly children: (request: ChildrenRequest) => Promise<ScopeListing>;
+}
+/**
+ * What an adapter implements: one page at a time. `createGraphSourceRouter` builds the whole port on it, so paging, streaming, resumption and error mapping behave identically for every source.
+ *
+ * A pager's cursors must be stable: the same scope and cursor return the same page while the source is unchanged, and a cursor never names a position relative to state held in memory, so a sync resumes in a different process. A cursor the pager did not issue, or one from a different scope list, throws `GraphSourceError` with `bad-request` and `invalid-cursor`; a scope identifier it cannot parse throws `bad-request` and `invalid-scope`.
+ */
+interface GraphSourcePager {
+  /** The identifier prefix this source emits, such as `github`. */
+  readonly source: string;
+  /**
+   * Reads one page.
+   * @param request - The scope, the cursor to start after, and the abort signal.
+   * @returns The page, with `next` absent when it is the last.
+   * @throws GraphSourceError for a failure that ends the call.
+   */
+  readonly page: (request: PageRequest) => Promise<SyncPage>;
+  /** Lists the scopes a person can choose from. Absent, the source offers no listing and the router answers its procedures with `NOT_IMPLEMENTED`. */
+  readonly scopes?: GraphSourceScopes;
+}
+/** The implemented `GraphSource` router: serve it over any oRPC transport, or call it in process with `createRouterClient`. */
+type GraphSourceRouter = ContractedRouter<typeof graphSourceContract, DefaultInitialContext>;
+/**
+ * Builds the `GraphSource` router over a pager. Serve it over any oRPC transport, or call it in process with `createRouterClient`.
+ * @param pager - The adapter's page reader.
+ * @returns The implemented router for `graphSourceContract`.
+ */
+declare const createGraphSourceRouter: (pager: GraphSourcePager) => GraphSourceRouter;
+//#endregion
+//#region ../../core/graph/source-contract/dist/assemble.d.ts
+/** A whole sync merged into one model, with what the model has no place for kept beside it. */
+interface AssembledSync {
+  /** The participants, bound activities and transitions of every page, each identifier once. */
+  readonly model: Model<OpenIds>;
+  /** The run state of every activity, keyed by its identifier. */
+  readonly overlay: Overlay<OpenIds>;
+  /** Every relation, each distinct one once. */
+  readonly relations: readonly Relation[];
+  /** Every gap, in page order. */
+  readonly gaps: readonly Gap[];
+}
+/**
+ * Merges the pages of a sync into one model. A record can appear on several pages, for example an issue in another repository reached through a dependency before its own repository is read; identity is the identifier, so it becomes one element, and where pages disagree the later page wins, being the more recent read.
+ * @param pages - The pages of one sync, in the order they arrived.
+ * @returns The model, overlay, relations and gaps of the whole sync.
+ */
+declare const assembleSync: (pages: readonly SyncPage[]) => AssembledSync;
+//#endregion
+//#region ../../core/graph/source-contract/dist/fake.d.ts
+/** A page's content without its cursor, which the fake derives. */
+type FakePage = Omit<SyncPage, "next">;
+/** What the in-memory fake serves. */
+interface FakeGraphSourceOptions {
+  /** The identifier prefix, such as `fake`. Every scope identifier must start with it and a colon. */
+  readonly source: string;
+  /** The pages of each known scope, keyed by scope identifier. A scope with no pages is known and empty. */
+  readonly scopes: Readonly<Record<string, readonly FakePage[]>>;
+  /** What `scopes.roots` lists, in order; nothing when absent. */
+  readonly roots?: readonly ScopeEntry[];
+  /** What `scopes.children` lists for each parent scope, in order. A parent named here, in `scopes` or among `roots` is known; any other parent is a `not-found` gap. */
+  readonly children?: Readonly<Record<string, readonly ScopeEntry[]>>;
+  /** Entries per listing page, a positive integer; absent, a listing is one page. */
+  readonly listingPageSize?: number;
+}
+/**
+ * The reference in-memory `GraphSourcePager`: a fixed set of pages per scope, served in scope order. A scope that is well formed but unknown yields one page holding a `not-found` gap, so a sync over several scopes still returns the rest. Cursors encode the scope identifier, page index and filter, so they are stable, resume in any instance built from the same pages, and are refused under a different filter. A filter is applied to each page as described at `filtered`.
+ *
+ * Its scope listing serves `roots` and `children` from the options, `listingPageSize` entries a page.
+ * @param options - The source prefix and the pages of each scope.
+ * @returns A pager for `createGraphSourceRouter`.
+ */
+declare const createFakeGraphSource: (options: FakeGraphSourceOptions) => GraphSourcePager;
+//#endregion
+//#region ../../adapters/graph/source-github-issues/dist/graphql.d.ts
+/** GitHub's GraphQL endpoint. */
+declare const githubGraphqlEndpoint = "https://api.github.com/graphql";
+/**
+ * Supplies the token for requests about one owner's repositories, so different organisations can use different credentials. The token is only ever sent in the `Authorization` header; this adapter never logs or returns it.
+ * @param owner - The login of the account whose repositories or board the request reads, or `undefined` for a request about the token's own holder (the viewer and the organisations it belongs to), which no owner names.
+ * @param signal - The caller's abort signal.
+ * @returns The token.
+ */
+type GitHubTokenPort = (owner: string | undefined, signal: AbortSignal | undefined) => Promise<string>;
+/** The part of `fetch` this adapter uses: one POST to the GraphQL endpoint. The global `fetch` satisfies it. */
+type GraphqlFetch = (url: string, init: RequestInit) => Promise<Response>;
+//#endregion
+export { scopeRootsInputSchema as $, ScopeEntry as A, badRequestReasons as B, Gap as C, Relation as D, OrderField as E, SourceParticipant as F, orderDirections as G, filterStates as H, SourceTransition as I, relationKinds as J, orderFields as K, SyncFilter as L, ScopeListingInput as M, ScopeRootsInput as N, RelationKind as O, SourceDescription as P, scopeListingSchema as Q, SyncInput as R, FilterState as S, OrderDirection as T, gapReasons as U, boundActivitySchema as V, gapSchema as W, scopeChildrenInputSchema as X, relationSchema as Y, scopeEntrySchema as Z, GraphSourceFailure as _, FakePage as a, BadRequestReason as b, assembleSync as c, GraphSourceRouter as d, sourceDescriptionSchema as et, GraphSourceScopes as f, GraphSourceError as g, createGraphSourceRouter as h, FakeGraphSourceOptions as i, transitionSchema as it, ScopeListing as j, ScopeChildrenInput as k, ChildrenRequest as l, PageRequest as m, GraphqlFetch as n, syncInputSchema as nt, createFakeGraphSource as o, ListingRequest as p, participantSchema as q, githubGraphqlEndpoint as r, syncPageSchema as rt, AssembledSync as s, GitHubTokenPort as t, syncFilterSchema as tt, GraphSourcePager as u, GraphSourceClient as v, GapReason as w, BoundActivity as x, graphSourceContract as y, SyncPage as z };