@lizard-build/sdk 0.1.71 → 0.1.73

package/dist/index.d.ts

@@ -460,6 +460,799 @@ declare class GitHubAPI {
     checkout(serviceId: string, branch: string): Promise<DeployHandle>;
 }
 
+/**
+ * Lizard Git (git.lizard.build): repositories, issues, pull requests, reviews, Actions-style
+ * CI, releases, webhooks, branch protection and the rest, with the same API key as the rest
+ * of the SDK. The key must be a whole account's (no scopes): Lizard Git refuses scoped keys.
+ *
+ * Repositories are named `"owner/name"`.
+ *
+ * ```ts
+ * const lizard = new Lizard()
+ * const repo = await lizard.git.repos.create({ name: 'app', private: true, readme: true })
+ * await lizard.git.repos.commitFiles('me/app', { branch: 'main', message: 'Add CI',
+ *   files: [{ path: '.lizard/workflows/ci.yml', content: 'on: push\njobs: ...' }] })
+ * const pr = await lizard.git.pulls.create('me/app', { title: 'Feature', head: 'feature', base: 'main' })
+ * ```
+ */
+declare const DEFAULT_GIT_URL = "https://git.lizard.build";
+type RepoRef = string;
+type Role = 'read' | 'write' | 'admin';
+interface Repo {
+    id: number;
+    owner: string;
+    ownerAvatar: string;
+    name: string;
+    description: string;
+    private: boolean;
+    defaultBranch: string;
+    stars: number;
+    pushedAt: number | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface RepoMeta {
+    repo: Repo;
+    role: 'owner' | Role | '';
+    canPush: boolean;
+    canAdmin: boolean;
+    starred: boolean;
+    empty: boolean;
+    cloneUrl: string;
+    branches: number;
+    tags: number;
+    openIssues: number;
+    openPulls: number;
+    forkOf: string | null;
+    forks: number;
+}
+interface Ref {
+    name: string;
+    sha: string;
+    kind: 'branch' | 'tag';
+    date: number;
+    subject: string;
+    author: string;
+    ahead?: number;
+    behind?: number;
+}
+interface Commit {
+    sha: string;
+    parents: string[];
+    authorName: string;
+    authorEmail: string;
+    date: number;
+    committerName: string;
+    committerDate: number;
+    subject: string;
+    body?: string;
+}
+interface TreeEntry {
+    name: string;
+    path: string;
+    type: 'blob' | 'tree' | 'commit';
+    mode: string;
+    size?: number;
+}
+interface Blob$1 {
+    commit: string;
+    path: string;
+    size: number;
+    content?: string;
+    binary?: boolean;
+    tooLarge?: boolean;
+    lastCommit?: Commit;
+}
+interface FileChange {
+    path: string;
+    /** Text, or base64 when `base64` is true. Leave out with `delete`. */
+    content?: string;
+    base64?: boolean;
+    delete?: boolean;
+    /** Rename: the old path (its content moves unless `content` is given). */
+    moveFrom?: string;
+}
+interface CommitFilesOpts {
+    branch: string;
+    message: string;
+    files: FileChange[];
+    /** The commit the branch must still point at (compare-and-swap); a moved branch answers 409. */
+    expect?: string;
+    /** Create `branch` from this ref when it doesn't exist yet. */
+    createFrom?: string;
+    /** Same key, same result: a retried call doesn't commit twice. */
+    idempotencyKey?: string;
+}
+interface Label {
+    id: number;
+    name: string;
+    color: string;
+    description: string;
+}
+interface Assignee {
+    login: string;
+    avatarUrl: string;
+}
+interface Issue {
+    number: number;
+    title: string;
+    body: string;
+    state: 'open' | 'closed' | 'merged';
+    isPull: boolean;
+    headRef?: string;
+    baseRef?: string;
+    headRepo?: string;
+    mergedSha?: string;
+    draft: boolean;
+    author: string;
+    authorAvatar: string;
+    comments: number;
+    labels: Label[];
+    assignees: Assignee[];
+    closedAt: number | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface IssueDetail {
+    issue: Issue;
+    comments: Array<{
+        id: number;
+        kind: string;
+        author: string;
+        body: string;
+        createdAt: number;
+        [k: string]: unknown;
+    }>;
+    canEdit: boolean;
+    canMerge: boolean;
+    /** Pull requests: head commit, merge check, what branch protection still needs. */
+    pull?: {
+        headSha?: string;
+        baseExists: boolean;
+        headExists: boolean;
+        commits?: number;
+        merge?: unknown;
+        gate?: unknown;
+        reviewRequests: unknown[];
+    };
+}
+interface IssueList {
+    items: Issue[];
+    open: number;
+    closed: number;
+}
+interface ListIssuesOpts {
+    state?: 'open' | 'closed' | 'all';
+    q?: string;
+    label?: string;
+    assignee?: string;
+}
+interface CreatePullOpts {
+    title: string;
+    body?: string;
+    /** A branch here, or `"owner:branch"` of a fork. */
+    head: string;
+    base?: string;
+    /** `"owner/name"` of the fork `head` is on (instead of `owner:branch`). */
+    headRepo?: string;
+    draft?: boolean;
+    reviewers?: string[];
+}
+interface UpdateIssueOpts {
+    title?: string;
+    body?: string;
+    state?: 'open' | 'closed';
+    labels?: string[];
+    assignees?: string[];
+    /** Pull requests only. */
+    reviewers?: string[];
+    draft?: boolean;
+}
+interface MergeOpts {
+    method?: 'merge' | 'squash' | 'rebase';
+    message?: string;
+    deleteBranch?: boolean;
+    bypass?: boolean;
+}
+interface LineComment {
+    path: string;
+    line: number;
+    side?: 'RIGHT' | 'LEFT';
+    body: string;
+}
+interface ReviewOpts {
+    event: 'APPROVE' | 'REQUEST_CHANGES' | 'COMMENT';
+    body?: string;
+    comments?: LineComment[];
+}
+interface Run {
+    id: number;
+    number: number;
+    workflow: string;
+    name: string;
+    event: string;
+    ref: string;
+    sha: string;
+    actor: string;
+    status: string;
+    title: string;
+    createdAt: number;
+    startedAt: number | null;
+    finishedAt: number | null;
+    jobs: Job[];
+}
+interface Job {
+    id: number;
+    key: string;
+    name: string;
+    status: string;
+    image: string;
+    steps: Array<{
+        name: string;
+        status: string;
+    }> | null;
+    logSize: number;
+    startedAt: number | null;
+    finishedAt: number | null;
+}
+interface ListRunsOpts {
+    branch?: string;
+    sha?: string;
+    workflow?: string;
+    status?: string;
+    pr?: number;
+    page?: number;
+}
+interface LogChunk {
+    offset: number;
+    next: number;
+    size: number;
+    text: string;
+    done: boolean;
+}
+interface Workflow {
+    path: string;
+    name: string;
+    events: string[];
+    dispatch: boolean;
+}
+interface Artifact {
+    name: string;
+    size: number;
+    job: string;
+    createdAt: number;
+}
+interface Collaborator {
+    login: string;
+    name: string;
+    avatarUrl: string;
+    role: Role;
+    createdAt: number;
+}
+interface Invitation {
+    id: number;
+    repo: string;
+    owner: string;
+    login?: string;
+    role: Role;
+    inviter: string;
+    createdAt: number;
+    expiresAt: number;
+}
+interface Webhook {
+    id: number;
+    url: string;
+    contentType: 'json' | 'form';
+    events: string[];
+    active: boolean;
+    hasSecret: boolean;
+    lastStatus: number;
+    lastError?: string;
+    lastDeliveryAt: number | null;
+    createdAt: number;
+}
+interface WebhookOpts {
+    url?: string;
+    secret?: string;
+    contentType?: 'json' | 'form';
+    events?: string[];
+    active?: boolean;
+}
+interface Delivery {
+    id: number;
+    event: string;
+    status: number;
+    error?: string;
+    durationMs: number;
+    createdAt: number;
+    [k: string]: unknown;
+}
+interface BranchRule {
+    id: number;
+    pattern: string;
+    requirePullRequest: boolean;
+    requiredApprovals: number;
+    requiredChecks: string[];
+    blockForcePush: boolean;
+    blockDeletion: boolean;
+    enforceAdmins: boolean;
+    requireCodeOwners: boolean;
+    createdAt: number;
+}
+type BranchRuleOpts = Partial<Omit<BranchRule, 'id' | 'createdAt'>>;
+interface Release {
+    id: number;
+    tag: string;
+    target: string;
+    sha: string;
+    name: string;
+    body: string;
+    draft: boolean;
+    prerelease: boolean;
+    author: string;
+    createdAt: number;
+    assets: Array<{
+        id: number;
+        name: string;
+        size: number;
+        contentType: string;
+        downloads?: number;
+    }>;
+}
+interface ReleaseOpts {
+    tag: string;
+    target?: string;
+    name?: string;
+    body?: string;
+    draft?: boolean;
+    prerelease?: boolean;
+}
+interface CommitStatus {
+    state: 'pending' | 'success' | 'failure' | 'error';
+    context: string;
+    description?: string;
+    target_url?: string;
+}
+interface CombinedStatus {
+    sha: string;
+    state: string;
+    total_count: number;
+    statuses: Array<CommitStatus & {
+        createdAt: number;
+        creator: string;
+    }>;
+}
+interface Notification {
+    id: number;
+    reason: string;
+    repo: string;
+    number: number;
+    title: string;
+    actor: string;
+    url: string;
+    unread: boolean;
+    updatedAt: number;
+}
+interface Token {
+    id: number;
+    name: string;
+    repos: string[];
+    refs: string[];
+    paths: string[];
+    readOnly: boolean;
+    createdAt: number;
+    lastUsedAt: number | null;
+}
+interface TokenOpts {
+    name: string;
+    repos?: string[];
+    refs?: string[];
+    paths?: string[];
+    readOnly?: boolean;
+}
+interface GitUser {
+    id: number;
+    login: string;
+    name: string;
+    avatarUrl: string;
+    bio: string;
+    createdAt: number;
+}
+/** HTTP to Lizard Git with the connection's API key. */
+declare class GitClient {
+    readonly config: ConnectionConfig;
+    readonly url: string;
+    constructor(config: ConnectionConfig, url?: string);
+    raw(method: string, path: string, body?: BodyInit, headers?: Record<string, string>): Promise<Response>;
+    request<T>(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body: unknown): Promise<T>;
+    delete<T = void>(path: string): Promise<T>;
+    bytes(path: string): Promise<Uint8Array>;
+}
+declare class GitReposAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    /** Yours and the ones you collaborate on by default; `owner`, `q`, `starred` narrow it. */
+    list(opts?: {
+        owner?: string;
+        member?: string;
+        starred?: string;
+        q?: string;
+        sort?: 'updated' | 'stars' | 'name';
+    }): Promise<Repo[]>;
+    /** Answers the new repository's `owner` and `name`. */
+    create(opts: {
+        name: string;
+        description?: string;
+        private?: boolean;
+        readme?: boolean;
+        defaultBranch?: string;
+    }): Promise<{
+        owner: string;
+        name: string;
+    }>;
+    get(repo: RepoRef): Promise<RepoMeta>;
+    update(repo: RepoRef, opts: {
+        name?: string;
+        description?: string;
+        private?: boolean;
+        defaultBranch?: string;
+    }): Promise<{
+        ok: boolean;
+    }>;
+    delete(repo: RepoRef): Promise<void>;
+    star(repo: RepoRef): Promise<void>;
+    unstar(repo: RepoRef): Promise<void>;
+    /** Fork into your account (`name` defaults to the same name). */
+    fork(repo: RepoRef, opts?: {
+        name?: string;
+    }): Promise<{
+        owner: string;
+        name: string;
+    }>;
+    forks(repo: RepoRef): Promise<Repo[]>;
+    /** Branches and tags. */
+    refs(repo: RepoRef): Promise<Ref[]>;
+    createBranch(repo: RepoRef, name: string, from?: string): Promise<{
+        name: string;
+        sha: string;
+    }>;
+    deleteBranch(repo: RepoRef, name: string): Promise<void>;
+    tree(repo: RepoRef, opts?: {
+        ref?: string;
+        path?: string;
+    }): Promise<{
+        commit: string;
+        path: string;
+        entries: TreeEntry[];
+    }>;
+    /** A file as JSON (text in `content`). */
+    file(repo: RepoRef, path: string, ref?: string): Promise<Blob$1>;
+    /** A file's bytes, whatever its size or type. */
+    raw(repo: RepoRef, path: string, ref: string): Promise<Uint8Array>;
+    /** Every file path at a ref. */
+    files(repo: RepoRef, ref?: string): Promise<string[]>;
+    search(repo: RepoRef, q: string, ref?: string): Promise<unknown>;
+    commits(repo: RepoRef, opts?: {
+        ref?: string;
+        path?: string;
+        page?: number;
+    }): Promise<{
+        commits: Commit[];
+        more: boolean;
+    }>;
+    commit(repo: RepoRef, sha: string): Promise<{
+        commit: Commit;
+        diff: unknown;
+    }>;
+    compare(repo: RepoRef, base: string, head: string): Promise<unknown>;
+    /** Commit files on the server: no clone, no push. Answers 409 when `expect` no longer matches. */
+    commitFiles(repo: RepoRef, opts: CommitFilesOpts): Promise<{
+        sha: string;
+        branch: string;
+        [k: string]: unknown;
+    }>;
+    /** Rebase `head` (branch or commit) onto `onto` on the server and move `onto` there; retried on races. */
+    land(repo: RepoRef, opts: {
+        head: string;
+        onto: string;
+        deleteHead?: boolean;
+    }): Promise<{
+        sha: string;
+        [k: string]: unknown;
+    }>;
+    /** Who moved which branch, when. */
+    reflog(repo: RepoRef, ref?: string): Promise<unknown[]>;
+    archive(repo: RepoRef, ref: string, format?: 'zip' | 'tar.gz'): Promise<Uint8Array>;
+    /** The HTTPS clone URL. With `withKey`, it carries the API key, so plain `git clone` works without a helper. */
+    cloneUrl(repo: RepoRef, opts?: {
+        withKey?: boolean;
+    }): string;
+}
+declare class GitIssuesAPI {
+    protected readonly c: GitClient;
+    private readonly pulls;
+    constructor(c: GitClient, pulls?: boolean);
+    protected base(repo: RepoRef): string;
+    list(repo: RepoRef, opts?: ListIssuesOpts): Promise<IssueList>;
+    get(repo: RepoRef, number: number): Promise<IssueDetail>;
+    update(repo: RepoRef, number: number, opts: UpdateIssueOpts): Promise<{
+        ok: boolean;
+    }>;
+    comment(repo: RepoRef, number: number, body: string): Promise<{
+        id: number;
+    }>;
+    close(repo: RepoRef, number: number): Promise<{
+        ok: boolean;
+    }>;
+    reopen(repo: RepoRef, number: number): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class GitIssuesOnlyAPI extends GitIssuesAPI {
+    constructor(c: GitClient);
+    create(repo: RepoRef, opts: {
+        title: string;
+        body?: string;
+    }): Promise<{
+        number: number;
+    }>;
+}
+declare class GitPullsAPI extends GitIssuesAPI {
+    constructor(c: GitClient);
+    create(repo: RepoRef, opts: CreatePullOpts): Promise<{
+        number: number;
+    }>;
+    /** Mark a draft ready for review. */
+    ready(repo: RepoRef, number: number): Promise<{
+        ok: boolean;
+    }>;
+    merge(repo: RepoRef, number: number, opts?: MergeOpts): Promise<{
+        sha: string;
+    }>;
+    diff(repo: RepoRef, number: number): Promise<unknown>;
+    commits(repo: RepoRef, number: number): Promise<Commit[]>;
+    reviews(repo: RepoRef, number: number): Promise<{
+        reviews: unknown[];
+        comments: unknown[];
+        decision: {
+            approvals: string[];
+            changesRequested: string[];
+        };
+    }>;
+    review(repo: RepoRef, number: number, opts: ReviewOpts): Promise<{
+        id: number;
+        state: string;
+    }>;
+    approve(repo: RepoRef, number: number, body?: string): Promise<{
+        id: number;
+        state: string;
+    }>;
+    requestChanges(repo: RepoRef, number: number, body: string): Promise<{
+        id: number;
+        state: string;
+    }>;
+    lineComment(repo: RepoRef, number: number, c: LineComment): Promise<{
+        id: number;
+    }>;
+    deleteLineComment(repo: RepoRef, number: number, id: number): Promise<void>;
+    /** The combined commit status of the pull request's head (CI and external checks). */
+    checks(repo: RepoRef, number: number): Promise<CombinedStatus>;
+}
+declare class GitSecretsAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    list(repo: RepoRef): Promise<{
+        configured: boolean;
+        secrets: Array<{
+            name: string;
+            updatedAt: number;
+        }>;
+    }>;
+    set(repo: RepoRef, name: string, value: string): Promise<void>;
+    delete(repo: RepoRef, name: string): Promise<void>;
+}
+declare class GitActionsAPI {
+    private readonly c;
+    readonly secrets: GitSecretsAPI;
+    constructor(c: GitClient);
+    runs(repo: RepoRef, opts?: ListRunsOpts): Promise<{
+        runs: Run[];
+        more: boolean;
+    }>;
+    run(repo: RepoRef, number: number): Promise<Run>;
+    cancel(repo: RepoRef, number: number): Promise<void>;
+    /** Run the same workflow at the same commit again (a new run). */
+    rerun(repo: RepoRef, number: number): Promise<{
+        number: number;
+    }>;
+    /** Let a run from a fork's pull request start (it waits for someone with write access). */
+    approve(repo: RepoRef, number: number): Promise<void>;
+    /** Part of a job's log from `offset`; follow `next` until `done`. */
+    log(repo: RepoRef, jobId: number, offset?: number): Promise<LogChunk>;
+    fullLog(repo: RepoRef, jobId: number): Promise<string>;
+    /** Each new piece of the log as it's written, until the job ends. */
+    followLog(repo: RepoRef, jobId: number, opts?: {
+        intervalMs?: number;
+        signal?: AbortSignal;
+    }): AsyncGenerator<string>;
+    /** Wait until the run ends (success, failure, cancelled, ...). */
+    wait(repo: RepoRef, number: number, opts?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }): Promise<Run>;
+    artifacts(repo: RepoRef, number: number): Promise<Artifact[]>;
+    /** An artifact as a .tar.gz. */
+    downloadArtifact(repo: RepoRef, number: number, name: string): Promise<Uint8Array>;
+    workflows(repo: RepoRef): Promise<{
+        enabled: boolean;
+        reason?: string;
+        workflows: Workflow[];
+    }>;
+    /** Start a workflow that has `on: workflow_dispatch`. */
+    dispatch(repo: RepoRef, opts: {
+        workflow: string;
+        ref?: string;
+        inputs?: Record<string, string>;
+    }): Promise<{
+        number: number;
+    }>;
+    /** Latest run status per commit, for the given commits. */
+    status(repo: RepoRef, shas: string[]): Promise<Record<string, string>>;
+}
+declare class GitCollaboratorsAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    list(repo: RepoRef): Promise<{
+        collaborators: Collaborator[];
+        invitations: Invitation[];
+        role: string;
+    }>;
+    /** Invite someone with a Lizard Git account (they sign in once first); they're in once they accept. */
+    invite(repo: RepoRef, login: string, role?: Role): Promise<{
+        login: string;
+        role: Role;
+        status: 'invited' | 'updated';
+    }>;
+    setRole(repo: RepoRef, login: string, role: Role): Promise<{
+        login: string;
+        role: Role;
+    }>;
+    /** Remove someone (or yourself: leave). */
+    remove(repo: RepoRef, login: string): Promise<void>;
+    cancelInvitation(repo: RepoRef, id: number): Promise<void>;
+    /** Invitations waiting for you. */
+    invitations(): Promise<Invitation[]>;
+    accept(id: number): Promise<void>;
+    decline(id: number): Promise<void>;
+}
+declare class GitWebhooksAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    list(repo: RepoRef): Promise<{
+        hooks: Webhook[];
+        events: string[];
+    }>;
+    /** GitHub-style payloads, signed with `X-Hub-Signature-256` when there's a secret. */
+    create(repo: RepoRef, opts: WebhookOpts & {
+        url: string;
+    }): Promise<Webhook>;
+    get(repo: RepoRef, id: number): Promise<Webhook>;
+    update(repo: RepoRef, id: number, opts: WebhookOpts): Promise<Webhook>;
+    delete(repo: RepoRef, id: number): Promise<void>;
+    ping(repo: RepoRef, id: number): Promise<void>;
+    deliveries(repo: RepoRef, id: number): Promise<Delivery[]>;
+    delivery(repo: RepoRef, id: number, deliveryId: number): Promise<Delivery>;
+    redeliver(repo: RepoRef, id: number, deliveryId: number): Promise<void>;
+}
+declare class GitBranchRulesAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    list(repo: RepoRef): Promise<BranchRule[]>;
+    create(repo: RepoRef, opts: BranchRuleOpts & {
+        pattern: string;
+    }): Promise<BranchRule>;
+    update(repo: RepoRef, id: number, opts: BranchRuleOpts): Promise<BranchRule>;
+    delete(repo: RepoRef, id: number): Promise<void>;
+}
+declare class GitLabelsAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    list(repo: RepoRef): Promise<Label[]>;
+    create(repo: RepoRef, opts: {
+        name: string;
+        color?: string;
+        description?: string;
+    }): Promise<Label>;
+    update(repo: RepoRef, name: string, opts: {
+        name?: string;
+        color?: string;
+        description?: string;
+    }): Promise<Label>;
+    delete(repo: RepoRef, name: string): Promise<void>;
+}
+declare class GitReleasesAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    list(repo: RepoRef): Promise<Release[]>;
+    /** Creates the tag too when it doesn't exist (at `target`, default branch by default). */
+    create(repo: RepoRef, opts: ReleaseOpts): Promise<Release>;
+    get(repo: RepoRef, id: number): Promise<Release>;
+    getByTag(repo: RepoRef, tag: string): Promise<Release>;
+    update(repo: RepoRef, id: number, opts: {
+        name?: string;
+        body?: string;
+        draft?: boolean;
+        prerelease?: boolean;
+    }): Promise<Release>;
+    delete(repo: RepoRef, id: number): Promise<void>;
+    uploadAsset(repo: RepoRef, id: number, name: string, data: Uint8Array | Blob$1 | string, contentType?: string): Promise<{
+        id: number;
+        name: string;
+        size: number;
+        contentType: string;
+    }>;
+    downloadAsset(repo: RepoRef, id: number, assetId: number): Promise<Uint8Array>;
+    deleteAsset(repo: RepoRef, id: number, assetId: number): Promise<void>;
+}
+declare class GitStatusesAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    /** Report a check on a commit (what required checks in branch rules wait for). */
+    create(repo: RepoRef, sha: string, status: CommitStatus): Promise<unknown>;
+    list(repo: RepoRef, ref: string): Promise<unknown[]>;
+    combined(repo: RepoRef, ref: string): Promise<CombinedStatus>;
+}
+declare class GitNotificationsAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    list(opts?: {
+        all?: boolean;
+    }): Promise<{
+        notifications: Notification[];
+        unread: number;
+    }>;
+    markRead(ids?: number[]): Promise<void>;
+}
+declare class GitTokensAPI {
+    private readonly c;
+    constructor(c: GitClient);
+    list(): Promise<Token[]>;
+    /** A Lizard Git token (lzg_...), optionally limited to repos, refs, paths, or read-only. The secret is in `token`, once. */
+    create(opts: TokenOpts): Promise<{
+        id: number;
+        name: string;
+        token: string;
+    }>;
+    delete(id: number): Promise<void>;
+}
+/** `lizard.git`: everything Lizard Git does, with the client's API key. */
+declare class GitAPI {
+    readonly client: GitClient;
+    readonly repos: GitReposAPI;
+    readonly issues: GitIssuesOnlyAPI;
+    readonly pulls: GitPullsAPI;
+    readonly actions: GitActionsAPI;
+    readonly collaborators: GitCollaboratorsAPI;
+    readonly webhooks: GitWebhooksAPI;
+    readonly branchRules: GitBranchRulesAPI;
+    readonly labels: GitLabelsAPI;
+    readonly releases: GitReleasesAPI;
+    readonly statuses: GitStatusesAPI;
+    readonly notifications: GitNotificationsAPI;
+    readonly tokens: GitTokensAPI;
+    constructor(config: ConnectionConfig, url?: string);
+    /** Who the key signs in as on Lizard Git. */
+    me(): Promise<GitUser>;
+    user(login: string): Promise<{
+        user: GitUser;
+        starred: Repo[];
+    }>;
+}
+
 /** A process this sandbox is currently running (one started through `exec`). */
 interface ProcessInfo {
     pid: number;
@@ -714,7 +1507,7 @@ declare class Fs {
      * }, 1000)
      * ```
      *
-     * Not available on Firecracker sandboxes yet: the call throws `LizardError` (501).
+     * Not available yet: the call throws `LizardError` (501).
      */
     watch(path: string, opts?: {
         recursive?: boolean;
@@ -864,12 +1657,12 @@ interface SandboxInfo {
     /** Region the sandbox runs in — the volume's region when one is attached. */
     region?: string;
     status?: string;
-    /** The sandbox runtime: `'firecracker'` (a microVM), `'container'`, or `null` when unknown. */
+    /** The sandbox runtime: `'firecracker'` (a microVM), or `null` when unknown. */
     runtime?: 'firecracker' | 'container' | null;
     pauseError?: string | null;
-    /** Machine size (`'small' | 'medium' | 'large'`); may be `null` for a sandbox billed by measured usage, such as one restored from a container snapshot. */
+    /** Machine size (`'small' | 'medium' | 'large'`); may be `null` for a sandbox billed by measured usage. */
     size?: 'small' | 'medium' | 'large' | null;
-    /** Flat hourly price in USD for `size`, billed per second while running; may be `null` when billed by measured usage (a container snapshot). */
+    /** Flat hourly price in USD for `size`, billed per second while running; may be `null` when billed by measured usage. */
     pricePerHour?: number | null;
     cpus?: number;
     memoryMb?: number;
@@ -1011,7 +1804,7 @@ interface SandboxSnapshot {
  */
 type SnapshotScope = 'user' | 'workspace' | 'project';
 interface SnapshotOpts {
-    /** Warm copies to keep ready (container sandboxes only; ignored for Firecracker, whose snapshots restore from disk). */
+    /** Warm copies to keep ready for an older snapshot. Firecracker snapshots ignore it: they restore from disk. */
     poolSize?: number;
     /** Where it may be restored. Default `'user'`: any of your projects and workspaces; with a key
      *  limited to a workspace or project, only what the key covers (a wider scope is narrowed). */
@@ -1259,11 +2052,11 @@ declare class Sandbox extends SandboxClient {
      * snapshot. A Firecracker snapshot is `ready` as soon as this returns: about 2 s, up to
      * a few minutes for a sandbox that filled most of its memory (its memory is uploaded
      * first), so the call waits up to 11 minutes. Start copies of it with {@link Sandbox.restore}
-     * (about 0.4 s each). The source keeps running. `poolSize` applies to container sandboxes only.
+     * (about 0.4 s each). The source keeps running. Firecracker snapshots ignore `poolSize`.
      */
     snapshot(name?: string, opts?: SnapshotOpts): Promise<SandboxSnapshot>;
     unexpose(port: number): Promise<void>;
-    /** Stream the sandbox's logs. Not available on Firecracker sandboxes yet (`LizardError`, 501). */
+    /** Stream the sandbox's logs. Not available yet (`LizardError`, 501). */
     logs(opts?: {
         tail?: number;
         signal?: AbortSignal;
@@ -1286,7 +2079,7 @@ declare class Sandbox extends SandboxClient {
     /** Change where a snapshot you took may be restored. */
     static setSnapshotScope(snapshotId: string, scope: SnapshotScope, opts?: ConnectionOpts): Promise<SandboxSnapshot>;
     static setSnapshotWarmPool(snapshotId: string, poolSize: number, opts?: ConnectionOpts): Promise<SandboxSnapshot>;
-    /** Release idle warm copies (container snapshots); retain saved state and existing claimed sandboxes. */
+    /** Release idle warm copies of an older snapshot; retain saved state and existing claimed sandboxes. Firecracker snapshots have no warm copies. */
     static pauseSnapshot(snapshotId: string, opts?: ConnectionOpts): Promise<SandboxSnapshot>;
     /** Refill the configured warm pool without another capture. */
     static resumeSnapshot(snapshotId: string, opts?: ConnectionOpts): Promise<SandboxSnapshot>;
@@ -1957,7 +2750,7 @@ interface VolumeInfo {
     status: string;
     /** Id of the sandbox the volume is attached to, or `null` when it is free. */
     attachedTo?: string | null;
-    /** Creation time: an ISO-8601 string for Firecracker volumes, unix milliseconds for container volumes. */
+    /** Creation time: an ISO-8601 string, or unix milliseconds for an older volume. */
     createdAt: string | number;
     /**
      * Whether `sizeGb` is actually enforced as a hard limit on the volume's node.
@@ -2026,13 +2819,11 @@ declare class Volume {
     /**
      * Resize a volume, by name or by id, to `sizeGb`.
      *
-     * A Firecracker volume (the default) can only grow. The change is in place and
-     * online: a sandbox with the volume attached keeps running and sees the new size.
-     * A smaller size throws `LizardError` (400) with `code: 'volume_shrink_unsupported'`.
+     * A volume grows in place and online: a sandbox with the volume attached keeps
+     * running and sees the new size. A smaller size throws `LizardError` (400) with
+     * `code: 'volume_shrink_unsupported'`.
      *
-     * On a container volume the change is in place and online: the size is a quota,
-     * so no data is copied and a mounted sandbox sees the new size immediately. Both
-     * growing and shrinking are allowed, but a shrink must leave at least 10% of the
+     * An older volume can also shrink, but the shrink must leave at least 10% of the
      * new size free — otherwise it throws `ConflictError` with
      * `code: 'volume_too_full_to_shrink'`.
      *
@@ -2042,7 +2833,7 @@ declare class Volume {
      * `volume_capacity_unavailable`, and `volume_resize_timeout` (a `TimeoutError`;
      * the size is left unchanged).
      *
-     * @returns The volume's updated info, including `sizeEnforced` for a container volume.
+     * @returns The volume's updated info, including `sizeEnforced` for an older volume.
      */
     static resize(projectId: string, nameOrId: string, sizeGb: number, opts?: ConnectionOpts): Promise<VolumeInfo>;
     getInfo(projectId: string): Promise<VolumeInfo>;
@@ -2058,6 +2849,8 @@ interface LizardOpts extends ConnectionOpts {
      * management (projects, services, addons, etc.).
      */
     project?: string;
+    /** Lizard Git's address. Defaults to `LIZARD_GIT_URL`, then https://git.lizard.build. */
+    gitUrl?: string;
 }
 /**
  * The Lizard client — entry point for sandboxes and platform management.
@@ -2114,6 +2907,11 @@ declare class Lizard {
     readonly metrics: MetricsAPI;
     readonly storage: StorageAPI;
     readonly github: GitHubAPI;
+    /**
+     * Lizard Git (git.lizard.build): repositories, issues, pull requests, reviews, CI runs,
+     * releases, webhooks, branch rules. Needs a key with no scopes.
+     */
+    readonly git: GitAPI;
     constructor(opts: LizardOpts);
     /** Resolve the client's project reference to a stable project ID (cached). */
     projectId(): Promise<string>;
@@ -2471,4 +3269,4 @@ declare class LizardCLI {
     }): Promise<CLIResult>;
 }
 
-export { type Account, type Addon, type AddonType, AddonsAPI, type ApiKey, type ApiKeyScope, ApiKeysAPI, AuthenticationError, type Balance, BillingAPI, type CLIOptions, type CLIResult, type CheckoutSession, type ClickOpts, type CodeContext, CodeSandbox, ConfigApplyError, type ConfigResult, ConflictError, type ConnectionOpts, type CostMetrics, type CreateAddonOpts, type CreateApiKeyOpts, type CreateContextOpts, type CreateProjectOpts, type CreateServiceOpts, type CreateVolumeOpts, type CreateWorkspaceOpts, type CreatedApiKey, type DeployEvent, DeployHandle, Desktop, type DesktopInfo, type DesktopStartOpts, type DomainInfo, type DomainStatus, DomainsAPI, Execution, ExecutionError, type ExposedPort, type FileInfo, type ForkResult, type FsEvent, type FsOpts, GitHubAPI, LimitExceededError, type ListTransactionsOpts, Lizard, LizardCLI, LizardError, type LizardOpts, type LogLine, type MetricPoint, type MetricRange, MetricsAPI, type MouseButton, NotFoundError, PaymentRequiredError, type Plan, PlatformClient, type ProcessInfo, type ProcessOpts, type ProcessResult, type ProcessSignal, type Project, type ProjectConfig, type ProjectCost, ProjectsAPI, type PromoRedemption, type RawMetrics, type Region, RegionsAPI, type ResaleMultipliers, type ResalePricing, type RunCodeLanguage, type RunCodeOpts, Sandbox, type SandboxInfo, type SandboxOpts, type SandboxSnapshot, type ScaleOpts, type ScrollDirection, type Secret, SecretsAPI, type Service, type ServiceMetrics, type ServiceUpdate, ServicesAPI, type SetSecretOpts, type SnapshotOpts, type SnapshotScope, type SnapshotWaitOpts, type StartCheckoutOpts, type StartProNowResult, StorageAPI, type StreamEvent, type Subscription, type SubscriptionStatus, TimeoutError, type Transaction, type TransactionPage, Volume, type VolumeInfo, type Workspace, type WorkspaceLimits, type WorkspaceLimitsInfo, type WorkspaceUsage, WorkspacesAPI, resolveProjectId };
+export { type Account, type Addon, type AddonType, AddonsAPI, type ApiKey, type ApiKeyScope, ApiKeysAPI, AuthenticationError, type Balance, BillingAPI, type BranchRule, type BranchRuleOpts, type CLIOptions, type CLIResult, type CheckoutSession, type ClickOpts, type CodeContext, CodeSandbox, type CombinedStatus, type CommitFilesOpts, type CommitStatus, ConfigApplyError, type ConfigResult, ConflictError, type ConnectionOpts, type CostMetrics, type CreateAddonOpts, type CreateApiKeyOpts, type CreateContextOpts, type CreateProjectOpts, type CreatePullOpts, type CreateServiceOpts, type CreateVolumeOpts, type CreateWorkspaceOpts, type CreatedApiKey, DEFAULT_GIT_URL, type DeployEvent, DeployHandle, Desktop, type DesktopInfo, type DesktopStartOpts, type DomainInfo, type DomainStatus, DomainsAPI, Execution, ExecutionError, type ExposedPort, type FileInfo, type ForkResult, type FsEvent, type FsOpts, GitAPI, GitActionsAPI, type Artifact as GitArtifact, type Blob$1 as GitBlob, GitBranchRulesAPI, GitClient, type Collaborator as GitCollaborator, GitCollaboratorsAPI, type Commit as GitCommit, type Delivery as GitDelivery, type FileChange as GitFileChange, GitHubAPI, type Invitation as GitInvitation, type Issue as GitIssue, type IssueDetail as GitIssueDetail, type IssueList as GitIssueList, GitIssuesOnlyAPI, type Job as GitJob, type Label as GitLabel, GitLabelsAPI, type Notification as GitNotification, GitNotificationsAPI, GitPullsAPI, type Ref as GitRef, type Release as GitRelease, GitReleasesAPI, type Repo as GitRepo, type RepoMeta as GitRepoMeta, GitReposAPI, type Role as GitRole, type Run as GitRun, GitSecretsAPI, GitStatusesAPI, type Token as GitToken, GitTokensAPI, type TreeEntry as GitTreeEntry, type GitUser, type Webhook as GitWebhook, GitWebhooksAPI, type Workflow as GitWorkflow, LimitExceededError, type LineComment, type ListIssuesOpts, type ListRunsOpts, type ListTransactionsOpts, Lizard, LizardCLI, LizardError, type LizardOpts, type LogChunk, type LogLine, type MergeOpts, type MetricPoint, type MetricRange, MetricsAPI, type MouseButton, NotFoundError, PaymentRequiredError, type Plan, PlatformClient, type ProcessInfo, type ProcessOpts, type ProcessResult, type ProcessSignal, type Project, type ProjectConfig, type ProjectCost, ProjectsAPI, type PromoRedemption, type RawMetrics, type Region, RegionsAPI, type ReleaseOpts, type RepoRef, type ResaleMultipliers, type ResalePricing, type ReviewOpts, type RunCodeLanguage, type RunCodeOpts, Sandbox, type SandboxInfo, type SandboxOpts, type SandboxSnapshot, type ScaleOpts, type ScrollDirection, type Secret, SecretsAPI, type Service, type ServiceMetrics, type ServiceUpdate, ServicesAPI, type SetSecretOpts, type SnapshotOpts, type SnapshotScope, type SnapshotWaitOpts, type StartCheckoutOpts, type StartProNowResult, StorageAPI, type StreamEvent, type Subscription, type SubscriptionStatus, TimeoutError, type TokenOpts, type Transaction, type TransactionPage, type UpdateIssueOpts, Volume, type VolumeInfo, type WebhookOpts, type Workspace, type WorkspaceLimits, type WorkspaceLimitsInfo, type WorkspaceUsage, WorkspacesAPI, resolveProjectId };