@sanity/cli-core 0.0.0-20260410130107

package/dist/_exports/index.d.ts

@@ -0,0 +1,1391 @@
+import { ClientConfig } from "@sanity/client";
+import { CLIError } from "@oclif/core/errors";
+import { Command } from "@oclif/core";
+import { CommandError } from "@oclif/core/interfaces";
+import { ConfigEnv } from "vite";
+import { ConsentStatus } from "@sanity/telemetry";
+import debugIt from "debug";
+import { InlineConfig } from "vite";
+import { Interfaces } from "@oclif/core";
+import { PluginOptions } from "babel-plugin-react-compiler";
+import { SanityClient } from "sanity";
+import { SanityClient as SanityClient_2 } from "@sanity/client";
+import { TelemetryLogger } from "@sanity/telemetry";
+import { URL as URL_2 } from "node:url";
+import { Worker as Worker_2 } from "node:worker_threads";
+import { WorkerOptions as WorkerOptions_2 } from "node:worker_threads";
+import { Workspace } from "sanity";
+import { z } from "zod/mini";
+
+declare type Args<T extends typeof Command> = Interfaces.InferredArgs<
+  T["args"]
+>;
+
+/**
+ * Clears the global CLI telemetry store.
+ * @internal
+ */
+export declare function clearCliTelemetry(): void;
+
+/**
+ * Clear the in-process token cache so the next `getCliToken()` call
+ * re-reads from disk or the environment.
+ *
+ * Called automatically by `setCliUserConfig('authToken', ...)`.
+ *
+ * @internal
+ */
+export declare function clearCliTokenCache(): void;
+
+/**
+ * @public
+ * Symbol used to store CLI telemetry state on globalThis.
+ * Use the accessor functions instead of accessing this directly.
+ */
+export declare const CLI_TELEMETRY_SYMBOL: unique symbol;
+
+/**
+ * @public
+ */
+export declare interface CliConfig {
+  /** The project ID and dataset the Sanity CLI should use to run its commands */
+  api?: {
+    dataset?: string;
+    projectId?: string;
+  };
+  /** Configuration for custom Sanity apps built with the App SDK */
+  app?: {
+    /** The entrypoint for your custom app. By default, `src/App.tsx` */
+    entry?: string;
+    /**
+     * Path to an icon file relative to project root.
+     * The file must be an SVG.
+     */
+    icon?: string;
+    /** @deprecated Use deployment.appId */
+    id?: string;
+    /** The ID for the Sanity organization that manages this application */
+    organizationId?: string;
+    /** The title of the custom app, as it is seen in Dashboard UI */
+    title?: string;
+  };
+  /** @deprecated Use deployment.autoUpdates */
+  autoUpdates?: boolean;
+  /** Options for custom app and Studio deployments */
+  deployment?: {
+    /**
+     * The ID for your custom app or Studio. Generated when deploying your app or Studio for the first time.
+     * Get your app ID by either:
+     * 1. Checking the output of `sanity deploy`, or
+     * 2. Checking your project’s Studio tab at https://sanity.io/manage
+     *
+     * @remarks This is required for all custom app deployments, and for Studios opting in to fine grained version control.
+     * {@link https://www.sanity.io/docs/studio/latest-version-of-sanity#k0896ed4574b7}
+     */
+    appId?: string;
+    /**
+     * Enable automatic updates for your Studio or custom app’s Sanity dependencies.
+     * {@link https://www.sanity.io/docs/studio/latest-version-of-sanity}
+     */
+    autoUpdates?: boolean;
+  };
+  /**
+   * Enable federated builds & dev environments for your studio or application.
+   * @experimental
+   */
+  federation?: {
+    enabled: boolean;
+  };
+  /** Define the GraphQL APIs that the CLI can deploy and interact with */
+  graphql?: Array<{
+    filterSuffix?: string;
+    generation?: "gen1" | "gen2" | "gen3";
+    id?: string;
+    nonNullDocumentFields?: boolean;
+    playground?: boolean;
+    source?: string;
+    tag?: string;
+    workspace?: string;
+  }>;
+  /** Configuration for the Media Library */
+  mediaLibrary?: {
+    /** The path to the Media Library aspects directory. When using the CLI to manage aspects, this is the directory they will be read from and written to. */
+    aspectsPath?: string;
+  };
+  /** Contains the property `basePath` which lets you change the top-level slug for the Studio. You typically need to set this if you embed the Studio in another application where it is one of many routes. Defaults to an empty string. */
+  project?: {
+    basePath?: string;
+  };
+  /** Configuration options for React Compiler */
+  reactCompiler?: PluginOptions;
+  /** Wraps the Studio in \<React.StrictMode\> root to aid in flagging potential problems related to concurrent features (startTransition, useTransition, useDeferredValue, Suspense). Can also be enabled by setting SANITY_STUDIO_REACT_STRICT_MODE="true"|"false". It only applies to sanity dev in development mode and is ignored in sanity build and in production. Defaults to false. */
+  reactStrictMode?: boolean;
+  /**
+   * Configuration for schema extraction (`sanity schema extract`)
+   */
+  schemaExtraction?: {
+    /**
+     * Enable schema extraction as part of sanity dev and sanity build
+     */
+    enabled?: boolean;
+    /**
+     * When true, schema fields marked as required will be non-optional in the output.
+     * Defaults to `false`
+     */
+    enforceRequiredFields?: boolean;
+    /**
+     * Output path for the extracted schema file.
+     * Defaults to `schema.json` in the working directory.
+     */
+    path?: string;
+    /**
+     * Additional glob patterns to watch for schema changes in watch mode.
+     * These extend the default patterns:
+     * - `sanity.config.{js,jsx,ts,tsx,mjs}`
+     * - `schema*\/**\/*.{js,jsx,ts,tsx,mjs}`
+     */
+    watchPatterns?: string[];
+    /**
+     * The name of the workspace to generate a schema for. Required if your Sanity project has more than one
+     * workspace.
+     */
+    workspace?: string;
+  };
+  /** Defines the hostname and port that the development server should run on. hostname defaults to localhost, and port to 3333. */
+  server?: {
+    hostname?: string;
+    port?: number;
+  };
+  /** @deprecated Use deployment.appId */
+  studioHost?: string;
+  /**
+   * Configuration for Sanity typegen
+   */
+  typegen?: Partial<TypeGenConfig> & {
+    /**
+     * Enable typegen as part of sanity dev and sanity build.
+     * When enabled, types are generated on startup and when files change.
+     * Defaults to `false`
+     */
+    enabled?: boolean;
+  };
+  /** Exposes the default Vite configuration for custom apps and the Studio so it can be changed and extended. */
+  vite?: UserViteConfig;
+}
+
+/**
+ * @public
+ */
+export declare type CLITelemetryStore =
+  TelemetryLogger<TelemetryUserProperties>;
+
+export declare function colorizeJson(input: unknown): string;
+
+/**
+ * A raw key-value store for CLI user configuration.
+ * Unlike the typed `getCliUserConfig`/`setCliUserConfig`, this operates on
+ * arbitrary keys without schema validation.
+ *
+ * @public
+ */
+export declare interface ConfigStore {
+  /** Remove a key from the config file. */
+  delete: (key: string) => void;
+  /** Read a value by key. Returns `undefined` if the key does not exist. */
+  get: (key: string) => unknown;
+  /** Write a value by key, merging it into the existing config. */
+  set: (key: string, value: unknown) => void;
+}
+
+export declare type ConsentInformation =
+  | {
+      reason: "fetchError" | "unauthenticated";
+      status: Extract<ConsentStatus, "undetermined">;
+    }
+  | {
+      reason?: "localOverride";
+      status: Extract<ConsentStatus, "denied">;
+    }
+  | {
+      reason?: never;
+      status: Extract<ConsentStatus, "granted">;
+    }
+  | {
+      reason?: never;
+      status: Extract<ConsentStatus, "unset">;
+    };
+
+/**
+ * Creates a new worker for a studio worker task.
+ *
+ * This uses a combination of vite for "bundling" + jsdom for emulating a browser
+ * environment under the hood, which means that the same thing that will work in vite
+ * _should_ work in the worker - to a degree. If the user has defined any typescript
+ * path aliases, these will have to be added as aliases to the vite config - the same
+ * behavior as you would see with regular vite. Other things that are accounted for:
+ *
+ * - TypeScript support (+JSX, enums and other "compilation needed" features)
+ * - CSS, font and other file imports will resolve to a file path
+ * - CSS module imports will resolve to a javascript object of class names
+ * - Environment variables are available both as `import.meta.env` and `process.env`,
+ *   and `.env` files are loaded in the same way that they would in a Sanity studio.
+ * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM
+ *   are defined directly to the Node environment as globals. While this polutes the
+ *   global namespace, it is done only in the worker thread.
+ * - Certain browser globals that are _not_ available in JSDOM are also provided to the
+ *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.
+ *   These are provided with a minimal stub implementation to make them not crash.
+ *
+ * @param filePath - Path to the worker file (`.ts` works and is encouraged)
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */
+export declare function createStudioWorker(
+  filePath: URL,
+  options: StudioWorkerTaskOptions,
+): Worker_2;
+
+/**
+ * `debug` instance for the CLI
+ *
+ * @internal
+ */
+declare const debug_2: debugIt.Debugger;
+export { debug_2 as debug };
+
+/**
+ * This function is a replacement for built in dynamic import
+ * This handles the case for windows file paths especially for absolute paths.
+ *
+ * @param source - File path
+ */
+export declare function doImport(source: string): Promise<any>;
+
+/**
+ * Standard exit codes for CLI commands.
+ *
+ * - 0, 1, 2 align with oclif defaults and Unix convention.
+ * - 3 is application-defined (oclif does not use it).
+ * - 130 follows the Unix convention of 128 + signal number (SIGINT = 2).
+ *
+ * @see CLAUDE.md "Exit Code Convention" for usage guidance and examples.
+ */
+export declare const exitCodes: {
+  /** Something went wrong that is not the user's fault (API errors, network, missing config, etc.). */
+  readonly RUNTIME_ERROR: 1;
+  /** The user interrupted via Ctrl+C (128 + SIGINT). Handled by SanityCommand.catch(). */
+  readonly SIGINT: 130;
+  /** Command completed normally. */
+  readonly SUCCESS: 0;
+  /** The user provided invalid input (bad args, unknown flags, validation failures). */
+  readonly USAGE_ERROR: 2;
+  /** The user declined a confirmation or chose not to proceed. */
+  readonly USER_ABORT: 3;
+};
+
+/**
+ * Finds the path for a given set of files.
+ *
+ * @param basePath - The base path to search for files.
+ * @param files - The files to search for.
+ * @internal
+ */
+export declare function findPathForFiles(
+  basePath: string,
+  files: string[],
+): Promise<PathResult[]>;
+
+/**
+ * Resolve project root directory and type.
+ *
+ * Project root is:
+ * - `studio` - A pre-blueprints Sanity studio root (containing `sanity.config.(ts|js)`)
+ * - `app` - A Sanity app root (containing `sanity.cli.(ts|js)`)
+ *
+ * If a Sanity Studio v2/v1 root is found (containing `sanity.json` with `root: true`),
+ * an error is thrown, as v2/v1 is no longer supported.
+ *
+ * @internal
+ */
+export declare function findProjectRoot(
+  cwd: string,
+): Promise<ProjectRootResult>;
+
+/**
+ * Resolve project root directory and type synchronously.
+ *
+ * Project root is:
+ * - `studio` - A pre-blueprints Sanity studio root (containing `sanity.config.(ts|js)`)
+ * - `app` - A Sanity app root (containing `sanity.cli.(ts|js)`)
+ *
+ * If a Sanity Studio v2/v1 root is found (containing `sanity.json` with `root: true`),
+ * an error is thrown, as v2/v1 is no longer supported.
+ *
+ * @param cwd - Current working directory to start searching from
+ * @returns Project root result
+ * @internal
+ */
+export declare function findProjectRootSync(cwd: string): ProjectRootResult;
+
+/**
+ * Resolves to a string containing the found config path, otherwise throws an error.
+ * Also throws if Sanity v2 studio root is found.
+ *
+ * @param basePath - The base path to start searching from
+ * @returns A promise that resolves to a string containing the found config path
+ * @throws On multiple config files found, if v2 studio root found, or no config found
+ * @internal
+ */
+export declare function findStudioConfigPath(basePath: string): Promise<string>;
+
+declare type Flags<T extends typeof Command> = Interfaces.InferredFlags<
+  (typeof SanityCommand)["baseFlags"] & T["flags"]
+>;
+
+/**
+ * Get the CLI config for a project, given the root path.
+ *
+ * Results are cached in-memory keyed by rootPath for the lifetime of the
+ * process. Since the CLI always runs from a single project root, the config
+ * won't change during a command's execution, so caching avoids redundant
+ * filesystem reads and jiti imports from the prerun hook, SanityCommand
+ * helpers, and action files.
+ *
+ * If loading fails the cached promise is evicted so the next call retries.
+ *
+ * @param rootPath - Root path for the project, eg where `sanity.cli.(ts|js)` is located.
+ * @returns The CLI config
+ * @internal
+ */
+export declare function getCliConfig(rootPath: string): Promise<CliConfig>;
+
+/**
+ * Get the CLI config for a project synchronously, given the root path.
+ *
+ * This loads the CLI config in the main thread using tsx/register for TypeScript support.
+ * Note: This is a synchronous operation and does not use worker threads like the async version.
+ *
+ * @param rootPath - Root path for the project, eg where `sanity.cli.(ts|js)` is located.
+ * @returns The CLI config
+ * @internal
+ */
+export declare function getCliConfigSync(rootPath: string): CliConfig;
+
+/**
+ * @public
+ */
+export declare function getCliTelemetry(): CLITelemetryStore;
+
+/**
+ * Get the CLI authentication token from the environment or the config file
+ *
+ * @returns A promise that resolves to a CLI token, or undefined if no token is found
+ * @internal
+ */
+export declare function getCliToken(): Promise<string | undefined>;
+
+/**
+ * Get the config value for the given property
+ *
+ * @param prop - The property to get the value for
+ * @returns The value of the given property
+ * @internal
+ */
+export declare function getCliUserConfig(prop: "authToken"): string | undefined;
+
+/**
+ * Create a "global" (unscoped) Sanity API client.
+ *
+ * @public
+ *
+ * @param options - The options to use for the client.
+ * @returns Promise that resolves to a configured Sanity API client.
+ */
+export declare function getGlobalCliClient({
+  requireUser,
+  token: providedToken,
+  unauthenticated,
+  ...config
+}: GlobalCliClientOptions): Promise<SanityClient_2>;
+
+/**
+ * Create a "project" (scoped) Sanity API client.
+ *
+ * @public
+ *
+ * @param options - The options to use for the client.
+ * @returns Promise that resolves to a configured Sanity API client.
+ */
+export declare function getProjectCliClient({
+  requireUser,
+  token: providedToken,
+  ...config
+}: ProjectCliClientOptions): Promise<SanityClient_2>;
+
+/**
+ * Gets an environment variable with the appropriate Sanity prefix based on whether it's an app or studio.
+ *
+ * @param suffix - The suffix for the environment variable (e.g., 'SERVER_HOSTNAME')
+ * @param isApp - Whether to use the app prefix (SANITY_APP_) or studio prefix (SANITY_STUDIO_)
+ * @returns The value of the environment variable, or undefined if not set
+ *
+ * @example
+ * ```ts
+ * // For studio: SANITY_STUDIO_SERVER_HOSTNAME
+ * const studioHostname = getSanityEnvVar('SERVER_HOSTNAME', false)
+ *
+ * // For app: SANITY_APP_SERVER_HOSTNAME
+ * const appHostname = getSanityEnvVar('SERVER_HOSTNAME', true)
+ * ```
+ *
+ * @internal
+ */
+export declare function getSanityEnvVar(
+  suffix: string,
+  isApp: boolean,
+): string | undefined;
+
+/**
+ * @internal
+ * @returns The Sanity URL for the given path, using the correct domain based on the environment
+ */
+export declare function getSanityUrl(path?: string): string;
+
+/**
+ * Get the studio config for a project, given the root path.
+ *
+ * @param rootPath - The root path for the project
+ * @returns The studio config (some properties may be missing)
+ * @public
+ */
+export declare function getStudioConfig(
+  rootPath: string,
+  options: {
+    resolvePlugins: true;
+  },
+): Promise<ResolvedStudioConfig>;
+
+export declare function getStudioConfig(
+  rootPath: string,
+  options: {
+    resolvePlugins: false;
+  },
+): Promise<RawStudioConfig>;
+
+/**
+ * Resolves the workspaces from the studio config.
+ *
+ * NOTE: This function should only be called from a worker thread.
+ *
+ * @param configPath - The path to the studio config
+ * @returns The workspaces
+ * @internal
+ */
+export declare function getStudioWorkspaces(
+  configPath: string,
+): Promise<Workspace[]>;
+
+/**
+ * Gets the base telemetry information needed for file operations.
+ *
+ * This shared utility extracts common logic used by:
+ * - `generateTelemetryFilePath` - for generating session-specific file paths
+ * - `findTelemetryFiles` - for discovering all telemetry files via glob patterns
+ *
+ * @returns Promise resolving to base telemetry information
+ * @throws Error if no auth token is found
+ * @internal
+ */
+export declare function getTelemetryBaseInfo(): Promise<TelemetryBaseInfo>;
+
+/**
+ * Starts a terminal timer
+ *
+ * @internal
+ */
+export declare function getTimer(): TimeMeasurer;
+
+/**
+ * Get a key-value store backed by the CLI user configuration file
+ * (`~/.config/sanity/config.json`).
+ *
+ * Each call to `get`, `set`, or `delete` performs a full synchronous
+ * read-modify-write cycle. This is intentional: sync I/O prevents
+ * intra-process race conditions that occurred with the previous async
+ * (configstore-backed) implementation.
+ *
+ * Note: there is no file-level locking, so concurrent writes from
+ * separate CLI processes could still conflict. In practice this is
+ * unlikely since CLI config writes are rare and user-initiated.
+ *
+ * @returns A {@link ConfigStore} for the CLI config file
+ * @public
+ */
+export declare function getUserConfig(): ConfigStore;
+
+/**
+ * @public
+ */
+export declare interface GlobalCliClientOptions extends ClientConfig {
+  /**
+   * The API version to use for this client.
+   */
+  apiVersion: string;
+  /**
+   * Whether to require a user to be authenticated to use this client.
+   * Default: `false`.
+   * Throws an error if `true` and user is not authenticated.
+   */
+  requireUser?: boolean;
+  /**
+   * Whether to skip reading the stored CLI token. When `true`, the client will
+   * have no token unless one is explicitly provided.
+   * Default: `false`.
+   */
+  unauthenticated?: boolean;
+}
+
+/**
+ * Imports a module using jiti and returns its exports.
+ * This is a thin wrapper around tsx to allow swapping out the underlying implementation in the future if needed.
+ *
+ * @param filePath - Path to the module to import.
+ * @param options - Options for the importModule function.
+ * @returns The exported module.
+ *
+ * @internal
+ */
+export declare function importModule<T = unknown>(
+  filePath: string | URL,
+  options?: ImportModuleOptions,
+): Promise<T>;
+
+declare interface ImportModuleOptions {
+  /**
+   * Whether to return the default export of the module.
+   * Default: true
+   */
+  default?: boolean;
+  /**
+   * Path to the tsconfig file to use for the import. If not provided, the tsconfig
+   * will be inferred from the nearest `tsconfig.json` file.
+   */
+  tsconfigPath?: string;
+}
+
+export declare const isCi: () => boolean;
+
+export declare function isInteractive(): boolean;
+
+/**
+ * Returns whether or not the given error is a `NotFoundError`
+ *
+ * @param err - The error to check
+ * @returns `true` if the error is a `NotFoundError`, `false` otherwise
+ * @internal
+ */
+export declare function isNotFoundError(err: unknown): err is NotFoundError;
+
+/**
+ * Returns whether or not the given error is a `ProjectRootNotFoundError`
+ *
+ * @param err - The error to check
+ * @returns `true` if the error is a `ProjectRootNotFoundError`, `false` otherwise
+ * @internal
+ */
+export declare function isProjectRootNotFoundError(
+  err: unknown,
+): err is ProjectRootNotFoundError;
+
+/**
+ * Checks if the environment is staging.
+ *
+ * @returns True if the environment is staging, false otherwise
+ * @internal
+ */
+export declare function isStaging(): boolean;
+
+/**
+ * Checks if the given value conforms to a minimum studio config shape.
+ *
+ * @param value - The value to check
+ * @returns Whether the value is a studio config
+ * @internal
+ */
+export declare function isStudioConfig(value: unknown): boolean;
+
+/**
+ * Mocks a browser-like environment for processes in the main thread by:
+ * - Injecting browser globals (window, document, ResizeObserver, etc.)
+ * - Loading studio environment variables from the project's sanity installation into process.env
+ *
+ * This is useful for commands like `sanity exec` that have to run user scripts
+ * in the main thread of the process (but in a child process).
+ *
+ * Be cautious when using this, since it will pollute the global namespace with browser globals.
+ *
+ * If your code can run in a worker thread, you should use the `studioWorkerTask` function instead.
+ *
+ * @param basePath - The root path of the Sanity Studio project
+ * @returns A cleanup function that removes the injected globals and environment variables
+ * @internal
+ */
+export declare function mockBrowserEnvironment(
+  basePath: string,
+): Promise<() => void>;
+
+/**
+ * Error thrown when a prompt is attempted in a non-interactive environment
+ * (e.g., CI, non-TTY, piped stdin). Callers can catch this specific error
+ * to provide appropriate fallback behavior.
+ *
+ * Extends `CLIError` to suppress stack traces in user-facing output.
+ */
+export declare class NonInteractiveError extends CLIError {
+  constructor(promptName: string);
+}
+
+/**
+ * Normalizes a path for cross-platform comparison by converting backslashes to forward slashes.
+ * Useful for converting windows paths to unix paths.
+ *
+ * @param path - Path to normalize
+ * @returns Normalized path with forward slashes
+ * @public
+ */
+export declare function normalizePath(path: string): string;
+
+/**
+ * Error thrown when a file or directory is not found
+ *
+ * `code` is always `ENOENT` to mirror Node.js behavior when a file is not found
+ *
+ * @internal
+ */
+export declare class NotFoundError extends Error {
+  code: string;
+  path?: string;
+  constructor(message: string, path?: string);
+}
+
+export declare interface Output {
+  error: Command["error"];
+  log: Command["log"];
+  warn: Command["warn"];
+}
+
+/**
+ * Comprehensive representation of a package.json file.
+ * Consolidates all properties from previous type definitions.
+ *
+ * @public
+ */
+export declare type PackageJson = z.infer<typeof packageJsonSchema>;
+
+/**
+ * Comprehensive package.json schema including all common properties.
+ * Feel free to add properties to this,
+ * 🟠ℹ️   BUT ENSURE OPTIONAL STUFF IS ACTUALLY OPTIONAL  ℹ️🟠
+ * 🟠ℹ️ SINCE THIS IS USED IN A NUMBER OF LOCATIONS WHERE ℹ️🟠
+ * 🟠ℹ️ WE CANNOT ENFORCE/GUARANTEE ANY PARTICULAR PROPS  ℹ️🟠
+ */
+declare const packageJsonSchema: z.ZodMiniObject<
+  {
+    name: z.ZodMiniString<string>;
+    version: z.ZodMiniString<string>;
+    dependencies: z.ZodMiniOptional<
+      z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>
+    >;
+    devDependencies: z.ZodMiniOptional<
+      z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>
+    >;
+    peerDependencies: z.ZodMiniOptional<
+      z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>
+    >;
+    exports: z.ZodMiniOptional<
+      z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniAny>
+    >;
+    main: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    types: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    author: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    engines: z.ZodMiniOptional<
+      z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>
+    >;
+    license: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    private: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    repository: z.ZodMiniOptional<
+      z.ZodMiniObject<
+        {
+          type: z.ZodMiniString<string>;
+          url: z.ZodMiniString<string>;
+        },
+        z.core.$strip
+      >
+    >;
+    scripts: z.ZodMiniOptional<
+      z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>
+    >;
+    type: z.ZodMiniOptional<
+      z.ZodMiniEnum<{
+        module: "module";
+        commonjs: "commonjs";
+      }>
+    >;
+  },
+  z.core.$loose
+>;
+
+/**
+ * @internal
+ */
+declare interface PathResult {
+  exists: boolean;
+  path: string;
+}
+
+/**
+ * @public
+ */
+export declare interface ProjectCliClientOptions extends ClientConfig {
+  /**
+   * The API version to use for this client.
+   */
+  apiVersion: string;
+  /**
+   * The project ID to use for this client.
+   */
+  projectId: string;
+  /**
+   * The dataset to use for this client.
+   */
+  dataset?: string;
+  /**
+   * Whether to require a user to be authenticated to use this client.
+   * Default: `false`.
+   * Throws an error if `true` and user is not authenticated.
+   */
+  requireUser?: boolean;
+}
+
+/**
+ * Error thrown when a project root directory cannot be found.
+ *
+ * This occurs when the CLI is run outside a Sanity project directory
+ * (one containing `sanity.config.(ts|js)` or `sanity.cli.(ts|js)`).
+ *
+ * Extends `CLIError` to suppress stack traces in user-facing output.
+ *
+ * @internal
+ */
+export declare class ProjectRootNotFoundError extends CLIError {
+  constructor(
+    message: string,
+    options?: {
+      cause?: Error;
+      suggestions?: string[];
+    },
+  );
+}
+
+/**
+ * Result of finding a project configuration
+ *
+ * @public
+ */
+export declare interface ProjectRootResult {
+  directory: string;
+  /**
+   * Path to the project configuration file, if found.
+   */
+  path: string;
+  /**
+   * Type of project root.
+   */
+  type: "app" | "studio";
+}
+
+/**
+ * Creates a Node.js Worker from the given file path and options, and wraps it
+ * in a Promise that resolves with the first message the worker sends, and
+ * rejects on error, message deserialization failure, or non-zero exit code.
+ * The worker is terminated after a message or error is received.
+ *
+ * @param filePath - URL to the worker file
+ * @param options - Options to pass to the Worker constructor
+ * @returns A promise that resolves with the first message from the worker
+ * @throws If the worker emits an error, a message deserialization error, or exits with a non-zero code
+ * @internal
+ */
+export declare function promisifyWorker<T = unknown>(
+  filePath: URL,
+  options?: PromisifyWorkerOptions,
+): Promise<T>;
+
+declare interface PromisifyWorkerOptions extends WorkerOptions_2 {
+  /** Optional timeout in milliseconds. If the worker does not respond within this time, it will be terminated and the promise rejected. */
+  timeout?: number;
+}
+
+declare const rawConfigSchema: z.ZodMiniUnion<
+  readonly [
+    z.ZodMiniArray<
+      z.ZodMiniObject<
+        {
+          basePath: z.ZodMiniOptional<z.ZodMiniString<string>>;
+          name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+          plugins: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
+          schema: z.ZodMiniOptional<
+            z.ZodMiniObject<
+              {
+                name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                types: z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>;
+              },
+              z.core.$loose
+            >
+          >;
+          title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+          unstable_sources: z.ZodMiniOptional<
+            z.ZodMiniArray<
+              z.ZodMiniObject<
+                {
+                  dataset: z.ZodMiniString<string>;
+                  projectId: z.ZodMiniString<string>;
+                  schema: z.ZodMiniObject<
+                    {
+                      _original: z.ZodMiniObject<
+                        {
+                          name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                          types: z.ZodMiniArray<
+                            z.ZodMiniObject<{}, z.core.$loose>
+                          >;
+                        },
+                        z.core.$loose
+                      >;
+                    },
+                    z.core.$loose
+                  >;
+                },
+                z.core.$loose
+              >
+            >
+          >;
+          dataset: z.ZodMiniString<string>;
+          projectId: z.ZodMiniString<string>;
+        },
+        z.core.$loose
+      >
+    >,
+    z.ZodMiniObject<
+      {
+        basePath: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        plugins: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
+        schema: z.ZodMiniOptional<
+          z.ZodMiniObject<
+            {
+              name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              types: z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>;
+            },
+            z.core.$loose
+          >
+        >;
+        title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        unstable_sources: z.ZodMiniOptional<
+          z.ZodMiniArray<
+            z.ZodMiniObject<
+              {
+                dataset: z.ZodMiniString<string>;
+                projectId: z.ZodMiniString<string>;
+                schema: z.ZodMiniObject<
+                  {
+                    _original: z.ZodMiniObject<
+                      {
+                        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                        types: z.ZodMiniArray<
+                          z.ZodMiniObject<{}, z.core.$loose>
+                        >;
+                      },
+                      z.core.$loose
+                    >;
+                  },
+                  z.core.$loose
+                >;
+              },
+              z.core.$loose
+            >
+          >
+        >;
+        dataset: z.ZodMiniString<string>;
+        projectId: z.ZodMiniString<string>;
+      },
+      z.core.$loose
+    >,
+  ]
+>;
+
+declare type RawStudioConfig = z.infer<typeof rawConfigSchema>;
+
+/**
+ * Read the `package.json` file at the given path
+ *
+ * @param filePath - Path to package.json to read
+ * @param options - Options object for controlling read behavior
+ * @returns The parsed package.json
+ * @public
+ */
+export declare function readPackageJson(
+  filePath: string | URL,
+  options?: ReadPackageJsonOptions,
+): Promise<PackageJson>;
+
+/**
+ * Options for reading package.json files
+ *
+ * @public
+ */
+export declare interface ReadPackageJsonOptions {
+  /**
+   * Default values to merge with the parsed package.json.
+   * Parsed values take precedence over defaults.
+   */
+  defaults?: Partial<PackageJson>;
+  /**
+   * Skip Zod schema validation. When true, the file is parsed but not validated.
+   * Defaults to false.
+   */
+  skipSchemaValidation?: boolean;
+}
+
+declare type RequireProps<T, K extends keyof T> = Omit<T, K> &
+  Required<Pick<T, K>>;
+
+declare const resolvedConfigSchema: z.ZodMiniArray<
+  z.ZodMiniObject<
+    {
+      basePath: z.ZodMiniString<string>;
+      name: z.ZodMiniString<string>;
+      plugins: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
+      title: z.ZodMiniString<string>;
+      unstable_sources: z.ZodMiniArray<
+        z.ZodMiniObject<
+          {
+            dataset: z.ZodMiniString<string>;
+            projectId: z.ZodMiniString<string>;
+            schema: z.ZodMiniObject<
+              {
+                _original: z.ZodMiniObject<
+                  {
+                    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    types: z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>;
+                  },
+                  z.core.$loose
+                >;
+              },
+              z.core.$loose
+            >;
+          },
+          z.core.$loose
+        >
+      >;
+      dataset: z.ZodMiniString<string>;
+      projectId: z.ZodMiniString<string>;
+      schema: z.ZodMiniObject<
+        {
+          _original: z.ZodMiniObject<
+            {
+              name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              types: z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>;
+            },
+            z.core.$loose
+          >;
+        },
+        z.core.$loose
+      >;
+    },
+    z.core.$loose
+  >
+>;
+
+declare type ResolvedStudioConfig = z.infer<typeof resolvedConfigSchema>;
+
+/**
+ * Resolves and imports a package from the local project's node_modules,
+ * relative to the given working directory. This avoids circular dependencies
+ * and ensures the correct version of the package is used.
+ *
+ * @param packageName - The name of the package to resolve (e.g., 'sanity')
+ * @param workDir - The working directory to resolve the package from
+ * @returns The imported module
+ * @throws If the package cannot be resolved or imported
+ *
+ * @example
+ * ```ts
+ * const {createSchema} = await resolveLocalPackage('sanity', workDir)
+ * ```
+ *
+ * @internal
+ */
+export declare function resolveLocalPackage<T = unknown>(
+  packageName: string,
+  workDir: string,
+): Promise<T>;
+
+/**
+ * Resolves and imports a package relative to another resolved module URL.
+ * Useful for resolving transitive dependencies that may not be directly
+ * accessible from the project root (e.g., in pnpm strict mode).
+ *
+ * @param packageName - The name of the package to resolve
+ * @param parentUrl - The URL of the parent module to resolve from
+ * @returns The imported module
+ * @throws If the package cannot be resolved or imported
+ *
+ * @example
+ * ```ts
+ * const sanityUrl = resolveLocalPackagePath('sanity', workDir)
+ * const ui = await resolveLocalPackageFrom<typeof import('@sanity/ui')>('@sanity/ui', sanityUrl)
+ * ```
+ *
+ * @internal
+ */
+export declare function resolveLocalPackageFrom<T = unknown>(
+  packageName: string,
+  parentUrl: URL,
+): Promise<T>;
+
+/**
+ * Resolves the URL of a package from the local project's node_modules,
+ * relative to the given working directory, without importing it.
+ *
+ * @param packageName - The name of the package to resolve (e.g., 'sanity')
+ * @param workDir - The working directory to resolve the package from
+ * @returns The resolved URL of the package entry point
+ * @throws If the package cannot be resolved
+ *
+ * @example
+ * ```ts
+ * // Resolve a transitive dependency via its parent package:
+ * const sanityUrl = resolveLocalPackagePath('sanity', workDir)
+ * const uiUrl = resolveLocalPackagePathFrom('@sanity/ui', sanityUrl)
+ * ```
+ *
+ * @internal
+ */
+export declare function resolveLocalPackagePath(
+  packageName: string,
+  workDir: string,
+): URL;
+
+/**
+ * `structuredClone()`, but doesn't throw on non-clonable values - instead it drops them.
+ *
+ * @param obj - The object to clone.
+ * @returns The cloned object.
+ * @internal
+ */
+export declare function safeStructuredClone<T>(obj: T): T;
+
+export declare abstract class SanityCommand<
+  T extends typeof Command,
+> extends Command {
+  protected args: Args<T>;
+  protected flags: Flags<T>;
+  /**
+   * Get the global API client.
+   *
+   * @param args - The global API client options.
+   * @returns The global API client.
+   *
+   * @deprecated use `getGlobalCliClient` function directly instead.
+   */
+  protected getGlobalApiClient: (
+    args: GlobalCliClientOptions,
+  ) => Promise<SanityClient>;
+  /**
+   * Get the project API client.
+   *
+   * @param args - The project API client options.
+   * @returns The project API client.
+   *
+   * @deprecated use `getProjectCliClient` function directly instead.
+   */
+  protected getProjectApiClient: (
+    args: ProjectCliClientOptions,
+  ) => Promise<SanityClient>;
+  /**
+   * Helper for outputting to the console.
+   *
+   * @example
+   * ```ts
+   * this.output.log('Hello')
+   * this.output.warn('Warning')
+   * this.output.error('Error')
+   * ```
+   */
+  protected output: Output;
+  /**
+   * The telemetry store.
+   *
+   * @returns The telemetry store.
+   */
+  protected telemetry: CLITelemetryStore;
+  /**
+   * Report real command errors to the CLI command trace.
+   * User aborts (SIGINT, ExitPromptError) are not reported — the trace is left
+   * incomplete, which accurately represents that the command was interrupted.
+   */
+  protected catch(err: CommandError): Promise<void>;
+  /**
+   * Get the CLI config.
+   *
+   * @returns The CLI config.
+   */
+  protected getCliConfig(): Promise<CliConfig>;
+  /**
+   * Get the project ID from passed flags or (if not provided) the CLI config.
+   *
+   * Optionally accepts a `fallback` function that is called when no project ID
+   * can be determined from flags or config. This allows commands to provide
+   * interactive project selection while keeping the prompt logic in the CLI package.
+   *
+   * If the fallback throws a `NonInteractiveError` (e.g. because the terminal is
+   * not interactive), it falls through to the standard error with suggestions.
+   *
+   * Optionally accepts a `deprecatedFlagName` for commands that have a deprecated
+   * flag (e.g. `--project`) that should be checked after `--project-id` but before
+   * the CLI config.
+   *
+   * @returns The project ID.
+   */
+  protected getProjectId(options?: {
+    deprecatedFlagName?: string;
+    fallback?: () => Promise<string>;
+  }): Promise<string>;
+  /**
+   * Get the project's root directory by resolving the config
+   *
+   * @returns The project root result.
+   */
+  protected getProjectRoot(): Promise<ProjectRootResult>;
+  init(): Promise<void>;
+  /**
+   * Check if the command is running in unattended mode.
+   *
+   * This means the command should not ask for user input, instead using defaults where
+   * possible, and if that does not make sense (eg there's missing information), then we
+   * should error out (remember to exit with a non-zero code).
+   *
+   * Most commands should take an explicit `--yes` flag to enable unattended mode, but
+   * some commands may also be run in unattended mode if `process.stdin` is not a TTY
+   * (eg when running in a CI environment).
+   */
+  protected isUnattended(): boolean;
+  /**
+   * Resolver for checking if the terminal is interactive. Override in tests to provide mock values.
+   *
+   * @returns Whether the terminal is interactive.
+   */
+  protected resolveIsInteractive(): boolean;
+  /**
+   * Get the CLI config, returning an empty config if no project root is found.
+   *
+   * Use this instead of `getCliConfig()` in commands that can operate without a
+   * project directory (e.g. when `--project-id` and `--dataset` flags are provided).
+   *
+   * @returns The CLI config, or an empty config object if no project root is found.
+   */
+  protected tryGetCliConfig(): Promise<CliConfig>;
+}
+
+export declare type SanityOrgUser = {
+  email: string;
+  id: string;
+  name: string;
+  profileImage?: string;
+  provider: "github" | "google" | "sanity" | `saml-${string}`;
+  tosAcceptedAt?: string;
+};
+
+/**
+ * Sets the global CLI telemetry state.
+ * @internal
+ */
+export declare function setCliTelemetry(
+  telemetry: CLITelemetryStore,
+  options?: {
+    reportTraceError?: TraceErrorReporter;
+  },
+): void;
+
+/**
+ * Set the config value for the given property.
+ * Validates that the passed value adheres to the defined CLI config schema.
+ *
+ * @param prop - The property to set the value for
+ * @param value - The value to set
+ * @internal
+ */
+export declare function setCliUserConfig(
+  prop: "authToken",
+  value: string | undefined,
+): void;
+
+/**
+ * Executes a worker file in a Sanity Studio browser context.
+ *
+ * This uses a combination of vite for "bundling" + jsdom for emulating a browser
+ * environment under the hood, which means that the same thing that will work in vite
+ * _should_ work in the worker - to a degree. If the user has defined any typescript
+ * path aliases, these will have to be added as aliases to the vite config - the same
+ * behavior as you would see with regular vite. Other things that are accounted for:
+ *
+ * - TypeScript support (+JSX, enums and other "compilation needed" features)
+ * - CSS, font and other file imports will resolve to a file path
+ * - CSS module imports will resolve to a javascript object of class names
+ * - Environment variables are available both as `import.meta.env` and `process.env`,
+ *   and `.env` files are loaded in the same way that they would in a Sanity studio.
+ * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM
+ *   are defined directly to the Node environment as globals. While this polutes the
+ *   global namespace, it is done only in the worker thread.
+ * - Certain browser globals that are _not_ available in JSDOM are also provided to the
+ *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.
+ *   These are provided with a minimal stub implementation to make them not crash.
+ *
+ * @param filePath - Path to the worker file (`.ts` works and is encouraged)
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */
+export declare function studioWorkerTask<T = unknown>(
+  filePath: URL,
+  options: StudioWorkerTaskOptions,
+): Promise<T>;
+
+/**
+ * Options for the studio worker task
+ *
+ * @internal
+ */
+declare interface StudioWorkerTaskOptions extends RequireProps<
+  WorkerOptions_2,
+  "name"
+> {
+  studioRootPath: string;
+  /** Optional timeout in milliseconds. If the worker does not respond within this time, it will be terminated and the promise rejected. */
+  timeout?: number;
+}
+
+/**
+ * Get a `debug` instance which extends the CLI debug instance with the given namespace,
+ * eg namespace would be `sanity:cli:<providedNamespace>`
+ *
+ * @param namespace - The namespace to extend the CLI debug instance with
+ * @returns The extended `debug` instance
+ */
+export declare const subdebug: (namespace: string) => debugIt.Debugger;
+
+/**
+ * Base information needed for telemetry file operations.
+ * Contains common data used by both file path generation and pattern matching.
+ */
+declare interface TelemetryBaseInfo {
+  /** Base filename pattern without sessionId suffix */
+  basePattern: string;
+  /** Base directory where telemetry files are stored */
+  directory: string;
+  /** Environment: 'staging' or 'production' */
+  environment: string;
+  /** Hashed token (first 8 chars of SHA256) for privacy */
+  hashedToken: string;
+}
+
+/**
+ * @public
+ */
+export declare interface TelemetryUserProperties {
+  cliVersion: string;
+  cpuArchitecture: string;
+  machinePlatform: string;
+  runtime: string;
+  runtimeVersion: string;
+  dataset?: string;
+  projectId?: string;
+}
+
+declare interface TimeMeasurer {
+  end: (name: string) => number;
+  getTimings: () => Record<string, number>;
+  start: (name: string) => void;
+}
+
+declare type TraceErrorReporter = (error: Error) => void;
+
+/**
+ * Tries to find the studio config path, returning `undefined` if not found.
+ *
+ * @param basePath - The base path to start searching from
+ * @returns A promise that resolves to a string containing the found config path, or `undefined` if not found
+ * @throws On errors other than config not found
+ * @internal
+ */
+export declare function tryFindStudioConfigPath(
+  basePath: string,
+): Promise<string | undefined>;
+
+/**
+ * Executes a worker file with tsx registered. This means you can import other
+ * typescript with fairly rich syntax, and still have that only apply to the worker
+ * thread instead of the full parent process. The worker should emit a message when
+ * complete using `parentPort`. Once it has received a single message will resolve the
+ * returned promise with that message. If you are expecting multiple messages, you will
+ * have to implement another method ;)
+ *
+ * @param filePath - Path to the worker file
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */
+export declare function tsxWorkerTask<T = unknown>(
+  filePath: URL_2,
+  options: TsxWorkerTaskOptions,
+): Promise<T>;
+
+/**
+ * Options for the tsx worker task
+ *
+ * @internal
+ */
+declare interface TsxWorkerTaskOptions extends RequireProps<
+  WorkerOptions_2,
+  "name"
+> {
+  rootPath: string;
+}
+
+declare interface TypeGenConfig {
+  formatGeneratedCode: boolean;
+  generates: string;
+  overloadClientMethods: boolean;
+  path: string | string[];
+  schema: string;
+}
+
+/**
+ * @public
+ */
+export declare type UserViteConfig =
+  | ((
+      config: InlineConfig,
+      env: ConfigEnv,
+    ) => InlineConfig | Promise<InlineConfig>)
+  | InlineConfig;
+
+export {};