@trebired/git-host 2.0.0 → 2.2.0

package/dist/internal/react/client.js

@@ -1,744 +0,0 @@
-import { io as connectSocket } from "socket.io-client";
-import { ACTIONS_RUN_DONE_EVENT, ACTIONS_RUN_ERROR_EVENT, ACTIONS_RUN_EVENT, ACTIONS_RUN_SUBSCRIBE_EVENT, LINGUIST_DONE_EVENT, LINGUIST_ERROR_EVENT, LINGUIST_PROGRESS_EVENT, LINGUIST_RESULT_EVENT, LINGUIST_START_EVENT, } from "#e1ead083c558";
-import { GitApiClientError, parseJsonResponse } from "./client/error.js";
-import { appendQuery, buildQuery, encodePathSegment, mergeHeaders, normalizeBaseUrl, resolveHeaders } from "./client/helpers.js";
-function resolveSocketEndpoint(baseUrl, pathOverride) {
-    const trimmed = normalizeBaseUrl(baseUrl);
-    let absolute = null;
-    try {
-        absolute = new URL(trimmed);
-    }
-    catch {
-        absolute = null;
-    }
-    const basePath = absolute
-        ? absolute.pathname.replace(/\/+$/g, "")
-        : trimmed.replace(/\/+$/g, "");
-    const path = (() => {
-        const next = String(pathOverride || "").trim().replace(/\/+$/g, "");
-        if (next)
-            return next.startsWith("/") ? next : `/${next}`;
-        const derived = `${basePath || ""}/socket.io`.replace(/\/{2,}/g, "/");
-        return derived.startsWith("/") ? derived : `/${derived}`;
-    })();
-    return absolute
-        ? { path, url: `${absolute.protocol}//${absolute.host}` }
-        : { path };
-}
-function joinQueryValue(value) {
-    if (Array.isArray(value)) {
-        const rows = value.map((entry) => String(entry || "").trim()).filter(Boolean);
-        return rows.length ? rows.join(",") : undefined;
-    }
-    const single = String(value || "").trim();
-    return single || undefined;
-}
-function createGitApiClient(options) {
-    const baseUrl = normalizeBaseUrl(options.baseUrl);
-    const fetchImpl = options.fetch || globalThis.fetch;
-    if (typeof fetchImpl !== "function") {
-        throw new TypeError("createGitApiClient() requires fetch support.");
-    }
-    async function request(repositoryKey, actionPath, input) {
-        const repositoryBasePath = `/repositories/${encodePathSegment(repositoryKey)}`;
-        const requestPath = `${repositoryBasePath}/${String(actionPath || "").replace(/^\/+/, "")}`;
-        const url = appendQuery(`${baseUrl}${requestPath}`, input?.query);
-        const resolvedHeaders = mergeHeaders(await resolveHeaders(options.headers, {
-            path: requestPath,
-            repositoryKey,
-        }), input?.headers);
-        const method = input?.method || "GET";
-        const body = input?.body == null || method === "GET"
-            ? undefined
-            : JSON.stringify(input.body);
-        const finalHeaders = body
-            ? mergeHeaders({ "content-type": "application/json; charset=utf-8" }, resolvedHeaders)
-            : resolvedHeaders;
-        const response = await fetchImpl(url, {
-            body,
-            headers: finalHeaders,
-            method,
-            signal: input?.signal,
-        });
-        const payload = await parseJsonResponse(response);
-        if (!payload && response.ok) {
-            throw new GitApiClientError({
-                code: "empty_response",
-                message: "Git API returned an empty response.",
-                status: response.status || 500,
-            });
-        }
-        if (payload && payload.ok === false) {
-            throw new GitApiClientError({
-                code: payload.error.code,
-                details: payload.error.details,
-                message: payload.error.message,
-                status: response.status || 500,
-            });
-        }
-        if (!response.ok) {
-            throw new GitApiClientError({
-                code: "http_error",
-                message: `Git API request failed with status ${response.status}.`,
-                status: response.status || 500,
-            });
-        }
-        return payload;
-    }
-    return {
-        baseUrl,
-        getArchiveLinks(repositoryKey, input = {}) {
-            const ref = input.ref || "HEAD";
-            const repositoryBasePath = `${baseUrl}/repositories/${encodePathSegment(repositoryKey)}`;
-            const zipDefaultHref = `${repositoryBasePath}/zipball/${encodePathSegment(ref)}`;
-            const tarDefaultHref = `${repositoryBasePath}/tarball/${encodePathSegment(ref)}`;
-            return {
-                tar_gz: {
-                    file_name: input.fileName,
-                    format: "tar.gz",
-                    href: String(options.buildArchiveUrl?.({
-                        baseUrl,
-                        defaultHref: tarDefaultHref,
-                        format: "tar.gz",
-                        ref,
-                        repositoryKey,
-                    }) || tarDefaultHref),
-                    ref,
-                    root_directory: input.rootDirectory,
-                },
-                zip: {
-                    file_name: input.fileName,
-                    format: "zip",
-                    href: String(options.buildArchiveUrl?.({
-                        baseUrl,
-                        defaultHref: zipDefaultHref,
-                        format: "zip",
-                        ref,
-                        repositoryKey,
-                    }) || zipDefaultHref),
-                    ref,
-                    root_directory: input.rootDirectory,
-                },
-            };
-        },
-        getReleaseAssetLink(repositoryKey, releaseId, asset) {
-            const defaultHref = String(asset.download_url || `${baseUrl}/repositories/${encodePathSegment(repositoryKey)}/releases/${encodePathSegment(releaseId)}/assets/${encodePathSegment(asset.id)}`);
-            return {
-                asset_id: asset.id,
-                content_type: asset.content_type,
-                file_name: asset.name,
-                href: String(options.buildReleaseAssetUrl?.({
-                    assetId: asset.id,
-                    baseUrl,
-                    defaultHref,
-                    releaseId,
-                    repositoryKey,
-                }) || defaultHref),
-                size: asset.size == null ? null : Number(asset.size) || 0,
-            };
-        },
-        async diff(repositoryKey, input) {
-            const response = await request(repositoryKey, "diff", {
-                headers: input.headers,
-                query: buildQuery({
-                    baseRef: input.baseRef,
-                    headRef: input.headRef,
-                    path: input.path,
-                }),
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        async listBranches(repositoryKey, input) {
-            const response = await request(repositoryKey, "branches", input);
-            return response.data;
-        },
-        async listActivity(repositoryKey, input) {
-            const response = await request(repositoryKey, "activity", {
-                headers: input?.headers,
-                query: buildQuery({
-                    actor: input?.actor,
-                    createdAfter: input?.createdAfter,
-                    createdBefore: input?.createdBefore,
-                    kind: joinQueryValue(input?.kind),
-                    source: joinQueryValue(input?.source),
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async listWorkflows(repositoryKey, input) {
-            const response = await request(repositoryKey, "actions", {
-                headers: input?.headers,
-                query: buildQuery({
-                    enabled: input?.enabled,
-                    query: input?.query,
-                    trigger: joinQueryValue(input?.trigger),
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async createWorkflow(repositoryKey, input) {
-            const response = await request(repositoryKey, "actions", {
-                body: {
-                    enabled: input.enabled !== false,
-                    env: input.env,
-                    name: input.name,
-                    slug: input.slug,
-                    source: input.source,
-                    steps: input.steps,
-                    trigger: input.trigger,
-                },
-                headers: input.headers,
-                method: "POST",
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        async updateWorkflow(repositoryKey, workflowId, input) {
-            const response = await request(repositoryKey, `actions/${encodePathSegment(workflowId)}`, {
-                body: {
-                    enabled: input.enabled,
-                    env: input.env,
-                    name: input.name,
-                    slug: input.slug,
-                    source: input.source,
-                    steps: input.steps,
-                    trigger: input.trigger,
-                },
-                headers: input.headers,
-                method: "PATCH",
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        async listWorkflowRuns(repositoryKey, input) {
-            const response = await request(repositoryKey, "actions/runs", {
-                headers: input?.headers,
-                query: buildQuery({
-                    actor: input?.actor,
-                    branch: input?.branch,
-                    createdAfter: input?.createdAfter,
-                    createdBefore: input?.createdBefore,
-                    query: input?.query,
-                    ref: input?.ref,
-                    status: joinQueryValue(input?.status),
-                    triggerKind: joinQueryValue(input?.triggerKind),
-                    workflowId: input?.workflowId,
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async listWorkflowRunSteps(repositoryKey, runId, input) {
-            const response = await request(repositoryKey, `actions/runs/${encodePathSegment(runId)}/steps`, input);
-            return response.data;
-        },
-        async listWorkflowRunEvents(repositoryKey, runId, input) {
-            const response = await request(repositoryKey, `actions/runs/${encodePathSegment(runId)}/events`, {
-                headers: input?.headers,
-                query: buildQuery({
-                    afterSequence: input?.afterSequence,
-                    limit: input?.limit,
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async runWorkflow(repositoryKey, input) {
-            const response = await request(repositoryKey, "actions/runs", {
-                body: {
-                    branch: input.branch,
-                    commitHash: input.commitHash,
-                    ref: input.ref,
-                    triggerContext: input.triggerContext,
-                    workflowId: input.workflowId,
-                },
-                headers: input.headers,
-                method: "POST",
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        async cancelWorkflowRun(repositoryKey, runId, input) {
-            const response = await request(repositoryKey, `actions/runs/${encodePathSegment(runId)}/cancel`, {
-                body: {},
-                headers: input?.headers,
-                method: "POST",
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async listCommits(repositoryKey, input) {
-            const response = await request(repositoryKey, "commits", {
-                headers: input?.headers,
-                query: buildQuery({
-                    limit: input?.limit,
-                    path: input?.path,
-                    ref: input?.ref,
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async listTags(repositoryKey, input) {
-            const response = await request(repositoryKey, "tags", input);
-            return response.data;
-        },
-        async listForks(repositoryKey, input) {
-            const response = await request(repositoryKey, "forks", input);
-            return response.data;
-        },
-        async listReleases(repositoryKey, input) {
-            const response = await request(repositoryKey, "releases", input);
-            return response.data;
-        },
-        async listTree(repositoryKey, input) {
-            const response = await request(repositoryKey, "tree", {
-                headers: input?.headers,
-                query: buildQuery({
-                    icons: input?.icons,
-                    linguist: input?.linguist,
-                    path: input?.path,
-                    recursive: input?.recursive,
-                    ref: input?.ref,
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async readBlob(repositoryKey, input) {
-            const response = await request(repositoryKey, "blob", {
-                headers: input.headers,
-                query: buildQuery({
-                    path: input.path,
-                    ref: input.ref,
-                }),
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        async readArchive(repositoryKey, input) {
-            const response = await request(repositoryKey, "archive", {
-                headers: input?.headers,
-                query: buildQuery({
-                    format: input?.format,
-                    prefix: input?.prefix,
-                    ref: input?.ref,
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async readBlame(repositoryKey, input) {
-            const response = await request(repositoryKey, "blame", {
-                headers: input.headers,
-                query: buildQuery({
-                    path: input.path,
-                    ref: input.ref,
-                }),
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        async readCommit(repositoryKey, commitRef, input) {
-            const response = await request(repositoryKey, `commits/${encodePathSegment(commitRef)}`, input);
-            return response.data;
-        },
-        async readLinguist(repositoryKey, input) {
-            const response = await request(repositoryKey, "linguist", {
-                headers: input?.headers,
-                query: buildQuery({
-                    ref: input?.ref,
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        openLinguistSocket(repositoryKey, input) {
-            const { path, url } = resolveSocketEndpoint(baseUrl, options.socketOptions && options.socketOptions.path);
-            let socket = null;
-            let settled = false;
-            let rejectCompleted = null;
-            let resolveCompleted = null;
-            const cleanup = () => {
-                socket?.off(LINGUIST_PROGRESS_EVENT);
-                socket?.off(LINGUIST_RESULT_EVENT);
-                socket?.off(LINGUIST_DONE_EVENT);
-                socket?.off(LINGUIST_ERROR_EVENT);
-                socket?.off("connect");
-                socket?.off("connect_error");
-                input?.signal?.removeEventListener("abort", onAbort);
-            };
-            const finish = (kind, value) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                if (kind === "resolve")
-                    resolveCompleted && resolveCompleted();
-                else
-                    rejectCompleted && rejectCompleted(value);
-                socket?.disconnect();
-            };
-            const onAbort = () => {
-                const abortError = new Error("Git linguist socket request was aborted.");
-                abortError.name = "AbortError";
-                finish("reject", abortError);
-            };
-            input?.signal?.addEventListener("abort", onAbort, { once: true });
-            const completed = new Promise((resolve, reject) => {
-                resolveCompleted = resolve;
-                rejectCompleted = reject;
-            });
-            void (async () => {
-                const repositoryBasePath = `/repositories/${encodePathSegment(repositoryKey)}`;
-                const requestPath = `${repositoryBasePath}/linguist/socket`;
-                const resolvedHeaders = mergeHeaders(await resolveHeaders(options.headers, {
-                    path: requestPath,
-                    repositoryKey,
-                }), input?.headers);
-                socket = connectSocket(url, {
-                    ...(options.socketOptions || {}),
-                    autoConnect: false,
-                    extraHeaders: {
-                        ...((options.socketOptions && options.socketOptions.extraHeaders) || {}),
-                        ...(resolvedHeaders || {}),
-                    },
-                    path,
-                    transports: (options.socketOptions && options.socketOptions.transports) || ["websocket"],
-                });
-                if (settled) {
-                    socket.disconnect();
-                    return;
-                }
-                socket.on("connect", () => {
-                    socket && socket.emit(LINGUIST_START_EVENT, {
-                        ref: input?.ref,
-                        repositoryKey,
-                    });
-                });
-                socket.on("connect_error", (error) => {
-                    finish("reject", error);
-                });
-                socket.on(LINGUIST_PROGRESS_EVENT, async (payload) => {
-                    const nextEvent = {
-                        progress: payload,
-                        type: "progress",
-                    };
-                    await input?.onProgress?.(nextEvent.progress);
-                    await input?.onEvent?.(nextEvent);
-                });
-                socket.on(LINGUIST_RESULT_EVENT, async (payload) => {
-                    const nextEvent = {
-                        ...payload,
-                        type: "result",
-                    };
-                    await input?.onResult?.(nextEvent);
-                    await input?.onEvent?.(nextEvent);
-                });
-                socket.on(LINGUIST_DONE_EVENT, async (payload) => {
-                    const nextEvent = {
-                        ...payload,
-                        type: "done",
-                    };
-                    await input?.onDone?.(nextEvent);
-                    await input?.onEvent?.(nextEvent);
-                    finish(nextEvent.ok === false ? "reject" : "resolve", nextEvent.ok === false
-                        ? new GitApiClientError({
-                            code: "git_api_error",
-                            message: "Git linguist socket ended without a successful result.",
-                            status: 500,
-                        })
-                        : undefined);
-                });
-                socket.on(LINGUIST_ERROR_EVENT, async (payload) => {
-                    const nextEvent = {
-                        ...payload,
-                        type: "error",
-                    };
-                    await input?.onError?.(nextEvent);
-                    await input?.onEvent?.(nextEvent);
-                    finish("reject", new GitApiClientError({
-                        code: nextEvent.error.code,
-                        details: nextEvent.error.details,
-                        message: nextEvent.error.message,
-                        status: nextEvent.status || 500,
-                    }));
-                });
-                socket.connect();
-            })().catch((error) => {
-                finish("reject", error);
-            });
-            return {
-                close() {
-                    onAbort();
-                },
-                completed,
-            };
-        },
-        openWorkflowRunSocket(repositoryKey, runId, input) {
-            const { path, url } = resolveSocketEndpoint(baseUrl, options.socketOptions && options.socketOptions.path);
-            let socket = null;
-            let settled = false;
-            let rejectCompleted = null;
-            let resolveCompleted = null;
-            const cleanup = () => {
-                socket?.off(ACTIONS_RUN_EVENT);
-                socket?.off(ACTIONS_RUN_DONE_EVENT);
-                socket?.off(ACTIONS_RUN_ERROR_EVENT);
-                socket?.off("connect");
-                socket?.off("connect_error");
-                input?.signal?.removeEventListener("abort", onAbort);
-            };
-            const finish = (kind, value) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                if (kind === "resolve")
-                    resolveCompleted && resolveCompleted();
-                else
-                    rejectCompleted && rejectCompleted(value);
-                socket?.disconnect();
-            };
-            const onAbort = () => {
-                const abortError = new Error("Git workflow run socket request was aborted.");
-                abortError.name = "AbortError";
-                finish("reject", abortError);
-            };
-            input?.signal?.addEventListener("abort", onAbort, { once: true });
-            const completed = new Promise((resolve, reject) => {
-                resolveCompleted = resolve;
-                rejectCompleted = reject;
-            });
-            void (async () => {
-                const repositoryBasePath = `/repositories/${encodePathSegment(repositoryKey)}`;
-                const requestPath = `${repositoryBasePath}/actions/runs/${encodePathSegment(runId)}/socket`;
-                const resolvedHeaders = mergeHeaders(await resolveHeaders(options.headers, {
-                    path: requestPath,
-                    repositoryKey,
-                }), input?.headers);
-                socket = connectSocket(url, {
-                    ...(options.socketOptions || {}),
-                    autoConnect: false,
-                    extraHeaders: {
-                        ...((options.socketOptions && options.socketOptions.extraHeaders) || {}),
-                        ...(resolvedHeaders || {}),
-                    },
-                    path,
-                    transports: (options.socketOptions && options.socketOptions.transports) || ["websocket"],
-                });
-                if (settled) {
-                    socket.disconnect();
-                    return;
-                }
-                socket.on("connect", () => {
-                    socket && socket.emit(ACTIONS_RUN_SUBSCRIBE_EVENT, {
-                        afterSequence: input?.afterSequence,
-                        repositoryKey,
-                        runId,
-                    });
-                });
-                socket.on("connect_error", (error) => {
-                    finish("reject", error);
-                });
-                socket.on(ACTIONS_RUN_EVENT, async (payload) => {
-                    await input?.onEvent?.(payload);
-                });
-                socket.on(ACTIONS_RUN_DONE_EVENT, async (payload) => {
-                    const nextEvent = {
-                        ...payload,
-                        type: "done",
-                    };
-                    await input?.onDone?.(nextEvent);
-                    await input?.onEvent?.(nextEvent);
-                    finish(nextEvent.ok === false ? "reject" : "resolve", nextEvent.ok === false
-                        ? new GitApiClientError({
-                            code: "git_api_error",
-                            message: "Git workflow run socket ended without a successful result.",
-                            status: 500,
-                        })
-                        : undefined);
-                });
-                socket.on(ACTIONS_RUN_ERROR_EVENT, async (payload) => {
-                    const nextEvent = {
-                        ...payload,
-                        type: "error",
-                    };
-                    await input?.onError?.(nextEvent);
-                    await input?.onEvent?.(nextEvent);
-                    finish("reject", new GitApiClientError({
-                        code: nextEvent.error.code,
-                        details: nextEvent.error.details,
-                        message: nextEvent.error.message,
-                        status: nextEvent.status || 500,
-                    }));
-                });
-                socket.connect();
-            })().catch((error) => {
-                finish("reject", error);
-            });
-            return {
-                close() {
-                    onAbort();
-                },
-                completed,
-            };
-        },
-        async readTag(repositoryKey, tagName, input) {
-            const response = await request(repositoryKey, `tags/${encodePathSegment(tagName)}`, input);
-            return response.data;
-        },
-        async readOverview(repositoryKey, input) {
-            const response = await request(repositoryKey, "overview", input);
-            return response.data;
-        },
-        async readRelease(repositoryKey, releaseId, input) {
-            const response = await request(repositoryKey, `releases/${encodePathSegment(releaseId)}`, input);
-            return response.data;
-        },
-        async readWorkflow(repositoryKey, workflowId, input) {
-            const response = await request(repositoryKey, `actions/${encodePathSegment(workflowId)}`, input);
-            return response.data;
-        },
-        async readWorkflowRun(repositoryKey, runId, input) {
-            const response = await request(repositoryKey, `actions/runs/${encodePathSegment(runId)}`, input);
-            return response.data;
-        },
-        async readSocialState(repositoryKey, input) {
-            const response = await request(repositoryKey, "social", input);
-            return response.data;
-        },
-        async readSummary(repositoryKey, input) {
-            const response = await request(repositoryKey, "summary", {
-                headers: input?.headers,
-                query: buildQuery({
-                    commitLimit: input?.commitLimit,
-                }),
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async createFork(repositoryKey, input) {
-            const response = await request(repositoryKey, "forks", {
-                body: {},
-                headers: input?.headers,
-                method: "POST",
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async createRelease(repositoryKey, input) {
-            const response = await request(repositoryKey, "releases", {
-                body: {
-                    assets: input.assets,
-                    createTag: input.createTag,
-                    draft: input.draft,
-                    existingTagName: input.existingTagName,
-                    notes: input.notes,
-                    prerelease: input.prerelease,
-                    publishedAt: input.publishedAt,
-                    title: input.title,
-                },
-                headers: input.headers,
-                method: "POST",
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        async updateRelease(repositoryKey, releaseId, input) {
-            const response = await request(repositoryKey, `releases/${encodePathSegment(releaseId)}`, {
-                body: {
-                    assets: input.assets,
-                    draft: input.draft,
-                    notes: input.notes,
-                    prerelease: input.prerelease,
-                    publishedAt: input.publishedAt,
-                    title: input.title,
-                },
-                headers: input.headers,
-                method: "PATCH",
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        async deleteRelease(repositoryKey, releaseId, input) {
-            const response = await request(repositoryKey, `releases/${encodePathSegment(releaseId)}`, {
-                body: {
-                    deleteTag: input?.deleteTag === true,
-                },
-                headers: input?.headers,
-                method: "DELETE",
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async starRepository(repositoryKey, input) {
-            const response = await request(repositoryKey, "stars", {
-                body: {},
-                headers: input?.headers,
-                method: "POST",
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async unstarRepository(repositoryKey, input) {
-            const response = await request(repositoryKey, "stars", {
-                body: {},
-                headers: input?.headers,
-                method: "DELETE",
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async watchRepository(repositoryKey, input) {
-            const response = await request(repositoryKey, "watch", {
-                body: {},
-                headers: input?.headers,
-                method: "POST",
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async unwatchRepository(repositoryKey, input) {
-            const response = await request(repositoryKey, "watch", {
-                body: {},
-                headers: input?.headers,
-                method: "DELETE",
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async syncFork(repositoryKey, forkId, input) {
-            const response = await request(repositoryKey, `forks/${encodePathSegment(forkId)}/sync`, {
-                body: {
-                    strategy: input?.strategy,
-                },
-                headers: input?.headers,
-                method: "POST",
-                signal: input?.signal,
-            });
-            return response.data;
-        },
-        async search(repositoryKey, input) {
-            const response = await request(repositoryKey, "search", {
-                headers: input.headers,
-                query: buildQuery({
-                    caseSensitive: input.caseSensitive,
-                    limit: input.limit,
-                    path: input.path,
-                    query: input.query,
-                    ref: input.ref,
-                    regexp: input.regexp,
-                }),
-                signal: input.signal,
-            });
-            return response.data;
-        },
-        request,
-    };
-}
-export { GitApiClientError, createGitApiClient };
-//# sourceMappingURL=client.js.map