renovate 44.115.2 → 44.115.4

package/dist/util/git/types.d.ts

@@ -4,19 +4,19 @@ import "../schema-utils/index.js";
 import { PlatformCommitOptions } from "../../config/types.js";
 import { StatusResult } from "simple-git";
 //#region lib/util/git/types.d.ts
-type GitNoVerifyOption = 'commit' | 'push';
+export type GitNoVerifyOption = 'commit' | 'push';
 /**
  * Represents a virtual branch tracked as `refs/remotes/origin/<name>`.
  * Used by platforms like Gerrit where changes are represented as refs
  * (e.g., refs/changes/34/1234/1) instead of regular branches.
  */
-interface VirtualBranch {
+export interface VirtualBranch {
   /** The ref this virtual branch is fetched from (e.g., 'refs/changes/34/1234/1') */
   ref: string;
   /** The commit SHA this virtual branch points to */
   sha: LongCommitSha;
 }
-interface StorageConfig {
+export interface StorageConfig {
   currentBranch?: string;
   defaultBranch?: string;
   url: string;
@@ -32,7 +32,7 @@ interface StorageConfig {
    */
   virtualBranches?: Record<string, VirtualBranch>;
 }
-interface FileAddition {
+export interface FileAddition {
   /**
    * Addition creates new file or modifies existing one
    */
@@ -51,7 +51,7 @@ interface FileAddition {
   isExecutable?: boolean;
   isSymlink?: boolean;
 }
-interface FileDeletion {
+export interface FileDeletion {
   /**
    * Deletion removes the file
    */
@@ -61,8 +61,8 @@ interface FileDeletion {
    */
   path: string;
 }
-type FileChange = FileAddition | FileDeletion;
-interface CommitFilesConfig {
+export type FileChange = FileAddition | FileDeletion;
+export interface CommitFilesConfig {
   baseBranch?: string;
   branchName: string;
   files: FileChange[];
@@ -76,25 +76,25 @@ interface CommitFilesConfig {
   /** Only needed by Gerrit platform */
   autoApprove?: boolean;
 }
-interface PushFilesConfig {
+export interface PushFilesConfig {
   sourceRef: string;
   targetRef?: string;
   files: FileChange[];
   pushOptions?: string[];
 }
-interface CommitResult {
+export interface CommitResult {
   parentCommitSha: LongCommitSha;
   commitSha: LongCommitSha;
   files: FileChange[];
 }
-type GitObjectType = 'blob' | 'tree' | 'commit';
-interface DiffTreeItem {
+export type GitObjectType = 'blob' | 'tree' | 'commit';
+export interface DiffTreeItem {
   path: string;
   mode: string;
   type: GitObjectType;
   sha: LongCommitSha | null;
 }
-type GitOperationType =
+export type GitOperationType =
 /**
  * The `git clone` sub-command.
  */
@@ -164,5 +164,5 @@ type GitOperationType =
  */
 'other';
 //#endregion
-export { CommitFilesConfig, CommitResult, DiffTreeItem, FileAddition, FileChange, FileDeletion, GitNoVerifyOption, GitObjectType, GitOperationType, PushFilesConfig, type StatusResult, StorageConfig, VirtualBranch };
+export type { StatusResult };
 //# sourceMappingURL=types.d.ts.map

package/dist/util/host-rules.d.ts

@@ -6,15 +6,15 @@ import "../types/index.js";
  *
  * Kept in sync with `redactedFields` through tests.
  */
-declare const confidentialFields: (keyof HostRule)[];
-interface LegacyHostRule {
+export declare const confidentialFields: (keyof HostRule)[];
+export interface LegacyHostRule {
   hostName?: string;
   domainName?: string;
   baseUrl?: string;
   host?: string;
   endpoint?: string;
 }
-declare function migrateRule(rule: LegacyHostRule & HostRule): HostRule;
+export declare function migrateRule(rule: LegacyHostRule & HostRule): HostRule;
 /**
  * Enforce the `allowedHeaders` allowlist on a set of host rules.
  *
@@ -27,8 +27,8 @@ declare function migrateRule(rule: LegacyHostRule & HostRule): HostRule;
  *
  * Headers that survive this allowlist are still subject to how {@link find} combines them: an admin's headers for a host are applied over those of any repository or preset rule matching the same request, so a repository can neither drop nor substitute them.
  */
-declare function filterAllowedHeaders(rules: HostRule[], allowedHeaders?: string[], warnOnDenied?: boolean): HostRule[];
-interface AddHostRuleOptions {
+export declare function filterAllowedHeaders(rules: HostRule[], allowedHeaders?: string[], warnOnDenied?: boolean): HostRule[];
+export interface AddHostRuleOptions {
   /** the effective allowlist. Defaults to `GlobalConfig`; pass it explicitly when `GlobalConfig` does not yet reflect the repository the rule is registered for */
   allowedHeaders?: string[];
   /**
@@ -44,28 +44,27 @@ interface AddHostRuleOptions {
    */
   inherited?: boolean;
 }
-declare function add(params: HostRule, options?: AddHostRuleOptions): void;
-interface HostRuleSearch {
+export declare function add(params: HostRule, options?: AddHostRuleOptions): void;
+export interface HostRuleSearch {
   hostType?: string;
   url?: string;
   readOnly?: boolean;
 }
-declare function matchesHost(url: string, matchHost: string): boolean;
-declare function find(search: HostRuleSearch): CombinedHostRule;
-declare function hosts({ hostType }: {
+export declare function matchesHost(url: string, matchHost: string): boolean;
+export declare function find(search: HostRuleSearch): CombinedHostRule;
+export declare function hosts({ hostType }: {
   hostType: string;
 }): string[];
-declare function hostType({ url }: {
+export declare function hostType({ url }: {
   url: string;
 }): string | null;
-declare function findAll({ hostType }: {
+export declare function findAll({ hostType }: {
   hostType: string;
 }): HostRule[];
 /**
  * @returns a deep copy of all known host rules without any filtering
  */
-declare function getAll(): HostRule[];
-declare function clear(): void;
+export declare function getAll(): HostRule[];
+export declare function clear(): void;
 //#endregion
-export { AddHostRuleOptions, HostRuleSearch, LegacyHostRule, add, clear, confidentialFields, filterAllowedHeaders, find, findAll, getAll, hostType, hosts, matchesHost, migrateRule };
 //# sourceMappingURL=host-rules.d.ts.map

package/dist/util/http/cache/types.d.ts

@@ -1,10 +1,9 @@
 import { GotOptions, HttpResponse } from "../types.js";
 //#region lib/util/http/cache/types.d.ts
-interface HttpCacheProvider {
+export interface HttpCacheProvider {
   setCacheHeaders<T extends Pick<GotOptions, 'headers'>>(method: string, url: string, opts: T): Promise<void>;
   bypassServer<T>(method: string, url: string, ignoreSoftTtl?: boolean): Promise<HttpResponse<T> | null>;
   wrapServerResponse<T>(method: string, url: string, resp: HttpResponse<T>): Promise<HttpResponse<T>>;
 }
 //#endregion
-export { HttpCacheProvider };
 //# sourceMappingURL=types.d.ts.map

package/dist/util/http/errors.d.ts

@@ -1,5 +1,4 @@
 //#region lib/util/http/errors.d.ts
-declare class EmptyResultError extends Error {}
+export declare class EmptyResultError extends Error {}
 //#endregion
-export { EmptyResultError };
 //# sourceMappingURL=errors.d.ts.map

package/dist/util/http/github.d.ts

@@ -2,16 +2,16 @@ import { GraphqlOptions, HttpMethod, HttpOptions, HttpResponse } from "./types.j
 import { HttpBase, InternalHttpOptions, InternalJsonUnsafeOptions } from "./http.js";
 import { GotLegacyError } from "./legacy.js";
 //#region lib/util/http/github.d.ts
-declare function setBaseUrl(url: string): void;
-interface GithubBaseHttpOptions extends HttpOptions {
+export declare function setBaseUrl(url: string): void;
+export interface GithubBaseHttpOptions extends HttpOptions {
   repository?: string;
 }
-interface GithubHttpOptions extends GithubBaseHttpOptions {
+export interface GithubHttpOptions extends GithubBaseHttpOptions {
   paginate?: boolean | string;
   paginationField?: string;
   pageLimit?: number;
 }
-type GithubGraphqlResponse<T = unknown> = {
+export type GithubGraphqlResponse<T = unknown> = {
   data: T;
   errors?: never;
 } | {
@@ -26,8 +26,8 @@ interface GraphqlPageCacheItem {
   pageLastResizedAt: string;
   pageSize: number;
 }
-type GraphqlPageCache = Record<string, GraphqlPageCacheItem>;
-declare class GithubHttp extends HttpBase<GithubHttpOptions> {
+export type GraphqlPageCache = Record<string, GraphqlPageCacheItem>;
+export declare class GithubHttp extends HttpBase<GithubHttpOptions> {
   protected get baseUrl(): string | undefined;
   constructor(hostType?: string, options?: HttpOptions);
   protected extraOptions(): readonly string[];
@@ -50,5 +50,4 @@ declare class GithubHttp extends HttpBase<GithubHttpOptions> {
   getRawTextFile(url: string, options?: InternalHttpOptions & GithubBaseHttpOptions): Promise<HttpResponse>;
 }
 //#endregion
-export { GithubBaseHttpOptions, GithubGraphqlResponse, GithubHttp, GithubHttpOptions, GraphqlPageCache, setBaseUrl };
 //# sourceMappingURL=github.d.ts.map

package/dist/util/http/gitlab.d.ts

@@ -2,11 +2,11 @@ import { HttpMethod, HttpOptions, HttpResponse } from "./types.js";
 import { HttpBase, InternalJsonUnsafeOptions } from "./http.js";
 import { RetryObject } from "got";
 //#region lib/util/http/gitlab.d.ts
-declare function setBaseUrl(url: string): void;
-interface GitlabHttpOptions extends HttpOptions {
+export declare function setBaseUrl(url: string): void;
+export interface GitlabHttpOptions extends HttpOptions {
   paginate?: boolean;
 }
-declare class GitlabHttp extends HttpBase<GitlabHttpOptions> {
+export declare class GitlabHttp extends HttpBase<GitlabHttpOptions> {
   protected get baseUrl(): string | undefined;
   constructor(type?: string, options?: GitlabHttpOptions);
   protected extraOptions(): readonly string[];
@@ -15,5 +15,4 @@ declare class GitlabHttp extends HttpBase<GitlabHttpOptions> {
   protected calculateRetryDelay(retryObject: RetryObject): number;
 }
 //#endregion
-export { GitlabHttp, GitlabHttpOptions, setBaseUrl };
 //# sourceMappingURL=gitlab.d.ts.map

package/dist/util/http/http.d.ts

@@ -4,16 +4,16 @@ import { Options, OptionsInit, RetryObject } from "got";
 import { ZodType, z } from "zod/v4";
 import "type-fest";
 //#region lib/util/http/http.d.ts
-interface InternalJsonUnsafeOptions<Opts extends HttpOptions = HttpOptions> {
+export interface InternalJsonUnsafeOptions<Opts extends HttpOptions = HttpOptions> {
   url: string | URL;
   httpOptions?: Opts;
 }
-interface InternalHttpOptions extends HttpOptions {
+export interface InternalHttpOptions extends HttpOptions {
   json?: HttpOptions['body'];
   method?: HttpMethod;
   parseJson?: Options['parseJson'];
 }
-declare abstract class HttpBase<JSONOpts extends HttpOptions = HttpOptions, Opts extends HttpOptions = HttpOptions> {
+export declare abstract class HttpBase<JSONOpts extends HttpOptions = HttpOptions, Opts extends HttpOptions = HttpOptions> {
   private readonly options;
   protected get baseUrl(): string | undefined;
   protected hostType: string;
@@ -104,5 +104,4 @@ declare abstract class HttpBase<JSONOpts extends HttpOptions = HttpOptions, Opts
   getToml<Schema extends ZodType<any, any, any>>(url: string, options: JSONOpts, schema: Schema): Promise<HttpResponse<z.infer<Schema>>>;
 }
 //#endregion
-export { HttpBase, InternalHttpOptions, InternalJsonUnsafeOptions };
 //# sourceMappingURL=http.d.ts.map

package/dist/util/http/legacy.d.ts

@@ -1,6 +1,6 @@
 import { RequestError } from "got";
 //#region lib/util/http/legacy.d.ts
-type GotLegacyError<E = unknown, T = unknown> = RequestError & {
+export type GotLegacyError<E = unknown, T = unknown> = RequestError & {
   statusCode?: number;
   body: {
     message?: string;
@@ -9,5 +9,4 @@ type GotLegacyError<E = unknown, T = unknown> = RequestError & {
   headers?: Record<string, T>;
 };
 //#endregion
-export { GotLegacyError };
 //# sourceMappingURL=legacy.d.ts.map

package/dist/util/http/types.d.ts

@@ -4,18 +4,18 @@ import { OptionsInit, OptionsOfBufferResponseBody, OptionsOfJSONResponseBody, Op
 import { ZodError } from "zod/v4";
 import { IncomingHttpHeaders } from "node:http";
 //#region lib/util/http/types.d.ts
-type GotContextOptions = {
+export type GotContextOptions = {
   authType?: string;
 } & Record<string, unknown>;
-type GotOptions = GotBufferOptions | GotTextOptions | GotJSONOptions;
-type GotBufferOptions = OptionsOfBufferResponseBody & GotExtraOptions;
-type GotTextOptions = OptionsOfTextResponseBody & GotExtraOptions;
-type GotJSONOptions = OptionsOfJSONResponseBody & GotExtraOptions;
-type GotStreamOptions = OptionsInit & GotExtraOptions;
+export type GotOptions = GotBufferOptions | GotTextOptions | GotJSONOptions;
+export type GotBufferOptions = OptionsOfBufferResponseBody & GotExtraOptions;
+export type GotTextOptions = OptionsOfTextResponseBody & GotExtraOptions;
+export type GotJSONOptions = OptionsOfJSONResponseBody & GotExtraOptions;
+export type GotStreamOptions = OptionsInit & GotExtraOptions;
 /**
  * Renovate extra options.
  */
-interface GotExtraOptions {
+export interface GotExtraOptions {
   abortOnError?: boolean;
   abortIgnoreStatusCodes?: number[];
   token?: string;
@@ -33,10 +33,10 @@ interface GotExtraOptions {
 /**
  * Renovate extra options that are not part of `got` options.
  */
-declare const GotExtraOptionKeys: (keyof GotExtraOptions)[];
-type OutgoingHttpHeaders = Record<string, string | string[] | undefined>;
-type GraphqlVariables = Record<string, unknown>;
-interface GraphqlOptions {
+export declare const GotExtraOptionKeys: (keyof GotExtraOptions)[];
+export type OutgoingHttpHeaders = Record<string, string | string[] | undefined>;
+export type GraphqlVariables = Record<string, unknown>;
+export interface GraphqlOptions {
   variables?: GraphqlVariables;
   paginate?: boolean;
   count?: number;
@@ -50,7 +50,7 @@ interface GraphqlOptions {
  * Renovate http options that are partly not part of `got` options.
  * Remember to delete these in `normalizeGotOptions` before passing to `got`.
  */
-interface HttpOptions {
+export interface HttpOptions {
   body?: any;
   username?: string;
   password?: string;
@@ -72,28 +72,27 @@ interface HttpOptions {
    */
   responseBecomesConfig?: boolean;
 }
-interface HttpHeaders extends IncomingHttpHeaders {
+export interface HttpHeaders extends IncomingHttpHeaders {
   link?: string | undefined;
 }
-type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head';
-interface HttpResponse<T = string> {
+export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head';
+export interface HttpResponse<T = string> {
   statusCode: number;
   body: T;
   headers: HttpHeaders;
   authorization?: boolean;
   cached?: boolean;
 }
-type Task<T> = () => Promise<T>;
-type GotTask<T = unknown> = Task<HttpResponse<T>>;
-interface ThrottleLimitRule {
+export type Task<T> = () => Promise<T>;
+export type GotTask<T = unknown> = Task<HttpResponse<T>>;
+export interface ThrottleLimitRule {
   matchHost: string;
   throttleMs: number;
 }
-interface ConcurrencyLimitRule {
+export interface ConcurrencyLimitRule {
   matchHost: string;
   concurrency: number;
 }
-type SafeJsonError = RequestError | ZodError | EmptyResultError;
+export type SafeJsonError = RequestError | ZodError | EmptyResultError;
 //#endregion
-export { ConcurrencyLimitRule, GotBufferOptions, GotContextOptions, GotExtraOptionKeys, GotExtraOptions, GotJSONOptions, GotOptions, GotStreamOptions, GotTask, GotTextOptions, GraphqlOptions, GraphqlVariables, HttpHeaders, HttpMethod, HttpOptions, HttpResponse, OutgoingHttpHeaders, SafeJsonError, Task, ThrottleLimitRule };
 //# sourceMappingURL=types.d.ts.map

package/dist/util/merge-confidence/common.d.ts

@@ -1,5 +1,4 @@
 //#region lib/util/merge-confidence/common.d.ts
-declare const MERGE_CONFIDENCE: readonly ['low', 'neutral', 'high', 'very high'];
+export declare const MERGE_CONFIDENCE: readonly ['low', 'neutral', 'high', 'very high'];
 //#endregion
-export { MERGE_CONFIDENCE };
 //# sourceMappingURL=common.d.ts.map

package/dist/util/merge-confidence/types.d.ts

@@ -1,6 +1,5 @@
 import { MERGE_CONFIDENCE } from "./common.js";
 //#region lib/util/merge-confidence/types.d.ts
-type MergeConfidence = (typeof MERGE_CONFIDENCE)[number];
+export type MergeConfidence = (typeof MERGE_CONFIDENCE)[number];
 //#endregion
-export { MergeConfidence };
 //# sourceMappingURL=types.d.ts.map

package/dist/util/result.d.ts

@@ -32,7 +32,7 @@ type RawValue<T extends Val> = Exclude<T, ZodSafeParseResult<T> | Promise<unknow
  * - `.transform()` are pipes which can be chained
  * - `.unwrap()` is the point of consumption
  */
-declare class Result<T extends Val, E extends Val = Error> {
+export declare class Result<T extends Val, E extends Val = Error> {
   private readonly res;
   private constructor();
   static ok<T extends Val>(val: T): Result<T, never>;
@@ -217,7 +217,7 @@ declare class Result<T extends Val, E extends Val = Error> {
  *
  * All the methods resemble `Result` methods, but work asynchronously.
  */
-declare class AsyncResult<T extends Val, E extends Val> implements PromiseLike<Result<T, E>> {
+export declare class AsyncResult<T extends Val, E extends Val> implements PromiseLike<Result<T, E>> {
   private asyncResult;
   private constructor();
   then<TResult1 = Result<T, E>>(onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null): PromiseLike<TResult1>;
@@ -295,5 +295,4 @@ declare class AsyncResult<T extends Val, E extends Val> implements PromiseLike<R
   onError(fn: (err: E) => void): AsyncResult<T, E>;
 }
 //#endregion
-export { AsyncResult, Result };
 //# sourceMappingURL=result.d.ts.map

package/dist/util/s3.d.ts

@@ -1,11 +1,10 @@
 import { S3Client, S3ClientConfig } from "@aws-sdk/client-s3";
 //#region lib/util/s3.d.ts
-declare function getS3Client(s3Endpoint?: string, s3PathStyle?: boolean, credentials?: S3ClientConfig['credentials']): S3Client;
-interface S3UrlParts {
+export declare function getS3Client(s3Endpoint?: string, s3PathStyle?: boolean, credentials?: S3ClientConfig['credentials']): S3Client;
+export interface S3UrlParts {
   Bucket: string;
   Key: string;
 }
-declare function parseS3Url(rawUrl: URL | string): S3UrlParts | null;
+export declare function parseS3Url(rawUrl: URL | string): S3UrlParts | null;
 //#endregion
-export { S3UrlParts, getS3Client, parseS3Url };
 //# sourceMappingURL=s3.d.ts.map

package/dist/util/schema-utils/git.d.ts

@@ -1,7 +1,6 @@
 import { z } from "zod/v4";
 //#region lib/util/schema-utils/git.d.ts
-declare const LongCommitSha: z.core.$ZodBranded<z.ZodString, "LongCommitSha", "out">;
-type LongCommitSha = z.infer<typeof LongCommitSha>;
+export declare const LongCommitSha: z.core.$ZodBranded<z.ZodString, "LongCommitSha", "out">;
+export type LongCommitSha = z.infer<typeof LongCommitSha>;
 //#endregion
-export { LongCommitSha };
 //# sourceMappingURL=git.d.ts.map

package/dist/util/string-match.d.ts

@@ -1,13 +1,12 @@
 //#region lib/util/string-match.d.ts
-type StringMatchPredicate = (s: string) => boolean;
-declare function isDockerDigest(input: string): boolean;
-declare function getRegexOrGlobPredicate(pattern: string): StringMatchPredicate;
-declare function matchRegexOrGlob(input: string, pattern: string): boolean;
-declare function matchRegexOrGlobList(input: string, patterns: string[]): boolean;
-declare function anyMatchRegexOrGlobList(inputs: string[], patterns: string[]): boolean;
-declare const UUIDRegex: RegExp;
-declare function isRegexMatch(input: unknown): input is string;
-declare function getRegexPredicate(input: string): StringMatchPredicate | null;
+export type StringMatchPredicate = (s: string) => boolean;
+export declare function isDockerDigest(input: string): boolean;
+export declare function getRegexOrGlobPredicate(pattern: string): StringMatchPredicate;
+export declare function matchRegexOrGlob(input: string, pattern: string): boolean;
+export declare function matchRegexOrGlobList(input: string, patterns: string[]): boolean;
+export declare function anyMatchRegexOrGlobList(inputs: string[], patterns: string[]): boolean;
+export declare const UUIDRegex: RegExp;
+export declare function isRegexMatch(input: unknown): input is string;
+export declare function getRegexPredicate(input: string): StringMatchPredicate | null;
 //#endregion
-export { StringMatchPredicate, UUIDRegex, anyMatchRegexOrGlobList, getRegexOrGlobPredicate, getRegexPredicate, isDockerDigest, isRegexMatch, matchRegexOrGlob, matchRegexOrGlobList };
 //# sourceMappingURL=string-match.d.ts.map

package/dist/util/timestamp.d.ts

@@ -1,11 +1,10 @@
 import { z } from "zod/v4";
 //#region lib/util/timestamp.d.ts
-type Timestamp = string & {
+export type Timestamp = string & {
   __timestamp: never;
 };
-declare function asTimestamp(input: unknown): Timestamp | null;
-declare const Timestamp: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Timestamp, unknown>>;
-declare const MaybeTimestamp: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodUnknown, z.ZodTransform<Timestamp, unknown>>>>;
+export declare function asTimestamp(input: unknown): Timestamp | null;
+export declare const Timestamp: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Timestamp, unknown>>;
+export declare const MaybeTimestamp: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodUnknown, z.ZodTransform<Timestamp, unknown>>>>;
 //#endregion
-export { MaybeTimestamp, Timestamp, asTimestamp };
 //# sourceMappingURL=timestamp.d.ts.map

package/dist/util/url.d.ts

@@ -1,25 +1,25 @@
 import _parseLinkHeader from "parse-link-header";
 //#region lib/util/url.d.ts
-declare function joinUrlParts(...parts: string[]): string;
-declare function ensurePathPrefix(url: string, prefix: string): string;
-declare function ensureTrailingSlash(url: string): string;
-declare function trimTrailingSlash(url: string): string;
-declare function trimLeadingSlash(path: string): string;
-declare function trimSlashes(path: string): string;
+export declare function joinUrlParts(...parts: string[]): string;
+export declare function ensurePathPrefix(url: string, prefix: string): string;
+export declare function ensureTrailingSlash(url: string): string;
+export declare function trimTrailingSlash(url: string): string;
+export declare function trimLeadingSlash(path: string): string;
+export declare function trimSlashes(path: string): string;
 /**
  * Resolves an input path against a base URL
  *
  * @param baseUrl - base URL to resolve against
  * @param input - input path (if this is a full URL, it will be returned)
  */
-declare function resolveBaseUrl(baseUrl: string, input: string | URL): string;
+export declare function resolveBaseUrl(baseUrl: string, input: string | URL): string;
 /**
  * Replaces the path of a URL with a new path
  *
  * @param baseUrl - source URL
  * @param path - replacement path (if this is a full URL, it will be returned)
  */
-declare function replaceUrlPath(baseUrl: string | URL, path: string): string;
+export declare function replaceUrlPath(baseUrl: string | URL, path: string): string;
 /**
  * Resolves a server-provided pagination "next" URL against the current request
  * URL, returning it only when it stays on the same origin.
@@ -35,16 +35,16 @@ declare function replaceUrlPath(baseUrl: string | URL, path: string): string;
  * @param nextUrl - the remote-server-provided pagination target (may be relative, and may be malicious)
  * @returns the resolved absolute URL if same-origin, otherwise `null`
  */
-declare function resolveSameOriginUrl(baseUrl: string | URL, nextUrl: string | URL): string | null;
-declare function getQueryString(params: Record<string, any>): string;
-declare function isHttpUrl(url: unknown): boolean;
-declare function parseUrl(url: URL | string | undefined | null): URL | null;
+export declare function resolveSameOriginUrl(baseUrl: string | URL, nextUrl: string | URL): string | null;
+export declare function getQueryString(params: Record<string, any>): string;
+export declare function isHttpUrl(url: unknown): boolean;
+export declare function parseUrl(url: URL | string | undefined | null): URL | null;
 /**
  * Tries to create an URL object from either a full URL string or a hostname
  * @param url either the full url or a hostname
  * @returns an URL object or null
  */
-declare function createURLFromHostOrURL(url: string): URL | null;
+export declare function createURLFromHostOrURL(url: string): URL | null;
 /**
  * Removes the `user:password@` userinfo from a URL.
  *
@@ -52,14 +52,13 @@ declare function createURLFromHostOrURL(url: string): URL | null;
  *
  * @returns the URL's `href` without userinfo, or `null` if `url` cannot be parsed
  */
-declare function stripUrlCredentials(url: URL): string;
-declare function stripUrlCredentials(url: string | URL): string | null;
-type LinkHeaderLinks = _parseLinkHeader.Links;
-declare function parseLinkHeader(linkHeader: string | null | undefined): LinkHeaderLinks | null;
+export declare function stripUrlCredentials(url: URL): string;
+export declare function stripUrlCredentials(url: string | URL): string | null;
+export type LinkHeaderLinks = _parseLinkHeader.Links;
+export declare function parseLinkHeader(linkHeader: string | null | undefined): LinkHeaderLinks | null;
 /**
  * prefix https:// to hosts with port or path
  */
-declare function massageHostUrl(url: string): string;
+export declare function massageHostUrl(url: string): string;
 //#endregion
-export { LinkHeaderLinks, createURLFromHostOrURL, ensurePathPrefix, ensureTrailingSlash, getQueryString, isHttpUrl, joinUrlParts, massageHostUrl, parseLinkHeader, parseUrl, replaceUrlPath, resolveBaseUrl, resolveSameOriginUrl, stripUrlCredentials, trimLeadingSlash, trimSlashes, trimTrailingSlash };
 //# sourceMappingURL=url.d.ts.map

package/dist/versioning-list.generated.d.ts

@@ -1,6 +1,5 @@
 //#region lib/versioning-list.generated.d.ts
-declare const AllVersioningsListLiteral: readonly ["apk", "aws-eks-addon", "aws-machine-image", "azure-rest-api", "bazel-module", "cargo", "composer", "conan", "conda", "deb", "debian", "deno", "devbox", "docker", "elm", "exact", "git", "github-actions", "glasskube", "go-mod-directive", "gradle", "hashicorp", "helm", "hermit", "hex", "ivy", "kubernetes-api", "lambda-node", "loose", "maven", "nixpkgs", "node", "npm", "nuget", "paket", "pep440", "perl", "poetry", "pvp", "python", "redhat", "regex", "rez", "rpm", "ruby", "rust-release-channel", "same-major", "semver", "semver-coerced", "semver-partial", "swift", "ubuntu", "unity3d", "unity3d-packages"];
-type VersioningName = typeof AllVersioningsListLiteral[number];
+export declare const AllVersioningsListLiteral: readonly ["apk", "aws-eks-addon", "aws-machine-image", "azure-rest-api", "bazel-module", "cargo", "composer", "conan", "conda", "deb", "debian", "deno", "devbox", "docker", "elm", "exact", "git", "github-actions", "glasskube", "go-mod-directive", "gradle", "hashicorp", "helm", "hermit", "hex", "ivy", "kubernetes-api", "lambda-node", "loose", "maven", "nixpkgs", "node", "npm", "nuget", "paket", "pep440", "perl", "poetry", "pvp", "python", "redhat", "regex", "rez", "rpm", "ruby", "rust-release-channel", "same-major", "semver", "semver-coerced", "semver-partial", "swift", "ubuntu", "unity3d", "unity3d-packages"];
+export type VersioningName = typeof AllVersioningsListLiteral[number];
 //#endregion
-export { AllVersioningsListLiteral, VersioningName };
 //# sourceMappingURL=versioning-list.generated.d.ts.map

package/dist/workers/global/autodiscover.d.ts

@@ -1,7 +1,6 @@
 import { AllConfig } from "../../config/types.js";
 //#region lib/workers/global/autodiscover.d.ts
-declare function autodiscoverRepositories(config: AllConfig): Promise<AllConfig>;
-declare function applyFilters(repos: string[], filters: string[]): string[];
+export declare function autodiscoverRepositories(config: AllConfig): Promise<AllConfig>;
+export declare function applyFilters(repos: string[], filters: string[]): string[];
 //#endregion
-export { applyFilters, autodiscoverRepositories };
 //# sourceMappingURL=autodiscover.d.ts.map

package/dist/workers/global/config/parse/index.d.ts

@@ -1,7 +1,6 @@
 import { AllConfig } from "../../../../config/types.js";
 //#region lib/workers/global/config/parse/index.d.ts
-declare function resolveGlobalExtends(globalExtends: string[], ignorePresets?: string[]): Promise<AllConfig>;
-declare function parseConfigs(env: NodeJS.ProcessEnv, argv: string[]): Promise<AllConfig>;
+export declare function resolveGlobalExtends(globalExtends: string[], ignorePresets?: string[]): Promise<AllConfig>;
+export declare function parseConfigs(env: NodeJS.ProcessEnv, argv: string[]): Promise<AllConfig>;
 //#endregion
-export { parseConfigs, resolveGlobalExtends };
 //# sourceMappingURL=index.d.ts.map

package/dist/workers/repository/init/types.d.ts

@@ -1,18 +1,17 @@
 import "../../../config/types.js";
 //#region lib/workers/repository/init/types.d.ts
-interface RepoConfigError {
+export interface RepoConfigError {
   validationError: string;
   validationMessage: string;
 }
-interface RepoFileConfig {
+export interface RepoFileConfig {
   configFileName?: string;
   configFileParsed?: any;
   configFileParseError?: RepoConfigError;
 }
-interface RepoInitConfig {
+export interface RepoInitConfig {
   defaultBranchSha?: string;
   repoConfig?: RepoFileConfig;
 }
 //#endregion
-export { RepoConfigError, RepoFileConfig, RepoInitConfig };
 //# sourceMappingURL=types.d.ts.map

package/dist/workers/repository/result.d.ts

@@ -1,7 +1,7 @@
 import { ConfigErrors, EXTERNAL_HOST_ERROR, MANAGER_LOCKFILE_ERROR, MISSING_API_CREDENTIALS, PlatformErrors, RepositoryErrors, SystemErrors, TemporaryErrors, UNKNOWN_ERROR } from "../../constants/error-messages.js";
 import { RenovateConfig } from "../../config/types.js";
 //#region lib/workers/repository/result.d.ts
-type ProcessStatus =
+export type ProcessStatus =
 /**
  * The repository has been disabled, and will not be processed.
  *
@@ -24,7 +24,7 @@ type ProcessStatus =
  * The repository has an onboarding PR from Renovate that has not yet been reviewed and merged.
  */
 'onboarding' | 'unknown';
-interface ProcessResult {
+export interface ProcessResult {
   res: RepositoryResult;
   status: ProcessStatus;
   enabled: boolean | undefined;
@@ -33,14 +33,13 @@ interface ProcessResult {
   exitCode: number;
 }
 /** a strong type for any repository result status that Renovate may report */
-type RepositoryResult =
+export type RepositoryResult =
 /** repository was processed successfully */
 'done' |
 /** Renovate performed branch-based automerge on one branch during its run */
 'automerged' |
 /** the repository is not yet onboarded, and its onboarding PR was processed during this run */
 'onboarding' | (typeof SystemErrors)[number] | (typeof RepositoryErrors)[number] | (typeof TemporaryErrors)[number] | (typeof ConfigErrors)[number] | (typeof PlatformErrors)[number] | typeof EXTERNAL_HOST_ERROR | typeof MISSING_API_CREDENTIALS | typeof MANAGER_LOCKFILE_ERROR | typeof UNKNOWN_ERROR;
-declare function processResult(config: RenovateConfig, res: RepositoryResult): ProcessResult;
+export declare function processResult(config: RenovateConfig, res: RepositoryResult): ProcessResult;
 //#endregion
-export { ProcessResult, ProcessStatus, RepositoryResult, processResult };
 //# sourceMappingURL=result.d.ts.map