@foss.global/forgefixtures 0.2.0

package/dist_ts/classes.giteaseed.d.ts

@@ -0,0 +1,13 @@
+import type { GiteaFixture } from './classes.giteafixture.js';
+import type { IGiteaSeedManifest, IGiteaSeedSpec } from './interfaces.giteaseed.js';
+/** Rejects inconsistent specs before the first mutation. */
+export declare const validateGiteaSeedSpec: (specArg: IGiteaSeedSpec) => void;
+/**
+ * Seeds a running {@link GiteaFixture} through Gitea's documented REST and
+ * Git LFS APIs, then reads everything back into a ground-truth manifest.
+ */
+export declare class GiteaSeedBuilder {
+    #private;
+    constructor(fixtureArg: GiteaFixture);
+    apply(specArg: IGiteaSeedSpec): Promise<IGiteaSeedManifest>;
+}

package/dist_ts/classes.giteaseed.js

@@ -0,0 +1,432 @@
+import * as plugins from './plugins.js';
+import * as responses from './responses.js';
+const defaultBranch = 'main';
+const lfsMediaType = 'application/vnd.git-lfs+json';
+const namePattern = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,38}$/;
+const colorPattern = /^#[0-9a-f]{6}$/;
+const segment = (valueArg) => encodeURIComponent(valueArg);
+/** Rejects inconsistent specs before the first mutation. */
+export const validateGiteaSeedSpec = (specArg) => {
+    const fail = (messageArg) => {
+        throw new TypeError(`Invalid Gitea seed spec: ${messageArg}`);
+    };
+    const unique = (valuesArg, whatArg) => {
+        const seen = new Set();
+        for (const value of valuesArg) {
+            if (seen.has(value.toLowerCase()))
+                fail(`duplicate ${whatArg} "${value}"`);
+            seen.add(value.toLowerCase());
+        }
+    };
+    const users = new Set(specArg.users.map((userArg) => userArg.username));
+    const organizations = new Set(specArg.organizations.map((organizationArg) => organizationArg.name));
+    for (const name of [...users, ...organizations])
+        if (!namePattern.test(name))
+            fail(`malformed name "${name}"`);
+    unique([...users, ...organizations], 'user or organization');
+    for (const username of specArg.deleteUsers ?? [])
+        if (!users.has(username))
+            fail(`cannot delete unknown user "${username}"`);
+    unique(specArg.repositories.map((repositoryArg) => `${repositoryArg.owner}/${repositoryArg.name}`), 'repository');
+    const deleted = new Set(specArg.deleteUsers ?? []);
+    for (const repository of specArg.repositories) {
+        const where = `${repository.owner}/${repository.name}`;
+        if (!namePattern.test(repository.name))
+            fail(`malformed repository name "${where}"`);
+        if (!users.has(repository.owner) && !organizations.has(repository.owner))
+            fail(`${where} has an unknown owner`);
+        if (deleted.has(repository.owner))
+            fail(`${where} is owned by a user scheduled for deletion`);
+        const knownUser = (usernameArg) => {
+            if (!users.has(usernameArg))
+                fail(`${where} references unknown user "${usernameArg}"`);
+        };
+        for (const collaborator of repository.collaborators ?? [])
+            knownUser(collaborator.username);
+        const lfsPaths = (repository.lfsObjects ?? []).map((fileArg) => fileArg.path);
+        const filePaths = [...(repository.files ?? []).map((fileArg) => fileArg.path), ...lfsPaths];
+        unique(filePaths, `${where} file`);
+        if (filePaths.includes('README.md'))
+            fail(`${where} cannot seed README.md; auto-initialisation creates it`);
+        if (lfsPaths.length > 0 && filePaths.includes('.gitattributes'))
+            fail(`${where} cannot combine LFS objects with its own .gitattributes`);
+        const branches = new Set([defaultBranch]);
+        for (const branch of repository.branches ?? []) {
+            if (branches.has(branch.name))
+                fail(`${where} declares branch "${branch.name}" twice`);
+            if (!branches.has(branch.from ?? defaultBranch))
+                fail(`${where} branch "${branch.name}" starts from an undeclared branch`);
+            branches.add(branch.name);
+        }
+        const labels = new Set((repository.labels ?? []).map((labelArg) => {
+            if (!colorPattern.test(labelArg.color))
+                fail(`${where} label "${labelArg.name}" needs a lowercase #rrggbb color`);
+            return labelArg.name;
+        }));
+        unique([...labels], `${where} label`);
+        const milestones = new Set((repository.milestones ?? []).map((milestoneArg) => milestoneArg.title));
+        unique([...milestones], `${where} milestone`);
+        unique((repository.tags ?? []).map((tagArg) => tagArg.name), `${where} tag`);
+        unique((repository.issuesAndPullRequests ?? []).map((itemArg) => itemArg.key), `${where} issue key`);
+        for (const item of repository.issuesAndPullRequests ?? []) {
+            knownUser(item.author);
+            for (const label of item.labels ?? [])
+                if (!labels.has(label))
+                    fail(`${where} ${item.key} uses unknown label "${label}"`);
+            if (item.kind === 'issue') {
+                if (item.milestone !== undefined && !milestones.has(item.milestone))
+                    fail(`${where} ${item.key} uses an unknown milestone`);
+                for (const assignee of item.assignees ?? [])
+                    knownUser(assignee);
+                for (const comment of item.comments ?? [])
+                    knownUser(comment.author);
+            }
+            else if (!branches.has(item.head) || !branches.has(item.base) || item.head === item.base) {
+                fail(`${where} ${item.key} needs two distinct declared branches`);
+            }
+        }
+    }
+};
+/**
+ * Seeds a running {@link GiteaFixture} through Gitea's documented REST and
+ * Git LFS APIs, then reads everything back into a ground-truth manifest.
+ */
+export class GiteaSeedBuilder {
+    #fixture;
+    constructor(fixtureArg) {
+        this.#fixture = fixtureArg;
+    }
+    async apply(specArg) {
+        validateGiteaSeedSpec(specArg);
+        const runtime = this.#fixture.runtime;
+        const http = this.#fixture.http;
+        const users = new Map();
+        for (const user of specArg.users) {
+            const created = await this.#api(http, 'POST', '/api/v1/admin/users', [201], {
+                json: {
+                    username: user.username,
+                    email: `${user.username.toLowerCase()}@example.com`,
+                    password: plugins.crypto.randomBytes(24).toString('base64url'),
+                    must_change_password: false,
+                    ...(user.fullName === undefined ? {} : { full_name: user.fullName }),
+                    visibility: user.visibility ?? 'public',
+                },
+            });
+            users.set(user.username, responses.integer(responses.field(created, 'id', 'created user'), 'user id'));
+        }
+        const organizations = [];
+        for (const organization of specArg.organizations) {
+            const created = await this.#api(http, 'POST', '/api/v1/orgs', [201], {
+                json: { username: organization.name, visibility: organization.visibility },
+            });
+            organizations.push({
+                name: organization.name,
+                id: responses.integer(responses.field(created, 'id', 'created organization'), 'organization id'),
+                visibility: this.#visibility(responses.field(created, 'visibility', 'created organization')),
+            });
+        }
+        const organizationNames = new Set(specArg.organizations.map((organizationArg) => organizationArg.name));
+        const seeded = [];
+        for (const repository of specArg.repositories) {
+            seeded.push(await this.#seedRepository(http, repository, organizationNames.has(repository.owner)));
+        }
+        for (const username of specArg.deleteUsers ?? []) {
+            await this.#api(http, 'DELETE', `/api/v1/admin/users/${segment(username)}`, [204]);
+        }
+        const deleted = new Set(specArg.deleteUsers ?? []);
+        const repositories = [];
+        for (const refs of seeded)
+            repositories.push(await this.#readBack(http, refs));
+        return {
+            baseUrl: runtime.baseUrl,
+            version: runtime.version,
+            users: [...users].map(([username, id]) => ({ username, id, deleted: deleted.has(username) })),
+            organizations,
+            repositories,
+        };
+    }
+    async #seedRepository(httpArg, specArg, ownedByOrganizationArg) {
+        const repoPath = `/api/v1/repos/${segment(specArg.owner)}/${segment(specArg.name)}`;
+        await this.#api(httpArg, 'POST', ownedByOrganizationArg ? `/api/v1/orgs/${segment(specArg.owner)}/repos` : `/api/v1/admin/users/${segment(specArg.owner)}/repos`, [201], {
+            json: {
+                name: specArg.name, private: specArg.private, description: specArg.description ?? '',
+                auto_init: true, default_branch: defaultBranch, readme: 'Default',
+            },
+        });
+        for (const collaborator of specArg.collaborators ?? []) {
+            await this.#api(httpArg, 'PUT', `${repoPath}/collaborators/${segment(collaborator.username)}`, [204], {
+                json: { permission: collaborator.permission },
+            });
+        }
+        const refs = {
+            spec: specArg, labels: new Map(), milestones: new Map(), tags: [], items: [], releases: [], lfsObjects: [],
+        };
+        for (const lfsObject of specArg.lfsObjects ?? []) {
+            refs.lfsObjects.push({ path: lfsObject.path, ...await this.#uploadLfsObject(httpArg, specArg, lfsObject.content) });
+        }
+        const defaultFiles = [...(specArg.files ?? [])];
+        if (refs.lfsObjects.length > 0) {
+            defaultFiles.push({
+                path: '.gitattributes',
+                content: refs.lfsObjects.map((objectArg) => `${objectArg.path} filter=lfs diff=lfs merge=lfs -text\n`).join(''),
+            });
+            for (const object of refs.lfsObjects) {
+                defaultFiles.push({
+                    path: object.path,
+                    content: `version https://git-lfs.github.com/spec/v1\noid sha256:${object.oid}\nsize ${object.size}\n`,
+                });
+            }
+        }
+        if (defaultFiles.length > 0) {
+            await this.#commitFiles(httpArg, repoPath, defaultFiles, { branch: defaultBranch }, 'Seed default branch files');
+        }
+        for (const branch of specArg.branches ?? []) {
+            await this.#commitFiles(httpArg, repoPath, branch.files, {
+                branch: branch.from ?? defaultBranch, new_branch: branch.name,
+            }, `Seed branch ${branch.name}`);
+        }
+        for (const label of specArg.labels ?? []) {
+            const created = await this.#api(httpArg, 'POST', `${repoPath}/labels`, [201], {
+                json: { name: label.name, color: label.color, description: label.description ?? '' },
+            });
+            refs.labels.set(label.name, responses.integer(responses.field(created, 'id', 'created label'), 'label id'));
+        }
+        for (const milestone of specArg.milestones ?? []) {
+            const created = await this.#api(httpArg, 'POST', `${repoPath}/milestones`, [201], {
+                json: { title: milestone.title, description: milestone.description ?? '', state: milestone.state ?? 'open' },
+            });
+            refs.milestones.set(milestone.title, {
+                id: responses.integer(responses.field(created, 'id', 'created milestone'), 'milestone id'),
+                state: this.#state(responses.field(created, 'state', 'created milestone')),
+            });
+        }
+        for (const tag of specArg.tags ?? []) {
+            const created = await this.#api(httpArg, 'POST', `${repoPath}/tags`, [200, 201], {
+                json: { tag_name: tag.name, target: tag.target, message: tag.message ?? '' },
+            });
+            refs.tags.push({ name: tag.name, commitSha: this.#tagCommitSha(created) });
+        }
+        for (const item of specArg.issuesAndPullRequests ?? []) {
+            refs.items.push(item.kind === 'issue'
+                ? await this.#seedIssue(httpArg, repoPath, refs, item)
+                : await this.#seedPullRequest(httpArg, repoPath, refs, item));
+        }
+        for (const release of specArg.releases ?? []) {
+            const created = await this.#api(httpArg, 'POST', `${repoPath}/releases`, [201], {
+                json: {
+                    tag_name: release.tagName, target_commitish: release.target, name: release.name, body: release.body ?? '',
+                    draft: release.draft ?? false, prerelease: release.prerelease ?? false,
+                },
+            });
+            refs.releases.push({
+                tagName: release.tagName,
+                id: responses.integer(responses.field(created, 'id', 'created release'), 'release id'),
+                draft: responses.boolean(responses.field(created, 'draft', 'created release'), 'release draft'),
+                prerelease: responses.boolean(responses.field(created, 'prerelease', 'created release'), 'release prerelease'),
+            });
+        }
+        return refs;
+    }
+    async #seedIssue(httpArg, repoPathArg, refsArg, issueArg) {
+        const created = await this.#api(httpArg, 'POST', `${repoPathArg}/issues`, [201], {
+            sudo: issueArg.author, json: { title: issueArg.title, body: issueArg.body ?? '' },
+        });
+        const number = responses.integer(responses.field(created, 'number', 'created issue'), 'issue number');
+        const issuePath = `${repoPathArg}/issues/${number}`;
+        for (const comment of issueArg.comments ?? []) {
+            await this.#api(httpArg, 'POST', `${issuePath}/comments`, [201], { sudo: comment.author, json: { body: comment.body } });
+        }
+        await this.#applyLabels(httpArg, issuePath, refsArg, issueArg.labels);
+        const edit = {};
+        if (issueArg.milestone !== undefined)
+            edit.milestone = refsArg.milestones.get(issueArg.milestone).id;
+        if (issueArg.assignees !== undefined)
+            edit.assignees = issueArg.assignees;
+        if (issueArg.state === 'closed')
+            edit.state = 'closed';
+        if (Object.keys(edit).length > 0)
+            await this.#api(httpArg, 'PATCH', issuePath, [201], { json: edit });
+        return { key: issueArg.key, kind: 'issue', number };
+    }
+    async #seedPullRequest(httpArg, repoPathArg, refsArg, pullArg) {
+        const created = await this.#api(httpArg, 'POST', `${repoPathArg}/pulls`, [201], {
+            sudo: pullArg.author, json: { title: pullArg.title, body: pullArg.body ?? '', head: pullArg.head, base: pullArg.base },
+        });
+        const number = responses.integer(responses.field(created, 'number', 'created pull request'), 'pull request number');
+        await this.#applyLabels(httpArg, `${repoPathArg}/issues/${number}`, refsArg, pullArg.labels);
+        if (pullArg.state === 'closed') {
+            await this.#api(httpArg, 'PATCH', `${repoPathArg}/pulls/${number}`, [201], { json: { state: 'closed' } });
+        }
+        return { key: pullArg.key, kind: 'pullRequest', number };
+    }
+    async #applyLabels(httpArg, issuePathArg, refsArg, labelsArg) {
+        if (!labelsArg || labelsArg.length === 0)
+            return;
+        await this.#api(httpArg, 'POST', `${issuePathArg}/labels`, [200], {
+            json: { labels: labelsArg.map((labelArg) => refsArg.labels.get(labelArg)) },
+        });
+    }
+    async #commitFiles(httpArg, repoPathArg, filesArg, branchArg, messageArg) {
+        await this.#api(httpArg, 'POST', `${repoPathArg}/contents`, [201], {
+            json: {
+                ...branchArg,
+                message: messageArg,
+                files: filesArg.map((fileArg) => ({
+                    operation: 'create',
+                    path: fileArg.path,
+                    content: Buffer.from(fileArg.content, 'utf8').toString('base64'),
+                })),
+            },
+        });
+    }
+    /** Uploads one object through the Git LFS batch API using the administrator's token as password. */
+    async #uploadLfsObject(httpArg, repositoryArg, contentArg) {
+        const content = Buffer.from(contentArg, 'utf8');
+        const oid = plugins.crypto.createHash('sha256').update(content).digest('hex');
+        const size = content.byteLength;
+        const runtime = this.#fixture.runtime;
+        const basic = `Basic ${Buffer.from(`${runtime.admin.username}:${runtime.admin.token}`).toString('base64')}`;
+        const batch = await httpArg.requestJson({
+            method: 'POST',
+            url: `/${segment(repositoryArg.owner)}/${segment(repositoryArg.name)}.git/info/lfs/objects/batch`,
+            headers: { accept: lfsMediaType, 'content-type': lfsMediaType, authorization: basic },
+            body: Buffer.from(JSON.stringify({ operation: 'upload', transfers: ['basic'], objects: [{ oid, size }] })),
+            expectedStatus: [200],
+        });
+        const objects = responses.array(responses.field(batch, 'objects', 'LFS batch response'), 'LFS batch objects');
+        if (objects.length !== 1)
+            throw new Error('The LFS batch response does not describe exactly one object.');
+        const object = responses.record(objects[0], 'LFS batch object');
+        if (object.oid !== oid || object.size !== size || object.error !== undefined) {
+            throw new Error(`The LFS batch refused object ${oid}.`);
+        }
+        const actions = object.actions === undefined ? {} : responses.record(object.actions, 'LFS actions');
+        const actionHeaders = (actionArg) => {
+            const headers = {};
+            if (actionArg.header === undefined)
+                return headers;
+            for (const [name, value] of Object.entries(responses.record(actionArg.header, 'LFS action header'))) {
+                headers[name] = responses.text(value, `LFS action header ${name}`);
+            }
+            return headers;
+        };
+        if (actions.upload !== undefined) {
+            const upload = responses.record(actions.upload, 'LFS upload action');
+            await httpArg.request({
+                method: 'PUT', url: responses.text(upload.href, 'LFS upload href'),
+                headers: { ...actionHeaders(upload), 'content-type': 'application/octet-stream' },
+                body: content, expectedStatus: [200],
+            });
+        }
+        if (actions.verify !== undefined) {
+            const verify = responses.record(actions.verify, 'LFS verify action');
+            await httpArg.request({
+                method: 'POST', url: responses.text(verify.href, 'LFS verify href'),
+                headers: { ...actionHeaders(verify), accept: lfsMediaType, 'content-type': lfsMediaType },
+                body: Buffer.from(JSON.stringify({ oid, size })), expectedStatus: [200],
+            });
+        }
+        return { oid, size };
+    }
+    async #readBack(httpArg, refsArg) {
+        const specArg = refsArg.spec;
+        const repoPath = `/api/v1/repos/${segment(specArg.owner)}/${segment(specArg.name)}`;
+        const repository = responses.record(await this.#api(httpArg, 'GET', repoPath, [200]), 'repository');
+        const owner = responses.record(repository.owner, 'repository owner');
+        const branches = [];
+        for (const name of [defaultBranch, ...(specArg.branches ?? []).map((branchArg) => branchArg.name)]) {
+            const branch = await this.#api(httpArg, 'GET', `${repoPath}/branches/${segment(name)}`, [200]);
+            branches.push({ name, commitSha: responses.text(responses.field(responses.field(branch, 'commit', 'branch'), 'id', 'branch commit'), 'branch commit id') });
+        }
+        const issues = [];
+        const pullRequests = [];
+        for (const item of refsArg.items) {
+            if (item.kind === 'issue') {
+                const issue = responses.record(await this.#api(httpArg, 'GET', `${repoPath}/issues/${item.number}`, [200]), 'issue');
+                const comments = responses.array(await this.#api(httpArg, 'GET', `${repoPath}/issues/${item.number}/comments`, [200]), 'comments');
+                const milestone = issue.milestone === null || issue.milestone === undefined
+                    ? null
+                    : responses.text(responses.field(issue.milestone, 'title', 'issue milestone'), 'milestone title');
+                issues.push({
+                    key: item.key,
+                    id: responses.integer(issue.id, 'issue id'),
+                    number: responses.integer(issue.number, 'issue number'),
+                    state: this.#state(issue.state),
+                    author: this.#author(issue.user),
+                    labels: responses.array(issue.labels ?? [], 'issue labels')
+                        .map((labelArg) => responses.text(responses.field(labelArg, 'name', 'issue label'), 'label name')),
+                    milestone,
+                    assignees: responses.array(issue.assignees ?? [], 'issue assignees').map((assigneeArg) => this.#author(assigneeArg).login),
+                    comments: comments.map((commentArg) => ({
+                        id: responses.integer(responses.field(commentArg, 'id', 'comment'), 'comment id'),
+                        author: this.#author(responses.field(commentArg, 'user', 'comment')),
+                    })),
+                });
+            }
+            else {
+                const pull = responses.record(await this.#api(httpArg, 'GET', `${repoPath}/pulls/${item.number}`, [200]), 'pull request');
+                const head = responses.record(pull.head, 'pull request head');
+                const base = responses.record(pull.base, 'pull request base');
+                pullRequests.push({
+                    key: item.key,
+                    id: responses.integer(pull.id, 'pull request id'),
+                    number: responses.integer(pull.number, 'pull request number'),
+                    state: this.#state(pull.state),
+                    author: this.#author(pull.user),
+                    head: responses.text(head.ref, 'pull request head ref'),
+                    base: responses.text(base.ref, 'pull request base ref'),
+                    headSha: responses.text(head.sha, 'pull request head sha'),
+                });
+            }
+        }
+        return {
+            owner: specArg.owner,
+            name: specArg.name,
+            fullName: responses.text(repository.full_name, 'repository full name'),
+            id: responses.integer(repository.id, 'repository id'),
+            ownerId: responses.integer(owner.id, 'repository owner id'),
+            private: responses.boolean(repository.private, 'repository private'),
+            internal: responses.boolean(repository.internal, 'repository internal'),
+            defaultBranch: responses.text(repository.default_branch, 'repository default branch'),
+            htmlUrl: responses.text(repository.html_url, 'repository html url'),
+            cloneUrl: responses.text(repository.clone_url, 'repository clone url'),
+            branches,
+            tags: refsArg.tags,
+            labels: [...refsArg.labels].map(([name, id]) => ({ name, id })),
+            milestones: [...refsArg.milestones].map(([title, milestone]) => ({ title, ...milestone })),
+            issues,
+            pullRequests,
+            releases: refsArg.releases,
+            lfsObjects: refsArg.lfsObjects,
+        };
+    }
+    /** Tag responses carry the target commit as `commit.sha`. */
+    #tagCommitSha(tagArg) {
+        return responses.text(responses.field(responses.field(tagArg, 'commit', 'tag'), 'sha', 'tag commit'), 'tag commit sha');
+    }
+    #author(userArg) {
+        const user = responses.record(userArg, 'user');
+        return { id: responses.integer(user.id, 'user id'), login: responses.text(user.login, 'user login') };
+    }
+    #state(valueArg) {
+        if (valueArg !== 'open' && valueArg !== 'closed')
+            throw new Error('Expected state to be open or closed.');
+        return valueArg;
+    }
+    #visibility(valueArg) {
+        if (valueArg !== 'public' && valueArg !== 'limited' && valueArg !== 'private') {
+            throw new Error('Expected visibility to be public, limited or private.');
+        }
+        return valueArg;
+    }
+    async #api(httpArg, methodArg, pathArg, expectedStatusArg, optionsArg = {}) {
+        const headers = { authorization: `token ${this.#fixture.runtime.admin.token}` };
+        if (optionsArg.sudo !== undefined)
+            headers.sudo = optionsArg.sudo;
+        return httpArg.requestJson({
+            method: methodArg, url: pathArg, headers, expectedStatus: expectedStatusArg,
+            ...(optionsArg.json === undefined ? {} : { json: optionsArg.json }),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.giteaseed.js","sourceRoot":"","sources":["../ts/classes.giteaseed.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.gitlabfixture.d.ts

@@ -0,0 +1,49 @@
+import type { ForgeFixtureHttpClient } from './classes.httpclient.js';
+import type { IForgeFixtureLifecycleOptions, IForgeFixtureReapReport, IGitlabFixtureRuntime } from './interfaces.js';
+export interface IGitlabFixtureOptions extends IForgeFixtureLifecycleOptions {
+    /** Container memory limit; swap is disabled. Defaults to 5 GiB. */
+    memoryBytes?: number;
+    /** CPU limit in billionths of a CPU. Defaults to 4 CPUs. */
+    nanoCpus?: number;
+}
+export interface IGitlabAccessTokenRequest {
+    username: string;
+    /** Token name; GitLab allows duplicates, so this is a label only. */
+    tokenName: string;
+    /** Personal access token scopes such as `api`, `read_api`, `read_repository` or `sudo`. */
+    scopes: string[];
+}
+/** Default rootless Docker socket of the current user. */
+export declare const defaultRootlessDockerSocket: () => string;
+/**
+ * A disposable self-managed GitLab CE from the pinned omnibus image, served over
+ * verified loopback TLS. The omnibus image must run as root, which this package
+ * permits only on a verified rootless Docker daemon.
+ */
+export declare class GitlabFixture {
+    #private;
+    constructor(optionsArg?: IGitlabFixtureOptions);
+    get runtime(): IGitlabFixtureRuntime;
+    /** HTTPS client scoped to this fixture's origin and CA. */
+    get http(): ForgeFixtureHttpClient;
+    /** Report of the stale-fixture reaper run that preceded this start. */
+    get reapReport(): IForgeFixtureReapReport | undefined;
+    /**
+     * Starts the fixture and returns once the container is healthy, an
+     * administrator token exists and GitLab reports the pinned version.
+     * A fixture starts at most once.
+     */
+    start(): Promise<IGitlabFixtureRuntime>;
+    /**
+     * Creates a personal access token with GitLab's documented programmatic
+     * method (`gitlab-rails runner`). The script travels on stdin, so neither it
+     * nor the token appears in process arguments; the token is returned, never logged.
+     */
+    createAccessToken(requestArg: IGitlabAccessTokenRequest): Promise<string>;
+    /**
+     * Removes every resource of this fixture. A start in progress is cancelled at
+     * its next checkpoint and awaited first, so nothing it created survives.
+     * Idempotent; retries incomplete cleanup.
+     */
+    stop(): Promise<void>;
+}