@sanity/workbench 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/core.d.ts

@@ -0,0 +1,2138 @@
+import { App } from "@sanity/federation";
+import type { ApplicationResource } from "@sanity/message-protocol";
+import type { CanvasResource } from "@sanity/message-protocol";
+import { Interface } from "@sanity/federation";
+import { InterfaceSchema } from "@sanity/federation";
+import { LocalApp } from "@sanity/federation";
+import { LocalInterface } from "@sanity/federation";
+import { LocalInterfaceSchema } from "@sanity/federation";
+import { LocalPanel } from "@sanity/federation";
+import { LocalService } from "@sanity/federation";
+import type { MediaResource } from "@sanity/message-protocol";
+import { Panel } from "@sanity/federation";
+import { PanelComponent } from "@sanity/federation";
+import type { Resource } from "@sanity/message-protocol";
+import { Service } from "@sanity/federation";
+import type { StudioResource } from "@sanity/message-protocol";
+import { z } from "zod";
+
+/**
+ * @public
+ */
+export declare abstract class AbstractApplication<
+  TType extends AbstractApplicationType,
+  TProtocolResource extends Resource = Extract<
+    Resource,
+    {
+      type: TType;
+    }
+  >,
+> {
+  readonly type: TType;
+  constructor(type: TType);
+  /**
+   * The in-app route this application navigates to, or `null` when it isn't
+   * navigable as a full-page app (US5 — e.g. an SDK app with no `app` view).
+   * The dock renders a navigable item only for a non-null `href`; the app
+   * routes 404 a `null`-href app on direct visit.
+   */
+  abstract get href(): string | null;
+  abstract get title(): string;
+  abstract get id(): string;
+  /**
+   * Whether the application is federated or not. This is used to determine
+   * if the application should be rendered in an iframe or not.
+   */
+  abstract get isFederated(): boolean;
+  /**
+   * Whether the application is served by a local CLI dev server rather than a
+   * deployed remote. Defaults to `false`; user applications flip this when
+   * constructed from a `LocalUserApplication` payload.
+   */
+  get isLocal(): boolean;
+  abstract get url(): URL;
+  /**
+   * Interfaces the application exposes (e.g. dock panels). Defaults to none;
+   * user applications surface what they declared via `unstable_defineApp`.
+   */
+  get interfaces(): readonly LocalInterface[];
+  /**
+   * Whether the application has a navigable full-page `app` view (US5). Defaults
+   * to `true` — studios, Canvas, and Media Library are always navigable. An SDK
+   * app overrides this to derive it from whether it declares an `app` interface.
+   */
+  get hasAppView(): boolean;
+  /**
+   * Federation module id of the app's full-page view (`${id}/App`), or `null`
+   * when it can't be federation-loaded: the app isn't federated (Canvas, Media
+   * Library, deployed apps shown in an iframe) or has no app view. Only a
+   * non-null `moduleId` is fetched and rendered by the remotes machine.
+   */
+  get moduleId(): string | null;
+  /**
+   * Federation module id of one of this app's panel view components, or `null`
+   * when the app isn't federated (a non-federated app's panels can't be loaded
+   * as remotes).
+   */
+  resolveViewModuleId(
+    view: LocalPanel,
+    component: PanelComponent,
+  ): string | null;
+  get initials(): string;
+  /**
+   * Converts the resource to a protocol resource that comlink expects
+   * for backwards compatibility with the old API format.
+   */
+  abstract toProtocolResource(): TProtocolResource;
+}
+
+/**
+ * @public
+ */
+export declare type AbstractApplicationType =
+  | "studio"
+  | "coreApp"
+  | "canvas"
+  | "media-library"
+  | "workspace";
+
+/**
+ * @public
+ */
+export declare const ActiveDeployment: z.ZodObject<
+  {
+    id: z.ZodString;
+    version: z.ZodString;
+    isActiveDeployment: z.ZodBoolean;
+    userApplicationId: z.ZodString;
+    isAutoUpdating: z.ZodBoolean;
+    size: z.ZodNumber;
+    deployedAt: z.ZodString;
+    deployedBy: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  },
+  z.core.$strip
+>;
+
+export { App };
+
+/**
+ * @public
+ */
+export declare type Application =
+  | CoreAppApplication
+  | StudioApplication
+  | StudioWorkspace
+  | CanvasApplication
+  | MediaLibraryApplication;
+
+/**
+ * @public
+ */
+export declare class ApplicationList<
+  TApplication extends Application = Application,
+> {
+  readonly applications: TApplication[];
+  /**
+   * @param applications - The applications to initialize the list with.
+   */
+  constructor(applications: TApplication[]);
+  findApplicationsByType<T extends TApplication["type"]>(
+    type: T,
+  ): Extract<
+    TApplication,
+    {
+      type: T;
+    }
+  >[];
+  findApplicationsByType<T extends TApplication["type"][]>(
+    types: T,
+  ): Extract<
+    TApplication,
+    {
+      type: T[number];
+    }
+  >[];
+  findApplication(type: "media-library"):
+    | Extract<
+        TApplication,
+        {
+          type: "media-library";
+        }
+      >
+    | undefined;
+  findApplication(type: "canvas"):
+    | Extract<
+        TApplication,
+        {
+          type: "canvas";
+        }
+      >
+    | undefined;
+  findApplication(
+    type: "coreApp",
+    id: UserApplicationId,
+  ):
+    | Extract<
+        TApplication,
+        {
+          type: "coreApp";
+        }
+      >
+    | undefined;
+  findApplication(
+    type: "studio",
+    id: UserApplicationId,
+  ):
+    | Extract<
+        TApplication,
+        {
+          type: "studio";
+        }
+      >
+    | undefined;
+  findApplication(
+    type: "workspace",
+    id: string,
+  ):
+    | Extract<
+        TApplication,
+        {
+          type: "workspace";
+        }
+      >
+    | undefined;
+  toProtocolResources(): Resource[];
+  static areApplicationsEqual(
+    application1?: Application,
+    application2?: Application,
+  ): boolean;
+}
+
+/**
+ * Validates and brands a string as a CanvasId.
+ * @public
+ */
+export declare function brandCanvasId(id: string): CanvasId;
+
+/**
+ * Validates and brands a string as a MediaLibraryId.
+ * @public
+ */
+export declare function brandMediaLibraryId(id: string): MediaLibraryId;
+
+/**
+ * Validates and brands a string as an OrganizationId.
+ * @public
+ */
+export declare function brandOrganizationId(id: string): OrganizationId;
+
+/**
+ * Validates and brands a string as a ProjectId.
+ * @public
+ */
+export declare function brandProjectId(id: string): ProjectId;
+
+/**
+ * Validates and brands a string as a UserApplicationId.
+ * @public
+ */
+export declare function brandUserApplicationId(id: string): UserApplicationId;
+
+/**
+ * Represents a Canvas resource as returned from the API.
+ * @public
+ */
+export declare type Canvas = z.output<typeof Canvas_2>;
+
+declare const Canvas_2: z.ZodObject<
+  {
+    id: z.core.$ZodBranded<z.ZodString, "CanvasId", "out">;
+    organizationId: z.core.$ZodBranded<z.ZodString, "OrganizationId", "out">;
+    status: z.ZodEnum<{
+      active: "active";
+      provisioning: "provisioning";
+    }>;
+  },
+  z.core.$strip
+>;
+
+/**
+ * Represents a Canvas resource as returned from the API.
+ * @public
+ */
+declare type Canvas = z.output<typeof Canvas_2>;
+
+/**
+ * Whilst the constructor takes an organization's canvas resource the existance
+ * therefore implies the organization has access to the canvas application which
+ * is what workbench most importantly wants to know.
+ * @public
+ */
+export declare class CanvasApplication extends AbstractApplication<"canvas"> {
+  readonly canvas: Canvas;
+  constructor(canvas: Canvas);
+  get id(): CanvasId;
+  get href(): string;
+  get title(): string;
+  get url(): URL;
+  get isFederated(): boolean;
+  toProtocolResource(): CanvasResource;
+}
+
+/**
+ * Canvas ID type, branded for type safety.
+ * @public
+ */
+export declare type CanvasId = z.output<typeof CanvasId_2>;
+
+/**
+ * Canvas ID schema, branded for type safety.
+ * @public
+ */
+declare const CanvasId_2: z.core.$ZodBranded<z.ZodString, "CanvasId", "out">;
+
+/**
+ * Canvas ID type, branded for type safety.
+ * @public
+ */
+declare type CanvasId = z.output<typeof CanvasId_2>;
+
+/**
+ * @public
+ */
+export declare const ClientManifest: z.ZodObject<
+  {
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    studioVersion: z.ZodOptional<z.ZodString>;
+    group: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    workspaces: z.ZodArray<
+      z.ZodObject<
+        {
+          name: z.ZodString;
+          title: z.ZodString;
+          subtitle: z.ZodOptional<z.ZodString>;
+          basePath: z.ZodString;
+          projectId: z.core.$ZodBranded<z.ZodString, "ProjectId", "out">;
+          dataset: z.ZodOptional<z.ZodString>;
+          icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+          schema: z.ZodString;
+          tools: z.ZodOptional<z.ZodString>;
+        },
+        z.core.$strip
+      >
+    >;
+  },
+  z.core.$strip
+>;
+
+/**
+ * @public
+ */
+export declare type ClientManifest = z.output<typeof ClientManifest>;
+
+declare type CompatibilityStatus =
+  (typeof StudioApplication.CompatibilityStatuses)[keyof typeof StudioApplication.CompatibilityStatuses];
+
+/**
+ * Workbench configuration.
+ *
+ * @public
+ */
+export declare interface Config {
+  /**
+   * The organization ID to use when rendering the workbench.
+   */
+  organizationId?: string;
+}
+
+/**
+ * @public
+ */
+export declare class CoreAppApplication extends UserApplication<
+  CoreAppUserApplication,
+  "coreApp",
+  ApplicationResource
+> {
+  readonly activeDeployment: CoreAppUserApplication["activeDeployment"];
+  constructor(
+    application: CoreAppUserApplication,
+    options?: {
+      isLocal?: boolean;
+      remoteApplication?: CoreAppApplication | null;
+    },
+  );
+  get href(): string | null;
+  get title(): string;
+  /**
+   * Resolves the core app's manifest from `activeDeployment.manifest`. This
+   * is the canonical (and only) slot for core app manifests — both for
+   * Sanity-deployed apps and for local CLI dev-server apps, which synthesise
+   * a deployment to surface the live manifest.
+   */
+  get manifest(): CoreAppUserApplicationManifest | null;
+  get subtitle(): undefined;
+  get updatedAt(): string;
+  get<TKey extends keyof CoreAppUserApplication>(
+    attr: TKey,
+  ): CoreAppUserApplication[TKey];
+  toProtocolResource(): ApplicationResource;
+}
+
+/**
+ * @public
+ */
+export declare type CoreAppUserApplication = z.output<
+  typeof CoreAppUserApplication_2
+>;
+
+/**
+ * Core application schema — validates and brands API
+ * responses from the `/user-applications?appType=coreApp`
+ * endpoint. Uses a discriminated union on `urlType`.
+ * @public
+ */
+declare const CoreAppUserApplication_2: z.ZodDiscriminatedUnion<
+  [
+    z.ZodObject<
+      {
+        id: z.core.$ZodBranded<z.ZodString, "UserApplicationId", "out">;
+        appHost: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        dashboardStatus: z.ZodEnum<{
+          default: "default";
+          disabled: "disabled";
+        }>;
+        interfaces: z.ZodOptional<
+          z.ZodArray<
+            z.ZodDiscriminatedUnion<
+              [
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"panel">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"worker">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"app">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+              ],
+              "interface_type"
+            >
+          >
+        >;
+        title: z.ZodString;
+        organizationId: z.core.$ZodBranded<
+          z.ZodString,
+          "OrganizationId",
+          "out"
+        >;
+        type: z.ZodLiteral<"coreApp">;
+        urlType: z.ZodLiteral<"internal">;
+        activeDeployment: z.ZodNullable<
+          z.ZodObject<
+            {
+              id: z.ZodString;
+              version: z.ZodString;
+              isActiveDeployment: z.ZodBoolean;
+              userApplicationId: z.ZodString;
+              isAutoUpdating: z.ZodBoolean;
+              size: z.ZodNumber;
+              deployedAt: z.ZodString;
+              deployedBy: z.ZodString;
+              createdAt: z.ZodString;
+              updatedAt: z.ZodString;
+              manifest: z.ZodNullable<
+                z.ZodObject<
+                  {
+                    version: z.ZodString;
+                    icon: z.ZodOptional<z.ZodString>;
+                    title: z.ZodOptional<z.ZodString>;
+                    group: z.ZodOptional<z.ZodString>;
+                    priority: z.ZodOptional<z.ZodNumber>;
+                  },
+                  z.core.$strip
+                >
+              >;
+            },
+            z.core.$strip
+          >
+        >;
+      },
+      z.core.$strip
+    >,
+    z.ZodObject<
+      {
+        id: z.core.$ZodBranded<z.ZodString, "UserApplicationId", "out">;
+        appHost: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        dashboardStatus: z.ZodEnum<{
+          default: "default";
+          disabled: "disabled";
+        }>;
+        interfaces: z.ZodOptional<
+          z.ZodArray<
+            z.ZodDiscriminatedUnion<
+              [
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"panel">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"worker">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"app">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+              ],
+              "interface_type"
+            >
+          >
+        >;
+        title: z.ZodString;
+        organizationId: z.core.$ZodBranded<
+          z.ZodString,
+          "OrganizationId",
+          "out"
+        >;
+        type: z.ZodLiteral<"coreApp">;
+        urlType: z.ZodLiteral<"external">;
+        activeDeployment: z.ZodNullable<
+          z.ZodObject<
+            {
+              id: z.ZodString;
+              version: z.ZodString;
+              isActiveDeployment: z.ZodBoolean;
+              userApplicationId: z.ZodString;
+              isAutoUpdating: z.ZodBoolean;
+              size: z.ZodNumber;
+              deployedAt: z.ZodString;
+              deployedBy: z.ZodString;
+              createdAt: z.ZodString;
+              updatedAt: z.ZodString;
+              manifest: z.ZodNullable<
+                z.ZodObject<
+                  {
+                    version: z.ZodString;
+                    icon: z.ZodOptional<z.ZodString>;
+                    title: z.ZodOptional<z.ZodString>;
+                    group: z.ZodOptional<z.ZodString>;
+                    priority: z.ZodOptional<z.ZodNumber>;
+                  },
+                  z.core.$strip
+                >
+              >;
+            },
+            z.core.$strip
+          >
+        >;
+      },
+      z.core.$strip
+    >,
+  ],
+  "urlType"
+>;
+
+/**
+ * @public
+ */
+declare type CoreAppUserApplication = z.output<typeof CoreAppUserApplication_2>;
+
+/**
+ * @public
+ */
+export declare const CoreAppUserApplicationManifest: z.ZodObject<
+  {
+    version: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    group: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+  },
+  z.core.$strip
+>;
+
+/**
+ * @public
+ */
+export declare type CoreAppUserApplicationManifest = z.output<
+  typeof CoreAppUserApplicationManifest
+>;
+
+/**
+ * Creates a leveled logger with an optional namespace prefix and bound
+ * context. Calls below the configured `logLevel` are suppressed; `"none"`
+ * silences the logger entirely.
+ *
+ * Use {@link Logger.child} to derive a sub-logger with an extended namespace
+ * (e.g. `parent:domain`) that inherits the parent's level and merges its
+ * bound context.
+ *
+ * @param options - Logger configuration.
+ * @param options.namespace - Prepended to every message in `[brackets]`.
+ * @param options.context - Bound context merged with per-call context.
+ *   Per-call keys win on conflict.
+ * @param options.logLevel - Maximum verbosity to emit. Default `"info"`.
+ *
+ * @example
+ * ```ts
+ * const log = createLogger({ namespace: "checkout", logLevel: "debug" });
+ * log.info("placed", { orderId: "abc" });
+ * // → [checkout] placed { orderId: "abc" }
+ *
+ * const auth = log.child("auth", { tenant: "acme" });
+ * auth.warn("token expiring");
+ * // → [checkout:auth] token expiring { tenant: "acme" }
+ * ```
+ *
+ * @public
+ */
+export declare function createLogger({
+  namespace,
+  context: baseContext,
+  logLevel,
+}?: LoggerOptions): Logger;
+
+/**
+ * Returns the API host based on the `__SANITY_STAGING__` runtime-time flag.
+ * If the flag is set to `true`, the staging API host is returned.
+ * Otherwise, the production API host is returned.
+ *
+ * @public
+ */
+export declare function getApiHost(): string | undefined;
+
+/**
+ * Returns the Sanity domain based on the `__SANITY_STAGING__` runtime-time flag.
+ * If the flag is set to `true`, the staging domain is returned.
+ * Otherwise, the production domain is returned.
+ *
+ * @public
+ */
+export declare function getSanityDomain(): string;
+
+/**
+ * Returns the current Sanity environment based on the `__SANITY_STAGING__` runtime-time flag.
+ * If the flag is set to `true`, "staging" is returned.
+ * Otherwise, "production" is returned.
+ *
+ * @public
+ */
+export declare function getSanityEnv(): "staging" | "production";
+
+export { Interface };
+
+export { InterfaceSchema };
+
+/**
+ * Joins multiple path segments into a single path string.
+ * Handles null, undefined, and URL objects gracefully.
+ *
+ * @public
+ * @param paths - An array of path segments to join.
+ * @returns A single joined path string.
+ */
+export declare const joinUrlPaths: (
+  ...paths: Array<string | URL | null | undefined>
+) => string;
+
+export { LocalApp };
+
+export { LocalInterface };
+
+export { LocalInterfaceSchema };
+
+export { LocalPanel };
+
+export { LocalService };
+
+/**
+ * Raw data for a local application discovered by the CLI dev server.
+ *
+ * The CLI forwards the full studio or app manifest so the workbench can
+ * derive icons, titles, workspaces and schema references the same way it
+ * does for deployed applications. The manifest shape is discriminated on
+ * `type`: studios receive a `ClientManifest`, core apps a `CoreAppUserApplicationManifest`.
+ *
+ * When set on a `UserApplication`, `isLocal` is `true` and `url`/`isFederated`
+ * honour the local dev-server instead of the deployed application's host.
+ *
+ * @public
+ */
+export declare const LocalUserApplication: z.ZodDiscriminatedUnion<
+  [
+    z.ZodObject<
+      {
+        host: z.ZodString;
+        port: z.ZodNumber;
+        interfaces: z.ZodOptional<
+          z.ZodArray<
+            z.ZodDiscriminatedUnion<
+              [
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"panel">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"worker">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"app">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+              ],
+              "interface_type"
+            >
+          >
+        >;
+        id: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"studio">;
+        manifest: z.ZodOptional<
+          z.ZodCustom<
+            {
+              version: number;
+              createdAt: string;
+              workspaces: {
+                name: string;
+                title: string;
+                basePath: string;
+                projectId: string & z.core.$brand<"ProjectId">;
+                schema: string;
+                subtitle?: string | undefined;
+                dataset?: string | undefined;
+                icon?: string | null | undefined;
+                tools?: string | undefined;
+              }[];
+              studioVersion?: string | undefined;
+              group?: string | undefined;
+              priority?: number | undefined;
+            },
+            {
+              version: number;
+              createdAt: string;
+              workspaces: {
+                name: string;
+                title: string;
+                basePath: string;
+                projectId: string & z.core.$brand<"ProjectId">;
+                schema: string;
+                subtitle?: string | undefined;
+                dataset?: string | undefined;
+                icon?: string | null | undefined;
+                tools?: string | undefined;
+              }[];
+              studioVersion?: string | undefined;
+              group?: string | undefined;
+              priority?: number | undefined;
+            }
+          >
+        >;
+      },
+      z.core.$strip
+    >,
+    z.ZodObject<
+      {
+        host: z.ZodString;
+        port: z.ZodNumber;
+        interfaces: z.ZodOptional<
+          z.ZodArray<
+            z.ZodDiscriminatedUnion<
+              [
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"panel">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"worker">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"app">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+              ],
+              "interface_type"
+            >
+          >
+        >;
+        id: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"coreApp">;
+        manifest: z.ZodOptional<
+          z.ZodCustom<
+            {
+              version: string;
+              icon?: string | undefined;
+              title?: string | undefined;
+              group?: string | undefined;
+              priority?: number | undefined;
+            },
+            {
+              version: string;
+              icon?: string | undefined;
+              title?: string | undefined;
+              group?: string | undefined;
+              priority?: number | undefined;
+            }
+          >
+        >;
+      },
+      z.core.$strip
+    >,
+  ],
+  "type"
+>;
+
+/**
+ * @public
+ */
+export declare type LocalUserApplication = z.output<
+  typeof LocalUserApplication
+>;
+
+declare type LogContext = {
+  [key: string]: unknown;
+};
+
+/**
+ * @public
+ */
+export declare interface Logger {
+  error: (message: string, context?: LogContext) => void;
+  warn: (message: string, context?: LogContext) => void;
+  info: (message: string, context?: LogContext) => void;
+  debug: (message: string, context?: LogContext) => void;
+  child: (domain: string, context?: LogContext) => Logger;
+}
+
+/**
+ * Shared workbench logger instance. Use this from both the workbench host
+ * and its remotes so lifecycle and diagnostic logs appear under a single
+ * namespace.
+ *
+ * @public
+ */
+export declare const logger: Logger;
+
+declare interface LoggerOptions {
+  namespace?: LogNamespace;
+  context?: LogContext;
+  logLevel?: LogLevel;
+}
+
+/**
+ * Log levels in order of verbosity (least to most)
+ * - none: Silent
+ * - error: Critical failures that prevent operation
+ * - warn: Issues that may cause problems but don't stop execution
+ * - info: High-level informational messages (default)
+ * - debug: Detailed debugging information (maintainer level)
+ * - trace: Very detailed tracing — sets `internal: true` on context
+ * @public
+ */
+export declare type LogLevel = "none" | "error" | "warn" | "info" | "debug";
+
+/**
+ * Namespaces organize logs by functional domain.
+ * @internal
+ */
+export declare type LogNamespace = string;
+
+/**
+ * Represents a MediaLibrary resource as returned from the API.
+ * @public
+ */
+export declare type MediaLibrary = z.output<typeof MediaLibrary_2>;
+
+declare const MediaLibrary_2: z.ZodObject<
+  {
+    id: z.core.$ZodBranded<z.ZodString, "MediaLibraryId", "out">;
+    organizationId: z.core.$ZodBranded<z.ZodString, "OrganizationId", "out">;
+    status: z.ZodEnum<{
+      active: "active";
+      provisioning: "provisioning";
+    }>;
+    aclMode: z.ZodEnum<{
+      private: "private";
+      public: "public";
+    }>;
+  },
+  z.core.$strip
+>;
+
+/**
+ * Represents a MediaLibrary resource as returned from the API.
+ * @public
+ */
+declare type MediaLibrary = z.output<typeof MediaLibrary_2>;
+
+/**
+ * Whilst the constructor takes an organization's media library resource the existance
+ * therefore implies the organization has access to the media library application which
+ * is what workbench most importantly wants to know.
+ * @public
+ */
+export declare class MediaLibraryApplication extends AbstractApplication<"media-library"> {
+  readonly library: MediaLibrary;
+  constructor(library: MediaLibrary);
+  get id(): string;
+  get href(): string;
+  get title(): string;
+  get isFederated(): boolean;
+  get url(): URL;
+  toProtocolResource(): MediaResource;
+}
+
+/**
+ * MediaLibrary ID type, branded for type safety.
+ * @public
+ */
+export declare type MediaLibraryId = z.output<typeof MediaLibraryId_2>;
+
+/**
+ * Canvas ID schema, branded for type safety.
+ * @public
+ */
+declare const MediaLibraryId_2: z.core.$ZodBranded<
+  z.ZodString,
+  "MediaLibraryId",
+  "out"
+>;
+
+/**
+ * MediaLibrary ID type, branded for type safety.
+ * @public
+ */
+declare type MediaLibraryId = z.output<typeof MediaLibraryId_2>;
+
+/**
+ * Organization schema — validates and brands API responses
+ * from the `/organizations/:id` endpoint.
+ * @public
+ */
+export declare const Organization: z.ZodObject<
+  {
+    id: z.core.$ZodBranded<z.ZodString, "OrganizationId", "out">;
+    name: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    dashboardStatus: z.ZodEnum<{
+      enabled: "enabled";
+      disabled: "disabled";
+    }>;
+    aiFeaturesStatus: z.ZodEnum<{
+      enabled: "enabled";
+      disabled: "disabled";
+    }>;
+    defaultRoleName: z.ZodNullable<z.ZodString>;
+  },
+  z.core.$strip
+>;
+
+/**
+ * Represents an organization with optional members and
+ * features arrays depending on the generic parameters.
+ * - `Organization` — base fields only (default)
+ * - `Organization<true>` — includes `members`
+ * - `Organization<true, true>` — includes both
+ * @public
+ */
+export declare type Organization<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+> = z.output<typeof Organization> &
+  (IncludeMembers extends true
+    ? {
+        members: OrganizationMember[];
+      }
+    : unknown) &
+  (IncludeFeatures extends true
+    ? {
+        features: string[];
+      }
+    : unknown);
+
+/**
+ * Organization ID schema, branded for type safety.
+ * @public
+ */
+export declare const OrganizationId: z.core.$ZodBranded<
+  z.ZodString,
+  "OrganizationId",
+  "out"
+>;
+
+/**
+ * Organization ID type, branded for type safety.
+ * @public
+ */
+export declare type OrganizationId = z.output<typeof OrganizationId>;
+
+/**
+ * @public
+ */
+export declare type OrganizationMember = z.output<typeof OrganizationMember_2>;
+
+declare const OrganizationMember_2: z.ZodObject<
+  {
+    sanityUserId: z.ZodString;
+    isCurrentUser: z.ZodBoolean;
+    user: z.ZodObject<
+      {
+        id: z.ZodString;
+        displayName: z.ZodString;
+        familyName: z.ZodString;
+        givenName: z.ZodString;
+        middleName: z.ZodNullable<z.ZodString>;
+        imageUrl: z.ZodNullable<z.ZodString>;
+        email: z.ZodString;
+        loginProvider: z.ZodString;
+      },
+      z.core.$strip
+    >;
+    roles: z.ZodArray<
+      z.ZodObject<
+        {
+          name: z.ZodString;
+          title: z.ZodString;
+          description: z.ZodOptional<z.ZodString>;
+        },
+        z.core.$strip
+      >
+    >;
+  },
+  z.core.$strip
+>;
+
+/**
+ * @public
+ */
+declare type OrganizationMember = z.output<typeof OrganizationMember_2>;
+
+export { Panel };
+
+export { PanelComponent };
+
+/**
+ * Validates and parses a raw API response into a branded
+ * Canvas.
+ * @public
+ */
+export declare function parseCanvas(data: unknown): Canvas;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * CoreAppUserApplicationData.
+ * @public
+ */
+export declare function parseCoreApplication(
+  data: unknown,
+): CoreAppUserApplication;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * MediaLibrary.
+ * @public
+ */
+export declare function parseMediaLibrary(data: unknown): MediaLibrary;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * Organization. The options control which schema is used —
+ * matching what the API returns based on query params.
+ * @public
+ */
+export declare function parseOrganization<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+>(
+  data: unknown,
+  options?: {
+    includeMembers?: IncludeMembers;
+    includeFeatures?: IncludeFeatures;
+  },
+): Organization<IncludeMembers, IncludeFeatures>;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * Project. The options control which schema is used —
+ * matching what the API returns based on query params.
+ * @public
+ */
+export declare function parseProject<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+>(
+  data: unknown,
+  options?: {
+    includeMembers?: IncludeMembers;
+    includeFeatures?: IncludeFeatures;
+  },
+): Project<IncludeMembers, IncludeFeatures>;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * StudioUserApplication.
+ * @public
+ */
+export declare function parseStudioUserApplication(
+  data: unknown,
+): StudioUserApplication;
+
+/**
+ * Project schema — validates and brands API responses
+ * from the `/projects/:id` endpoint.
+ * @public
+ */
+export declare const Project: z.ZodObject<
+  {
+    id: z.core.$ZodBranded<z.ZodString, "ProjectId", "out">;
+    displayName: z.ZodString;
+    studioHost: z.ZodNullable<z.ZodString>;
+    organizationId: z.core.$ZodBranded<z.ZodString, "OrganizationId", "out">;
+    metadata: z.ZodObject<
+      {
+        color: z.ZodOptional<z.ZodString>;
+        externalStudioHost: z.ZodOptional<z.ZodString>;
+        initialTemplate: z.ZodOptional<z.ZodString>;
+        cliInitializedAt: z.ZodOptional<z.ZodString>;
+        integration: z.ZodOptional<z.ZodString>;
+      },
+      z.core.$strip
+    >;
+    isBlocked: z.ZodBoolean;
+    isDisabled: z.ZodBoolean;
+    isDisabledByUser: z.ZodBoolean;
+    activityFeedEnabled: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  },
+  z.core.$strip
+>;
+
+/**
+ * Represents a Sanity project with optional members and
+ * features arrays depending on the generic parameters.
+ * By default, neither members nor features are included.
+ * - `Project` — base fields only (default)
+ * - `Project<true>` — includes `members`
+ * - `Project<true, true>` — includes both
+ * @public
+ */
+export declare type Project<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+> = z.output<typeof Project> &
+  (IncludeMembers extends true
+    ? {
+        members: ProjectMember[];
+      }
+    : unknown) &
+  (IncludeFeatures extends true
+    ? {
+        features: string[];
+      }
+    : unknown);
+
+/**
+ * Project ID schema, branded for type safety.
+ * @public
+ */
+export declare const ProjectId: z.core.$ZodBranded<
+  z.ZodString,
+  "ProjectId",
+  "out"
+>;
+
+/**
+ * Project ID type, branded for type safety.
+ * @public
+ */
+export declare type ProjectId = z.output<typeof ProjectId>;
+
+/**
+ * @public
+ */
+export declare type ProjectMember = z.output<typeof ProjectMember_2>;
+
+declare const ProjectMember_2: z.ZodObject<
+  {
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    isCurrentUser: z.ZodBoolean;
+    isRobot: z.ZodBoolean;
+    roles: z.ZodArray<
+      z.ZodObject<
+        {
+          name: z.ZodString;
+          title: z.ZodString;
+          description: z.ZodString;
+        },
+        z.core.$strip
+      >
+    >;
+  },
+  z.core.$strip
+>;
+
+/**
+ * @public
+ */
+declare type ProjectMember = z.output<typeof ProjectMember_2>;
+
+/**
+ * Options for rendering a remote module, such as a user application.
+ *
+ * @public
+ */
+export declare interface RemoteModuleRenderOptions {
+  reactStrictMode?: boolean;
+}
+
+/**
+ * The resolved configuration after processing
+ * and validating the provided config.
+ *
+ * @public
+ */
+export declare type ResolvedConfig = Omit<Config, "organizationId"> & {
+  organizationId: OrganizationId;
+};
+
+/**
+ * @public
+ */
+export declare const ServerManifest: z.ZodObject<
+  {
+    buildId: z.ZodOptional<z.ZodString>;
+    bundleVersion: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    group: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    workspaces: z.ZodOptional<
+      z.ZodArray<
+        z.ZodObject<
+          {
+            name: z.ZodString;
+            title: z.ZodString;
+            subtitle: z.ZodOptional<z.ZodString>;
+            basePath: z.ZodString;
+            projectId: z.core.$ZodBranded<z.ZodString, "ProjectId", "out">;
+            icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            dataset: z.ZodString;
+            schemaDescriptorId: z.ZodString;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+  },
+  z.core.$strip
+>;
+
+/**
+ * @public
+ */
+export declare type ServerManifest = z.output<typeof ServerManifest>;
+
+export { Service };
+
+/**
+ * @public
+ */
+export declare class StudioApplication extends UserApplication<
+  StudioUserApplication,
+  "studio",
+  never
+> {
+  /**
+   * Returns a list of studio workspaces based on the application manifest.
+   * If there is no manifest, or alternatively it is not valid, then we create a default workspace.
+   */
+  readonly workspaces: readonly StudioWorkspace[];
+  readonly project: Project<false, false>;
+  /**
+   * The projects actually referenced by this studio — the application's own
+   * project plus any project used by a workspace. Preserved so the instance
+   * can be re-constructed (e.g. by dock wrappers) without having to thread
+   * the full organization project list through again.
+   */
+  readonly projects: Project<false, false>[];
+  /**
+   * @param application - The studio application to create a list of workspaces for
+   * @param projects - The projects available in the organization. It's not enough to just pass
+   * the project that associates with the application because that is the project the app is deployed in relation to.
+   * The workspaces may have different projects completely.
+   */
+  constructor(
+    application: StudioUserApplication,
+    projects: Project<false, false>[],
+    options?: {
+      isLocal?: boolean;
+      remoteApplication?: StudioApplication | null;
+    },
+  );
+  /**
+   * Factory hook called for each workspace during construction. Subclasses
+   * override this to substitute a `StudioWorkspace` subclass (e.g. a UI-aware
+   * variant in a downstream package) without re-implementing the constructor's
+   * workspace-derivation logic.
+   */
+  protected createWorkspace(
+    workspace: Workspace,
+    project: Project<false, false>,
+    isDefaultWorkspace: boolean,
+  ): StudioWorkspace;
+  get href(): string;
+  get title(): string;
+  get subtitle(): string;
+  get<TKey extends keyof StudioUserApplication>(
+    attr: TKey,
+  ): StudioUserApplication[TKey];
+  /**
+   * Resolves the studio's most authoritative manifest. The lookup order is:
+   *
+   * 1. `activeDeployment.manifest` — deployment manifests are the new
+   *    primitive within Sanity and are preferred whenever available.
+   * 2. `manifestData.value` — fallback to support older studios that
+   *    haven't produced a deployment manifest yet.
+   * 3. `application.manifest` — last-resort legacy field.
+   *
+   * Returns `null` when no manifest is available. The return shape is a
+   * union because the deployment and client manifests are not
+   * interchangeable — consumers that depend on client-only fields (e.g.
+   * `studioVersion`, workspace `schema`) must narrow or read the raw
+   * field they need.
+   */
+  get manifest(): ClientManifest | ServerManifest | null;
+  get hasManifest(): boolean;
+  get hasSchema(): boolean;
+  private resolveVersion;
+  get version(): string | null;
+  get compatibilityStatus(): CompatibilityStatus;
+  /**
+   * Used to calculate the compatibility status of a given studio application.
+   * Optionally if you've resolved the version elsewhere provide that value to
+   * get the new compatibility status without mutating the application.
+   */
+  static resolveCompatibilityStatus(
+    application: StudioApplication,
+    version?: string | null,
+  ): CompatibilityStatus;
+  get isAutoRedirecting(): boolean;
+  /**
+   * Mirrors the `isRedirectable` function from Saison defined in
+   * https://github.com/sanity-io/saison/blob/83556405d23e07f6d3a71c76249c67e33fe1101f/src/utils/applications.ts
+   *
+   * Returns whether a studio application is auto-redirecting, meaning it can only be accessed in the context of
+   * Dashboard.
+   */
+  static resolveIsAutoRedirecting(
+    application: StudioApplication,
+    versionArg?: string | null,
+  ): boolean;
+  /**
+   * Returns a list of issues that prevent the studio from functioning properly in the Dashboard.
+   * This static value depends on the version of the studio that comes from the `activeDeployment` property.
+   * As such, if the studio is auto-updating, this list will be incorrect & instead you should use
+   * the static method `resolveIssues` to get the correct issues by passing the resolved version.
+   */
+  get issues(): StudioIssues;
+  static resolveIssues(
+    application: StudioApplication,
+    version?: string | null,
+  ): StudioIssues;
+  protected isFeatureSupported(
+    feature: StudioDashboardIssue,
+    version?: string | null,
+  ): boolean;
+  toProtocolResource(): never;
+  static CompatibilityStatuses: {
+    readonly UNKNOWN: "unknown";
+    readonly PARTIALLY_COMPATIBLE: "partially-compatible";
+    readonly FULLY_COMPATIBLE: "fully-compatible";
+  };
+  static StudioIssues: {
+    readonly ISSUE_ACTIVITY: "ACTIVITY";
+    readonly ISSUE_AGENT: "AGENT";
+    readonly ISSUE_FAVORITES: "FAVORITES";
+    readonly ISSUE_URL_SYNCING: "URL_SYNCING";
+    readonly ISSUE_UI_ADJUSTMENT: "UI_ADJUSTMENT";
+    readonly ISSUE_CONTENT_MAPPING: "CONTENT_MAPPING";
+    readonly ISSUE_LOGIN: "LOGIN";
+    readonly ISSUE_MANIFEST: "MANIFEST";
+  };
+  static Features: (
+    | {
+        id: "AGENT";
+        version: string;
+      }
+    | {
+        id: "FAVORITES";
+        version: string;
+      }
+    | {
+        id: "ACTIVITY";
+        version: string;
+      }
+    | {
+        id: "URL_SYNCING";
+        version: string;
+      }
+    | {
+        id: "UI_ADJUSTMENT";
+        version: string;
+      }
+    | {
+        id: "CONTENT_MAPPING";
+        version: string;
+      }
+    | {
+        id: "LOGIN";
+        version: string;
+      }
+  )[];
+  static MinimumStudioVersion: "2.28.0";
+  static MinimumStudioVersionWithNoIssues: string | undefined;
+}
+
+declare type StudioDashboardIssue =
+  (typeof StudioApplication.StudioIssues)[keyof typeof StudioApplication.StudioIssues];
+
+declare type StudioIssues = Array<{
+  id: StudioDashboardIssue;
+  version?: string;
+}>;
+
+/**
+ * Studio user application schema — validates and brands API
+ * responses from the `/user-applications?appType=studio`
+ * endpoint. Uses a discriminated union on `urlType`.
+ * @public
+ */
+export declare const StudioUserApplication: z.ZodDiscriminatedUnion<
+  [
+    z.ZodObject<
+      {
+        id: z.core.$ZodBranded<z.ZodString, "UserApplicationId", "out">;
+        appHost: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        dashboardStatus: z.ZodEnum<{
+          default: "default";
+          disabled: "disabled";
+        }>;
+        interfaces: z.ZodOptional<
+          z.ZodArray<
+            z.ZodDiscriminatedUnion<
+              [
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"panel">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"worker">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"app">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+              ],
+              "interface_type"
+            >
+          >
+        >;
+        title: z.ZodNullable<z.ZodString>;
+        projectId: z.core.$ZodBranded<z.ZodString, "ProjectId", "out">;
+        type: z.ZodLiteral<"studio">;
+        manifest: z.ZodNullable<
+          z.ZodObject<
+            {
+              version: z.ZodNumber;
+              createdAt: z.ZodString;
+              studioVersion: z.ZodOptional<z.ZodString>;
+              group: z.ZodOptional<z.ZodString>;
+              priority: z.ZodOptional<z.ZodNumber>;
+              workspaces: z.ZodArray<
+                z.ZodObject<
+                  {
+                    name: z.ZodString;
+                    title: z.ZodString;
+                    subtitle: z.ZodOptional<z.ZodString>;
+                    basePath: z.ZodString;
+                    projectId: z.core.$ZodBranded<
+                      z.ZodString,
+                      "ProjectId",
+                      "out"
+                    >;
+                    dataset: z.ZodOptional<z.ZodString>;
+                    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    schema: z.ZodString;
+                    tools: z.ZodOptional<z.ZodString>;
+                  },
+                  z.core.$strip
+                >
+              >;
+            },
+            z.core.$strip
+          >
+        >;
+        manifestData: z.ZodNullable<
+          z.ZodObject<
+            {
+              value: z.ZodObject<
+                {
+                  version: z.ZodNumber;
+                  createdAt: z.ZodString;
+                  studioVersion: z.ZodOptional<z.ZodString>;
+                  group: z.ZodOptional<z.ZodString>;
+                  priority: z.ZodOptional<z.ZodNumber>;
+                  workspaces: z.ZodArray<
+                    z.ZodObject<
+                      {
+                        name: z.ZodString;
+                        title: z.ZodString;
+                        subtitle: z.ZodOptional<z.ZodString>;
+                        basePath: z.ZodString;
+                        projectId: z.core.$ZodBranded<
+                          z.ZodString,
+                          "ProjectId",
+                          "out"
+                        >;
+                        dataset: z.ZodOptional<z.ZodString>;
+                        icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        schema: z.ZodString;
+                        tools: z.ZodOptional<z.ZodString>;
+                      },
+                      z.core.$strip
+                    >
+                  >;
+                },
+                z.core.$strip
+              >;
+            },
+            z.core.$strip
+          >
+        >;
+        autoUpdatingVersion: z.ZodNullable<z.ZodString>;
+        config: z.ZodObject<
+          {
+            "live-manifest": z.ZodOptional<
+              z.ZodObject<
+                {
+                  createdAt: z.ZodString;
+                  updatedAt: z.ZodString;
+                  updatedBy: z.ZodString;
+                  value: z.ZodObject<
+                    {
+                      buildId: z.ZodOptional<z.ZodString>;
+                      bundleVersion: z.ZodOptional<z.ZodString>;
+                      version: z.ZodOptional<z.ZodString>;
+                      group: z.ZodOptional<z.ZodString>;
+                      priority: z.ZodOptional<z.ZodNumber>;
+                      workspaces: z.ZodOptional<
+                        z.ZodArray<
+                          z.ZodObject<
+                            {
+                              name: z.ZodString;
+                              title: z.ZodString;
+                              subtitle: z.ZodOptional<z.ZodString>;
+                              basePath: z.ZodString;
+                              projectId: z.core.$ZodBranded<
+                                z.ZodString,
+                                "ProjectId",
+                                "out"
+                              >;
+                              icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                              dataset: z.ZodString;
+                              schemaDescriptorId: z.ZodString;
+                            },
+                            z.core.$strip
+                          >
+                        >
+                      >;
+                    },
+                    z.core.$strip
+                  >;
+                },
+                z.core.$strip
+              >
+            >;
+          },
+          z.core.$strip
+        >;
+        urlType: z.ZodLiteral<"internal">;
+        activeDeployment: z.ZodNullable<
+          z.ZodObject<
+            {
+              id: z.ZodString;
+              version: z.ZodString;
+              isActiveDeployment: z.ZodBoolean;
+              userApplicationId: z.ZodString;
+              isAutoUpdating: z.ZodBoolean;
+              size: z.ZodNumber;
+              deployedAt: z.ZodString;
+              deployedBy: z.ZodString;
+              createdAt: z.ZodString;
+              updatedAt: z.ZodString;
+              manifest: z.ZodNullable<
+                z.ZodObject<
+                  {
+                    buildId: z.ZodOptional<z.ZodString>;
+                    bundleVersion: z.ZodOptional<z.ZodString>;
+                    version: z.ZodOptional<z.ZodString>;
+                    group: z.ZodOptional<z.ZodString>;
+                    priority: z.ZodOptional<z.ZodNumber>;
+                    workspaces: z.ZodOptional<
+                      z.ZodArray<
+                        z.ZodObject<
+                          {
+                            name: z.ZodString;
+                            title: z.ZodString;
+                            subtitle: z.ZodOptional<z.ZodString>;
+                            basePath: z.ZodString;
+                            projectId: z.core.$ZodBranded<
+                              z.ZodString,
+                              "ProjectId",
+                              "out"
+                            >;
+                            icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            dataset: z.ZodString;
+                            schemaDescriptorId: z.ZodString;
+                          },
+                          z.core.$strip
+                        >
+                      >
+                    >;
+                  },
+                  z.core.$strip
+                >
+              >;
+            },
+            z.core.$strip
+          >
+        >;
+      },
+      z.core.$strip
+    >,
+    z.ZodObject<
+      {
+        id: z.core.$ZodBranded<z.ZodString, "UserApplicationId", "out">;
+        appHost: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        dashboardStatus: z.ZodEnum<{
+          default: "default";
+          disabled: "disabled";
+        }>;
+        interfaces: z.ZodOptional<
+          z.ZodArray<
+            z.ZodDiscriminatedUnion<
+              [
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"panel">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"worker">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+                z.ZodObject<
+                  {
+                    interface_type: z.ZodLiteral<"app">;
+                    name: z.ZodString;
+                    entry_point: z.ZodString;
+                  },
+                  z.core.$strip
+                >,
+              ],
+              "interface_type"
+            >
+          >
+        >;
+        title: z.ZodNullable<z.ZodString>;
+        projectId: z.core.$ZodBranded<z.ZodString, "ProjectId", "out">;
+        type: z.ZodLiteral<"studio">;
+        manifest: z.ZodNullable<
+          z.ZodObject<
+            {
+              version: z.ZodNumber;
+              createdAt: z.ZodString;
+              studioVersion: z.ZodOptional<z.ZodString>;
+              group: z.ZodOptional<z.ZodString>;
+              priority: z.ZodOptional<z.ZodNumber>;
+              workspaces: z.ZodArray<
+                z.ZodObject<
+                  {
+                    name: z.ZodString;
+                    title: z.ZodString;
+                    subtitle: z.ZodOptional<z.ZodString>;
+                    basePath: z.ZodString;
+                    projectId: z.core.$ZodBranded<
+                      z.ZodString,
+                      "ProjectId",
+                      "out"
+                    >;
+                    dataset: z.ZodOptional<z.ZodString>;
+                    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    schema: z.ZodString;
+                    tools: z.ZodOptional<z.ZodString>;
+                  },
+                  z.core.$strip
+                >
+              >;
+            },
+            z.core.$strip
+          >
+        >;
+        manifestData: z.ZodNullable<
+          z.ZodObject<
+            {
+              value: z.ZodObject<
+                {
+                  version: z.ZodNumber;
+                  createdAt: z.ZodString;
+                  studioVersion: z.ZodOptional<z.ZodString>;
+                  group: z.ZodOptional<z.ZodString>;
+                  priority: z.ZodOptional<z.ZodNumber>;
+                  workspaces: z.ZodArray<
+                    z.ZodObject<
+                      {
+                        name: z.ZodString;
+                        title: z.ZodString;
+                        subtitle: z.ZodOptional<z.ZodString>;
+                        basePath: z.ZodString;
+                        projectId: z.core.$ZodBranded<
+                          z.ZodString,
+                          "ProjectId",
+                          "out"
+                        >;
+                        dataset: z.ZodOptional<z.ZodString>;
+                        icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        schema: z.ZodString;
+                        tools: z.ZodOptional<z.ZodString>;
+                      },
+                      z.core.$strip
+                    >
+                  >;
+                },
+                z.core.$strip
+              >;
+            },
+            z.core.$strip
+          >
+        >;
+        autoUpdatingVersion: z.ZodNullable<z.ZodString>;
+        config: z.ZodObject<
+          {
+            "live-manifest": z.ZodOptional<
+              z.ZodObject<
+                {
+                  createdAt: z.ZodString;
+                  updatedAt: z.ZodString;
+                  updatedBy: z.ZodString;
+                  value: z.ZodObject<
+                    {
+                      buildId: z.ZodOptional<z.ZodString>;
+                      bundleVersion: z.ZodOptional<z.ZodString>;
+                      version: z.ZodOptional<z.ZodString>;
+                      group: z.ZodOptional<z.ZodString>;
+                      priority: z.ZodOptional<z.ZodNumber>;
+                      workspaces: z.ZodOptional<
+                        z.ZodArray<
+                          z.ZodObject<
+                            {
+                              name: z.ZodString;
+                              title: z.ZodString;
+                              subtitle: z.ZodOptional<z.ZodString>;
+                              basePath: z.ZodString;
+                              projectId: z.core.$ZodBranded<
+                                z.ZodString,
+                                "ProjectId",
+                                "out"
+                              >;
+                              icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                              dataset: z.ZodString;
+                              schemaDescriptorId: z.ZodString;
+                            },
+                            z.core.$strip
+                          >
+                        >
+                      >;
+                    },
+                    z.core.$strip
+                  >;
+                },
+                z.core.$strip
+              >
+            >;
+          },
+          z.core.$strip
+        >;
+        urlType: z.ZodLiteral<"external">;
+        activeDeployment: z.ZodNullable<
+          z.ZodObject<
+            {
+              id: z.ZodString;
+              version: z.ZodString;
+              isActiveDeployment: z.ZodBoolean;
+              userApplicationId: z.ZodString;
+              isAutoUpdating: z.ZodBoolean;
+              size: z.ZodNumber;
+              deployedAt: z.ZodString;
+              deployedBy: z.ZodString;
+              createdAt: z.ZodString;
+              updatedAt: z.ZodString;
+              manifest: z.ZodNullable<
+                z.ZodObject<
+                  {
+                    buildId: z.ZodOptional<z.ZodString>;
+                    bundleVersion: z.ZodOptional<z.ZodString>;
+                    version: z.ZodOptional<z.ZodString>;
+                    group: z.ZodOptional<z.ZodString>;
+                    priority: z.ZodOptional<z.ZodNumber>;
+                    workspaces: z.ZodOptional<
+                      z.ZodArray<
+                        z.ZodObject<
+                          {
+                            name: z.ZodString;
+                            title: z.ZodString;
+                            subtitle: z.ZodOptional<z.ZodString>;
+                            basePath: z.ZodString;
+                            projectId: z.core.$ZodBranded<
+                              z.ZodString,
+                              "ProjectId",
+                              "out"
+                            >;
+                            icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            dataset: z.ZodString;
+                            schemaDescriptorId: z.ZodString;
+                          },
+                          z.core.$strip
+                        >
+                      >
+                    >;
+                  },
+                  z.core.$strip
+                >
+              >;
+            },
+            z.core.$strip
+          >
+        >;
+      },
+      z.core.$strip
+    >,
+  ],
+  "urlType"
+>;
+
+/**
+ * @public
+ */
+export declare type StudioUserApplication = z.output<
+  typeof StudioUserApplication
+>;
+
+/**
+ * @public
+ */
+export declare class StudioWorkspace extends AbstractApplication<
+  "workspace",
+  StudioResource
+> {
+  /**
+   * Workspaces always belong to a studio application.
+   * They do not exist on their own & therefore can access
+   * information about the studio they're in via this property.
+   */
+  private readonly studioApplication;
+  private readonly workspace;
+  readonly project: Project<false, false>;
+  private readonly isDefaultWorkspace;
+  constructor(
+    studioApplication: StudioApplication,
+    workspace: Workspace,
+    project: Project<false, false>,
+    isDefaultWorkspace: boolean,
+  );
+  /**
+   * The studio application that this workspace belongs to.
+   */
+  get studio(): StudioApplication;
+  get id(): string;
+  get href(): string;
+  get title(): string;
+  get subtitle(): string | undefined;
+  get<TKey extends Exclude<keyof Workspace, "id" | "icon" | "title">>(
+    attr: TKey,
+  ): Workspace[TKey];
+  get isFederated(): boolean;
+  /**
+   * With comlink, studio-applications were not considered applications at all, only workspaces. This is partially why
+   * we create default workspaces when the application has no manifest or the manifest has no workspaces.
+   *
+   * Thereby, to create it we depend on a lot of information from the parent application even if it's duplicated across
+   * different workspaces.
+   */
+  toProtocolResource(): StudioResource;
+  /**
+   * @returns the URL to the workspace of a studio application.
+   */
+  get url(): URL;
+  static makeId(
+    applicationId: UserApplicationId,
+    workspaceName: string,
+  ): string;
+  static splitId(id: string): [string, string];
+}
+
+/**
+ * @public
+ */
+export declare abstract class UserApplication<
+  TUserApplication extends UserApplicationBase,
+  TType extends Extract<AbstractApplicationType, "coreApp" | "studio">,
+  TProtocolResource extends Resource = Extract<
+    Resource,
+    {
+      type: TType;
+    }
+  >,
+> extends AbstractApplication<TType, TProtocolResource> {
+  #private;
+  readonly application: TUserApplication;
+  readonly id: UserApplicationId;
+  /**
+   * For local applications (`isLocal === true`), the deployed application
+   * that shares the same `id` — if one was passed at construction. `null`
+   * for deployed applications or when no remote twin was provided.
+   */
+  readonly remoteApplication: this | null;
+  constructor(
+    application: TUserApplication,
+    type: TType,
+    options?: {
+      isLocal?: boolean;
+      remoteApplication?: UserApplication<
+        TUserApplication,
+        TType,
+        TProtocolResource
+      > | null;
+    },
+  );
+  abstract get subtitle(): string | undefined;
+  /**
+   * Local dev servers are rendered as federated remotes; deployed applications
+   * are rendered in an iframe.
+   */
+  get isFederated(): boolean;
+  get isLocal(): boolean;
+  get interfaces(): readonly LocalInterface[];
+  /**
+   * @returns A fully resolved URL instance for the application.
+   * For internal applications, constructs a URL using the Sanity studio domain
+   * pattern resolved from the environment at the consuming app's build time.
+   * For external applications (including local dev servers), returns the
+   * provided app host as a URL.
+   */
+  get url(): URL;
+  /**
+   * Unified manifest accessor for user applications. Resolves the most
+   * authoritative manifest available for the application, preferring the
+   * deployment manifest (`activeDeployment.manifest`) before falling back to
+   * any client-side manifest. The returned shape depends on the application
+   * type and source: studios may yield either a `ServerManifest` (deployment)
+   * or a `ClientManifest` (fallback); core apps yield a
+   * `CoreAppUserApplicationManifest`. Returns `null` when no manifest is
+   * available.
+   */
+  abstract get manifest():
+    | ClientManifest
+    | ServerManifest
+    | CoreAppUserApplicationManifest
+    | null;
+}
+
+/**
+ * @public
+ */
+export declare const UserApplicationBase: z.ZodObject<
+  {
+    id: z.core.$ZodBranded<z.ZodString, "UserApplicationId", "out">;
+    appHost: z.ZodString;
+    urlType: z.ZodEnum<{
+      internal: "internal";
+      external: "external";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    dashboardStatus: z.ZodEnum<{
+      default: "default";
+      disabled: "disabled";
+    }>;
+    interfaces: z.ZodOptional<
+      z.ZodArray<
+        z.ZodDiscriminatedUnion<
+          [
+            z.ZodObject<
+              {
+                interface_type: z.ZodLiteral<"panel">;
+                name: z.ZodString;
+                entry_point: z.ZodString;
+              },
+              z.core.$strip
+            >,
+            z.ZodObject<
+              {
+                interface_type: z.ZodLiteral<"worker">;
+                name: z.ZodString;
+                entry_point: z.ZodString;
+              },
+              z.core.$strip
+            >,
+            z.ZodObject<
+              {
+                interface_type: z.ZodLiteral<"app">;
+                name: z.ZodString;
+                entry_point: z.ZodString;
+              },
+              z.core.$strip
+            >,
+          ],
+          "interface_type"
+        >
+      >
+    >;
+  },
+  z.core.$strip
+>;
+
+/**
+ * @public
+ */
+export declare type UserApplicationBase = z.output<typeof UserApplicationBase>;
+
+/**
+ * User application ID schema, branded for type safety.
+ * @public
+ */
+export declare const UserApplicationId: z.core.$ZodBranded<
+  z.ZodString,
+  "UserApplicationId",
+  "out"
+>;
+
+/**
+ * User application ID type, branded for type safety.
+ * @public
+ */
+export declare type UserApplicationId = z.output<typeof UserApplicationId>;
+
+/**
+ * @public
+ */
+export declare type Workspace = z.output<typeof Workspace_2>;
+
+declare const Workspace_2: z.ZodObject<
+  {
+    name: z.ZodString;
+    title: z.ZodString;
+    subtitle: z.ZodOptional<z.ZodString>;
+    basePath: z.ZodString;
+    projectId: z.core.$ZodBranded<z.ZodString, "ProjectId", "out">;
+    dataset: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  },
+  z.core.$strip
+>;
+
+/**
+ * @public
+ */
+declare type Workspace = z.output<typeof Workspace_2>;
+
+export {};