@sanity/workbench 0.1.0-alpha.5 → 0.1.0-alpha.7

package/dist/core.d.ts

@@ -0,0 +1,906 @@
+import type { ApplicationResource } from "@sanity/message-protocol";
+import type { CanvasResource } from "@sanity/message-protocol";
+import type { CoreApplication } from "@sanity/message-protocol";
+import type { MediaResource } from "@sanity/message-protocol";
+import type { Resource } from "@sanity/message-protocol";
+import type { StudioApplication as StudioApplication_2 } from "@sanity/message-protocol";
+import type { StudioResource } from "@sanity/message-protocol";
+import type { UserApplication as UserApplication_2 } from "@sanity/message-protocol";
+import type { WorkspaceManifest } 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);
+  abstract get href(): string;
+  abstract get title(): string;
+  abstract get id(): string;
+  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";
+
+declare type Application =
+  | CoreAppApplication
+  | StudioApplication
+  | StudioWorkspace
+  | CanvasApplication
+  | MediaLibraryApplication
+  | LocalApplication;
+
+/**
+ * @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"> {
+  private readonly canvas;
+  constructor(canvas: Canvas);
+  get id(): CanvasId;
+  get href(): string;
+  get title(): string;
+  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>;
+
+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;
+}
+
+/**
+ * @internal
+ */
+export declare class CoreAppApplication extends UserApplication<
+  CoreApplication,
+  "coreApp",
+  ApplicationResource
+> {
+  readonly activeDeployment: CoreApplication["activeDeployment"];
+  constructor(application: CoreApplication);
+  get href(): string;
+  get title(): string;
+  get subtitle(): undefined;
+  get updatedAt(): string;
+  get<TKey extends keyof CoreApplication>(attr: TKey): CoreApplication[TKey];
+  toProtocolResource(): ApplicationResource;
+}
+
+/**
+ * @public
+ */
+export declare function createLogger({
+  namespace,
+  context: baseContext,
+  logLevel,
+}?: LoggerOptions): Logger;
+
+/**
+ * An Application wrapping a locally-discovered CLI application.
+ * Provides a deterministic id, title and href suitable for use in navigation.
+ *
+ * @internal
+ */
+export declare class LocalApplication extends AbstractApplication<
+  "studio" | "coreApp",
+  never
+> {
+  readonly localApplication: LocalApplicationData;
+  constructor(localApplication: LocalApplicationData);
+  get id(): string;
+  get title(): string;
+  get href(): string;
+  toProtocolResource(): never;
+}
+
+/**
+ * Raw data for a local application discovered by the CLI dev server.
+ *
+ * @experimental
+ * @public
+ */
+export declare interface LocalApplicationData {
+  host: string;
+  port: number;
+  type: "studio" | "coreApp";
+}
+
+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;
+}
+
+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"> {
+  private readonly library;
+  constructor(library: MediaLibrary);
+  get id(): string;
+  get href(): string;
+  get title(): string;
+  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.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>;
+
+/**
+ * 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
+ * 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>;
+
+/**
+ * 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.ZodLiteral<"manage" | "cli">;
+      },
+      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;
+};
+
+/**
+ * @internal
+ */
+export declare class StudioApplication extends UserApplication<
+  StudioApplication_2,
+  "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>;
+  /**
+   * @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: StudioApplication_2,
+    projects: Project<false, false>[],
+  );
+  get href(): string;
+  get title(): string;
+  get subtitle(): string;
+  get<TKey extends keyof StudioApplication_2>(
+    attr: TKey,
+  ): StudioApplication_2[TKey];
+  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;
+}>;
+
+/**
+ * @internal
+ */
+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 | null | undefined;
+  get<TKey extends Exclude<keyof Workspace, "id" | "icon" | "title">>(
+    attr: TKey,
+  ): Workspace[TKey];
+  /**
+   * 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];
+}
+
+/**
+ * @internal
+ */
+export declare abstract class UserApplication<
+  TUserApplication extends UserApplication_2,
+  TType extends Extract<AbstractApplicationType, "coreApp" | "studio">,
+  TProtocolResource extends Resource = Extract<
+    Resource,
+    {
+      type: TType;
+    }
+  >,
+> extends AbstractApplication<TType, TProtocolResource> {
+  readonly application: TUserApplication;
+  readonly id: UserApplicationId;
+  constructor(application: TUserApplication, type: TType);
+  abstract get subtitle(): string | undefined;
+  /**
+   * @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, returns the provided app host as a URL.
+   */
+  get url(): URL;
+}
+
+/**
+ * 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>;
+
+declare type Workspace = Omit<
+  WorkspaceManifest,
+  "dataset" | "schema" | "projectId"
+> & {
+  projectId: ProjectId;
+  dataset?: string;
+  schema?: string;
+};
+
+export {};