@volter/twin-github 0.1.2 → 2.0.0

package/dist/src/github-twin.d.ts

@@ -0,0 +1,1411 @@
+/** What the World keeps of a person's password: its hash, never the password (src/screens/session.tsx checks it). */
+export declare const passwordHash: (login: string, password: string) => string;
+/** A person's authenticator app: the RFC 6238 code of a base32 secret at an instant, as GitHub's TOTP setup encodes it
+ *  (docs.github.com/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication:
+ *  SHA1, 6 digits, a 30-second period). `step` counts 30-second periods since the epoch. */
+export declare const totpStep: (at: string) => number;
+export declare function totpCode(secret: string, step: number): string;
+/** The engine slot's plane, as handlers reach it (semantics/ imports shared helpers from here). */
+export { deleteBareRepo, deleteGitRefInPlane, diffFilesInPlane, mergeBaseInPlane, mergeIntoBranchInPlane, ensureBareRepo, forkBareRepo, setBareRepoHead, hasBareRepo, isAncestorInPlane, isValidBranchName, listGitPlaneRefs, objectExistsInPlane, objectTypeInPlane, readGitBlobFromPlane, readGitCommitFromPlane, readGitTagFromPlane, readGitTreeFromPlane, updateGitRefInPlane, writeGitBlobToPlane, writeGitCommitToPlane, writeGitTagToPlane, writeGitTreeToPlane, } from './github-git-plane.js';
+export declare function mergePullRequest(repo: string, pr: GithubPr, method: 'merge' | 'squash' | 'rebase', occurredAt: string, root: string | undefined, merger: string | undefined, write: GithubWrite): Promise<{
+    ok: true;
+    sha: string;
+} | {
+    ok: false;
+    status: number;
+    message: string;
+}>;
+export declare function rulesetsFor(st: GithubState, repo: string, branch: string, enforcement?: 'active' | 'evaluate'): GithubRuleset[];
+/** A stored write as the kernel records it: a handler passes its context's (semantics/shared.ts `put`). */
+export type GithubWrite = (w: {
+    operation: string;
+    subjectType: string;
+    subjectId: string;
+    fields: Record<string, unknown>;
+}) => Promise<unknown>;
+/** A write decided from the tree with nothing written in between (semantics/shared.ts `atomic` for a
+ *  handler's context; the kernel's lock otherwise). */
+export type GithubAtomic = <T>(decide: () => {
+    value: T;
+    write?: Parameters<GithubWrite>[0];
+}) => Promise<T>;
+export declare function kernelAtomic(occurredAt: string, root?: string): GithubAtomic;
+export declare function recordRulesetVersion(repo: string, id: number, login: string, occurredAt: string, root: string | undefined, write: GithubWrite): Promise<void>;
+export declare function recordRuleSuite(repo: string, suite: Omit<GithubRuleSuite, 'id'>, occurredAt: string, root: string | undefined, write: GithubWrite): Promise<void>;
+export type GithubReview = {
+    id: number;
+    repository: string;
+    number: number;
+    state?: string;
+    body?: string;
+    submitted_at?: string;
+    commit_id?: string;
+    user_login?: string;
+    user_type?: 'User' | 'Bot';
+    /** the reviewer's relation to the repository when they submitted it */
+    author_association?: string;
+};
+export type GithubReviewOverlay = {
+    id: number;
+    state?: string;
+    body?: string;
+    dismissed_message?: string;
+};
+export type GithubComment = {
+    id: number;
+    repository: string;
+    number: number;
+    kind: 'issue' | 'review';
+    subject_id?: string;
+    commit_id?: string;
+    body?: string;
+    created_at?: string;
+    updated_at?: string;
+    path?: string;
+    line?: number;
+    side?: string;
+    start_line?: number;
+    diff_hunk?: string;
+    in_reply_to?: number;
+    review_id?: number;
+    user_login?: string;
+    user_type?: 'User' | 'Bot';
+    external_id?: string;
+    /** the writer's relation to the repository when they wrote it */
+    author_association?: string;
+};
+export type GithubPullFile = {
+    filename: string;
+    status: string;
+    additions: number;
+    deletions: number;
+    changes: number;
+    patch?: string;
+    sha?: string;
+    previous_filename?: string;
+};
+export type GithubPullCommit = {
+    sha: string;
+    message?: string;
+    author_name?: string;
+    author_email?: string;
+    author_date?: string;
+};
+export type GithubPr = {
+    id: string;
+    number: number;
+    repository: string;
+    /** the repository it was opened in, when a transfer has since moved it: its id stays the one it was given there */
+    born_in?: string;
+    locked?: boolean;
+    active_lock_reason?: string | null;
+    updated_at?: string;
+    user_login?: string | null;
+    user_type?: string;
+    /** the author's relation to the repository when they opened it (GitHub's author_association) */
+    author_association?: string;
+    maintainer_can_modify?: boolean;
+    base_ref?: string;
+    head_sha?: string;
+    head_ref?: string;
+    /** the repository the head branch lives in when it is not the pull request's own: a fork in the same network, as a
+     *  pull request from a fork has it (docs.github.com/pull-requests/collaborating-with-pull-requests/proposing-changes-
+     *  to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) */
+    head_repo?: string;
+    changed_files?: number;
+    commits?: number;
+    additions?: number;
+    deletions?: number;
+    review_count: number;
+    comment_count: number;
+    title?: string;
+    body?: string;
+    state?: string;
+    merged?: boolean;
+    merged_at?: string;
+    merge_commit_sha?: string;
+    merged_by_login?: string;
+    created_at?: string;
+    labels?: string[];
+    assignees?: string[];
+    requested_reviewers?: string[];
+    milestone?: number;
+    draft?: boolean;
+    merge_method?: string;
+    mergeable_state?: string;
+    state_history?: Array<{
+        state: string;
+        state_reason?: string | null;
+        at?: string;
+    }>;
+    /** what happened to it, in order, from its writes: who labeled, assigned, milestoned, locked, closed or reopened it, and when */
+    activity?: GithubActivity[];
+    is_pull_request?: boolean;
+};
+export type GithubStatus = {
+    id: number;
+    repository: string;
+    sha: string;
+    state: string;
+    context?: string;
+    description?: string;
+    target_url?: string;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubCheckRun = {
+    id: number;
+    /** the checking system's own id for the run, as it gave it */
+    external_id?: string;
+    repository: string;
+    head_sha: string;
+    name: string;
+    status?: string;
+    conclusion?: string;
+    details_url?: string;
+    started_at?: string;
+    completed_at?: string;
+    check_suite_id?: number;
+    /** the GitHub App that wrote the run; an observed run may not say */
+    app_slug?: string;
+    output_title?: string;
+    output_summary?: string;
+    output_text?: string;
+    annotations?: GithubCheckAnnotation[];
+};
+export type GithubCheckAnnotation = {
+    path: string;
+    start_line: number;
+    end_line: number;
+    annotation_level: string;
+    message: string;
+    title?: string;
+    raw_details?: string;
+    start_column?: number;
+    end_column?: number;
+};
+export type GithubMilestone = {
+    id: number;
+    number: number;
+    repository: string;
+    title?: string;
+    description?: string;
+    state?: string;
+    due_on?: string;
+    created_at?: string;
+    updated_at?: string;
+    /** who created it */
+    creator_login?: string;
+    /** the open and closed issues and pull requests in it, counted by the fold */
+    open_issues?: number;
+    closed_issues?: number;
+};
+export type GithubIssue = {
+    id: string;
+    number: number;
+    repository: string;
+    /** the repository it was opened in, when a transfer has since moved it: its id stays the one it was given there */
+    born_in?: string;
+    title?: string;
+    body?: string;
+    state?: string;
+    created_at?: string;
+    updated_at?: string;
+    labels?: string[];
+    assignees?: string[];
+    milestone?: number;
+    state_reason?: string | null;
+    state_history?: Array<{
+        state: string;
+        state_reason?: string | null;
+        at?: string;
+    }>;
+    /** what happened to it, in order, from its writes: who labeled, assigned, milestoned, locked, closed or reopened it, and when */
+    activity?: GithubActivity[];
+    locked?: boolean;
+    active_lock_reason?: string | null;
+    sub_issue_numbers?: number[];
+    parent_issue_number?: number;
+    /** who opened it */
+    user_login?: string | null;
+    /** their relation to the repository when they opened it */
+    author_association?: string;
+};
+export type GithubReaction = {
+    id: number;
+    repository: string;
+    subject_type: 'issue' | 'comment' | 'discussion' | 'release';
+    subject_key: string;
+    content: string;
+    created_at?: string;
+};
+export type GithubLabel = {
+    id: number;
+    repository: string;
+    name: string;
+    color?: string;
+    description?: string | null;
+    default?: boolean;
+};
+export type GithubRepo = {
+    id: number;
+    owner: string;
+    name: string;
+    full_name: string;
+    description?: string | null;
+    private?: boolean;
+    default_branch?: string;
+    topics?: string[];
+    homepage?: string | null;
+    has_issues?: boolean;
+    has_projects?: boolean;
+    has_wiki?: boolean;
+    has_discussions?: boolean;
+    archived?: boolean;
+    fork?: boolean;
+    parent_full_name?: string;
+    created_at?: string;
+    updated_at?: string;
+    /** What GitHub counts and detects on a repository, as observed from the vendor or, for a local
+     *  repository, derived by the fold from the World (stars, watchers, forks, open issues and pull
+     *  requests, the last push, the files' bytes, their language and licence). */
+    facts?: GithubRepoFacts;
+};
+export type GithubRepoFacts = {
+    stargazers_count: number;
+    subscribers_count: number;
+    forks_count: number;
+    open_issues_count: number;
+    pushed_at: string | null;
+    size: number;
+    language: string | null;
+    license: Record<string, unknown> | null;
+    has_pages: boolean;
+};
+export type GithubBranch = {
+    repository: string;
+    name: string;
+    commit_sha: string;
+    protected?: boolean;
+    protection_config?: {
+        required_status_checks?: {
+            strict: boolean;
+            contexts: string[];
+            checks: Array<{
+                context: string;
+                app_id: number | null;
+            }>;
+        } | null;
+        enforce_admins?: boolean;
+        required_pull_request_reviews?: Record<string, unknown> | null;
+        restrictions?: Record<string, unknown> | null;
+    };
+};
+export type GithubCollaborator = {
+    repository: string;
+    login: string;
+    permission: string;
+};
+export type GithubWebhook = {
+    id: number;
+    repository: string;
+    name: string;
+    active: boolean;
+    events: string[];
+    url?: string;
+    content_type?: string;
+    secret?: string;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubContentFile = {
+    repository: string;
+    path: string;
+    content_b64?: string;
+    sha: string;
+    size: number;
+    branch?: string;
+};
+export type GithubUser = {
+    login: string;
+    id: number;
+    type: 'User' | 'Organization';
+    name?: string | null;
+    bio?: string | null;
+    company?: string | null;
+    blog?: string | null;
+    location?: string | null;
+    email?: string | null;
+};
+export type GithubGistFile = {
+    filename: string;
+    content?: string;
+    language?: string;
+    size?: number;
+};
+/** One saved version of a gist: its id (a sha), when, by whom, and its files then. */
+export type GithubGistVersion = {
+    version: string;
+    committed_at: string;
+    user_login: string;
+    files: GithubGistFile[];
+    additions: number;
+    deletions: number;
+};
+export type GithubGist = {
+    id: string;
+    /** who created it */
+    owner?: string;
+    description?: string | null;
+    public?: boolean;
+    files: GithubGistFile[];
+    created_at?: string;
+    updated_at?: string;
+    /** its versions, newest first: every create and every edit of its files saves one */
+    history?: GithubGistVersion[];
+};
+export type GithubNotification = {
+    id: string;
+    repository: string;
+    subject_title: string;
+    subject_type: string;
+    subject_url?: string;
+    reason: string;
+    unread: boolean;
+    updated_at?: string;
+    /** The person's own choice about the thread: absent while it stands as GitHub made it (subscribed, since they
+     *  take part), set when they subscribe or ignore it, null once they unsubscribe. */
+    subscription?: {
+        subscribed: boolean;
+        ignored: boolean;
+        created_at?: string;
+    } | null;
+};
+export type GithubWorkflow = {
+    id: number;
+    repository: string;
+    name: string;
+    path: string;
+    state?: string;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubWorkflowRun = {
+    id: number;
+    repository: string;
+    workflow_id: number;
+    name?: string;
+    run_number: number;
+    event: string;
+    status: string;
+    conclusion?: string;
+    head_sha: string;
+    head_branch?: string;
+    created_at?: string;
+    updated_at?: string;
+    actor_login?: string;
+    approvals?: {
+        environment: string;
+        state: 'approved' | 'rejected';
+        comment: string;
+        user_login: string;
+        at: string;
+    }[];
+    /** the repository the run's commit came from when it is not the run's own: the fork of a pull request from one */
+    head_repository?: string;
+};
+export type GithubJobStep = {
+    name: string;
+    status: string;
+    conclusion?: string;
+    number: number;
+};
+export type GithubJob = {
+    id: number;
+    run_id: number;
+    repository: string;
+    name: string;
+    status: string;
+    conclusion?: string;
+    head_sha: string;
+    started_at?: string;
+    completed_at?: string;
+    steps: GithubJobStep[];
+    /** the runner labels its workflow's `runs-on` asks for, its workflow's name and its run's branch, when queued */
+    labels?: string[];
+    workflow_name?: string;
+    head_branch?: string;
+    created_at?: string;
+};
+export type GithubReleaseAsset = {
+    id: number;
+    repository: string;
+    release_id: number;
+    name: string;
+    label?: string;
+    content_type?: string;
+    size?: number;
+    state?: string;
+    download_count?: number;
+    created_at?: string;
+    updated_at?: string;
+    /** who uploaded it */
+    uploader_login?: string;
+};
+export type GithubRelease = {
+    id: number;
+    repository: string;
+    tag_name: string;
+    target_commitish?: string;
+    name?: string;
+    body?: string;
+    draft?: boolean;
+    prerelease?: boolean;
+    created_at?: string;
+    published_at?: string;
+    /** who created it: a person, or an app's bot (a workflow's GITHUB_TOKEN is github-actions[bot]) */
+    author_login?: string;
+};
+export type GithubTag = {
+    name: string;
+    commit_sha: string;
+    repository: string;
+};
+export type GithubDiscussionCategory = {
+    id: number;
+    repository: string;
+    name: string;
+    slug: string;
+    emoji?: string;
+    description?: string;
+    is_answerable?: boolean;
+};
+export type GithubDiscussion = {
+    number: number;
+    repository: string;
+    title?: string;
+    body?: string;
+    category_slug?: string;
+    state?: string;
+    state_reason?: string;
+    answer_comment_id?: number | null;
+    locked?: boolean;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubDiscussionComment = {
+    id: number;
+    repository: string;
+    discussion_number: number;
+    parent_id?: number | null;
+    body?: string;
+    is_answer?: boolean;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubGitRef = {
+    repository: string;
+    ref: string;
+    object_sha: string;
+    object_type: string;
+};
+export type GithubGitCommit = {
+    repository: string;
+    sha: string;
+    message: string;
+    tree_sha: string;
+    parents: string[];
+    author_name?: string;
+    author_email?: string;
+    created_at?: string;
+};
+export type GithubGitTreeEntry = {
+    path: string;
+    mode: string;
+    type: string;
+    sha: string;
+    size?: number;
+};
+export type GithubGitTree = {
+    repository: string;
+    sha: string;
+    tree: GithubGitTreeEntry[];
+    truncated?: boolean;
+};
+export type GithubGitBlob = {
+    repository: string;
+    sha: string;
+    content_b64: string;
+    size: number;
+    encoding: string;
+};
+export type GithubGitTagObject = {
+    repository: string;
+    sha: string;
+    tag: string;
+    message: string;
+    object_sha: string;
+    object_type: string;
+    tagger_name?: string;
+    created_at?: string;
+};
+export type GithubDeployment = {
+    payload?: unknown;
+    id: number;
+    repository: string;
+    ref: string;
+    sha: string;
+    task: string;
+    environment: string;
+    description?: string | null;
+    transient_environment?: boolean;
+    production_environment?: boolean;
+    created_at?: string;
+    updated_at?: string;
+    creator_login?: string;
+};
+export type GithubDeploymentStatus = {
+    id: number;
+    repository: string;
+    deployment_id: number;
+    state: string;
+    description?: string | null;
+    environment?: string;
+    environment_url?: string;
+    log_url?: string;
+    created_at?: string;
+    creator_login?: string;
+};
+export type GithubEnvironment = {
+    repository: string;
+    born_in?: string;
+    name: string;
+    wait_timer?: number;
+    reviewers?: string[];
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubActionsSecret = {
+    scope: string;
+    container: string;
+    name: string;
+    created_at?: string;
+    updated_at?: string; /** an organization's: all, private or selected repositories */
+    visibility?: string;
+};
+export type GithubActionsVariable = {
+    scope: string;
+    container: string;
+    name: string;
+    value: string;
+    created_at?: string;
+    updated_at?: string; /** an organization's: all, private or selected repositories */
+    visibility?: string;
+};
+export type GithubActionsCache = {
+    id: number;
+    repository: string;
+    key: string;
+    ref: string;
+    size_in_bytes: number;
+    created_at?: string;
+    last_accessed_at?: string;
+};
+export type GithubActionsArtifact = {
+    id: number;
+    repository: string;
+    name: string;
+    size_in_bytes: number;
+    run_id?: number;
+    expired?: boolean;
+    created_at?: string;
+};
+export type GithubOrg = {
+    login: string;
+    description?: string | null;
+    name?: string | null;
+    company?: string | null;
+    blog?: string | null;
+    location?: string | null;
+    email?: string | null;
+    billing_email?: string | null;
+    created_at?: string;
+    updated_at?: string;
+    two_factor_requirement_enabled?: boolean;
+};
+export type GithubOrgMembership = {
+    org: string;
+    login: string;
+    role: string;
+    state: string;
+    created_at?: string;
+};
+export type GithubOutsideCollaborator = {
+    org: string;
+    login: string;
+};
+export type GithubOrgWebhook = {
+    id: number;
+    org: string;
+    name: string;
+    active: boolean;
+    events: string[];
+    url?: string;
+    content_type?: string;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubTeam = {
+    id: number;
+    org: string;
+    slug: string;
+    name: string;
+    description?: string | null;
+    privacy?: string;
+    permission?: string;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubTeamMembership = {
+    org: string;
+    team_slug: string;
+    login: string;
+    role: string;
+    state: string;
+};
+export type GithubTeamRepo = {
+    org: string;
+    team_slug: string;
+    repository: string;
+    permission: string;
+};
+export type GithubCommitComment = {
+    id: number;
+    repository: string;
+    commit_sha: string;
+    body?: string;
+    path?: string | null;
+    line?: number | null;
+    position?: number | null;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubIssueType = {
+    id: number;
+    org: string;
+    name: string;
+    description?: string | null;
+    color?: string | null;
+    is_enabled?: boolean;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubDeployKey = {
+    id: number;
+    repository: string;
+    key: string;
+    title: string;
+    read_only: boolean;
+    created_at?: string;
+};
+export type GithubAutolink = {
+    id: number;
+    repository: string;
+    key_prefix: string;
+    url_template: string;
+    is_alphanumeric: boolean;
+};
+export type GithubRuleset = {
+    id: number;
+    repository: string;
+    name: string;
+    target: string;
+    enforcement: string;
+    rules: Array<Record<string, unknown>>;
+    conditions?: Record<string, unknown>;
+    bypass_actors?: Array<Record<string, unknown>>;
+    created_at?: string;
+    updated_at?: string;
+    versions?: {
+        version_id: number;
+        actor_login: string;
+        updated_at: string;
+        state: Record<string, unknown>;
+    }[];
+};
+export type GithubRuleSuite = {
+    id: number;
+    repository: string;
+    ref: string;
+    actor_login: string;
+    before_sha: string;
+    after_sha: string;
+    pushed_at: string;
+    result: 'pass' | 'fail' | 'bypass';
+    rules: {
+        ruleset_id: number;
+        ruleset_name: string;
+        rule_type: string;
+        enforcement: string;
+        result: 'pass' | 'fail';
+        details: string | null;
+    }[];
+};
+export type GithubUserEmail = {
+    email: string;
+    primary: boolean;
+    verified: boolean;
+    visibility: string | null;
+};
+export type GithubUserSshKey = {
+    id: number;
+    key: string;
+    title: string;
+    created_at?: string;
+};
+export type GithubUserGpgKey = {
+    id: number;
+    key_id: string;
+    raw_key: string;
+    created_at?: string;
+};
+export type GithubProject = {
+    creator_login?: string;
+    id: number;
+    owner: string;
+    owner_type: string;
+    number: number;
+    title: string;
+    short_description?: string | null;
+    readme?: string | null;
+    public?: boolean;
+    closed?: boolean;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubProjectField = {
+    id: number;
+    project_id: number;
+    name: string;
+    data_type: string;
+    options?: Array<{
+        id: string;
+        name: string;
+        description: string;
+        color: string;
+    }>;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubProjectItem = {
+    id: number;
+    project_id: number;
+    content_type: 'Issue' | 'PullRequest' | 'DraftIssue';
+    content_repository?: string;
+    content_number?: number;
+    title?: string;
+    body?: string;
+    field_values: Record<string, unknown>;
+    creator_login?: string;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubProjectView = {
+    id: number;
+    project_id: number;
+    number: number;
+    name: string;
+    layout: string;
+    filter?: string | null;
+    visible_fields?: number[];
+    sort_by?: unknown[];
+    group_by?: number[];
+    vertical_group_by?: number[];
+    creator_login?: string;
+    created_at?: string;
+    updated_at?: string;
+};
+/** Where and on what an analysis last found a code scanning alert. */
+export type GithubCodeScanningInstance = {
+    ref: string;
+    analysis_key: string;
+    commit_sha: string;
+    state: string;
+    message: string;
+    path: string;
+    start_line: number;
+    end_line: number;
+};
+export type GithubCodeScanningAlert = {
+    dismissed_by_login?: string | null;
+    number: number;
+    repository: string;
+    state: string;
+    rule_id: string;
+    rule_severity: string;
+    rule_description?: string;
+    tool_name: string;
+    tool_version?: string;
+    dismissed_reason?: string | null;
+    dismissed_comment?: string | null;
+    dismissed_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+    fixed_at?: string | null;
+    most_recent_instance?: GithubCodeScanningInstance;
+};
+export type GithubCodeScanningAnalysis = {
+    id: number;
+    repository: string;
+    ref: string;
+    commit_sha: string;
+    analysis_key: string;
+    environment?: string;
+    tool_name: string;
+    results_count: number;
+    rules_count: number;
+    sarif_id?: string;
+    created_at?: string;
+    deletable?: boolean;
+};
+export type GithubDependabotAlert = {
+    dismissed_by_login?: string | null;
+    number: number;
+    repository: string;
+    state: string;
+    package_name: string;
+    ecosystem: string;
+    ghsa_id: string;
+    severity: string;
+    summary?: string;
+    manifest_path?: string;
+    dismissed_reason?: string | null;
+    dismissed_comment?: string | null;
+    dismissed_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+};
+/** Where a secret was found: the file, its lines and columns, the blob and the commit. */
+export type GithubSecretLocation = {
+    path: string;
+    start_line: number;
+    end_line: number;
+    start_column: number;
+    end_column: number;
+    blob_sha: string;
+    commit_sha: string;
+};
+export type GithubSecretScanningAlert = {
+    number: number;
+    repository: string;
+    state: string;
+    secret_type: string;
+    secret_type_display_name?: string;
+    resolution?: string | null;
+    resolution_comment?: string | null;
+    resolved_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+    locations?: GithubSecretLocation[];
+    _secret?: string;
+};
+export type GithubAppInstallation = {
+    id: number;
+    account_login: string;
+    account_type: string;
+    app_id: number;
+    app_slug: string;
+    target_type: string;
+    repository_selection: string;
+    permissions: Record<string, string>;
+    events: string[];
+    created_at?: string;
+    updated_at?: string;
+    repositories?: string[];
+};
+export type GithubAppRegistration = {
+    id: number;
+    slug: string;
+    name: string;
+    owner: string;
+    client_id: string;
+    permissions: Record<string, string>;
+    events: string[];
+    setup_url?: string;
+    callback_url?: string;
+    request_oauth_on_install: boolean;
+    hook_url?: string;
+    webhook_secret?: string;
+    description?: string | null;
+    created_at?: string; /** the app's homepage (a manifest's `url`) */
+    url?: string;
+};
+/** The registered GitHub Apps at `root`. */
+export declare function githubApps(root?: string): GithubAppRegistration[];
+/** GitHub's App object (GET /apps/{app_slug}). */
+export declare function toGithubApp(a: GithubAppRegistration, installations: number, st?: GithubState): Record<string, unknown>;
+/** One thing done to an issue or pull request, as its timeline tells it. */
+export type GithubActivity = {
+    event: 'labeled' | 'unlabeled' | 'assigned' | 'unassigned' | 'milestoned' | 'demilestoned' | 'locked' | 'unlocked' | 'closed' | 'reopened' | 'merged';
+    at?: string;
+    by?: string;
+    label?: string;
+    assignee?: string;
+    milestone?: unknown;
+    state_reason?: string | null;
+    lock_reason?: string | null;
+    commit_id?: string | null;
+};
+export type GithubOAuthGrant = {
+    token: string;
+    client_id: string;
+    scopes: string[];
+    created_at?: string;
+    login?: string;
+};
+export type GithubPackage = {
+    id: number;
+    name: string;
+    package_type: string;
+    owner: string;
+    visibility: string;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubPackageVersion = {
+    id: number;
+    package_name: string;
+    package_type: string;
+    owner: string;
+    name: string;
+    tags?: string[];
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubPagesSite = {
+    repository: string;
+    cname?: string | null;
+    cert_requested_at?: string | null;
+    status: string;
+    source_branch: string;
+    source_path: string;
+    build_type?: string;
+    public?: boolean;
+    https_enforced?: boolean;
+    html_url?: string;
+    created_at?: string;
+    updated_at?: string;
+};
+export type GithubPagesBuild = {
+    id: number;
+    repository: string;
+    status: string;
+    error_message?: string | null;
+    commit?: string;
+    duration?: number;
+    created_at?: string;
+};
+export type GithubCodespace = {
+    name: string;
+    repository: string;
+    state: string;
+    machine: string;
+    git_branch: string;
+    owner: string;
+    created_at?: string;
+    updated_at?: string;
+};
+/** One person's star or watch of a repository (`from` → `to` = login → owner/repo), or a follow (follower → followee). */
+export type GithubEdge = {
+    from: string;
+    to: string;
+};
+export type GithubState = {
+    prs: GithubPr[];
+    issues: GithubIssue[];
+    reviews: GithubReview[];
+    comments: GithubComment[];
+    statuses: GithubStatus[];
+    checkRuns: GithubCheckRun[];
+    milestones: GithubMilestone[];
+    workflows: GithubWorkflow[];
+    workflowRuns: GithubWorkflowRun[];
+    jobs: GithubJob[];
+    releases: GithubRelease[];
+    releaseAssets: GithubReleaseAsset[];
+    tags: GithubTag[];
+    discussions: GithubDiscussion[];
+    discussionComments: GithubDiscussionComment[];
+    reactions: GithubReaction[];
+    labels: GithubLabel[];
+    repos: GithubRepo[];
+    branches: GithubBranch[];
+    collaborators: GithubCollaborator[];
+    webhooks: GithubWebhook[];
+    contents: GithubContentFile[];
+    gists: GithubGist[];
+    notifications: GithubNotification[];
+    gitRefs: GithubGitRef[];
+    gitCommits: GithubGitCommit[];
+    gitTrees: GithubGitTree[];
+    gitBlobs: GithubGitBlob[];
+    gitTagObjects: GithubGitTagObject[];
+    deployments: GithubDeployment[];
+    deploymentStatuses: GithubDeploymentStatus[];
+    environments: GithubEnvironment[];
+    actionsSecrets: GithubActionsSecret[];
+    actionsVariables: GithubActionsVariable[];
+    actionsCaches: GithubActionsCache[];
+    actionsArtifacts: GithubActionsArtifact[];
+    orgs: GithubOrg[];
+    orgMembers: GithubOrgMembership[];
+    outsideCollaborators: GithubOutsideCollaborator[];
+    orgWebhooks: GithubOrgWebhook[];
+    teams: GithubTeam[];
+    teamMembers: GithubTeamMembership[];
+    teamRepos: GithubTeamRepo[];
+    commitComments: GithubCommitComment[];
+    issueTypes: GithubIssueType[];
+    deployKeys: GithubDeployKey[];
+    autolinks: GithubAutolink[];
+    rulesets: GithubRuleset[];
+    ruleSuites: GithubRuleSuite[];
+    userEmails: GithubUserEmail[];
+    userSshKeys: GithubUserSshKey[];
+    userGpgKeys: GithubUserGpgKey[];
+    blockedUsers: Set<string>;
+    userProfile: Partial<GithubUser>;
+    projects: GithubProject[];
+    projectFields: GithubProjectField[];
+    projectItems: GithubProjectItem[];
+    projectViews: GithubProjectView[];
+    stars: Set<string>;
+    watching: Set<string>;
+    following: Set<string>;
+    starEdges: GithubEdge[];
+    watchEdges: GithubEdge[];
+    followEdges: GithubEdge[];
+    codeScanningAlerts: GithubCodeScanningAlert[];
+    codeScanningAnalyses: GithubCodeScanningAnalysis[];
+    dependabotAlerts: GithubDependabotAlert[];
+    secretScanningAlerts: GithubSecretScanningAlert[];
+    appInstallations: GithubAppInstallation[];
+    oauthGrants: GithubOAuthGrant[];
+    packages: GithubPackage[];
+    packageVersions: GithubPackageVersion[];
+    pagesSites: GithubPagesSite[];
+    pagesBuilds: GithubPagesBuild[];
+    codespaces: GithubCodespace[];
+};
+/** The category list for a repo: GitHub's defaults (a custom category is made on github.com's discussion settings,
+ *  which the twin does not have). */
+export declare function discussionCategoriesFor(repository: string): GithubDiscussionCategory[];
+export declare function observedId(subjectId: string): number;
+/** GitHub's projection of the tree at `root`. */
+export declare function githubState(root?: string): GithubState;
+export declare function toLabels(names: string[] | undefined, repository: string, labels?: GithubLabel[]): Array<Record<string, unknown>>;
+export declare function toAssignees(logins: string[] | undefined): Array<Record<string, unknown>>;
+export declare function toGithubMilestone(ms: GithubMilestone): Record<string, unknown>;
+export declare function toGithubRest(pr: GithubPr, milestones?: GithubMilestone[]): Record<string, unknown>;
+export declare const GITHUB_WORLD_USER = "octocat";
+/** The user a request's token authenticates, as GitHub attributes a write to the token's owner: a personal token
+ *  minted at `POST /_twin/users/:login/tokens` names its user, an app installation's token its bot (`<app>[bot]`).
+ *  Any other token (the World's shared fake) names no one, and the twin keeps its deterministic defaults. */
+export declare function callerLogin(token: string | undefined, root?: string): string | undefined;
+/** Whether a token GitHub issued has stopped working (an installation token expired with its run, a grant revoked). It is
+ *  refused, never taken as the World's own user: "Authenticating with invalid credentials will initially return a
+ *  `401 Unauthorized` response" (https://docs.github.com/rest/authentication/authenticating-to-the-rest-api); the message,
+ *  "Bad credentials", is GitHub's live answer, which its pages do not quote. A token the twin never issued is the World's
+ *  shared token, and is not refused. */
+export declare function revokedToken(token: string | undefined, root?: string): boolean;
+export declare function twinUserId(login: string): number;
+/** How GitHub describes a person's relation to a repository (author_association): its owner, a member of the
+ *  organization that owns it, a collaborator, someone whose pull request it merged, or none of these. */
+export declare function authorAssociation(st: GithubState, repo: string, login: string | null | undefined): string;
+/** A GitHub node id in the legacy form GitHub still issues and accepts: base64 of the type name's length, the type
+ *  name and the object's id (`MDU6SXNzdWUx` is `05:Issue1`). Deterministic, so a replay mints the same one. */
+export declare const nodeId: (type: string, id: string | number) => string;
+/** The links GitHub gives every account, as it writes them; the avatar is served by avatars.githubusercontent.com. */
+export declare function userLinks(login: string, id: number): Record<string, string>;
+export declare function toSimpleUser(login: string, type?: 'User' | 'Bot'): Record<string, unknown>;
+export declare function implicitReviewId(repository: string, number: number): number;
+export declare function reviewStateForEvent(event: unknown): string;
+export declare function toGithubReview(a: {
+    id: number;
+    repository: string;
+    number: number;
+    state?: string;
+    body?: string;
+    submitted_at?: string;
+    commit_id?: string;
+    user_login?: string;
+    user_type?: 'User' | 'Bot';
+    author_association?: string;
+}): Record<string, unknown>;
+export declare function toGithubComment(a: {
+    id: number;
+    repository: string;
+    number: number;
+    body?: string;
+    at?: string;
+    updated_at?: string;
+    user_login?: string;
+    user_type?: 'User' | 'Bot';
+}): Record<string, unknown>;
+export declare function serializeIssueComment(c: GithubComment): Record<string, unknown>;
+export declare function toGithubReviewComment(a: {
+    id: number;
+    repository: string;
+    number: number;
+    body?: string;
+    at?: string;
+    updated_at?: string;
+    path?: string;
+    line?: number;
+    side?: string;
+    start_line?: number;
+    diff_hunk?: string;
+    in_reply_to?: number;
+    review_id?: number;
+    user_login?: string;
+    user_type?: 'User' | 'Bot';
+    commit_id?: string;
+    author_association?: string;
+}): Record<string, unknown>;
+export declare function serializeReviewComment(c: GithubComment): Record<string, unknown>;
+export declare function toGithubPullFile(repository: string, sha: string, f: GithubPullFile): Record<string, unknown>;
+export declare function issueCommentCount(repository: string, number: number, comments?: GithubComment[]): number;
+/** An issue's numeric id: GitHub's `id`, distinct from its number, what the sub-issue API names a child by. */
+export declare function githubIssueId(repo: string, number: number): number;
+export declare function toGithubIssue(iss: GithubIssue, milestones?: GithubMilestone[], pull?: GithubPr, comments?: GithubComment[]): Record<string, unknown>;
+export declare function pullRequestAsIssue(pr: GithubPr): GithubIssue;
+export declare function toGithubStatus(s: GithubStatus): Record<string, unknown>;
+export declare function combineStatuses(repository: string, sha: string, statuses: GithubStatus[]): Record<string, unknown>;
+export declare function toGithubCheckRun(c: GithubCheckRun, st?: GithubState): Record<string, unknown>;
+export declare function toGithubAnnotation(c: GithubCheckRun, an: GithubCheckAnnotation): Record<string, unknown>;
+export declare function toGithubCheckSuite(repository: string, headSha: string, runs: GithubCheckRun[], app?: string, st?: GithubState): Record<string, unknown>;
+export declare function toGithubReaction(r: GithubReaction): Record<string, unknown>;
+export declare function toGithubLabel(l: GithubLabel): Record<string, unknown>;
+export declare function toGithubRepo(r: GithubRepo): Record<string, unknown>;
+export declare function toGithubBranch(b: GithubBranch): Record<string, unknown>;
+export declare function toGithubBranchProtection(b: GithubBranch): Record<string, unknown>;
+export declare function normalizeRequiredStatusChecks(v: unknown): {
+    strict: boolean;
+    contexts: string[];
+    checks: Array<{
+        context: string;
+        app_id: number | null;
+    }>;
+} | null;
+export declare function toGithubCollaborator(c: GithubCollaborator): Record<string, unknown>;
+export declare function toGithubWebhookConfig(h: GithubWebhook): Record<string, unknown>;
+export declare function hookConfigOverlaps(hooks: GithubWebhook[], candidate: Pick<GithubWebhook, 'repository' | 'url' | 'content_type' | 'secret' | 'events'>, excluding?: number): boolean;
+export declare function validateGithubWebhook(body: Record<string, any>, configOnly: boolean, creating: boolean): GithubResponse | undefined;
+export declare function toGithubWebhook(h: GithubWebhook): Record<string, unknown>;
+export declare function planeQueryRef(query: string | undefined): string | undefined;
+export declare function resolvePlaneRef(repo: string, ref: string | undefined, defaultBranch: string, root?: string): Promise<string | null>;
+type PlaneTreeEntry = {
+    path: string;
+    mode: string;
+    type: string;
+    sha: string;
+    size?: number;
+};
+type PlaneLookup = {
+    kind: 'file';
+    entry: PlaneTreeEntry;
+} | {
+    kind: 'submodule';
+    entry: PlaneTreeEntry;
+} | {
+    kind: 'dir';
+    entries: PlaneTreeEntry[];
+};
+export declare function planeEntryAt(repo: string, commitSha: string, path: string, root?: string): Promise<PlaneLookup | null>;
+export declare function planeFileContent(repo: string, ref: string, path: string, entry: {
+    sha: string;
+    size?: number;
+}, root?: string): Promise<Record<string, unknown> | null>;
+export declare function planeContents(repo: string, ref: string | undefined, path: string, defaultBranch: string, root?: string): Promise<{
+    status: number;
+    body: unknown;
+} | null>;
+/** A path's contents: from the git plane when the repository has one; otherwise the file the REST
+ *  writes stored, a directory listing of the stored files under it, or the plane's (a `git push`). */
+export declare function githubContents(state: GithubState, repo: string, p: string, query: string | undefined, root?: string): Promise<GithubResponse>;
+export declare function planeAncestors(repo: string, sha: string, root?: string): Promise<Map<string, number>>;
+/** The commits a repository's default branch reaches, read from its history: sha, message and author name (none in a
+ *  repository without history). */
+export declare function defaultBranchCommits(state: GithubState, repo: string, root?: string): Promise<Array<{
+    sha: string;
+    message: string;
+    author: string;
+}>>;
+export declare function planeCommitBody(repo: string, sha: string, root?: string): Promise<Record<string, unknown> | null>;
+export declare function toGithubContent(f: GithubContentFile): Record<string, unknown>;
+export declare function toGithubUser(u: GithubUser): Record<string, unknown>;
+/** An organization as GitHub answers it; with the World's state, its public repositories and followers counted. */
+export declare function toGithubOrg(o: GithubOrg, st?: GithubState): Record<string, unknown>;
+export declare function toGithubOrgMembership(m: GithubOrgMembership): Record<string, unknown>;
+export declare function toGithubOrgWebhook(h: GithubOrgWebhook): Record<string, unknown>;
+/** A team as GitHub answers it; with the World's state, its members and repositories counted (team-full). */
+export declare function toGithubTeam(t: GithubTeam, st?: GithubState): Record<string, unknown>;
+/** A team membership as GitHub answers it, addressed under its organization's and team's ids
+ *  (docs.github.com/rest/teams/members#get-team-membership-for-a-user). */
+export declare function toGithubTeamMembership(m: GithubTeamMembership, st?: GithubState): Record<string, unknown>;
+export declare function toGithubCommitComment(c: GithubCommitComment): Record<string, unknown>;
+export declare function toGithubIssueType(t: GithubIssueType): Record<string, unknown>;
+export declare function toGithubGist(g: GithubGist): Record<string, unknown>;
+export declare function toGithubNotification(n: GithubNotification): Record<string, unknown>;
+export declare function toGithubWorkflow(w: GithubWorkflow): Record<string, unknown>;
+export declare function toGithubWorkflowRun(r: GithubWorkflowRun, st?: GithubState): Record<string, unknown>;
+export declare function toGithubJob(j: GithubJob): Record<string, unknown>;
+export declare function toGithubReleaseAsset(a: GithubReleaseAsset): Record<string, unknown>;
+export declare function toGithubRelease(r: GithubRelease, assets?: GithubReleaseAsset[]): Record<string, unknown>;
+export declare function toGithubTag(t: GithubTag): Record<string, unknown>;
+export declare function toGithubGitRef(r: GithubGitRef): Record<string, unknown>;
+export declare function toGithubGitCommit(c: GithubGitCommit): Record<string, unknown>;
+export declare function toGithubGitTree(t: GithubGitTree): Record<string, unknown>;
+export declare function toGithubGitBlob(b: GithubGitBlob): Record<string, unknown>;
+export declare function toGithubGitTagObject(t: GithubGitTagObject): Record<string, unknown>;
+export declare function toGithubDeployment(d: GithubDeployment): Record<string, unknown>;
+export declare function toGithubDeploymentStatus(s: GithubDeploymentStatus): Record<string, unknown>;
+export declare function toGithubEnvironment(e: GithubEnvironment): Record<string, unknown>;
+export declare function toGithubDeployKey(k: GithubDeployKey): Record<string, unknown>;
+export declare function toGithubAutolink(a: GithubAutolink): Record<string, unknown>;
+export declare function toGithubRuleset(r: GithubRuleset): Record<string, unknown>;
+export declare function toGithubUserEmail(e: GithubUserEmail): Record<string, unknown>;
+export declare function toGithubUserSshKey(k: GithubUserSshKey): Record<string, unknown>;
+export declare function toGithubUserGpgKey(k: GithubUserGpgKey): Record<string, unknown>;
+export declare function toGithubProject(p: GithubProject): Record<string, unknown>;
+export declare function toGithubCodeScanningAlert(a: GithubCodeScanningAlert): Record<string, unknown>;
+export declare function toGithubCodeScanningAnalysis(a: GithubCodeScanningAnalysis): Record<string, unknown>;
+export declare function toGithubDependabotAlert(a: GithubDependabotAlert): Record<string, unknown>;
+export declare function toGithubSecretScanningAlert(a: GithubSecretScanningAlert): Record<string, unknown>;
+export declare function toGithubAppInstallation(i: GithubAppInstallation): Record<string, unknown>;
+export declare function toGithubPackage(p: GithubPackage, versionCount: number): Record<string, unknown>;
+export declare function toGithubPackageVersion(v: GithubPackageVersion): Record<string, unknown>;
+export declare function toGithubPagesSite(s: GithubPagesSite): Record<string, unknown>;
+export declare function toGithubPagesBuild(b: GithubPagesBuild): Record<string, unknown>;
+export declare function toGithubCodespace(c: GithubCodespace): Record<string, unknown>;
+export declare function toGithubActionsSecret(s: GithubActionsSecret): Record<string, unknown>;
+export declare function toGithubActionsVariable(v: GithubActionsVariable): Record<string, unknown>;
+export declare function toGithubActionsCache(c: GithubActionsCache): Record<string, unknown>;
+export declare function toGithubActionsArtifact(a: GithubActionsArtifact): Record<string, unknown>;
+export declare function buildIssueTimeline(repository: string, iss: GithubIssue, extra?: {
+    pull?: GithubPr;
+    comments?: GithubComment[];
+    reviews?: GithubReview[];
+}): Array<Record<string, unknown>>;
+export type GithubResponse = {
+    status: number;
+    body: unknown;
+};
+export declare function githubNotFound(): GithubResponse;
+export declare function paginate<T>(items: T[], query: string | undefined): T[];
+export declare function githubActivityEvents(state: GithubState): Array<Record<string, unknown>>;
+export declare function nextRepoNumber(st: GithubState, repo: string): number;
+export declare function normalizeLabels(input: unknown): string[];
+export declare function normalizeLogins(input: unknown): string[];
+export declare function applyTriageFields(fields: Record<string, unknown>, body: Record<string, any>): void;
+export declare function nextSeq(prefix: string, root?: string): number;
+export declare function actionsId(key: string): number;
+export declare function seedUser(login: string): GithubUser;
+export type GithubWriteEvent = {
+    event: string;
+    action: string;
+    repository: string;
+    number: number;
+    pr?: Record<string, unknown>;
+    body?: string;
+    comment?: Record<string, unknown>;
+    review?: Record<string, unknown>;
+    issue?: Record<string, unknown>;
+    ref?: string;
+    before?: string;
+    after?: string;
+};
+export type GithubWriteOutcome = {
+    response: GithubResponse;
+    webhook?: GithubWriteEvent;
+    webhooks?: GithubWriteEvent[];
+};
+/**
+ * Handle a GitHub REST WRITE as a local action (R5/R18). Supports:
+ *   POST   /repos/:o/:r/pulls            → create PR  (pull_request: opened)
+ *   PATCH  /repos/:o/:r/pulls/:n         → edit PR    (pull_request: edited/closed)
+ *   PUT    /repos/:o/:r/pulls/:n/merge   → merge PR   (pull_request: closed; 405 if not mergeable)
+ *   POST   /repos/:o/:r/pulls/:n/reviews → submit review (pull_request_review)
+ *   POST   /repos/:o/:r/issues           → create issue (issues: opened)
+ *   PATCH  /repos/:o/:r/issues/:n        → edit issue  (issues: edited/closed)
+ *   POST   /repos/:o/:r/issues/:n/comments → comment (issue_comment)
+ * Mirror mode rejects writes (R4). No real GitHub I/O (R16).
+ */
+/**
+ * The PR's REAL changed-file list from the git plane: resolve the base branch tip + the PR
+ * head sha; when both commits exist in the bare repo, `git diff-tree` computes the truth.
+ * Null when either side is not in the plane (observed/simulated PRs keep their carried or
+ * empty file lists — never fabricated). This is what merge-gate scope classification reads
+ * (GET /pulls/:n/files + GraphQL changedFiles), so a pushed PR must answer with its actual
+ * paths, not 0 files.
+ */
+export declare function prPlaneDiffFiles(state: GithubState, repo: string, pr: GithubPr, root?: string): Promise<GithubPullFile[] | null>;
+/**
+ * GitHub closes open PRs whose HEAD BRANCH is deleted. Shared by the receive-pack reconcile
+ * and the REST ref delete so both paths converge. Returns the closed PR numbers. A pull request's head branch may
+ * live in a fork (`repo` is where the branch was, the callback names the pull request's own repository).
+ */
+export declare function closePrsForDeletedBranch(repo: string, branch: string, root: string | undefined, occurredAt: string, onChanged: ((snapshot: Record<string, unknown>, repository: string) => void) | undefined, atomically: GithubAtomic, by: {
+    operation: string;
+    actor: 'api' | 'external';
+}): Promise<number[]>;
+/**
+ * Re-point every OPEN PR whose head branch is `branch` at the branch's new tip — GitHub's
+ * `synchronize` semantic: a push (receive-pack or an API ref update) moves the PR head, so
+ * statuses/checks/reviews earned on the old head no longer match. Returns the PR numbers
+ * moved (the receive-pack path emits `pull_request synchronize` webhooks for them).
+ */
+export declare function syncPrHeadsToBranchTip(repo: string, branch: string, sha: string, root: string | undefined, occurredAt: string, onChanged?: (snapshot: Record<string, unknown>, repository: string) => void, atomically?: GithubAtomic): Promise<number[]>;
+/** Register a GitHub App: {slug, name, owner, permissions, events, setup_url?, callback_url?, request_oauth_on_install?,
+ *  hook_attributes?: {url}, webhook_secret?, description?}. GitHub registers apps in its settings UI (the twin's door,
+ *  POST /_twin/apps) or from a manifest (src/screens/app-manifest.tsx). A slug that is not one, or is taken, is 422. */
+export declare function registerGithubApp(body: Record<string, any>, occurredAt: string, root?: string): Promise<{
+    response: GithubResponse;
+    app?: GithubAppRegistration;
+}>;
+/** The twin's own doors under /_twin/: what stands in for an act GitHub does in its web UI or its runners, which have
+ *  no API. A request to any other path is not a door's (undefined). */
+export declare function handleGithubDoor(request: Request, scope: {
+    root?: string;
+    now: () => string;
+}): Promise<Response | undefined>;
+/** The subject id a write landed under: a head that performed it adopts the vendor's id (an issue's
+ *  number), recorded in the alias map. */
+export declare function adoptedSubjectId(type: string, id: string, root?: string): string;
+/** A request's issue or pull-request number, resolved through the alias map: a caller on a branch
+ *  may still name one by the number it minted locally after the head adopted GitHub's
+ *  (docs/contributing/architecture.md#alias-aware-lookup-at-the-request-boundary). */
+export declare function resolveGithubNumber(owner: string, name: string, number: string, root?: string): string;
+/** A GitHub REST read made in-process, through the same fetch the server serves (the derived
+ *  dispatch, its semantics handlers, and the hand-written routes for what has not moved). */
+export declare function handleGithubRequest(req: {
+    method: string;
+    path: string;
+    root?: string;
+    token?: string;
+    cookie?: string;
+}): Promise<GithubResponse>;
+/** A GitHub REST write made in-process, stamped at `occurredAt` (the World clock when absent). A write
+ *  GitHub announces delivers its webhooks from the fetch, as it does over HTTP, and the events it
+ *  announced ride the answer: one as `webhook`, several as `webhooks`. */
+export declare function applyGithubWrite(req: {
+    method: string;
+    path: string;
+    body?: string;
+    root?: string;
+    readOnly?: boolean;
+    occurredAt?: string;
+    token?: string;
+    contentType?: string;
+    cookie?: string;
+}): Promise<GithubWriteOutcome>;