@trebired/git-host 1.7.0 → 2.0.0

package/dist/internal/react/client.js

@@ -0,0 +1,744 @@
+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