@cloudflare/deploy-helpers 0.1.2 → 0.1.3

package/dist/index.d.mts

@@ -1,139 +1,54 @@
-import { ContainerNormalizedConfig } from '@cloudflare/containers-shared';
-import { FetchResultFetcher, FetchListResultFetcher, Logger, Config, Entry, AssetsOptions, CfPlacement, EphemeralDirectory, LegacyAssetPaths, Route, ComplianceConfig, ZoneIdRoute, ZoneNameRoute, CustomDomainRoute } from '@cloudflare/workers-utils';
-import { NodeJSCompatMode } from 'miniflare';
-
-/**
- * client needs to handle logger and fetch/auth implementation
- * these are passed into this package to handle any API requests/logs
- */
-type DeployHelpersContext = {
-    fetchResult: FetchResultFetcher;
-    fetchListResult: FetchListResultFetcher;
-    logger: Logger;
-    confirm: (text: string, options?: {
-        defaultValue?: boolean;
-        fallbackValue?: boolean;
-    }) => Promise<boolean>;
-    prompt: (text: string, options?: {
-        defaultValue?: string;
-    }) => Promise<string>;
-    isNonInteractiveOrCI: () => boolean;
-};
+import { D as DeployProps, W as WorkerBuildResult, V as VersionsUploadProps, T as TriggerProps, a as TriggerDeployment } from './context-CUxVlvJf.mjs';
+export { B as BuildBundleInfo, b as DeployHelpersContext, S as SharedDeployVersionsProps, i as initDeployHelpersContext } from './context-CUxVlvJf.mjs';
+import { ContainerNormalizedConfig, ImageURIConfig } from '@cloudflare/containers-shared';
+import * as _cloudflare_workers_utils from '@cloudflare/workers-utils';
+import { Config, ComplianceConfig, LegacyAssetPaths, Binding, Route, ZoneIdRoute, ZoneNameRoute, CustomDomainRoute, CfPlacement, CfModule, CfWorkerSourceMap, RawConfig, ConfigBindingFieldName, CfCapnp, CfModuleType, CfWorkerInit, CfScriptFormat, AssetsOptions, ParseError, WorkerMetadataBinding, CfUserLimits, TailConsumer, StreamingTailConsumer, Observability, StartDevWorkerInput, CfTailConsumer, ContainerApp } from '@cloudflare/workers-utils';
+import { FormData } from 'undici';
+import { Options } from '@cspotcode/source-map-support';
+import Protocol from 'devtools-protocol';
+import { NodeJSCompatMode, WorkerRegistry } from 'miniflare';
+
 /**
- * Shared fields produced by merging CLI args with wrangler config.
- * After this point, no raw config/arg merging should happen.
- *
- * Use props for all resolved/merged values. Only access config directly
- * for raw values that aren't merged with CLI args (e.g., config.durable_objects,
- * config.unsafe, config.tail_consumers).
+ * Wrangler-specific functions injected into `deploy()`. These remain in
+ * wrangler because they depend on wrangler-only systems (account selection,
+ * metrics, the dev-mode worker registry, container orchestration, etc.).
  */
-type SharedDeployVersionsProps = {
-    config: Config;
-    /** Merged from args.script/config.main/config.site.entry-point/config.assets. */
-    entry: Entry;
-    /** From config.rules. */
-    rules: Config["rules"];
-    /** Merged: --name arg ?? config.name, with CI override applied. */
-    name: string;
-    workerNameOverridden: boolean;
-    /** Merged: --compatibility-date arg ?? config.compatibility_date. Still optional — validated as required in stage 4. */
-    compatibilityDate: string | undefined;
-    /** Merged: --compatibility-flags arg ?? config.compatibility_flags. */
-    compatibilityFlags: string[];
-    /** computed based on compat date and args */
-    nodejsCompatMode: NodeJSCompatMode;
-    /** Merged from --assets arg and config.assets. */
-    assetsOptions: AssetsOptions | undefined;
-    /** Merged: --jsx-factory arg || config.jsx_factory. */
-    jsxFactory: string;
-    /** Merged: --jsx-fragment arg || config.jsx_fragment. */
-    jsxFragment: string;
-    /** Merged: --tsconfig arg ?? config.tsconfig. */
-    tsconfig: string | undefined;
-    /** Merged: --minify arg ?? config.minify. */
-    minify: boolean | undefined;
-    /** Merged: !(--bundle arg ?? !config.no_bundle). */
-    noBundle: boolean;
-    /** Merged: --upload-source-maps arg ?? config.upload_source_maps. */
-    uploadSourceMaps: boolean | undefined;
-    /** Merged: --keep-vars arg || config.keep_vars. */
-    keepVars: boolean;
-    /** Merged from --site arg and config.site. */
-    isWorkersSite: boolean;
-    /** Merged: { ...config.define, ...--define arg }. CLI overrides config. */
-    defines: Record<string, string>;
-    /** Merged: { ...config.alias, ...--alias arg }. CLI overrides config. */
-    alias: Record<string, string>;
-    /**
-     * Whether to use the deprecated service environments API path.
-     * True only when config opts in (legacy_env: false) AND --env is specified.
-     */
-    useServiceEnvApiPath: boolean;
-    placement: CfPlacement | undefined;
-    /** Output directory for the bundled Worker. From --outdir arg or a temp directory. */
-    destination: string | EphemeralDirectory;
-    /** From --dry-run arg. */
-    dryRun: boolean;
-    /** From --env arg. */
-    env: string | undefined;
-    /** From --outdir arg. Already used to derive `destination`, but also needed for outdir README and noBundleWorker. */
-    outdir: string | undefined;
-    /** From --outfile arg. */
-    outfile: string | undefined;
-    /** From --tag arg. */
-    tag: string | undefined;
-    /** From --message arg. */
-    message: string | undefined;
-    /** From --secrets-file arg. */
-    secretsFile: string | undefined;
-    /** From collectKeyValues(--var arg). Pre-resolved key-value pairs. */
-    var: Record<string, string>;
-    /** From --experimental-auto-create arg. */
-    experimentalAutoCreate: boolean;
-};
-type DeployProps = SharedDeployVersionsProps & {
-    /** Discriminant for DeployProps vs VersionsUploadProps */
-    command: "deploy";
-    /** Merged from --site arg and config.site. */
-    legacyAssetPaths: LegacyAssetPaths | undefined;
-    /** Merged: --triggers arg ?? config.triggers.crons. */
-    triggers: string[] | undefined;
-    /** Merged: --routes arg ?? config.routes ?? config.route. AND --domains and custom_domains*/
-    routes: Route[];
-    /** Merged: --logpush arg ?? config.logpush. */
-    logpush: boolean | undefined;
-    containers: ContainerNormalizedConfig[];
-    /** From --dispatch-namespace arg. Deploy-only (Workers for Platforms). */
-    dispatchNamespace: string | undefined;
-    /** From --strict arg. Deploy-only. */
-    strict: boolean;
-    /** From --metafile arg. Deploy-only. */
-    metafile: string | boolean | undefined;
-    /** From --old-asset-ttl arg. Deploy-only. */
-    oldAssetTtl: number | undefined;
-};
-type VersionsUploadProps = SharedDeployVersionsProps & {
-    /** Discriminant for DeployProps vs VersionsUploadProps */
-    command: "versions upload";
-    /** CLI-only (--preview-alias), or auto-generated from CI branch name. */
-    previewAlias: string | undefined;
-};
-interface TriggerDeployment {
-    targets: string[];
-    error?: Error;
-}
-type TriggerProps = {
-    config: Config;
-    accountId: string;
-    scriptName: string;
-    env: string | undefined;
-    crons: string[] | undefined;
-    routes: Route[];
-    useServiceEnvironments: boolean;
-    firstDeploy: boolean;
+type DeployCallbacks = {
+    syncWorkersSite: ((complianceConfig: ComplianceConfig, accountId: string | undefined, scriptName: string, siteAssets: LegacyAssetPaths | undefined, preview: boolean, dryRun: boolean | undefined, oldAssetTTL: number | undefined) => Promise<{
+        manifest: {
+            [filePath: string]: string;
+        } | undefined;
+        namespace: string | undefined;
+    }>) | undefined;
+    provisionBindings: ((bindings: Record<string, Binding>, accountId: string, scriptName: string, autoCreate: boolean, config: Config, requireRemote?: boolean) => Promise<void>) | undefined;
+    getNormalizedContainerOptions: ((config: Config, args: {
+        containersRollout?: "gradual" | "immediate" | "none";
+        dryRun?: boolean;
+    }) => Promise<ContainerNormalizedConfig[]>) | undefined;
+    buildContainer: ((containerConfig: Exclude<ContainerNormalizedConfig, ImageURIConfig>, imageTag: string, dryRun: boolean, pathToDocker: string) => Promise<unknown>) | undefined;
+    deployContainers: ((config: Config, normalisedContainerConfig: ContainerNormalizedConfig[], args: {
+        versionId: string;
+        accountId: string;
+        scriptName: string;
+    }) => Promise<void>) | undefined;
+    analyseBundle: ((workerBundle: string | FormData) => Promise<Record<string, unknown>>) | undefined;
 };
+declare function deploy(props: DeployProps, config: Config, buildResult: WorkerBuildResult, callbacks: DeployCallbacks): Promise<{
+    sourceMapSize?: number;
+    versionId: string | null;
+    workerTag: string | null;
+    targets?: string[];
+}>;
 
-declare function triggersDeploy(props: TriggerProps, ctx: DeployHelpersContext): Promise<string[] | void>;
+type VersionsUploadCallbacks = Pick<DeployCallbacks, "provisionBindings" | "analyseBundle">;
+declare function versionsUpload(props: VersionsUploadProps, config: Config, buildResult: WorkerBuildResult, callbacks: VersionsUploadCallbacks): Promise<{
+    versionId: string | null;
+    workerTag: string | null;
+    versionPreviewUrl?: string | undefined;
+    versionPreviewAliasUrl?: string | undefined;
+}>;
+
+declare function triggersDeploy(props: TriggerProps): Promise<string[] | void>;
 declare function getSubdomainValues(config_workers_dev: boolean | undefined, config_preview_urls: boolean | undefined, routes: Route[]): {
     workers_dev: boolean;
     preview_urls?: boolean;
@@ -152,7 +67,7 @@ type GetWorkersDevSubdomainOptions = {
 /**
  * Gets the <user-subdomain>.(fed.)workers.dev URL for the given account.
  */
-declare function getWorkersDevSubdomain(complianceConfig: ComplianceConfig, accountId: string, ctx: DeployHelpersContext, options?: GetWorkersDevSubdomainOptions): Promise<string>;
+declare function getWorkersDevSubdomain(complianceConfig: ComplianceConfig, accountId: string, options?: GetWorkersDevSubdomainOptions): Promise<string>;
 
 interface Zone {
     id: string;
@@ -162,7 +77,7 @@ type ZoneIdCache = Map<string, Promise<string | null>>;
 declare function getZoneForRoute(complianceConfig: ComplianceConfig, from: {
     route: Route;
     accountId: string;
-}, ctx: DeployHelpersContext, zoneIdCache?: ZoneIdCache): Promise<Zone | undefined>;
+}, zoneIdCache?: ZoneIdCache): Promise<Zone | undefined>;
 /**
  * Given something that resembles a host, try to infer a zone id from it.
  *
@@ -173,7 +88,7 @@ declare function getZoneForRoute(complianceConfig: ComplianceConfig, from: {
 declare function getZoneIdFromHost(complianceConfig: ComplianceConfig, from: {
     host: string;
     accountId: string;
-}, ctx: DeployHelpersContext, zoneIdCache?: ZoneIdCache): Promise<string>;
+}, zoneIdCache?: ZoneIdCache): Promise<string>;
 
 type RouteObject = ZoneIdRoute | ZoneNameRoute | CustomDomainRoute;
 type CustomDomain = {
@@ -208,8 +123,8 @@ declare function publishRoutes(complianceConfig: ComplianceConfig, routes: Route
     scriptName: string;
     useServiceEnvironments: boolean;
     accountId: string;
-}, ctx: DeployHelpersContext): Promise<string[]>;
-declare function publishCustomDomains(complianceConfig: ComplianceConfig, workerUrl: string, accountId: string, domains: Array<RouteObject>, ctx: DeployHelpersContext): Promise<TriggerDeployment>;
+}): Promise<string[]>;
+declare function publishCustomDomains(complianceConfig: ComplianceConfig, workerUrl: string, accountId: string, domains: Array<RouteObject>): Promise<TriggerDeployment>;
 
 interface PostQueueBody {
     queue_name: string;
@@ -281,14 +196,563 @@ interface PurgeQueueResponse {
     started_at: string;
     complete: boolean;
 }
-declare function listQueues(complianceConfig: ComplianceConfig, accountId: string, ctx: DeployHelpersContext, page?: number, name?: string): Promise<QueueResponse[]>;
-declare function getQueue(complianceConfig: ComplianceConfig, accountId: string, queueName: string, ctx: DeployHelpersContext): Promise<QueueResponse>;
-declare function postConsumer(complianceConfig: ComplianceConfig, accountId: string, queueName: string, body: PostTypedConsumerBody, ctx: DeployHelpersContext): Promise<TypedConsumerResponse>;
-declare function putConsumerById(complianceConfig: ComplianceConfig, accountId: string, queueId: string, consumerId: string, body: PostTypedConsumerBody, ctx: DeployHelpersContext): Promise<TypedConsumerResponse>;
-declare function putConsumer(complianceConfig: ComplianceConfig, accountId: string, queueName: string, scriptName: string, envName: string | undefined, body: PostTypedConsumerBody, ctx: DeployHelpersContext): Promise<TypedConsumerResponse>;
-declare function deletePullConsumer(complianceConfig: ComplianceConfig, accountId: string, queueName: string, ctx: DeployHelpersContext): Promise<void>;
-declare function listConsumers(complianceConfig: ComplianceConfig, accountId: string, queueName: string, ctx: DeployHelpersContext): Promise<Consumer[]>;
-declare function deleteWorkerConsumer(complianceConfig: ComplianceConfig, accountId: string, queueName: string, scriptName: string, envName: string | undefined, ctx: DeployHelpersContext): Promise<void>;
-declare function updateQueueConsumers(complianceConfig: ComplianceConfig, accountId: string, scriptName: string, config: Config, ctx: DeployHelpersContext): Promise<Promise<TriggerDeployment>[]>;
-
-export { type Consumer, type ConsumerSettings, type CustomDomain, type CustomDomainChangeset, type DeployHelpersContext, type DeployProps, type PostQueueBody, type PostQueueResponse, type PostTypedConsumerBody, type Producer, type PurgeQueueBody, type PurgeQueueResponse, type QueueResponse, type QueueSettings, type RouteObject, type ScriptReference, type SharedDeployVersionsProps, type TriggerDeployment, type TriggerProps, type TypedConsumerResponse, type VersionsUploadProps, type Zone, type ZoneIdCache, deletePullConsumer, deleteWorkerConsumer, getQueue, getSubdomainValues, getSubdomainValuesAPIMock, getWorkersDevSubdomain, getZoneForRoute, getZoneIdFromHost, listConsumers, listQueues, postConsumer, publishCustomDomains, publishRoutes, putConsumer, putConsumerById, renderRoute, triggersDeploy, updateQueueConsumers };
+declare function listQueues(complianceConfig: ComplianceConfig, accountId: string, page?: number, name?: string): Promise<QueueResponse[]>;
+declare function getQueue(complianceConfig: ComplianceConfig, accountId: string, queueName: string): Promise<QueueResponse>;
+declare function postConsumer(complianceConfig: ComplianceConfig, accountId: string, queueName: string, body: PostTypedConsumerBody): Promise<TypedConsumerResponse>;
+declare function putConsumerById(complianceConfig: ComplianceConfig, accountId: string, queueId: string, consumerId: string, body: PostTypedConsumerBody): Promise<TypedConsumerResponse>;
+declare function putConsumer(complianceConfig: ComplianceConfig, accountId: string, queueName: string, scriptName: string, envName: string | undefined, body: PostTypedConsumerBody): Promise<TypedConsumerResponse>;
+declare function deletePullConsumer(complianceConfig: ComplianceConfig, accountId: string, queueName: string): Promise<void>;
+declare function listConsumers(complianceConfig: ComplianceConfig, accountId: string, queueName: string): Promise<Consumer[]>;
+declare function deleteWorkerConsumer(complianceConfig: ComplianceConfig, accountId: string, queueName: string, scriptName: string, envName: string | undefined): Promise<void>;
+declare function updateQueueConsumers(complianceConfig: ComplianceConfig, accountId: string, scriptName: string, config: Config): Promise<Promise<TriggerDeployment>[]>;
+declare function ensureQueuesExistByConfig(config: Config, accountId: string): Promise<void>;
+
+/**
+ * Parse placement out of a Config
+ */
+declare function parseConfigPlacement(config: Config): CfPlacement | undefined;
+
+/**
+ This is the error code from the Cloudflare API signaling that a worker could not be found on the target account
+ */
+declare const WORKER_NOT_FOUND_ERR_CODE: 10007;
+/**
+ This is the error code from the Cloudflare API signaling that a worker environment (legacy) could not be found on the target account
+ */
+declare const WORKER_LEGACY_ENVIRONMENT_NOT_FOUND_ERR_CODE: 10090;
+/**
+ This is the error message from the Cloudflare API signaling that a worker could not be found on the target account
+ */
+declare const workerNotFoundErrorMessage = "This Worker does not exist on your account.";
+/**
+ * Given an error from the Cloudflare API discerns whether it is caused by a worker that could not be found on the target account
+ *
+ * @param error The error object
+ * @returns true if the object represents an error from the Cloudflare API caused by a not found worker, false otherwise
+ */
+declare function isWorkerNotFoundError(error: unknown): boolean;
+
+/**
+ * Whether deprecated service environments are enabled.
+ */
+declare function useServiceEnvironments(config: Config | {
+    legacy_env?: boolean;
+    legacy: {
+        useServiceEnvironments?: boolean;
+    };
+}): boolean;
+
+/**
+ * Cloudflare API error codes used by deploy-helpers.
+ */
+/** The inherit binding references a binding that does not exist on the previous version. */
+declare const INVALID_INHERIT_BINDING_CODE: 10057;
+
+type SecretsValidationOptions = {
+    type: "deploy";
+    workerExists: boolean;
+} | {
+    type: "upload";
+};
+/**
+ * When `secrets.required` is defined in config, validate the secrets exist on the Worker.
+ * For deploy, if the Worker doesn't exist yet, fail immediately.
+ * For upload, always add inherit bindings — the API handles the case where
+ * the Worker doesn't exist (versions upload cannot create new Workers).
+ * Secrets already provided (e.g. via --secrets-file) are excluded since
+ * they are part of the upload and don't need to be inherited.
+ */
+declare function addRequiredSecretsInheritBindings(config: Config, bindings: Record<string, Binding>, options: SecretsValidationOptions): void;
+/**
+ * Reformats API errors for strict inherit binding validation failures into
+ * user-friendly messages listing the missing required secrets.
+ * The API returns all missing inherit bindings at once, each as a separate
+ * error in response.errors, which maps to individual err.notes entries.
+ */
+declare function handleMissingSecretsError(err: unknown, config: Config, options: SecretsValidationOptions): void;
+
+interface SourceMapMetadata {
+    tmpDir: string;
+    entryDirectory: string;
+}
+interface SourceMapBundle {
+    sourceMapPath?: string | undefined;
+    sourceMapMetadata?: SourceMapMetadata | undefined;
+    [key: string]: unknown;
+}
+/**
+ * Loads source maps that appear in the given build output.
+ */
+declare function loadSourceMaps(main: CfModule, modules: CfModule[], bundle: SourceMapBundle): CfWorkerSourceMap[];
+/**
+ * Attaches a sourcemap, if found, to a JavaScript module.
+ */
+declare function tryAttachSourcemapToModule(module: CfModule): void;
+
+type JsonLike = string | number | boolean | null | JsonLike[] | undefined | {
+    [id: string]: JsonLike;
+};
+/**
+ * Given two objects A and B that are Json serializable this function computes the difference between them
+ *
+ * The difference object includes:
+ *  - fields in object B but not in object A included as `<fieldKey__added>`
+ *  - fields in object A but not in object B included as `<fieldKey__deleted>`
+ *  - fields present in both objects but modified as `<fieldKey>: { __old: <objectAValue>, __new: <objectBValue> }`
+ *
+ * Additionally the difference object contains a `toString` method that can be used to generate a string representation
+ * of the difference between the two objects (to be presented to users)
+ *
+ * @param jsonObjA The first target object
+ * @param jsonObjB The second target object
+ * @returns An object representing the diff between the two objects, or null if the objects are equal
+ */
+declare function diffJsonObjects(jsonObjA: Record<string, JsonLike>, jsonObjB: Record<string, JsonLike>): Record<string, JsonLike> | null;
+/**
+ * Given a diff object (generated by `diffJsonObjects`) this function computes whether the
+ * difference is non-destructive, i.e. if the second object only contained additions to the
+ * first one and no removal nor modifications.
+ *
+ * @param diff The difference object to use (generated by `diffJsonObjects`)
+ * @returns `true` if the difference is non-destructive, `false` if it is
+ */
+declare function isNonDestructive(diff: JsonLike): boolean;
+/**
+ * A modified value in json-diff is represented as an object with two properties:
+ * `__old` and `__new`. Where the former contains the old version of the value and
+ * the latter the new one.
+ * This utility, given an arbitrary value, discerns whether the value represents the
+ * diff of a modified value.
+ *
+ * @param value The target value to check
+ * @returns True if the value represents a value modified, false otherwise
+ */
+declare function isModifiedDiffValue<T extends JsonLike>(value: unknown): value is {
+    __old: T;
+    __new: T;
+};
+
+/**
+ * Object representing the difference of two configuration objects.
+ */
+type ConfigDiff = {
+    /** The actual (raw) computed diff of the two objects */
+    diff: Record<string, JsonLike> | null;
+    /**
+     * Flag indicating whether the difference includes some destructive changes.
+     *
+     * In other words, if the second config is not applying any change or only adding options, such diff is considered non destructive, on the other hand if the config is removing or modifying values it is considered destructive instead.
+     */
+    nonDestructive: boolean;
+};
+/**
+ * Computes the difference between a remote representation of a Worker's config and a local configuration.
+ *
+ * @param remoteConfig The remote representation of a Worker's config
+ * @param localResolvedConfig The local (resolved) config
+ * @returns Object containing the diffing information
+ */
+declare function getRemoteConfigDiff(remoteConfig: RawConfig, localResolvedConfig: Config): ConfigDiff;
+/**
+ * Given a config diff generates a patch object that can be passed to `experimental_patchConfig` to revert the
+ * changes in the config object that are described by the config diff.
+ *
+ * If the config is for a specific target environment, only the environment config object will be targeted for the patch.
+ *
+ * @param configDiff The target config diff
+ * @param targetEnvironment the target environment if any
+ * @returns The patch object to pass to `experimental_patchConfig` to revert the changes
+ */
+declare function getConfigPatch(configDiff: {
+    diff: Record<string, JsonLike> | null;
+    nonDestructive: boolean;
+}["diff"], targetEnvironment?: string | undefined): RawConfig;
+
+declare function validateFileSecrets(content: unknown, jsonFilePath: string): content is Record<string, string | null>;
+/** Error thrown when no input is provided to parseBulkInputToObject */
+declare class NoInputError extends Error {
+    constructor();
+}
+/** Result from parsing bulk secret input without nullable values, including metadata for analytics */
+type BulkInputResult = {
+    content: Record<string, string>;
+    secretSource: "file" | "stdin";
+    secretFormat: "json" | "dotenv";
+};
+/** Result from parsing bulk secret input with nullable values, including metadata for analytics */
+type BulkInputNullableResult = {
+    content: Record<string, string | null>;
+    secretSource: "file" | "stdin";
+    secretFormat: "json" | "dotenv";
+};
+/** Override for callers that need non-nullable */
+declare function parseBulkInputToObject(input?: string, includeNull?: false): Promise<BulkInputResult | undefined>;
+/** Override for callers that need nullable */
+declare function parseBulkInputToObject(input?: string, includeNull?: true): Promise<BulkInputNullableResult | undefined>;
+
+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>;
+
+declare function handleUnsafeCapnp(capnp: CfCapnp): Buffer;
+
+declare const moduleTypeMimeType: {
+    [type in CfModuleType]: string | undefined;
+};
+declare function fromMimeType(mimeType: string): CfModuleType;
+/**
+ * Creates a `FormData` upload from Worker data and bindings
+ */
+declare function createWorkerUploadForm(worker: Omit<CfWorkerInit, "bindings" | "rawBindings">, bindings: Record<string, Binding> | undefined, options?: {
+    dryRun?: true;
+    unsafe?: {
+        metadata?: Record<string, unknown>;
+        capnp?: CfCapnp;
+    };
+}): FormData;
+
+/**
+ * Inject bindings into the Worker to support Workers Sites. These are injected at the last minute so that
+ * they don't display in the output of `printBindings()`
+ */
+declare function addWorkersSitesBindings(bindings: Record<string, Binding>, namespace: string | undefined, manifest: {
+    [filePath: string]: string;
+} | undefined, format: CfScriptFormat): {
+    [x: string]: Binding;
+};
+
+declare function deployWfpUserWorker(dispatchNamespace: string, versionId: string | null): void;
+
+declare function getDeployConfirmFunction(options: {
+    strictMode?: boolean;
+}): (text: string) => Promise<boolean>;
+
+/**
+ * Sanitizes a branch name to create a valid DNS label alias.
+ * Converts to lowercase, replaces invalid chars with dashes, removes consecutive dashes.
+ */
+declare function sanitizeBranchName(branchName: string): string;
+/**
+ * Gets the current branch name from CI environment or git.
+ */
+declare function getBranchName(): string | undefined;
+/**
+ * Creates a truncated alias with hash suffix when the branch name is too long.
+ * Hash from original branch name to preserve uniqueness.
+ */
+declare function createTruncatedAlias(branchName: string, sanitizedAlias: string, availableSpace: number): string | undefined;
+/**
+ * Generates a preview alias based on the current git branch.
+ * Alias must be <= 63 characters, alphanumeric + dashes only, and start with a letter.
+ * Returns undefined if not in a git directory or requirements cannot be met.
+ */
+declare function generatePreviewAlias(scriptName: string): string | undefined;
+
+type RetrieveSourceMapFunction = NonNullable<Options["retrieveSourceMap"]>;
+declare function maybeRetrieveFileSourceMap(filePath?: string): ReturnType<RetrieveSourceMapFunction>;
+declare function getSourceMappedStack(details: Protocol.Runtime.ExceptionDetails): string;
+declare function getSourceMappedString(value: string, retrieveSourceMap?: RetrieveSourceMapFunction): string;
+
+declare function printBundleSize(main: {
+    name: string;
+    content: string;
+}, modules: CfModule[]): Promise<void>;
+
+/**
+ * Computes and validates the Node.js compatibility mode we are running.
+ *
+ * NOTES:
+ * - The v2 mode is configured via `nodejs_compat_v2` compat flag or via `nodejs_compat` plus a compatibility date of Sept 23rd. 2024 or later.
+ * - See `EnvironmentInheritable` for `noBundle`.
+ *
+ * @param compatibilityDateStr The compatibility date
+ * @param compatibilityFlags The compatibility flags
+ * @param noBundle Whether to skip internal build steps and directly deploy script
+ *
+ */ declare function validateNodeCompatMode(compatibilityDateStr: string | undefined, // Default to some arbitrary old date
+compatibilityFlags: string[], { noBundle, }: {
+    noBundle?: boolean;
+}): NodeJSCompatMode;
+
+declare const validateRoutes: (routes: Route[], assets: AssetsOptions | undefined) => void;
+
+declare function hasDefinedEnvironments(config: Config): boolean;
+declare function applyServiceAndEnvironmentTags(config: Config, tags: string[]): string[];
+declare function warnOnErrorUpdatingServiceAndEnvironmentTags(): void;
+declare function tagsAreEqual(a: string[], b: string[]): boolean;
+
+declare function helpIfErrorIsSizeOrScriptStartup(err: unknown, dependencies: {
+    [path: string]: {
+        bytesInOutput: number;
+    };
+}, workerBundle: FormData | string, projectRoot: string | undefined, analyseBundle?: (bundle: FormData | string) => Promise<unknown>): Promise<string | null>;
+/**
+ * Returns a formatted error message that describes the script size error.
+ * It includes the largest dependencies if available.
+ */
+declare function diagnoseScriptSizeError(err: ParseError, dependencies: {
+    [path: string]: {
+        bytesInOutput: number;
+    };
+}): string;
+/**
+ * Returns a formatted error message that describes the startup error.
+ * If profiling is successful, it will include a link to the generated CPU profile.
+ */
+declare function diagnoseStartupError(err: ParseError, workerBundle: FormData | string, projectRoot: string | undefined, analyseBundle?: (bundle: FormData | string) => Promise<unknown>): Promise<string>;
+
+type Percentage = number;
+type UUID = string;
+type VersionId = UUID;
+type ApiDeployment = {
+    id: string;
+    source: "api" | string;
+    strategy: "percentage" | string;
+    author_email: string;
+    annotations?: Record<string, string>;
+    created_on: string;
+    versions: Array<{
+        version_id: VersionId;
+        percentage: Percentage;
+    }>;
+};
+type ApiVersion = {
+    id: VersionId;
+    number: number;
+    metadata: {
+        created_on: string;
+        modified_on: string;
+        source: "api" | string;
+        author_id: string;
+        author_email: string;
+    };
+    annotations?: {
+        "workers/triggered_by"?: "upload" | string;
+        "workers/message"?: string;
+        "workers/tag"?: string;
+    };
+    resources: {
+        bindings: WorkerMetadataBinding[];
+        script: {
+            etag: string;
+            handlers: string[] | null;
+            placement_mode?: "smart";
+            last_deployed_from: string;
+        };
+        script_runtime: {
+            compatibility_date?: string;
+            compatibility_flags?: string[];
+            usage_model: "bundled" | "unbound" | "standard";
+            limits: CfUserLimits;
+        };
+    };
+    startup_time_ms?: number;
+};
+type VersionCache = Map<VersionId, ApiVersion>;
+
+declare function fetchVersion(complianceConfig: ComplianceConfig, accountId: string, workerName: string, versionId: VersionId, versionCache: VersionCache | undefined): Promise<ApiVersion>;
+declare function fetchVersions(complianceConfig: ComplianceConfig, accountId: string, workerName: string, versionCache: VersionCache | undefined, versionIds: VersionId[]): Promise<ApiVersion[]>;
+declare function fetchLatestDeployments(complianceConfig: ComplianceConfig, accountId: string, workerName: string): Promise<ApiDeployment[]>;
+declare function fetchLatestDeployment(complianceConfig: ComplianceConfig, accountId: string, workerName: string): Promise<ApiDeployment | undefined>;
+declare function fetchDeploymentVersions(complianceConfig: ComplianceConfig, accountId: string, workerName: string, deployment: ApiDeployment | undefined, versionCache: VersionCache): Promise<[ApiVersion[], Map<VersionId, Percentage>]>;
+declare function fetchDeployableVersions(complianceConfig: ComplianceConfig, accountId: string, workerName: string, versionCache: VersionCache): Promise<ApiVersion[]>;
+declare function createDeployment(complianceConfig: ComplianceConfig, accountId: string, workerName: string, versionTraffic: Map<VersionId, Percentage>, message: string | undefined, force: boolean | undefined): Promise<{
+    id: string;
+}>;
+type NonVersionedScriptSettings = {
+    logpush: boolean;
+    tags: string[] | null;
+    tail_consumers: TailConsumer[];
+    streaming_tail_consumers: StreamingTailConsumer[];
+    observability: Observability;
+};
+declare function patchNonVersionedScriptSettings(complianceConfig: ComplianceConfig, accountId: string, workerName: string, settings: Partial<NonVersionedScriptSettings>): Promise<Partial<NonVersionedScriptSettings>>;
+
+type Workflow = {
+    name: string;
+    id: string;
+    created_on: string;
+    modified_on: string;
+    script_name: string;
+    class_name: string;
+};
+interface WorkflowConflict {
+    name: string;
+    currentOwner: string;
+}
+declare const WORKFLOW_NOT_FOUND_CODE = 10200;
+declare function checkWorkflowConflicts(config: Config, accountId: string, scriptName: string): Promise<{
+    hasConflicts: false;
+} | {
+    hasConflicts: true;
+    conflicts: WorkflowConflict[];
+    message: string;
+}>;
+
+type CustomDomainsRes = {
+    id: string;
+    zone_id: string;
+    zone_name: string;
+    hostname: string;
+    service: string;
+    environment: string;
+    cert_id: string;
+    enabled: boolean;
+    previews_enabled: boolean;
+}[];
+type WorkerSubdomainRes = {
+    enabled: boolean;
+    previews_enabled: boolean;
+};
+type CronTriggersRes = {
+    schedules: {
+        cron: string;
+        created_on: Date;
+        modified_on: Date;
+    }[];
+};
+type RoutesRes = {
+    id: string;
+    pattern: string;
+    zone_name: string;
+    script: string;
+}[];
+/**
+ * Downloads all information required to construct a Wrangler config file for a Worker from the API
+ */
+declare function fetchWorkerConfig(accountId: string, workerName: string, environment: string): Promise<{
+    bindings: _cloudflare_workers_utils.WorkerMetadataBinding[];
+    routes: RoutesRes;
+    customDomains: CustomDomainsRes;
+    subdomainStatus: WorkerSubdomainRes;
+    serviceEnvMetadata: {
+        environment: string;
+        created_on: string;
+        modified_on: string;
+        script: {
+            id: string;
+            tag: string;
+            tags: string[];
+            etag: string;
+            handlers: string[];
+            modified_on: string;
+            created_on: string;
+            migration_tag: string;
+            usage_model: "bundled" | "unbound";
+            limits: {
+                cpu_ms: number;
+                subrequests: number;
+            };
+            compatibility_date: string;
+            compatibility_flags: string[];
+            last_deployed_from?: "wrangler" | "dash" | "api";
+            placement_mode?: "smart";
+            tail_consumers?: _cloudflare_workers_utils.TailConsumer[];
+            observability?: _cloudflare_workers_utils.Observability;
+        };
+    };
+    cronTriggers: CronTriggersRes;
+}>;
+/**
+ * Downloads all the remote information we can gather for a worker and from them generates a raw configuration object that
+ * approximates what a wrangler config object for the worker was/would have been.
+ */
+declare function downloadWorkerConfig(workerName: string, environment: string, entrypoint: string, accountId: string): Promise<RawConfig>;
+
+/**
+ * For a given Worker + migrations config, figure out which migrations
+ * to upload based on the current migration tag of the deployed Worker.
+ */
+declare function getMigrationsToUpload(scriptName: string, props: {
+    accountId: string | undefined;
+    config: Config;
+    useServiceEnvironments: boolean | undefined;
+    env: string | undefined;
+    dispatchNamespace: string | undefined;
+}): Promise<CfWorkerInit["migrations"]>;
+
+declare function verifyWorkerMatchesCITag(complianceConfig: ComplianceConfig, accountId: string, workerName: string, configPath: string | undefined): Promise<void>;
+
+declare function fetchSecrets(config: Config, accountId: string, environment: string | undefined): Promise<{
+    name: string;
+    type: string;
+}[]>;
+declare function checkRemoteSecretsOverride(config: Config, accountId: string, targetEnv: string | undefined): Promise<{
+    override: false;
+} | {
+    override: true;
+    deployErrorMessage: string;
+}>;
+
+declare function confirmLatestDeploymentOverwrite(config: Config, accountId: string, scriptName: string): Promise<boolean>;
+declare function printVersions(versions: ApiVersion[], traffic: Map<VersionId, Percentage>): void;
+
+type PrintContext = {
+    log?: (message: string) => void;
+    registry?: WorkerRegistry | 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 StartDevWorkerInput["bindings"] format
+ */
+declare function printBindings(bindings: StartDevWorkerInput["bindings"], tailConsumers?: CfTailConsumer[], streamingTailConsumers?: CfTailConsumer[], containers?: ContainerApp[], context?: PrintContext): void;
+/**
+ * Validates the user's `remote` setting for a given binding against the
+ * binding type's local-development capabilities (sourced from
+ * {@link getBindingLocalSupport}). Throws `UserError` for invalid combinations
+ * and emits warnings for valid-but-noteworthy ones.
+ */
+declare function warnOrError(type: Binding["type"], remote: boolean | undefined): void;
+
+type AssetManifest = {
+    [path: string]: {
+        hash: string;
+        size: number;
+    };
+};
+declare const syncAssets: (complianceConfig: ComplianceConfig, accountId: string | undefined, assetDirectory: string, scriptName: string, dispatchNamespace?: string) => Promise<string>;
+declare const buildAssetManifest: (dir: string) => Promise<AssetManifest>;
+
+declare const hashFile: (filepath: string) => string;
+
+declare const isJwtExpired: (token: string) => boolean | undefined;
+
+export { type ApiDeployment, type ApiVersion, type AssetManifest, type BulkInputNullableResult, type BulkInputResult, type Consumer, type ConsumerSettings, type CustomDomain, type CustomDomainChangeset, type DeployCallbacks, DeployProps, INVALID_INHERIT_BINDING_CODE, type JsonLike, NoInputError, type NonVersionedScriptSettings, type Percentage, type PostQueueBody, type PostQueueResponse, type PostTypedConsumerBody, type Producer, type PurgeQueueBody, type PurgeQueueResponse, type QueueResponse, type QueueSettings, type RetrieveSourceMapFunction, type RouteObject, type ScriptReference, type SourceMapBundle, TriggerDeployment, TriggerProps, type TypedConsumerResponse, type VersionCache, type VersionId, type VersionsUploadCallbacks, VersionsUploadProps, WORKER_LEGACY_ENVIRONMENT_NOT_FOUND_ERR_CODE, WORKER_NOT_FOUND_ERR_CODE, WORKFLOW_NOT_FOUND_CODE, WorkerBuildResult, type Workflow, type WorkflowConflict, type Zone, type ZoneIdCache, addRequiredSecretsInheritBindings, addWorkersSitesBindings, applyServiceAndEnvironmentTags, buildAssetManifest, checkRemoteSecretsOverride, checkWorkflowConflicts, confirmLatestDeploymentOverwrite, convertConfigToBindings, createDeployment, createTruncatedAlias, createWorkerUploadForm, deletePullConsumer, deleteWorkerConsumer, deploy, deployWfpUserWorker, diagnoseScriptSizeError, diagnoseStartupError, diffJsonObjects, downloadWorkerConfig, ensureQueuesExistByConfig, extractBindingsOfType, fetchDeployableVersions, fetchDeploymentVersions, fetchLatestDeployment, fetchLatestDeployments, fetchSecrets, fetchVersion, fetchVersions, fetchWorkerConfig, fromMimeType, generatePreviewAlias, getBindings, getBranchName, getConfigPatch, getDeployConfirmFunction, getMigrationsToUpload, getQueue, getRemoteConfigDiff, getSourceMappedStack, getSourceMappedString, getSubdomainValues, getSubdomainValuesAPIMock, getWorkersDevSubdomain, getZoneForRoute, getZoneIdFromHost, handleMissingSecretsError, handleUnsafeCapnp, hasDefinedEnvironments, hashFile, helpIfErrorIsSizeOrScriptStartup, isJwtExpired, isModifiedDiffValue, isNonDestructive, isUnsafeBindingType, isWorkerNotFoundError, listConsumers, listQueues, loadSourceMaps, maybeRetrieveFileSourceMap, moduleTypeMimeType, parseBulkInputToObject, parseConfigPlacement, patchNonVersionedScriptSettings, postConsumer, printBindings, printBundleSize, printVersions, publishCustomDomains, publishRoutes, putConsumer, putConsumerById, renderRoute, sanitizeBranchName, syncAssets, tagsAreEqual, triggersDeploy, tryAttachSourcemapToModule, updateQueueConsumers, useServiceEnvironments, validateFileSecrets, validateNodeCompatMode, validateRoutes, verifyWorkerMatchesCITag, versionsUpload, warnOnErrorUpdatingServiceAndEnvironmentTags, warnOrError, workerNotFoundErrorMessage };