@nightintelligence/cloudflare-workers-utils 0.35.0-patch1

package/dist/index.d.mts

@@ -0,0 +1,1263 @@
+import { C as ComputedFields, B as Binding, R as RawConfig, b as Config, E as Exports, D as DurableObjectExport, W as WorkerEntrypointExport, c as ContainerApp, d as WorkerMetadataBinding, e as CfTailConsumer, L as Logger, f as Route } from './compliance-j3-tqeao.mjs';
+export { A as ARTIFACTS_EVENT_TYPES, g as Access, h as ApiCredentials, i as ArtifactsEventTrigger, j as ArtifactsEventType, k as AssetConfigMetadata, l as Assets, m as AssetsOptions, n as AsyncHook, o as BinaryFile, p as COMPLIANCE_REGION_CONFIG_PUBLIC, q as COMPLIANCE_REGION_CONFIG_UNKNOWN, r as CacheOptions, s as CfAIBinding, t as CfAISearch, u as CfAISearchNamespace, v as CfAccount, w as CfAgentMemory, x as CfAnalyticsEngineDataset, y as CfArtifacts, z as CfAssetsBinding, F as CfBrowserBinding, G as CfCapnp, H as CfD1Database, I as CfDataBlobBindings, J as CfDevPluginCfg, K as CfDispatchNamespace, M as CfDurableObject, N as CfDurableObjectMigrations, O as CfExports, P as CfFlagship, Q as CfHelloWorld, S as CfHyperdrive, T as CfImagesBinding, U as CfKvNamespace, V as CfLogfwdr, X as CfLogfwdrBinding, Y as CfMTlsCertificate, Z as CfMediaBinding, _ as CfModule, $ as CfModuleType, a0 as CfPipeline, a1 as CfPlacement, a2 as CfQueue, a3 as CfR2Bucket, a4 as CfRateLimit, a5 as CfScriptFormat, a6 as CfSecretsStoreSecrets, a7 as CfSendEmailBindings, a8 as CfService, a9 as CfStreamBinding, aa as CfTextBlobBindings, ab as CfUnsafe, ac as CfUnsafeBinding, ad as CfUserLimits, ae as CfVars, af as CfVectorize, ag as CfVersionMetadataBinding, ah as CfVpcNetwork, ai as CfVpcService, aj as CfWasmModuleBindings, ak as CfWebSearch, al as CfWorkerContext, am as CfWorkerInit, an as CfWorkerLoader, ao as CfWorkerSourceMap, ap as CfWorkflow, aq as CloudchamberConfig, ar as ComplianceConfig, as as ConfigFields, at as ConfigModuleRuleType, au as ConfiguredExport, av as ContainerEngine, aw as CustomDomainRoute, ax as DispatchNamespaceOutbound, ay as DockerConfiguration, az as DurableObjectBindings, aA as DurableObjectExportStorage, aB as DurableObjectMigration, aC as ENVIRONMENT_TAG_PREFIX, aD as Entry, aE as Environment, aF as EnvironmentNonInheritable, aG as ExportsReconciliationEntryBase, aH as ExportsReconciliationErrorDetail, aI as ExportsReconciliationInfo, aJ as ExportsReconciliationRename, aK as ExportsReconciliationResult, aL as ExportsReconciliationTransfer, aM as ExportsReconciliationTransferPending, aN as ExportsReconciliationWarning, aO as FetchKVGetValueFetcher, aP as FetchListResultFetcher, aQ as FetchPagedListResultFetcher, aR as FetchResult, aS as FetchResultFetcher, aT as File, aU as Hook, aV as HookValues, aW as INHERIT_SYMBOL, aX as JSON_CONFIG_FORMATS, aY as Json, aZ as LOGGER_LEVELS, a_ as LegacyAssetPaths, a$ as LocalS3Credentials, b0 as LogLevel, b1 as LoggerLevel, b2 as NodeJSCompatMode, b3 as Observability, b4 as PATH_TO_DEPLOY_CONFIG, b5 as PreviewsConfig, b6 as RawDevConfig, b7 as RawEnvironment, a as RedirectedRawConfig, b8 as Rule, b9 as SERVICE_TAG_PREFIX, ba as ServiceFetch, bb as ServiceMetadataRes, bc as StartDevWorkerInput, bd as StreamingTailConsumer, be as TailConsumer, bf as Trigger, bg as UserLimits, bh as ValidatedAssetsOptions, bi as WorkerMetadata, bj as WorkflowBinding, bk as ZoneIdRoute, bl as ZoneNameRoute, bm as addAuthorizationHeader, bn as defaultWranglerConfig, bo as extractAccountTag, bp as extractWAFBlockRayId, bq as fetchInternalBase, br as fetchKVGetValueBase, bs as fetchListResultBase, bt as fetchResultBase, bu as getBrowserRenderingHeadfulFromEnv, bv as getBuildConditionsFromEnv, bw as getBuildPlatformFromEnv, bx as getC3CommandFromEnv, by as getCIGeneratePreviewAlias, bz as getCIMatchTag, bA as getCIOverrideName, bB as getCIOverrideNetworkModeHost, bC as getCfFetchEnabledFromEnv, bD as getCfFetchPathFromEnv, bE as getCloudflareApiBaseUrl, bF as getCloudflareApiEnvironmentFromEnv, bG as getCloudflareComplianceRegion, bH as getCloudflareEnv, bI as getCloudflareIncludeProcessEnvFromEnv, bJ as getCloudflareLoadDevVarsFromDotEnv, bK as getCloudflaredPathFromEnv, bL as getComplianceRegionSubdomain, bM as getD1ExtraLocationChoices, bN as getDisableConfigWatching, bO as getLocalExplorerEnabledFromEnv, bP as getLocalObservabilityEnabledFromEnv, bQ as getNoSkillsUpdatePromptsFromEnv, bR as getOpenNextDeployFromEnv, bS as getOutputFileDirectoryFromEnv, bT as getOutputFilePathFromEnv, bU as getRegistryPath, bV as getSanitizeLogs, bW as getSubdomainMixedStateCheckDisabled, bX as getTraceHeader, bY as getWorkersCIBranchName, bZ as getWranglerCacheDirFromEnv, b_ as getWranglerHideBanner, b$ as getWranglerSendErrorReportsFromEnv, c0 as getWranglerSendMetricsFromEnv, c1 as hasCursor, c2 as hasMorePages, c3 as isDoNotTrackEnabled, c4 as isWAFBlockResponse, c5 as maybeAddTraceHeader, c6 as parseRetryAfterMs, c7 as parseRetryAfterValue, c8 as performApiFetchBase, c9 as renderError, ca as throwFetchError, cb as truncate } from './compliance-j3-tqeao.mjs';
+import * as jsoncParser from 'jsonc-parser';
+import { UserError, TelemetryMessage } from './errors.mjs';
+export { CommandLineArgsError, DeprecationError, FatalError, JsonFriendlyFatalError, MissingConfigError, createFatalError } from './errors.mjs';
+export { constructWranglerConfig } from './browser.mjs';
+export { GetGlobalConfigPathOptions, getGlobalConfigPath, getGlobalWranglerCachePath } from './global-wrangler-config-path.mjs';
+import { CompatDate } from './compatibility-date.mjs';
+export { NODEJS_COMPAT_DEFAULT_ON_DATE, NODEJS_COMPAT_V2_SWITCH_OVER_DATE, getTodaysCompatDate, isCompatDate, isNodejsCompatDefaultOn, resolveNodejsCompat, stripRedundantNodejsCompatFlags } from './compatibility-date.mjs';
+export { isDirectory, removeDir, removeDirSync } from './fs-helpers.mjs';
+export { Counter, MetricsRegistry } from './prometheus-metrics.mjs';
+import { ChildProcess } from 'node:child_process';
+export { _forceColour, formatZodError } from './zod-format.mjs';
+export { getDockerPath } from './docker-path.mjs';
+import 'node:url';
+import 'undici';
+import '@cloudflare/workers-shared';
+import 'cloudflare';
+import 'zod';
+
+type ResolveConfigPathOptions = {
+    useRedirectIfAvailable?: boolean;
+};
+type ConfigPaths = {
+    /** Absolute path to the actual configuration being used (possibly redirected from the user's config). */
+    configPath: string | undefined;
+    /** Absolute path to the user's configuration, which may not be the same as `configPath` if it was redirected. */
+    userConfigPath: string | undefined;
+    /** Absolute path to the deploy config path used */
+    deployConfigPath: string | undefined;
+    /** Was a redirected config file read? */
+    redirected: boolean;
+};
+/**
+ * Resolve the path to the configuration file, given the `config` and `script` optional command line arguments.
+ * `config` takes precedence, then `script`, then we just use the cwd.
+ *
+ * Returns an object with two paths: `configPath` and `userConfigPath`. If defined these are absolute file paths.
+ */
+declare function resolveWranglerConfigPath({ config, script, }: {
+    config?: string;
+    script?: string;
+}, options: {
+    useRedirectIfAvailable?: boolean;
+}): ConfigPaths;
+/**
+ * Find the wrangler configuration file by searching up the file-system
+ * from the current working directory.
+ */
+declare function findWranglerConfig(referencePath?: string, { useRedirectIfAvailable }?: {
+    useRedirectIfAvailable?: boolean | undefined;
+}): ConfigPaths;
+declare function isRedirectedConfig(config: Pick<ComputedFields, "configPath" | "userConfigPath">): boolean;
+
+/**
+ * Diagnostic errors and warnings.
+ *
+ * The structure is a tree, where each node can contain zero or more errors, warnings and child diagnostics objects.
+ * You can check whether the overall tree has errors or warnings, and you can render a string representation of the errors or warnings.
+ */
+declare class Diagnostics {
+    description: string;
+    errors: string[];
+    warnings: string[];
+    children: Diagnostics[];
+    /** Set to true when an unexpected/unknown field is encountered during validation. */
+    hasUnexpectedFields: boolean;
+    /**
+     * Create a new Diagnostics object.
+     * @param description A general description of this collection of messages.
+     */
+    constructor(description: string);
+    /**
+     * Merge the given `diagnostics` into this as a child.
+     */
+    addChild(diagnostics: Diagnostics): void;
+    /** Does this or any of its children have errors. */
+    hasErrors(): boolean;
+    /** Does this or any of its children have unexpected fields. */
+    hasUnexpectedFieldsInTree(): boolean;
+    /** Render the errors of this and all its children. */
+    renderErrors(): string;
+    /** Does this or any of its children have warnings. */
+    hasWarnings(): boolean;
+    /** Render the warnings of this and all its children. */
+    renderWarnings(): string;
+    private render;
+}
+
+/**
+ * R2 bucket names must:
+ * - contain lower case letters, numbers, and `-`
+ * - start and end with with a lower case letter or number
+ * - be between 6 and 63 characters long
+ *
+ * See https://developers.cloudflare.com/r2/buckets/create-buckets/#bucket-level-operations
+ */
+declare function isValidR2BucketName(name: string | undefined): name is string;
+declare const bucketFormatMessage = "Bucket names must begin and end with an alphanumeric character, only contain lowercase letters, numbers, and hyphens, and be between 3 and 63 characters long.";
+/**
+ * Config field names for bindings (e.g., "kv_namespaces", "d1_databases").
+ * These are the keys used in Wrangler's config file
+ */
+type ConfigBindingFieldName = "data_blobs" | "durable_objects" | "kv_namespaces" | "send_email" | "queues" | "d1_databases" | "vectorize" | "ai_search_namespaces" | "ai_search" | "websearch" | "agent_memory" | "hyperdrive" | "r2_buckets" | "logfwdr" | "services" | "analytics_engine_datasets" | "text_blobs" | "browser" | "ai" | "images" | "stream" | "media" | "version_metadata" | "unsafe" | "vars" | "wasm_modules" | "dispatch_namespaces" | "mtls_certificates" | "workflows" | "pipelines" | "secrets_store_secrets" | "artifacts" | "ratelimits" | "assets" | "unsafe_hello_world" | "flagship" | "worker_loaders" | "vpc_services" | "vpc_networks";
+/**
+ * Get a friendly name for a binding type, handling unsafe bindings
+ */
+declare function getBindingTypeFriendlyName(bindingType: Binding["type"]): string;
+type NormalizeAndValidateConfigArgs = {
+    name?: string;
+    env?: string;
+    "dispatch-namespace"?: string;
+    remote?: boolean;
+    localProtocol?: string;
+    upstreamProtocol?: string;
+    script?: string;
+    enableContainers?: boolean;
+    generateTypes?: boolean;
+};
+declare function isPagesConfig(rawConfig: RawConfig): boolean;
+/**
+ * Validate the given `rawConfig` object that was loaded from `configPath`.
+ *
+ * The configuration is normalized, which includes using default values for missing field,
+ * and copying over inheritable fields into named environments.
+ *
+ * Any errors or warnings from the validation are available in the returned `diagnostics` object.
+ *
+ * @param rawConfig The config loaded from `configPath`
+ * @param configPath The path to the config file
+ * @param userConfigPath
+ * @param args
+ * @param preserveOriginalMain
+ * @returns The normalized `config` and `diagnostics` message
+ */
+declare function normalizeAndValidateConfig(rawConfig: RawConfig, configPath: string | undefined, userConfigPath: string | undefined, args: NormalizeAndValidateConfigArgs, preserveOriginalMain?: boolean): {
+    config: Config;
+    diagnostics: Diagnostics;
+};
+/**
+ * Returns whether the provided `imagePath` is a path to a Dockerfile.
+ *
+ * @param imagePath path to Dockerfile or image registry path
+ * @param configPath path to the wrangler config file, if any
+ * @returns `true` if it is a dockerfile, `false` if it is a registry link, throws if neither
+ */
+declare function isDockerfile(imagePath: string, configPath: string | undefined): boolean;
+
+type ExportType = Exports[string]["type"];
+interface PartitionedExports {
+    "durable-object": Record<string, DurableObjectExport>;
+    worker: Record<string, WorkerEntrypointExport>;
+}
+declare function partitionExports(exports: Exports | undefined): PartitionedExports;
+
+/**
+ * A container can be linked to a Durable Object from either direction:
+ *
+ *  - the container names the class via `containers[].class_name`, or
+ *  - the Durable Object names the container via `exports[Class].container`.
+ *
+ * This returns the second direction as a lookup of container name to Durable
+ * Object class name. Only live `durable-object` exports can attach a container,
+ * so tombstones are ignored.
+ *
+ * When two exports name the same container the first wins. That is a config
+ * error caught during validation, so the choice only affects which class a
+ * rejected config reports.
+ */
+declare function getContainerNameToClassNameMap(exports: Exports | undefined): Map<string, string>;
+/**
+ * The Durable Object class a container backs, resolved from either direction of
+ * the container/Durable Object link.
+ *
+ * Returns `undefined` when the container is not linked to a Durable Object at
+ * all, which validation rejects.
+ */
+declare function resolveContainerClassName(container: Pick<ContainerApp, "class_name" | "name">, exports: Exports | undefined): string | undefined;
+/**
+ * The set of Durable Object class names that have a container attached, resolved
+ * from either direction of the container/Durable Object link.
+ */
+declare function getContainerDurableObjectClassNames(containers: ContainerApp[] | undefined, exports: Exports | undefined): Set<string>;
+
+type ConfigBindingOptions = Pick<Config, "ai" | "browser" | "d1_databases" | "dispatch_namespaces" | "durable_objects" | "queues" | "r2_buckets" | "services" | "kv_namespaces" | "mtls_certificates" | "vectorize" | "workflows" | "vpc_services">;
+
+declare function configFormat(configPath: string | undefined): "json" | "jsonc" | "toml" | "none";
+declare function configFileName(configPath: string | undefined): "wrangler.json" | "wrangler.jsonc" | "wrangler.toml" | "Wrangler configuration";
+declare function formatConfigSnippet(snippet: RawConfig, configPath: Config["configPath"], formatted?: boolean): string;
+type ReadConfigCommandArgs = NormalizeAndValidateConfigArgs & {
+    config?: string;
+    script?: string;
+};
+type ReadConfigOptions = ResolveConfigPathOptions & {
+    hideWarnings?: boolean;
+    preserveOriginalMain?: boolean;
+};
+declare const experimental_readRawConfig: (args: ReadConfigCommandArgs, options?: ReadConfigOptions) => {
+    rawConfig: RawConfig;
+    configPath: string | undefined;
+    userConfigPath: string | undefined;
+    deployConfigPath: string | undefined;
+    redirected: boolean;
+};
+
+/**
+ * Returns a map of exports that are only of type "durable-object".
+ */
+declare function getDurableObjectExports(exports: Config["exports"] | undefined): Record<string, DurableObjectExport>;
+declare function hasDurableObjectExports(exports: Config["exports"] | undefined): boolean;
+
+declare const experimental_patchConfig: (configPath: string, 
+/**
+ * if you want to add something new, e.g. a binding, you can just provide that {kv_namespace:[{binding:"KV"}]}
+ * and set isArrayInsertion = true
+ *
+ * if you want to edit or delete existing array elements, you have to provide the whole array
+ * e.g. {kv_namespace:[{binding:"KV", id:"new-id"}, {binding:"KV2", id:"untouched"}]}
+ * and set isArrayInsertion = false
+ */
+patch: RawConfig, isArrayInsertion?: boolean) => string;
+/**
+ * Custom error class for config patching errors
+ */
+declare class PatchConfigError extends Error {
+}
+
+type Message = {
+    text: string;
+    location?: Location;
+    notes?: Message[];
+    kind?: "warning" | "error";
+};
+type MessageInit = Message & TelemetryMessage;
+type Location = ParseFile & {
+    line: number;
+    column: number;
+    length?: number;
+    lineText?: string;
+    suggestion?: string;
+};
+type ParseFile = {
+    file?: string;
+    fileText?: string;
+};
+/**
+ * An error that's thrown when something fails to parse.
+ */
+declare class ParseError extends UserError implements Message {
+    readonly text: string;
+    readonly notes: Message[];
+    readonly location?: Location;
+    readonly kind: "warning" | "error";
+    constructor({ text, notes, location, kind, telemetryMessage }: MessageInit);
+}
+declare class APIError extends ParseError {
+    #private;
+    code?: number;
+    accountTag?: string;
+    /**
+     * Optional structured metadata hoisted from the first `FetchError.meta`
+     * on the v4 response envelope. Consumers can inspect this to render
+     * endpoint-specific structured error payloads.
+     */
+    meta?: {
+        details?: unknown;
+    } & Record<string, unknown>;
+    /**
+     * Optional number of milliseconds the API asked us to wait before retrying,
+     * derived from the response's `Retry-After` header (if present).
+     */
+    retryAfterMs?: number;
+    constructor({ status, retryAfterMs, ...rest }: MessageInit & {
+        status?: number;
+        retryAfterMs?: number;
+    });
+    get status(): number | undefined;
+    isGatewayError(): boolean;
+    isRetryable(): boolean;
+    get reportable(): boolean;
+    preventReport(): void;
+}
+/**
+ * Parses a TOML string to an object.
+ *
+ * Note: throws a `ParseError` if parsing fails.
+ *
+ * @param tomlContent The TOML content to parse.
+ * @param filePath Optional file path for error reporting.
+ * @returns The parsed TOML object.
+ */
+declare function parseTOML(tomlContent: string, filePath?: string): unknown;
+/**
+ * A minimal type describing a package.json file.
+ */
+type PackageJSON = {
+    name?: string;
+    version?: string;
+    private?: boolean;
+    devDependencies?: Record<string, unknown>;
+    dependencies?: Record<string, unknown>;
+    scripts?: Record<string, unknown>;
+    /**
+     * NOTE: This is **not** a standard `package.json` field — don't confuse it
+     * with the standard `bundledDependencies`. It is a convention introduced by
+     * vite+ (https://viteplus.dev): vite+ installs `@voidzero-dev/vite-plus-core`
+     * under the `vite` npm alias and records the versions of the tools it bundles
+     * here, keyed by package name
+     * (e.g. `{ "vite": "8.1.2", "rolldown": "...", "tsdown": "..." }`).
+     *
+     * We read it to recover the underlying Vite version when Vite is installed via
+     * such an alias. It is optional and absent for the vast majority of packages.
+     */
+    bundledVersions?: Record<string, string | undefined>;
+};
+/**
+ * A typed version of `parseJSON()`.
+ */
+declare function parsePackageJSON(input: string, file?: string): PackageJSON;
+/**
+ * Parses JSON and throws a `ParseError`.
+ */
+declare function parseJSON(input: string, file?: string): unknown;
+/**
+ * A wrapper around `JSONC.parse` that throws a `ParseError`.
+ */
+declare function parseJSONC(input: string, file?: string, options?: jsoncParser.ParseOptions): unknown;
+/**
+ * Reads a file into a node Buffer.
+ */
+declare function readFileSyncToBuffer(file: string): Buffer;
+/**
+ * Reads a file and parses it based on its type.
+ */
+declare function readFileSync(file: string): string;
+/**
+ * Calculates the line and column location from an index.
+ */
+declare function indexLocation(file: ParseFile, index: number): Location;
+/**
+ * Guesses the line and column location of a search query.
+ */
+declare function searchLocation(file: ParseFile, query: unknown): Location;
+/**
+ * Parse a human-readable time duration in seconds (including fractional)
+ *
+ * Invalid values will return NaN
+ */
+declare function parseHumanDuration(s: string): number;
+declare function parseNonHyphenedUuid(uuid: string | null): string | null;
+declare function parseByteSize(s: string, base?: number | undefined): number;
+
+/**
+ * Local-dev capability of each binding type. Source of truth for
+ * `pickRemoteBindings()` and `validateBindingRemoteSetting()`.
+ *
+ * - `local-and-remote`: local simulator; `remote: true` opts into proxying.
+ * - `local-only`: local simulator only; `remote: true` is a config error.
+ * - `remote`: no local simulator *yet* — requires explicit `remote: true`.
+ *   Move to `local-and-remote` once a simulator lands.
+ * - `DO-NOT-USE-this-resource-will-never-have-a-local-simulator`: no local
+ *   simulator, *ever* — fundamentally remote-only. Always auto-routed; user
+ *   is warned about usage charges. Adding here is permanent; prefer any
+ *   other variant if a simulator is plausible.
+ */
+type BindingLocalSupport = "local-and-remote" | "local-only" | "remote" | "DO-NOT-USE-this-resource-will-never-have-a-local-simulator";
+declare function getBindingLocalSupport(type: Binding["type"]): BindingLocalSupport;
+/**
+ * Validates the user's `remote` setting for a given binding against the
+ * binding type's local-development capabilities. Throws `UserError` for
+ * invalid combinations and uses the caller-provided logger for
+ * valid-but-noteworthy ones.
+ */
+declare function validateBindingRemoteSetting(type: Binding["type"], remote: boolean | undefined, warn: (message: string) => void): void;
+
+/**
+ * Pages now supports configuration via a Wrangler configuration file. As opposed to
+ * Workers however, Pages only supports a limited subset of all available
+ * configuration keys.
+ *
+ * This file contains all Wrangler configuration file validation things, specific to
+ * Pages.
+ */
+
+declare function validatePagesConfig(config: Config, envNames: string[], projectName?: string): Diagnostics;
+
+/**
+ * Returns whether `target` has the required property `property` of type `type`.
+ *
+ * @param target the object to test.
+ * @param property the property name to test.
+ * @param type the expected type of the property.
+ * @param choices optional list of allowed values for the property.
+ * @returns whether `target` has the required property `property` of type `type`, and optionally one of `choices`.
+ */
+declare const isRequiredProperty: <T extends object>(target: object, property: keyof T, type: TypeofType, choices?: unknown[]) => target is T;
+/**
+ * Returns whether `target` has the optional property `property` of type `type`.
+ *
+ * @param target the object to test.
+ * @param property the property name to test.
+ * @param type the expected type of the property.
+ * @returns whether `target` has the optional property `property` of type `type`.
+ */
+declare const isOptionalProperty: <T extends object>(target: object, property: keyof T, type: TypeofType) => target is T;
+/**
+ * Returns whether `target` has the property `property`.
+ *
+ * @param target the object to test.
+ * @param property the property name to test.
+ * @returns whether `target` has the property `property`.
+ */
+declare const hasProperty: <T extends object>(target: object, property: keyof T) => target is T;
+/**
+ * JavaScript `typeof` operator return values.
+ */
+type TypeofType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+
+declare function assertNever(_value: never): void;
+
+/**
+ * Resolves the filesystem path for an installed npm package.
+ *
+ * Tries three strategies in order:
+ * 1. `require.resolve("<pkg>/package.json")` — works when the package exports its `package.json`
+ * 2. `require.resolve("<pkg>")` — fallback for packages that don't export `package.json`
+ * 3. Direct `node_modules` filesystem lookup — fallback for ESM-only packages whose exports
+ *    map has no `"require"` or `"default"` condition (and no `"./package.json"` export),
+ *    which makes them invisible to `require.resolve`
+ *
+ * @param packageName - The npm package name to resolve (supports scoped packages like `@scope/pkg`)
+ * @param projectPath - The project directory to resolve from
+ * @returns The resolved directory path, or `undefined` if the package is not installed
+ */
+declare function getPackagePath(packageName: string, projectPath: string): string | undefined;
+/**
+ * Checks whether an npm package is installed in a target project.
+ *
+ * @param packageName - The name of the target package
+ * @param projectPath - The path of the project to check
+ * @returns `true` if the package is installed, `false` otherwise
+ */
+declare function isPackageInstalled(packageName: string, projectPath: string): boolean;
+/**
+ * Gets the exact version of an npm package installed in a project by resolving
+ * it from node_modules and reading its package.json.
+ *
+ * @param packageName - The name of the target package
+ * @param projectPath - The path of the project to check
+ * @param opts - Options
+ * @param opts.stopAtProjectPath - If `true`, stop walking up at the project's path
+ * @returns The installed version string, or `undefined` if the package is not installed
+ */
+declare function getInstalledPackageVersion(packageName: string, projectPath: string, opts?: {
+    stopAtProjectPath?: boolean;
+}): string | undefined;
+
+/**
+ * Maps a set of bindings defined as worker metadata bindings (straight from the Cloudflare API) to bindings defined in the local format.
+ *
+ * @param bindings The set of worker metadata bindings to convert
+ * @param accountId The ID of the account
+ * @param complianceConfig The compliance region configuration
+ * @returns A RawConfig object with its bindings populated based on the provided bindings
+ */
+declare function mapWorkerMetadataBindings(bindings: WorkerMetadataBinding[]): RawConfig;
+
+interface ConvertBindingsOptions {
+    /**
+     * Use preview IDs (preview_id, preview_bucket_name, preview_database_id) instead of production IDs when resolving a binding ID.
+     * This means that the rest of Wrangler does not need to be aware of preview IDs, and can just use regular IDs.
+     */
+    usePreviewIds?: boolean;
+    /**
+     * Exclude bindings that Pages doesn't support
+     */
+    pages?: boolean;
+}
+/**
+ * Convert Config to the Record<string, Binding> format for consistent internal use.
+ */
+declare function convertConfigToBindings(config: Partial<Pick<Config, ConfigBindingFieldName>>, options?: ConvertBindingsOptions): Record<string, Binding>;
+declare function isUnsafeBindingType(type: string): type is `unsafe_${string}`;
+/**
+ * What configuration key does this binding use for referring to it's binding name?
+ */
+declare const nameBindings: readonly ["durable_object_namespace", "logfwdr", "ratelimit", "unsafe_ratelimit", "send_email"];
+type FlatBinding<Type> = Extract<Binding, {
+    type: Type;
+}> & (Type extends (typeof nameBindings)[number] ? {
+    name: string;
+} : {
+    binding: string;
+});
+declare function extractBindingsOfType<Type extends Binding["type"]>(type: Type, bindings: Record<string, Binding> | undefined): FlatBinding<Type>[];
+/**
+ * Get bindings from a Config object in the standard Record<string, Binding> format.
+ */
+declare function getBindings(config: Config | undefined, options?: {
+    pages?: boolean;
+}): Record<string, Binding>;
+
+type PrintBindingsOptions = {
+    log: (message: string) => void;
+    tailConsumers?: CfTailConsumer[];
+    streamingTailConsumers?: CfTailConsumer[];
+    containers?: ContainerApp[];
+    registry?: Record<string, {
+        debugPortAddress?: string;
+    }> | null;
+    local?: boolean;
+    isMultiWorker?: boolean;
+    remoteBindingsDisabled?: boolean;
+    name?: string;
+    provisioning?: boolean;
+    warnIfNoBindings?: boolean;
+    unsafeMetadata?: Record<string, unknown>;
+};
+/**
+ * Print all the bindings a worker would have access to.
+ * Accepts the flat binding record used by StartDevWorkerInput["bindings"].
+ */
+declare function printBindings(bindings: Record<string, Binding> | undefined, options: PrintBindingsOptions): void;
+
+/**
+ * Environment variables supported by Wrangler for configuration and authentication.
+ * Each variable is documented with its individual JSDoc comment below.
+ */
+type VariableNames = 
+/** Overrides the account ID for API requests. Can also be set in Wrangler config via `account_id` field. */
+"CLOUDFLARE_ACCOUNT_ID"
+/** API token for authentication. Preferred over API key + email. */
+ | "CLOUDFLARE_API_TOKEN"
+/** Legacy API key for authentication. Requires CLOUDFLARE_EMAIL. It is preferred to use `CLOUDFLARE_API_TOKEN`. */
+ | "CLOUDFLARE_API_KEY"
+/** Email address for API key authentication. Used with `CLOUDFLARE_API_KEY`. It is preferred to use `CLOUDFLARE_API_TOKEN`. */
+ | "CLOUDFLARE_EMAIL"
+/** Custom API base URL. Defaults to https://api.cloudflare.com/client/v4 */
+ | "CLOUDFLARE_API_BASE_URL"
+/** Set to "fedramp_high" for FedRAMP High compliance region. This will update the API/AUTH URLs used to make requests to Cloudflare. */
+ | "CLOUDFLARE_COMPLIANCE_REGION"
+/** API token for R2 SQL service. */
+ | "WRANGLER_R2_SQL_AUTH_TOKEN"
+/** Controls whether to fetch the cf.json file. Set to "false" or "0" to disable fetching and use fallback data. Defaults to "true". */
+ | "CLOUDFLARE_CF_FETCH_ENABLED"
+/** Custom path for caching the cf.json file. Overrides the default node_modules/.mf/cf.json location. */
+ | "CLOUDFLARE_CF_FETCH_PATH"
+/** Local database connection strings for Hyperdrive development. The * should be replaced with the Hyperdrive binding name in the Worker. */
+ | `CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_${string}`
+/** Suppress Hyperdrive-related warnings during development. */
+ | "NO_HYPERDRIVE_WARNING"
+/** Path to HTTPS private key file for running the local development server in HTTPS mode. Without this Wrangler will generate keys automatically. */
+ | "WRANGLER_HTTPS_KEY_PATH"
+/** Path to HTTPS certificate file for running the local development server in HTTPS mode. Without this Wrangler will generate keys automatically. */
+ | "WRANGLER_HTTPS_CERT_PATH"
+/** Load development variables from .env files (default: true). */
+ | "CLOUDFLARE_LOAD_DEV_VARS_FROM_DOT_ENV"
+/** Include process.env in development variables (default: false). */
+ | "CLOUDFLARE_INCLUDE_PROCESS_ENV"
+/** Include a trace header in all API requests that Wrangler makes (for internal use only) */
+ | "WRANGLER_TRACE_ID"
+/** Disable the check for mixed state of subdomain flags (`workers_dev`, `preview_urls`, etc.) (default: false). */
+ | "WRANGLER_DISABLE_SUBDOMAIN_MIXED_STATE_CHECK"
+/** Set log level: "debug", "info", "log", "warn", "error". */
+ | "WRANGLER_LOG"
+/** Directory for debug log files. */
+ | "WRANGLER_LOG_PATH"
+/** Sanitize sensitive data in debug logs (default: true). */
+ | "WRANGLER_LOG_SANITIZE"
+/** Directory for ND-JSON output files. */
+ | "WRANGLER_OUTPUT_FILE_DIRECTORY"
+/** Hide the Wrangler version banner */
+ | "WRANGLER_HIDE_BANNER"
+/** Specific path for ND-JSON output file. */
+ | "WRANGLER_OUTPUT_FILE_PATH"
+/** Comma-separated list of build conditions for esbuild. */
+ | "WRANGLER_BUILD_CONDITIONS"
+/** Build platform for esbuild (e.g., "node", "browser"). */
+ | "WRANGLER_BUILD_PLATFORM"
+/** Path to file-based dev registry folder. */
+ | "WRANGLER_REGISTRY_PATH"
+/** Additional D1 location choices (internal use). */
+ | "WRANGLER_D1_EXTRA_LOCATION_CHOICES"
+/** The Workers environment to target (equivalent to the `--env` CLI param) */
+ | "CLOUDFLARE_ENV"
+/** Custom directory for Wrangler's cache files (overrides `node_modules/.cache/wrangler`). */
+ | "WRANGLER_CACHE_DIR"
+/** Custom path to cloudflared binary (overrides automatic binary management). */
+ | "CLOUDFLARED_PATH"
+/** Set to "staging" to use staging APIs instead of production. */
+ | "WRANGLER_API_ENVIRONMENT"
+/** Custom auth domain (usually auto-configured). */
+ | "WRANGLER_AUTH_DOMAIN"
+/** Custom auth URL (usually auto-configured). */
+ | "WRANGLER_AUTH_URL"
+/** Custom OAuth client ID (usually auto-configured). */
+ | "WRANGLER_CLIENT_ID"
+/** Custom OAuth client ID for the `cf` CLI's OAuth app (usually auto-configured). */
+ | "CLOUDFLARE_CLIENT_ID"
+/** Custom token URL (usually auto-configured). */
+ | "WRANGLER_TOKEN_URL"
+/** Custom token revocation URL (usually auto-configured). */
+ | "WRANGLER_REVOKE_URL"
+/** Direct authorization token for API requests. */
+ | "WRANGLER_CF_AUTHORIZATION_TOKEN"
+/** Cloudflare Access Service Token Client ID. Used to authenticate with Access-protected domains in non-interactive environments (e.g. CI). */
+ | "CLOUDFLARE_ACCESS_CLIENT_ID"
+/** Cloudflare Access Service Token Client Secret. Used with CLOUDFLARE_ACCESS_CLIENT_ID. */
+ | "CLOUDFLARE_ACCESS_CLIENT_SECRET"
+/**
+ * Store OAuth credentials in the OS keychain instead of a plaintext TOML
+ * file. Overrides the persistent `keyring_enabled` preference written by
+ * `wrangler login --use-keyring`.
+ */
+ | "CLOUDFLARE_AUTH_USE_KEYRING"
+/** Enable the local explorer UI at /cdn-cgi/local/explorer (experimental, default: false). */
+ | "X_LOCAL_EXPLORER"
+/** Enable local-dev observability capture (experimental, default: false). */
+ | "X_LOCAL_OBSERVABILITY"
+/** Open the browser in headful (visible) mode when using the Browser Run API in local dev (default: false). */
+ | "X_BROWSER_HEADFUL"
+/** Override command used by `wrangler init` (default: "create cloudflare"). */
+ | "WRANGLER_C3_COMMAND"
+/** Enable/disable telemetry data collection. */
+ | "WRANGLER_SEND_METRICS"
+/** Enable/disable error reporting to Sentry. */
+ | "WRANGLER_SEND_ERROR_REPORTS"
+/** Suppress the prompt that offers to update Cloudflare agent skills. */
+ | "WRANGLER_NO_SKILLS_UPDATE_PROMPTS"
+/** CI branch name (internal use). */
+ | "WORKERS_CI_BRANCH"
+/** CI tag matching configuration (internal use). */
+ | "WRANGLER_CI_MATCH_TAG"
+/** CI override name configuration (internal use). */
+ | "WRANGLER_CI_OVERRIDE_NAME"
+/** CI network mode host override (internal use). */
+ | "WRANGLER_CI_OVERRIDE_NETWORK_MODE_HOST"
+/** CI preview alias generation (internal use). */
+ | "WRANGLER_CI_GENERATE_PREVIEW_ALIAS"
+/** Disable config watching in ConfigController. */
+ | "WRANGLER_CI_DISABLE_CONFIG_WATCHING"
+/** Disable telemetry when set to an opt-out value. */
+ | "DO_NOT_TRACK"
+/** Path to docker binary (default: "docker"). */
+ | "WRANGLER_DOCKER_BIN"
+/** Docker host configuration (handled separately from environment variable factory). */
+ | "WRANGLER_DOCKER_HOST"
+/** Docker host configuration (handled separately from environment variable factory). */
+ | "DOCKER_HOST"
+/** Environment variable used to signal that the current process is being run by the open-next deploy command. */
+ | "OPEN_NEXT_DEPLOY";
+type DeprecatedNames = "CF_ACCOUNT_ID" | "CF_API_TOKEN" | "CF_API_KEY" | "CF_EMAIL" | "CF_API_BASE_URL";
+type ElementType<A> = A extends readonly (infer T)[] ? T : never;
+/**
+ * Create a function used to access a boolean environment variable. It may return undefined if the variable is not set.
+ *
+ * This is not memoized to allow us to change the value at runtime, such as in testing.
+ *
+ * The environment variable must be either "true" or "false" (after lowercasing), otherwise it will throw an error.
+ */
+declare function getBooleanEnvironmentVariableFactory(options: {
+    variableName: VariableNames;
+}): () => boolean | undefined;
+declare function getBooleanEnvironmentVariableFactory(options: {
+    variableName: VariableNames;
+    defaultValue: boolean | (() => boolean);
+}): () => boolean;
+/**
+ * Create a function used to access an environment variable. It may return undefined if the variable is not set.
+ *
+ * This is not memoized to allow us to change the value at runtime, such as in testing.
+ * A warning is shown if the client is using a deprecated version - but only once.
+ * If a list of choices is provided, then the environment variable must be one of those given.
+ */
+declare function getEnvironmentVariableFactory<Choices extends readonly string[]>(options: {
+    variableName: VariableNames;
+    deprecatedName?: DeprecatedNames;
+    choices?: Choices;
+}): () => ElementType<Choices> | undefined;
+/**
+ * Create a function used to access an environment variable, with a default value if the variable is not set.
+ *
+ * This is not memoized to allow us to change the value at runtime, such as in testing.
+ * A warning is shown if the client is using a deprecated version - but only once.
+ * If a list of choices is provided, then the environment variable must be one of those given.
+ */
+declare function getEnvironmentVariableFactory<Choices extends readonly string[]>(options: {
+    variableName: VariableNames;
+    deprecatedName?: DeprecatedNames;
+    defaultValue: () => ElementType<Choices>;
+    readonly choices?: Choices;
+}): () => ElementType<Choices>;
+
+/**
+ * The compatibility date to use when the user has not specified one.
+ *
+ * This is the release date of the `workerd` version pinned in the pnpm catalog,
+ * so it is fixed for a given release of workers-sdk and updated whenever
+ * `workerd` is upgraded.
+ *
+ * It deliberately tracks `workerd` rather than the current date, because
+ * workerd rejects a compatibility date later than either of:
+ *
+ * - its `MAXIMUM_COMPATIBILITY_DATE`, which is its release date plus 7 days, or
+ * - today's date (UTC).
+ *
+ * Run `pnpm update:compat-date` to refresh this value; `pnpm check:compat-date`
+ * asserts that it matches the pinned `workerd` version.
+ *
+ * @see https://github.com/cloudflare/workerd/blob/main/src/workerd/io/BUILD.bazel
+ * @see https://github.com/cloudflare/workerd/blob/main/src/workerd/io/compatibility-date.c%2B%2B
+ */
+declare const DEFAULT_COMPAT_DATE: CompatDate;
+
+/**
+ * A file-backed key/value cache scoped to a consumer's cache directory.
+ *
+ * The mechanism is generic (JSON blobs keyed by file name); the only
+ * consumer-specific input is the logger used for debug output, so the whole
+ * bundle is built by {@link createConfigCache}. Wrangler wraps this with its
+ * logger singleton in `src/config-cache.ts`; `@cloudflare/workers-auth` builds
+ * its own instance with the logger injected into `createWranglerAuth`.
+ */
+interface ConfigCache {
+    getCacheFolder: () => string;
+    getConfigCache: <T>(fileName: string) => Partial<T>;
+    saveToConfigCache: <T>(fileName: string, newValues: Partial<T>) => void;
+    purgeConfigCaches: () => void;
+}
+interface ConfigCacheOptions {
+    /**
+     * Namespace for the cache directory, so different Cloudflare CLIs get
+     * isolated caches (`<node_modules>/.cache/<namespace>` or
+     * `.<namespace>/cache`). Defaults to `"wrangler"` for backward compatibility.
+     *
+     * `purgeConfigCaches()` deletes the whole cache folder, so a non-default
+     * namespace also ensures e.g. `cf login`/`logout` never wipes wrangler's
+     * cache.
+     */
+    namespace?: string;
+}
+/**
+ * Build a file-backed config cache bound to the given logger.
+ */
+declare function createConfigCache(logger: Logger, options?: ConfigCacheOptions): ConfigCache;
+
+/**
+ * A short-lived directory. Automatically removed when the process exits, but
+ * can be removed earlier by calling `remove()`.
+ */
+interface EphemeralDirectory {
+    path: string;
+    remove(): void;
+}
+/**
+ * Gets the path to the project's `.wrangler` folder.
+ */
+declare function getWranglerHiddenDirPath(projectRoot: string | undefined): string;
+/**
+ * Removes stale `.wrangler/tmp/*` entries left behind by previous wrangler
+ * sessions that exited abnormally (SIGKILL, OOM, host crash) and so missed
+ * the `signal-exit` cleanup. Runs at most once per tmp root per process.
+ *
+ * Exported for tests.
+ */
+declare function sweepStaleWranglerTmpDirs(tmpRoot: string): void;
+/**
+ * Gets a temporary directory in the project's `.wrangler` folder with the
+ * specified prefix. We create temporary directories in `.wrangler` as opposed
+ * to the OS's temporary directory to avoid issues with different drive letters
+ * on Windows. For example, when `esbuild` outputs a file to a different drive
+ * than the input sources, the generated source maps are incorrect.
+ */
+declare function getWranglerTmpDir(projectRoot: string | undefined, prefix: string, cleanup?: boolean): EphemeralDirectory;
+
+interface QuickTunnelResult {
+    mode: "quick";
+    publicUrl: URL;
+}
+interface NamedTunnelResult {
+    mode: "named";
+}
+type TunnelResult = QuickTunnelResult | NamedTunnelResult;
+interface Tunnel {
+    ready: () => Promise<TunnelResult>;
+    isOpen: () => boolean;
+    dispose: () => void;
+    extendExpiry: (ms?: number) => void;
+}
+interface TunnelOptions {
+    origin: URL;
+    token?: string;
+    timeoutMs?: number;
+    expiryMs?: number;
+    reminderIntervalMs?: number;
+    extendHint?: string;
+    logger?: Pick<Logger, "debug" | "log" | "warn">;
+}
+/**
+ * Start a Cloudflare Quick Tunnel for a local dev origin.
+ *
+ * Spawns `cloudflared tunnel --url <origin>` and waits for the public URL
+ * to appear in its stderr output. Returns a controller with a `ready()`
+ * promise that resolves once the tunnel URL is available, and a `dispose()`
+ * function to stop the tunnel.
+ */
+declare function startTunnel(options: TunnelOptions): Tunnel;
+
+/**
+ * cloudflared binary management for Wrangler tunnel commands.
+ *
+ * This module handles downloading, caching, and running the cloudflared binary.
+ * It uses the Cloudflare update worker (update.argotunnel.com) to resolve
+ * the latest version and download URL, matching cloudflared's own update mechanism.
+ */
+
+/**
+ * Spawn cloudflared process with automatic binary management
+ */
+declare function spawnCloudflared(args: string[], options?: {
+    stdio?: "inherit" | "pipe";
+    env?: Record<string, string>;
+    skipVersionCheck?: boolean;
+    confirmDownload?: (message: string) => Promise<boolean>;
+    logger?: Pick<Logger, "debug" | "log" | "warn">;
+}): Promise<ChildProcess>;
+
+type NpmVersionCheckResult = {
+    status: "up-to-date";
+} | {
+    status: "update-available";
+    latest: string;
+} | {
+    status: "failed";
+};
+/**
+ * Checks if a newer version of a package is available on npm.
+ *
+ * Uses the `update-check` library to query the npm registry for the latest
+ * version. The dist tag used for comparison depends on the current version —
+ * "beta" for pre-release versions (0.0.0-*) and "latest" for stable versions.
+ *
+ * @param name - The npm package name to check
+ * @param version - The current version to compare against
+ * @returns A discriminated result:
+ *   - `{ status: "update-available", latest: string }` if a newer version exists
+ *   - `{ status: "up-to-date" }` if the installed version is already the latest
+ *   - `{ status: "failed" }` if the check could not be completed (network error, timeout, etc.)
+ */
+declare function fetchLatestNpmVersion(name: string, version: string): Promise<NpmVersionCheckResult>;
+
+/**
+ * Returns whether the process can handle interactive input (e.g. hotkeys).
+ *
+ * A process is considered interactive when **both** conditions are met:
+ * - It is **not** running in a Cloudflare CI environment (Pages or Workers CI).
+ * - `stdin` and `stdout` are connected to a TTY (not piped from/to another process).
+ *
+ * Note: generic CI environments (e.g. GitHub Actions) do **not** disable interactivity,
+ * because a real PTY may still be attached and hotkeys should still work.
+ *
+ * Use this for features that require a TTY but should remain functional in generic CI:
+ * - Registering hotkeys (e.g. `x` to exit `wrangler dev`)
+ * - Enabling raw mode / keypress handling
+ * - Showing animated spinners or progress indicators
+ * - Reading secrets from an interactive prompt vs stdin
+ *
+ * Use {@link isNonInteractiveOrCI} instead when user input should be suppressed
+ * in **all** CI environments.
+ *
+ * @returns `true` if the process is interactive, `false` otherwise.
+ */
+declare function isInteractive(): boolean;
+/**
+ * Returns whether the process should not prompt the user.
+ *
+ * Returns `true` when the process is non-interactive (no TTY) **or** running
+ * in any CI environment (detected via `ci-info`). This is stricter than
+ * {@link isInteractive} which only checks for Cloudflare-specific CI,
+ * because user prompts should never appear in CI even when a PTY is attached.
+ *
+ * Use this for anything that should be suppressed or adapted in CI:
+ * - User prompts (confirmations, text input, select dialogs)
+ * - OAuth login flows
+ * - Output format decisions (JSON in CI, pretty when interactive)
+ * - Banner / decoration display
+ * - Redacting sensitive info (account names, emails) in CI logs
+ * - Writing config changes back to disk (e.g. provisioned resource IDs)
+ *
+ * @returns `true` if the process is non-interactive or running in CI.
+ */
+declare function isNonInteractiveOrCI(): boolean;
+/**
+ * Whether the process is running in any CI environment (per `ci-info`).
+ *
+ * Distinct from {@link isNonInteractiveOrCI}: this ignores TTY state, so it is
+ * `true` only for genuine CI, not for merely non-interactive contexts (agents,
+ * piped commands). Used for behaviour that should key off CI specifically — e.g.
+ * redacting account names / emails in public CI logs while still showing them to
+ * non-interactive local tooling.
+ *
+ * Exposed from this package (rather than having consumers `import "ci-info"`
+ * directly) so the value flows through the mockable `ci-info` boundary and
+ * consumers don't take a fresh, unmockable dependency on it.
+ */
+declare function isCI(): boolean;
+
+/**
+ * Wrapper around the `open` package that gracefully handles environments where
+ * a browser opener (e.g. `xdg-open` on Linux) is unavailable. In those cases
+ * the URL is printed so the user can copy-paste it manually, rather than
+ * crashing with a confusing "file not found" error.
+ *
+ * The consumer's `logger` is passed in rather than imported: this package is
+ * shared across CLIs and has no logger singleton of its own.
+ *
+ * @param url the URL to point the browser at
+ * @param logger the consumer's logger, used to surface the manual-open fallback
+ */
+declare function openInBrowser(url: string, logger: Logger): Promise<void>;
+
+/**
+ * Write an entry to the output file.
+ *
+ * Control whether (and where) to write this file by setting either
+ * `WRANGLER_OUTPUT_FILE_DIRECTORY` or `WRANGLER_OUTPUT_FILE_PATH`.
+ *
+ * @param entry The structured output entry to append.
+ * @returns Nothing.
+ */
+declare function writeOutput(entry: OutputEntry): void;
+/**
+ * Clear the cached output file path.
+ *
+ * @returns Nothing.
+ */
+declare function clearOutputFilePath(): void;
+interface OutputEntryBase<T extends string> {
+    version: number;
+    type: T;
+}
+interface OutputEntryBundleSize {
+    /** The uncompressed size of the Worker bundle. */
+    raw_bytes: number;
+    /** The gzip-compressed size of the Worker bundle. */
+    gzip_bytes: number;
+}
+/**
+ * All the different types of entry that can be written to the output file.
+ */
+type OutputEntry = OutputEntrySession | OutputEntryDeployment | OutputEntryPreview | OutputEntryPagesDeployment | OutputEntryVersionUpload | OutputEntryVersionDeployment | OutputEntryPagesDeploymentDetailed | OutputEntryCommandFailed | OutputEntryAutoConfig;
+interface OutputEntrySession extends OutputEntryBase<"wrangler-session"> {
+    version: 1;
+    /** The semver version string taken from Wrangler's package.json. */
+    wrangler_version: string;
+    /** The arguments passed to Wrangler. */
+    command_line_args: string[];
+    /** The absolute path to a file that contains debug logs for this Wrangler instance. */
+    log_file_path: string;
+}
+interface OutputEntryDeployment extends OutputEntryBase<"deploy"> {
+    version: 1;
+    /** The name of the Worker. */
+    worker_name: string | null;
+    /** The GUID that identifies the Worker. This never changes even if the name is changed. */
+    worker_tag: string | null;
+    /** A GUID that identifies this deployed version of the Worker. This version is associated with an automatically created deployment, with this version set at 100%. */
+    version_id: string | null;
+    /** A list of URLs that represent the HTTP triggers associated with this deployment */
+    targets: string[] | undefined;
+    /** set if the worker's name was overridden */
+    worker_name_overridden: boolean;
+    /** wrangler environment used */
+    wrangler_environment: string | undefined;
+    /** Exact Worker bundle sizes in bytes. */
+    bundle_size?: OutputEntryBundleSize;
+}
+interface OutputEntryPreview extends OutputEntryBase<"preview"> {
+    version: 1;
+    /** The name of the Worker. */
+    worker_name: string | null;
+    /** The ID of the Preview resource. */
+    preview_id: string;
+    /** The human-readable name of the Preview resource. */
+    preview_name: string;
+    /** The slug of the Preview resource. */
+    preview_slug: string;
+    /** A list of URLs associated with the Preview resource. */
+    preview_urls: string[] | undefined;
+    /** The ID of the Preview deployment resource. */
+    deployment_id: string;
+    /** A list of URLs associated with the Preview deployment. */
+    deployment_urls: string[] | undefined;
+}
+interface OutputEntryAutoConfig extends OutputEntryBase<"autoconfig"> {
+    version: 1;
+    /** The command that triggered autoconfig */
+    command: "setup" | "deploy";
+    /** The summary of the autoconfig process */
+    summary: {
+        wranglerConfig?: {
+            name?: string;
+            compatibility_date?: string;
+        };
+        [key: string]: unknown;
+    };
+}
+interface OutputEntryPagesDeployment extends OutputEntryBase<"pages-deploy"> {
+    version: 1;
+    /** The name of the Pages project. */
+    pages_project: string | null;
+    /** A GUID that identifies this Pages deployment. */
+    deployment_id: string | null;
+    /** The URL associated with this deployment */
+    url: string | undefined;
+}
+interface OutputEntryPagesDeploymentDetailed extends OutputEntryBase<"pages-deploy-detailed"> {
+    version: 1;
+    /** The name of the Pages project. */
+    pages_project: string | null;
+    /** A GUID that identifies this Pages deployment. */
+    deployment_id: string | null;
+    /** The URL associated with this deployment */
+    url: string | undefined;
+    /** The Alias url, if it exists */
+    alias: string | undefined;
+    /** The environment being deployed to */
+    environment: "production" | "preview";
+    /** The production branch of the pages project */
+    production_branch: string;
+    deployment_trigger: {
+        metadata: {
+            /** Commit hash of the deployment trigger metadata for the pages project */
+            commit_hash: string;
+        };
+    };
+}
+interface OutputEntryVersionUpload extends OutputEntryBase<"version-upload"> {
+    version: 1;
+    /** The name of the Worker. */
+    worker_name: string | null;
+    /** The GUID that identifies the Worker. This never changes even if the name is changed. */
+    worker_tag: string | null;
+    /** A GUID that identifies this uploaded, but not yet deployed, version of the Worker. This version will need to be "deployed" to receive traffic. */
+    version_id: string | null;
+    /** The preview URL associated with this version upload */
+    preview_url: string | undefined;
+    /** The ephemeral aliased preview URL associated with this version upload */
+    preview_alias_url: string | undefined;
+    /** set if the worker's name was overridden */
+    worker_name_overridden: boolean;
+    /** wrangler environment used */
+    wrangler_environment: string | undefined;
+    /** Exact Worker bundle sizes in bytes. */
+    bundle_size?: OutputEntryBundleSize;
+}
+interface OutputEntryVersionDeployment extends OutputEntryBase<"version-deploy"> {
+    version: 1;
+    /** The name of the Worker. */
+    worker_name: string | null;
+    /** The GUID that identifies the Worker. This never changes even if the name is changed. */
+    worker_tag: string | null;
+    /** The ID of the gradual rollout deployment. */
+    deployment_id: string;
+    /** The percentage of traffic that goes to each version. */
+    version_traffic: Map<string, number>;
+}
+interface OutputEntryCommandFailed extends OutputEntryBase<"command-failed"> {
+    version: 1;
+    /** The code in the error. */
+    code: number | undefined;
+    /** The message in the error. */
+    message: string | undefined;
+    /** How many milliseconds to retry the operation after if available. */
+    retry_after_ms: number | undefined;
+}
+
+declare function retryOnAPIFailure<T>(action: () => T | Promise<T>, logger: Logger, backoff?: number, attempts?: number, abortSignal?: AbortSignal): Promise<T>;
+
+declare function formatTime(duration: number): string;
+
+/**
+ * Get the hostname on which to run a Worker.
+ *
+ * The most accurate place is usually
+ * `route.pattern`, as that includes any subdomains. For example:
+ * ```js
+ * {
+ * 	pattern: foo.example.com
+ * 	zone_name: example.com
+ * }
+ * ```
+ * However, in the case of patterns that _can't_ be parsed as a hostname
+ * (primarily the pattern `*/ declare function getHostFromRoute(route: Route): string | undefined;
+/**
+ * Best-effort derivation of the Cloudflare zone name that owns a given route,
+ * for use as the `CF-Worker` header value on outbound subrequests in local
+ * development (see https://developers.cloudflare.com/fundamentals/reference/http-headers/#cf-worker).
+ *
+ * In production, `CF-Worker` is set to the zone name — for a route
+ * `foo.example.com/*` on zone `example.com`, the header is `example.com`.
+ * When the user has explicitly told us the zone name in their route config
+ * (`zone_name`), use it. Otherwise, fall back to {@link getHostFromRoute},
+ * which returns the route pattern's hostname — this is the closest local
+ * approximation without performing an API lookup, and matches the behaviour
+ * users see when their route's hostname is already the apex (e.g.
+ * `example.com/*`).
+ */
+declare function getZoneFromRoute(route: Route): string | undefined;
+/**
+ * Given something that resembles a URL, try to extract a host from it.
+ */
+declare function getHostFromUrl(urlLike: string): string | undefined;
+
+/**
+ * Describes a supported package manager and its associated CLI commands
+ * and lock file conventions.
+ */
+interface PackageManager {
+    /** The package manager identifier. */
+    type: "npm" | "yarn" | "pnpm" | "bun" | "nub";
+    /** The command used to execute packages (e.g. `npx`, `pnpm`, `bunx`). */
+    npx: string;
+    /** The command segments used to download and execute packages (e.g. `["npx"]`, `["pnpm", "dlx"]`). */
+    dlx: string[];
+    /** Lock file names produced by this package manager. */
+    lockFiles: string[];
+}
+/**
+ * Manage packages using npm.
+ */
+declare const NpmPackageManager: {
+    readonly type: "npm";
+    readonly npx: "npx";
+    readonly dlx: ["npx"];
+    readonly lockFiles: ["package-lock.json"];
+};
+/**
+ * Manage packages using pnpm.
+ */
+declare const PnpmPackageManager: {
+    readonly type: "pnpm";
+    readonly npx: "pnpm";
+    readonly lockFiles: ["pnpm-lock.yaml"];
+    readonly dlx: ["pnpm", "dlx"];
+};
+/**
+ * Manage packages using yarn.
+ */
+declare const YarnPackageManager: {
+    readonly type: "yarn";
+    readonly npx: "yarn";
+    readonly dlx: ["yarn", "dlx"];
+    readonly lockFiles: ["yarn.lock"];
+};
+/**
+ * Manage packages using bun.
+ */
+declare const BunPackageManager: {
+    readonly type: "bun";
+    readonly npx: "bunx";
+    readonly dlx: ["bunx"];
+    readonly lockFiles: ["bun.lockb", "bun.lock"];
+};
+/**
+ * Manage packages using nub.
+ */
+declare const NubPackageManager: {
+    readonly type: "nub";
+    readonly npx: "nubx";
+    readonly dlx: ["nubx"];
+    readonly lockFiles: ["nub.lock"];
+};
+
+/**
+ * Checks whether the provided worker name is valid, this means that:
+ *  - the name is not empty
+ *  - the name doesn't start nor ends with a dash
+ *  - the name doesn't contain special characters besides dashes
+ *  - the name is not longer than 63 characters
+ *
+ * See: https://developers.cloudflare.com/workers/configuration/routing/workers-dev/#limitations
+ *
+ * @param input The name to check
+ * @returns Object indicating whether the name is valid, and if not a cause indicating why it isn't
+ */
+declare function checkWorkerNameValidity(input: string): {
+    valid: false;
+    cause: string;
+} | {
+    valid: true;
+};
+/**
+ * Given an input string it converts it to a valid worker name.
+ *
+ * A worker name is valid if:
+ *  - the name is not empty
+ *  - the name doesn't start nor ends with a dash
+ *  - the name doesn't contain special characters besides dashes
+ *  - the name is not longer than 63 characters
+ *
+ * See: https://developers.cloudflare.com/workers/configuration/routing/workers-dev/#limitations
+ *
+ * @param input The input to convert
+ * @returns The input itself if it was already valid, the input converted to a valid worker name otherwise
+ */
+declare function toValidWorkerName(input: string): string;
+/**
+ * Derives a valid worker name from a project name (or worker name) and project path.
+ *
+ * The name is determined by (in order of precedence):
+ * 1. The WRANGLER_CI_OVERRIDE_NAME environment variable (for CI environments)
+ * 2. The provided project/worker name (if non-empty)
+ * 3. The directory basename of the project path
+ *
+ * The resulting name is sanitized to be a valid worker name.
+ *
+ * @param projectOrWorkerName An optional project or worker name to use
+ * @param projectPath The path to the project directory (used as fallback)
+ * @returns A valid worker name
+ */
+declare function getWorkerName(projectOrWorkerName: string | undefined, projectPath: string): string;
+/**
+ * Derives a valid worker name from a project directory.
+ *
+ * The name is determined by (in order of precedence):
+ * 1. The WRANGLER_CI_OVERRIDE_NAME environment variable (for CI environments)
+ * 2. The `name` field from package.json in the project directory
+ * 3. The directory basename
+ *
+ * The resulting name is sanitized to be a valid worker name.
+ *
+ * @param projectPath The path to the project directory
+ * @returns A valid worker name
+ */
+declare function getWorkerNameFromProject(projectPath: string): string;
+
+type DiscriminatedPath<Discriminator extends string> = string & {
+    _discriminator: Discriminator;
+};
+/**
+ * A branded string that expects to be URL compatible.
+ *
+ * Require this type when you want callers to ensure that they have converted file-path strings into URL-safe paths.
+ */
+type UrlPath = DiscriminatedPath<"UrlPath">;
+/**
+ * Convert a file-path string to a URL-path string.
+ *
+ * Use this helper to convert a `string` to a `UrlPath` when it is not clear whether the string needs normalizing.
+ * Replaces all back-slashes with forward-slashes, and throws an error if the path contains a drive letter (e.g. `C:`).
+ *
+ * @param filePath - The file path to convert
+ * @returns The URL-safe path
+ */
+declare function toUrlPath(filePath: string): UrlPath;
+
+/**
+ * @deprecated new code should use getBindingTypeFriendlyName() instead
+ */
+declare const friendlyBindingNames: Record<ConfigBindingFieldName, string>;
+
+export { APIError, Binding, type BindingLocalSupport, BunPackageManager, CfTailConsumer, CompatDate, Config, type ConfigBindingFieldName, type ConfigBindingOptions, type ConfigCache, type ConfigCacheOptions, ContainerApp, type ConvertBindingsOptions, DEFAULT_COMPAT_DATE, Diagnostics, DurableObjectExport, type EphemeralDirectory, type ExportType, Exports, type Location, Logger, type Message, type NormalizeAndValidateConfigArgs, NpmPackageManager, type NpmVersionCheckResult, NubPackageManager, type OutputEntry, type PackageJSON, type PackageManager, ParseError, type ParseFile, type PartitionedExports, PatchConfigError, PnpmPackageManager, type PrintBindingsOptions, RawConfig, type ResolveConfigPathOptions, Route, TelemetryMessage, type Tunnel, type TunnelOptions, type UrlPath, UserError, WorkerEntrypointExport, WorkerMetadataBinding, YarnPackageManager, assertNever, bucketFormatMessage, checkWorkerNameValidity, clearOutputFilePath, configFileName, configFormat, convertConfigToBindings, createConfigCache, experimental_patchConfig, experimental_readRawConfig, extractBindingsOfType, fetchLatestNpmVersion, findWranglerConfig, formatConfigSnippet, formatTime, friendlyBindingNames, getBindingLocalSupport, getBindingTypeFriendlyName, getBindings, getBooleanEnvironmentVariableFactory, getContainerDurableObjectClassNames, getContainerNameToClassNameMap, getDurableObjectExports, getEnvironmentVariableFactory, getHostFromRoute, getHostFromUrl, getInstalledPackageVersion, getPackagePath, getWorkerName, getWorkerNameFromProject, getWranglerHiddenDirPath, getWranglerTmpDir, getZoneFromRoute, hasDurableObjectExports, hasProperty, indexLocation, isCI, isDockerfile, isInteractive, isNonInteractiveOrCI, isOptionalProperty, isPackageInstalled, isPagesConfig, isRedirectedConfig, isRequiredProperty, isUnsafeBindingType, isValidR2BucketName, mapWorkerMetadataBindings, normalizeAndValidateConfig, openInBrowser, parseByteSize, parseHumanDuration, parseJSON, parseJSONC, parseNonHyphenedUuid, parsePackageJSON, parseTOML, partitionExports, printBindings, readFileSync, readFileSyncToBuffer, resolveContainerClassName, resolveWranglerConfigPath, retryOnAPIFailure, searchLocation, spawnCloudflared, startTunnel, sweepStaleWranglerTmpDirs, toUrlPath, toValidWorkerName, validateBindingRemoteSetting, validatePagesConfig, writeOutput };