import { t as FederationInstance } from "./module-federation-tUlbbgvL.js";
import { J as CanvasApplication, U as OrganizationId, V as RemoteModule, _ as StudioApplication, j as CoreApplication, n as ApplicationList, r as MediaLibraryApplication, t as Application, tt as LocalApplication, v as StudioWorkspace, y as Project, z as LocalAppConfig } from "./application-list-Dh3Y9exX.js";
import { _ as SystemPreferencesEvent, c as NavigationLocation, g as SystemPreferencesContext, h as SystemPreferencesAdapter, u as PayloadOf } from "./bus-CMwGmM1c.js";
import "./index-C15YDHgO.js";
import "./index-Bs5HQGp0.js";
import { Observable } from "rxjs";
import { ActorRefFrom, InspectionEvent } from "xstate";
import { AuthStateType, CurrentUser, OrganizationBase, SanityInstance } from "@sanity/sdk";
import "@sanity/telemetry";
interface ApplicationStoreInput {
  instance: SanityInstance;
  organizationId: OrganizationId;
  /** Apps served by attached dev servers; empty in production. */
  localApplications: Observable<LocalApplication[]>;
  /** App configs those dev servers forward; empty in production. */
  appConfigs: Observable<LocalAppConfig[]>;
  /** Gates and enriches studios: no reachable project, no dock entry. */
  projects: Observable<Project<false, false>[]>;
}
/**
 * Everything the OS derives from the organization's installed applications.
 * @internal
 */
interface OrganizationApplications {
  applications: ApplicationList<Exclude<Application, StudioWorkspace>>;
  /**
   * The media library's config as a module ref, or `null` when it has none. A
   * dev server's working copy wins over the deployed one, so a local config can
   * be tried against a real organization.
   */
  mediaLibraryConfig: RemoteModule | null;
}
/**
 * The id comes from the OS config, not from the session.
 * @internal
 */
interface OrganizationInput extends OSBaseInput {
  organizationId: string;
}
/**
 * The resolved organization the parent keys its resource queries on. Exported so
 * the root machine can read it off this actor's snapshot.
 * @internal
 */
type CurrentOrganization = Pick<OrganizationBase, "id" | "name" | "slug">;
/** @internal */
interface ProjectsInput extends OSBaseInput {
  organizationId: OrganizationId;
}
/**
 * @public
 */
interface RemoteRenderOptions {
  basePath?: string;
  scheme?: "light" | "dark";
  /**
   * This is a temporary measure designed to authenticate federated
   * studios & SDK apps before we write a working protocol.
   */
  unstable_temporaryToken?: string | null;
}
/**
 * A loaded render-contract module. `TProps` is what its `render` accepts —
 * `RemoteRenderOptions` for an application's full-page view, the view's props
 * for a dock-panel component.
 * @public
 */
interface LoadedRemoteModule<TProps = RemoteRenderOptions> {
  render: (rootElement: HTMLElement, props?: TProps) => () => void;
}
/**
 * A worker service's loader module — the `worker` interface's expose. Carries
 * the worker bundle URL (root-relative to the app origin) for the host to
 * bootstrap, not a render function; the services counterpart of
 * {@link LoadedRemoteModule}.
 * @public
 */
interface ServiceLoaderModule {
  url: string;
  type: string;
  name: string;
  version: number;
}
/**
 * The federated-module shape each interface type exposes, keyed by
 * `type`. Every interface — `panel`, `app`, `worker` — loads through
 * the same {@link moduleLoaderLogic} lifecycle; this maps what its loaded module looks
 * like so each consumer narrows the machine's shape-agnostic `module` to the
 * right type: a render contract for `panel`/`app` (rendered by an island), a
 * worker loader for `worker` (run as a Web Worker, never rendered).
 * @public
 */
interface RemoteModuleByInterfaceType {
  panel: LoadedRemoteModule;
  app: LoadedRemoteModule;
  worker: ServiceLoaderModule;
}
/**
 * @public
 */
interface RemoteError {
  message: string;
  cause: unknown;
}
/**
 * Thrown by a render consumer (e.g. the island) when a loaded module doesn't
 * expose a `render` function. Render-specific — `moduleLoaderLogic` itself is
 * shape-agnostic, so this lives with the consumer that needs the contract, not
 * the loader. Surfaced via `RemoteError.cause` for consumers that discriminate.
 * @public
 */
declare class ModuleShapeError extends Error {
  constructor(remoteId: string);
}
/**
 * @internal
 */
interface ModuleLoaderInput {
  /** Fully-qualified module id — `${appId}/${expose}`. One loader per moduleId. */
  moduleId: string;
  instance: FederationInstance;
}
type ModuleLoaderContext = ModuleLoaderInput & {
  /** The loaded module, shape-agnostic — each consumer narrows it. @see {@link RemoteModuleByInterfaceType} */
  module: unknown;
  error: RemoteError | null;
};
/**
 * Loads and tracks a single federated module — an application's `App` entry,
 * one panel view component, or a worker service's loader.
 *
 * The deep bit behind a tiny interface: given `{ moduleId, instance }` it does
 * the federation load, normalises failure, and exposes the whole lifecycle as
 * three tags — `loading` → `ready` | `failed` — with the loaded `module` (or
 * `error`) in context. Interface-agnostic: it never inspects the module's
 * shape, so the same loader serves a render island and a worker alike, leaving
 * the render-vs-worker contract to the consumer.
 *
 * Spawned by an app's `remoteLogic`, one per expose (`${appId}/${moduleId}`)
 * — its panels warmed upfront, its `App` view on demand. State names are
 * internal; the tags are the read interface.
 *
 * Sends a `remote.settled` event to its parent on entry to either terminal
 * state, reserved for future supervision/retry.
 *
 * @internal
 */
declare const moduleLoaderLogic: import("xstate").StateMachine<ModuleLoaderContext, import("xstate").AnyEventObject, {
  [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
}, {
  src: "load";
  logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
  id: string | undefined;
}, {
  type: "setError";
  params: {
    error: unknown;
  };
} | {
  type: "setModule";
  params: {
    module: unknown;
  };
}, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
  id: "remote";
  states: {
    readonly loading: {};
    readonly loaded: {};
    readonly error: {};
  };
}>;
/**
 * @internal
 */
interface ServiceInput {
  /** Stable child key, `${appId}:${serviceName}`. */
  key: string;
  appId: string;
  serviceName: string;
  entry: string;
  instance: FederationInstance;
}
type ServiceContext = ServiceInput & {
  /** Resolved worker-bundle URL, absolute on the app origin. */
  workerUrl: string | null;
};
/**
 * Lifecycle machine for a single background service worker.
 *
 * Spawned by an app's `remoteLogic`, one per `(app, service)`, so a worker
 * runs whenever its app is available and is disposed when the app leaves.
 * `loading` loads the worker's loader module through the shared
 * {@link moduleLoaderLogic} lifecycle — the same machine every interface (panel,
 * app, worker) loads through — and reads the bundle URL off it. A worker isn't a
 * render module, so it's never handed to an island; `running` bootstraps it as
 * a Web Worker from that URL.
 *
 * @internal
 */
declare const serviceLogic: import("xstate").StateMachine<ServiceContext, import("xstate").AnyEventObject, {
  [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
    type: string;
  }, {
    key: string;
    serviceName: string;
    workerUrl: string;
  }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
    module: unknown;
    error: RemoteError | null;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "load";
    logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "setError";
    params: {
      error: unknown;
    };
  } | {
    type: "setModule";
    params: {
      module: unknown;
    };
  }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "remote";
    states: {
      readonly loading: {};
      readonly loaded: {};
      readonly error: {};
    };
  }>> | undefined;
}, {
  src: "loadInterface";
  logic: import("xstate").StateMachine<ModuleLoaderInput & {
    module: unknown;
    error: RemoteError | null;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "load";
    logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "setError";
    params: {
      error: unknown;
    };
  } | {
    type: "setModule";
    params: {
      module: unknown;
    };
  }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "remote";
    states: {
      readonly loading: {};
      readonly loaded: {};
      readonly error: {};
    };
  }>;
  id: string | undefined;
} | {
  src: "runWorker";
  logic: import("xstate").CallbackActorLogic<{
    type: string;
  }, {
    key: string;
    serviceName: string;
    workerUrl: string;
  }, import("xstate").EventObject>;
  id: string | undefined;
}, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
  id: "service";
  states: {
    readonly loading: {};
    readonly running: {};
    readonly error: {};
  };
}>;
/**
 * @internal
 */
interface RemoteInput {
  /** The application this remote represents. */
  app: Application;
  /** The shared federation instance, supplied by the remotes supervisor. */
  instance: FederationInstance;
}
type RemoteContext = {
  app: Application;
  instance: FederationInstance;
  /**
   * Loaders for exposes an island has rendered — a panel or the App view —
   * keyed by moduleId. Each is a {@link moduleLoaderLogic}, read via `useRemote`.
   */
  exposes: Map<string, ActorRefFrom<typeof moduleLoaderLogic>>;
  /** Running workers, keyed by service name — one {@link serviceLogic} each. */
  services: Map<string, ActorRefFrom<typeof serviceLogic>>;
};
/**
 * One federated application's remote — spawned per app by the {@link
 * remotesLogic} supervisor, which supplies the shared federation instance. Each
 * kind of interface is warmed or run at a different moment:
 *
 * - worker   — loaded and started on spawn (a service runs while its app exists)
 * - panel    — assets preloaded on spawn; loaded (evaluated) when the panel opens
 * - App view — assets preloaded on hover; loaded on navigation
 *
 * So only workers evaluate at boot; panels and the App view warm their assets
 * and defer evaluation to render. Registration happens first, so any later
 * load/preload resolves a known remote. Workers and loaded exposes are children,
 * disposed by cascade when the app leaves the list; `app.update` re-warms panels
 * and reconciles workers.
 *
 * @internal
 */
declare const remoteLogic: import("xstate").StateMachine<RemoteContext, {
  type: "app.update";
  app: Application;
} | {
  type: "expose.load.request";
  moduleId: string;
} | {
  type: "expose.preload.request";
  moduleId: string;
} | {
  type: "remote.settled";
  moduleId: string;
  status: "loaded" | "error";
}, {
  [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<ModuleLoaderInput & {
    module: unknown;
    error: RemoteError | null;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "load";
    logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "setError";
    params: {
      error: unknown;
    };
  } | {
    type: "setModule";
    params: {
      module: unknown;
    };
  }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "remote";
    states: {
      readonly loading: {};
      readonly loaded: {};
      readonly error: {};
    };
  }> | import("xstate").StateMachine<ServiceInput & {
    workerUrl: string | null;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
      type: string;
    }, {
      key: string;
      serviceName: string;
      workerUrl: string;
    }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
      module: unknown;
      error: RemoteError | null;
    }, import("xstate").AnyEventObject, {
      [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
    }, {
      src: "load";
      logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
      id: string | undefined;
    }, {
      type: "setError";
      params: {
        error: unknown;
      };
    } | {
      type: "setModule";
      params: {
        module: unknown;
      };
    }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
      id: "remote";
      states: {
        readonly loading: {};
        readonly loaded: {};
        readonly error: {};
      };
    }>> | undefined;
  }, {
    src: "loadInterface";
    logic: import("xstate").StateMachine<ModuleLoaderInput & {
      module: unknown;
      error: RemoteError | null;
    }, import("xstate").AnyEventObject, {
      [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
    }, {
      src: "load";
      logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
      id: string | undefined;
    }, {
      type: "setError";
      params: {
        error: unknown;
      };
    } | {
      type: "setModule";
      params: {
        module: unknown;
      };
    }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
      id: "remote";
      states: {
        readonly loading: {};
        readonly loaded: {};
        readonly error: {};
      };
    }>;
    id: string | undefined;
  } | {
    src: "runWorker";
    logic: import("xstate").CallbackActorLogic<{
      type: string;
    }, {
      key: string;
      serviceName: string;
      workerUrl: string;
    }, import("xstate").EventObject>;
    id: string | undefined;
  }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "service";
    states: {
      readonly loading: {};
      readonly running: {};
      readonly error: {};
    };
  }>> | undefined;
}, {
  src: "moduleLoader";
  logic: import("xstate").StateMachine<ModuleLoaderInput & {
    module: unknown;
    error: RemoteError | null;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "load";
    logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "setError";
    params: {
      error: unknown;
    };
  } | {
    type: "setModule";
    params: {
      module: unknown;
    };
  }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "remote";
    states: {
      readonly loading: {};
      readonly loaded: {};
      readonly error: {};
    };
  }>;
  id: string | undefined;
} | {
  src: "service";
  logic: import("xstate").StateMachine<ServiceInput & {
    workerUrl: string | null;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
      type: string;
    }, {
      key: string;
      serviceName: string;
      workerUrl: string;
    }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
      module: unknown;
      error: RemoteError | null;
    }, import("xstate").AnyEventObject, {
      [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
    }, {
      src: "load";
      logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
      id: string | undefined;
    }, {
      type: "setError";
      params: {
        error: unknown;
      };
    } | {
      type: "setModule";
      params: {
        module: unknown;
      };
    }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
      id: "remote";
      states: {
        readonly loading: {};
        readonly loaded: {};
        readonly error: {};
      };
    }>> | undefined;
  }, {
    src: "loadInterface";
    logic: import("xstate").StateMachine<ModuleLoaderInput & {
      module: unknown;
      error: RemoteError | null;
    }, import("xstate").AnyEventObject, {
      [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
    }, {
      src: "load";
      logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
      id: string | undefined;
    }, {
      type: "setError";
      params: {
        error: unknown;
      };
    } | {
      type: "setModule";
      params: {
        module: unknown;
      };
    }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
      id: "remote";
      states: {
        readonly loading: {};
        readonly loaded: {};
        readonly error: {};
      };
    }>;
    id: string | undefined;
  } | {
    src: "runWorker";
    logic: import("xstate").CallbackActorLogic<{
      type: string;
    }, {
      key: string;
      serviceName: string;
      workerUrl: string;
    }, import("xstate").EventObject>;
    id: string | undefined;
  }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "service";
    states: {
      readonly loading: {};
      readonly running: {};
      readonly error: {};
    };
  }>;
  id: string | undefined;
}, {
  type: "ensureExpose";
  params: import("xstate").NonReducibleUnknown;
} | {
  type: "preloadExpose";
  params: unknown;
} | {
  type: "preloadPanels";
  params: unknown;
} | {
  type: "reconcileServices";
  params: import("xstate").NonReducibleUnknown;
} | {
  type: "registerSelf";
  params: unknown;
} | {
  type: "updateApp";
  params: import("xstate").NonReducibleUnknown;
}, never, never, {}, string, RemoteInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
  id: "remote";
}>;
/**
 * @public
 */
type WorkbenchUserProperties = {
  version: string;
  organizationId: string;
  environment: string;
  userAgent: string;
};
/**
 * @internal
 */
interface TelemetryInput extends OSBaseInput, WorkbenchUserProperties {}
/** @internal exported for testing */
declare const inspect: (event: InspectionEvent) => void;
/**
 * How the machine reaches the router, which owns the history stack: ask it to
 * navigate, and read back where it is. `history` mirrors the Navigation API's
 * option of the same name.
 * @public
 */
type NavigationAdapter = {
  navigate: (href: string, options: {
    history: "push" | "replace";
  }) => Promise<void>;
  location: Observable<string>;
};
type OSInput = WorkbenchUserProperties & {
  systemPreferencesAdapter?: SystemPreferencesAdapter;
  /**
   * How the OS reaches the router. Absent in a headless host, where a
   * navigation request has nowhere to go.
   */
  navigationAdapter?: NavigationAdapter;
  /**
   * Apps served by attached dev servers. A stream, so the applications machine
   * can subscribe directly and a dev server coming or going rebuilds the list
   * without a host re-render.
   */
  localApplications?: Observable<LocalApplication[]>;
  appConfigs?: Observable<LocalAppConfig[]>;
};
type OSContext = {
  instance: SanityInstance;
  /**
   * The organization id the resource queries key on. Seeded from host config so
   * it is always a string, then replaced with the id from the organization
   * response once it resolves.
   */
  organizationId: string;
  /**
   * The single module-federation instance every interface loads through. Owned
   * by the `remotes` supervisor's per-app children, so an app's remote is
   * registered once for all its interfaces (views, panels, workers).
   */
  federationInstance: FederationInstance;
  userProperties: WorkbenchUserProperties;
  systemPreferencesAdapter: SystemPreferencesAdapter | undefined;
  navigationAdapter: NavigationAdapter;
  localApplications: Observable<LocalApplication[]>;
  appConfigs: Observable<LocalAppConfig[]>;
};
/**
 * The base inputs for the OS machine.
 * @internal
 */
interface OSBaseInput extends Pick<OSContext, "instance"> {}
/**
 * The sanity OS machine, responsible for managing the global state of the OS.
 * @public
 * @example
 * ```ts
 * import { os, createOSOptions } from "@sanity/workbench/system";
 * import { useActor } from "@xstate/react";
 *
 * const [state, send] = useActor(os, createOSOptions({
 *   version: "1.0.0",
 *   organizationId: "...",
 *   environment: "production",
 *   userAgent: navigator.userAgent,
 * }));
 * ```
 */
declare const os: import("xstate").StateMachine<OSContext, {
  type: "boot.auth.ready";
} | {
  type: "boot.auth.failed";
} | {
  type: "boot.organization.ready";
} | {
  type: "boot.organization.failed";
}, {
  applications?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
    instance: ApplicationStoreInput["instance"];
    organizationId: ApplicationStoreInput["organizationId"];
    localApplications: ApplicationStoreInput["localApplications"];
    appConfigs: ApplicationStoreInput["appConfigs"];
    projects: ApplicationStoreInput["projects"];
    applications: ApplicationList<Exclude<Application, {
      type: "workspace";
    }>> | undefined;
    listError: unknown;
    published: {
      foreground: Application | null;
      mediaLibraryConfig: RemoteModule | null | undefined;
    };
    pathname: string | undefined;
    commits$: Observable<string>;
  }, {
    type: "applications.sync";
    applications: NonNullable<ApplicationList<CanvasApplication | CoreApplication | MediaLibraryApplication | StudioApplication> | undefined>;
    mediaLibraryConfig: RemoteModule | null;
  } | {
    type: "applications.error";
    error?: unknown;
  } | {
    type: "location.updated";
    pathname: string;
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").ObservableActorLogic<string, Observable<string>, import("xstate").EventObject> | import("xstate").ObservableActorLogic<OrganizationApplications, ApplicationStoreInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "applicationStore";
    logic: import("xstate").ObservableActorLogic<OrganizationApplications, ApplicationStoreInput, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "commitFeed";
    logic: import("xstate").ObservableActorLogic<string, Observable<string>, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "publishApplications";
    params: unknown;
  } | {
    type: "publishApplicationsError";
    params: unknown;
  } | {
    type: "publishForeground";
    params: unknown;
  } | {
    type: "publishMediaLibraryConfig";
    params: unknown;
  } | {
    type: "recordPublished";
    params: unknown;
  } | {
    type: "storeApplicationsError";
    params: unknown;
  } | {
    type: "storeLocation";
    params: unknown;
  } | {
    type: "sync";
    params: unknown;
  } | {
    type: "syncRemotes";
    params: unknown;
  }, never, never, "failed" | "loading" | "ready", "applications-resolved" | "error", ApplicationStoreInput & {
    location: NavigationAdapter["location"];
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "applications";
    states: {
      readonly loading: {};
      readonly ready: {};
      readonly failed: {};
    };
  }>> | undefined;
  auth?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
    instance: SanityInstance;
    token: string | null;
    currentUser: import("@sanity/sdk").CurrentUser | null;
    error: unknown;
  }, {
    type: "auth.logout";
  } | {
    type: "token.refresh";
    reply: (token: string) => void;
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").ObservableActorLogic<import("@sanity/sdk").AuthState, OSBaseInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<void, LogoutInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "authState";
    logic: import("xstate").ObservableActorLogic<import("@sanity/sdk").AuthState, OSBaseInput, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "logoutActor";
    logic: import("xstate").PromiseActorLogic<void, LogoutInput, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "tokenRefreshResponder";
    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "clearAuth";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "publishCurrentUser";
    params: unknown;
  } | {
    type: "publishToken";
    params: unknown;
  } | {
    type: "replyToken";
    params: {
      reply: (token: string) => void;
    };
  } | {
    type: "setError";
    params: {
      error: unknown;
    };
  } | {
    type: "setLoggedIn";
    params: {
      token: string;
      currentUser: import("@sanity/sdk").CurrentUser;
    };
  }, {
    type: "isAuthState";
    params: {
      state: import("@sanity/sdk").AuthState | undefined;
      type: import("@sanity/sdk").AuthStateType;
    };
  } | {
    type: "isLoggedInComplete";
    params: {
      state: import("@sanity/sdk").AuthState | undefined;
    };
  }, "authTimeout", "init" | "logging-out" | import("@sanity/sdk").AuthStateType, "authenticated" | "authenticating" | "error", AuthInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "auth";
    states: {
      readonly init: {};
      readonly "logging-in": {};
      readonly "logged-in": {};
      readonly "logging-out": {};
      readonly "logged-out": {};
      readonly error: {};
    };
  }>> | undefined;
  navigation?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
    navigate: NavigationAdapter["navigate"];
    commits$: NavigationAdapter["location"];
    applications$: Observable<ApplicationList<Application> | null>;
    applications: ApplicationList | null;
    href: string | null;
    published: NavigationLocation | null;
    transition: {
      request: {
        payload: PayloadOf<"navigation.location.update">;
        reply: (reply: {
          ok: true;
        } | {
          ok: false;
          reason: "not-navigable" | "interrupted" | "failed";
        }) => void;
        signal: AbortSignal;
      };
      href: string;
      navigationType: "push" | "replace";
    } | null;
    request: {
      payload: PayloadOf<"navigation.location.update">;
      reply: (reply: {
        ok: true;
      } | {
        ok: false;
        reason: "not-navigable" | "interrupted" | "failed";
      }) => void;
      signal: AbortSignal;
    } | null;
  }, {
    type: "applications.changed";
    applications: ApplicationList | null;
  } | {
    type: "navigation.committed";
    href: string;
  } | {
    type: "navigation.request.committed";
  } | {
    type: "navigation.failed";
    error: unknown;
  } | {
    type: "navigation.superseded";
  } | {
    type: "navigation.aborted";
  } | ({
    type: "navigation.requested";
  } & {
    payload: PayloadOf<"navigation.location.update">;
    reply: (reply: {
      ok: true;
    } | {
      ok: false;
      reason: "not-navigable" | "interrupted" | "failed";
    }) => void;
    signal: AbortSignal;
  }), {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").AnyEventObject, {
      navigate: NavigationAdapter["navigate"];
      transition: {
        request: {
          payload: PayloadOf<"navigation.location.update">;
          reply: (reply: {
            ok: true;
          } | {
            ok: false;
            reason: "not-navigable" | "interrupted" | "failed";
          }) => void;
          signal: AbortSignal;
        };
        href: string;
        navigationType: "push" | "replace";
      } | null;
    }, import("xstate").EventObject> | import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").ObservableActorLogic<string, Observable<string>, import("xstate").EventObject> | import("xstate").ObservableActorLogic<ApplicationList<Application> | null, Observable<ApplicationList<Application> | null>, import("xstate").EventObject>> | undefined;
  }, {
    src: "applicationsFeed";
    logic: import("xstate").ObservableActorLogic<ApplicationList<Application> | null, Observable<ApplicationList<Application> | null>, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "commitFeed";
    logic: import("xstate").ObservableActorLogic<string, Observable<string>, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "navigationRequests";
    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "navigationRun";
    logic: import("xstate").CallbackActorLogic<import("xstate").AnyEventObject, {
      navigate: NavigationAdapter["navigate"];
      transition: {
        request: {
          payload: PayloadOf<"navigation.location.update">;
          reply: (reply: {
            ok: true;
          } | {
            ok: false;
            reason: "not-navigable" | "interrupted" | "failed";
          }) => void;
          signal: AbortSignal;
        };
        href: string;
        navigationType: "push" | "replace";
      } | null;
    }, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "beginTransition";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "endTransition";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "holdRequest";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "publish";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "releaseRequest";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "replyCommitted";
    params: unknown;
  } | {
    type: "replyFailed";
    params: unknown;
  } | {
    type: "replyInterrupted";
    params: unknown;
  } | {
    type: "replyWithoutNavigating";
    params: unknown;
  } | {
    type: "reportFailure";
    params: unknown;
  } | {
    type: "storeApplications";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "storeHref";
    params: import("xstate").NonReducibleUnknown;
  }, {
    type: "listPending";
    params: unknown;
  } | {
    type: "needsNavigation";
    params: unknown;
  }, "commitDeadline", "idle" | "navigating", string, NavigationAdapter & {
    applications: Observable<ApplicationList | null>;
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "navigation";
    states: {
      readonly idle: {};
      readonly navigating: {};
    };
  }>> | undefined;
  organization?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
    instance: SanityInstance;
    organizationId: string;
    currentOrganization: CurrentOrganization | null;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").ObservableActorLogic<CurrentOrganization, OrganizationInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "organizationState";
    logic: import("xstate").ObservableActorLogic<CurrentOrganization, OrganizationInput, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "publishOrganization";
    params: {
      organization: CurrentOrganization | null;
    };
  } | {
    type: "storeOrganization";
    params: {
      organization: CurrentOrganization | null;
    };
  }, never, never, "failed" | "resolved" | "resolving", "error" | "organization-resolved", OrganizationInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "organization";
    states: {
      readonly resolving: {};
      readonly resolved: {};
      readonly failed: {};
    };
  }>> | undefined;
  panels?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
    applications$: Observable<ApplicationList<Application> | null>;
    applications: ApplicationList | null;
    panel: ({
      appId: string;
      name: string;
      mode: "aside";
      size?: number;
    } | {
      appId: string;
      name: string;
      mode: "full";
    }) | null;
    panelSizes: Record<string, number>;
  }, {
    type: "panel.set";
    value: ({
      name: string;
      mode: "aside" | "full";
    } | {
      name: string;
      size: number;
    }) | null;
    appId: string;
  } | {
    type: "applications.changed";
    applications: ApplicationList | null;
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").ObservableActorLogic<ApplicationList<Application> | null, Observable<ApplicationList<Application> | null>, import("xstate").EventObject>> | undefined;
  }, {
    src: "applicationsFeed";
    logic: import("xstate").ObservableActorLogic<ApplicationList<Application> | null, Observable<ApplicationList<Application> | null>, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "panelRequests";
    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "publishPanel";
    params: unknown;
  } | {
    type: "storeApplications";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "storePanel";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "warnUndeclaredPanel";
    params: unknown;
  }, {
    type: "appDeclaresPanel";
    params: unknown;
  } | {
    type: "appOwnsPanel";
    params: unknown;
  }, never, {}, string, {
    applications: Observable<ApplicationList | null>;
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "panels";
  }>> | undefined;
  projects?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
    instance: SanityInstance;
    organizationId: OrganizationId;
    projects: {
      id: string & import("zod").$brand<"ProjectId">;
      displayName: string;
      studioHost: string | null;
      organizationId: string & import("zod").$brand<"OrganizationId">;
      metadata: {
        color?: string | undefined;
        externalStudioHost?: string | null | undefined;
        initialTemplate?: string | undefined;
        cliInitializedAt?: string | undefined;
        integration?: string | undefined;
      };
      isBlocked: boolean;
      isDisabled: boolean;
      isDisabledByUser: boolean;
      activityFeedEnabled: boolean;
      createdAt: string;
      updatedAt: string;
    }[] | undefined;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").ObservableActorLogic<{
      id: string & import("zod").$brand<"ProjectId">;
      displayName: string;
      studioHost: string | null;
      organizationId: string & import("zod").$brand<"OrganizationId">;
      metadata: {
        color?: string | undefined;
        externalStudioHost?: string | null | undefined;
        initialTemplate?: string | undefined;
        cliInitializedAt?: string | undefined;
        integration?: string | undefined;
      };
      isBlocked: boolean;
      isDisabled: boolean;
      isDisabledByUser: boolean;
      activityFeedEnabled: boolean;
      createdAt: string;
      updatedAt: string;
    }[], ProjectsInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "projectsState";
    logic: import("xstate").ObservableActorLogic<{
      id: string & import("zod").$brand<"ProjectId">;
      displayName: string;
      studioHost: string | null;
      organizationId: string & import("zod").$brand<"OrganizationId">;
      metadata: {
        color?: string | undefined;
        externalStudioHost?: string | null | undefined;
        initialTemplate?: string | undefined;
        cliInitializedAt?: string | undefined;
        integration?: string | undefined;
      };
      isBlocked: boolean;
      isDisabled: boolean;
      isDisabledByUser: boolean;
      activityFeedEnabled: boolean;
      createdAt: string;
      updatedAt: string;
    }[], ProjectsInput, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "storeProjects";
    params: {
      projects: {
        id: string & import("zod").$brand<"ProjectId">;
        displayName: string;
        studioHost: string | null;
        organizationId: string & import("zod").$brand<"OrganizationId">;
        metadata: {
          color?: string | undefined;
          externalStudioHost?: string | null | undefined;
          initialTemplate?: string | undefined;
          cliInitializedAt?: string | undefined;
          integration?: string | undefined;
        };
        isBlocked: boolean;
        isDisabled: boolean;
        isDisabledByUser: boolean;
        activityFeedEnabled: boolean;
        createdAt: string;
        updatedAt: string;
      }[] | undefined;
    };
  }, never, never, "failed" | "resolved" | "resolving", "error" | "projects-resolved", ProjectsInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "projects";
    states: {
      readonly resolving: {};
      readonly resolved: {};
      readonly failed: {};
    };
  }>> | undefined;
  remotes?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
    instance: FederationInstance;
    children: Map<string, ActorRefFrom<typeof remoteLogic>>;
  }, {
    type: "remotes.sync";
    applications: ReadonlyArray<Application>;
  } | {
    type: "remote.load.request";
    moduleId: string;
  } | {
    type: "remote.preload.request";
    moduleId: string;
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
      app: Application;
      instance: FederationInstance;
      exposes: Map<string, ActorRefFrom<typeof moduleLoaderLogic>>;
      services: Map<string, ActorRefFrom<typeof serviceLogic>>;
    }, {
      type: "app.update";
      app: Application;
    } | {
      type: "expose.load.request";
      moduleId: string;
    } | {
      type: "expose.preload.request";
      moduleId: string;
    } | {
      type: "remote.settled";
      moduleId: string;
      status: "loaded" | "error";
    }, {
      [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<ModuleLoaderInput & {
        module: unknown;
        error: RemoteError | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
      }, {
        src: "load";
        logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
        id: string | undefined;
      }, {
        type: "setError";
        params: {
          error: unknown;
        };
      } | {
        type: "setModule";
        params: {
          module: unknown;
        };
      }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "remote";
        states: {
          readonly loading: {};
          readonly loaded: {};
          readonly error: {};
        };
      }> | import("xstate").StateMachine<ServiceInput & {
        workerUrl: string | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>> | undefined;
      }, {
        src: "loadInterface";
        logic: import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>;
        id: string | undefined;
      } | {
        src: "runWorker";
        logic: import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject>;
        id: string | undefined;
      }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "service";
        states: {
          readonly loading: {};
          readonly running: {};
          readonly error: {};
        };
      }>> | undefined;
    }, {
      src: "moduleLoader";
      logic: import("xstate").StateMachine<ModuleLoaderInput & {
        module: unknown;
        error: RemoteError | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
      }, {
        src: "load";
        logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
        id: string | undefined;
      }, {
        type: "setError";
        params: {
          error: unknown;
        };
      } | {
        type: "setModule";
        params: {
          module: unknown;
        };
      }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "remote";
        states: {
          readonly loading: {};
          readonly loaded: {};
          readonly error: {};
        };
      }>;
      id: string | undefined;
    } | {
      src: "service";
      logic: import("xstate").StateMachine<ServiceInput & {
        workerUrl: string | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>> | undefined;
      }, {
        src: "loadInterface";
        logic: import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>;
        id: string | undefined;
      } | {
        src: "runWorker";
        logic: import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject>;
        id: string | undefined;
      }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "service";
        states: {
          readonly loading: {};
          readonly running: {};
          readonly error: {};
        };
      }>;
      id: string | undefined;
    }, {
      type: "ensureExpose";
      params: import("xstate").NonReducibleUnknown;
    } | {
      type: "preloadExpose";
      params: unknown;
    } | {
      type: "preloadPanels";
      params: unknown;
    } | {
      type: "reconcileServices";
      params: import("xstate").NonReducibleUnknown;
    } | {
      type: "registerSelf";
      params: unknown;
    } | {
      type: "updateApp";
      params: import("xstate").NonReducibleUnknown;
    }, never, never, {}, string, RemoteInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
      id: "remote";
    }>> | undefined;
  }, {
    src: "remote";
    logic: import("xstate").StateMachine<{
      app: Application;
      instance: FederationInstance;
      exposes: Map<string, ActorRefFrom<typeof moduleLoaderLogic>>;
      services: Map<string, ActorRefFrom<typeof serviceLogic>>;
    }, {
      type: "app.update";
      app: Application;
    } | {
      type: "expose.load.request";
      moduleId: string;
    } | {
      type: "expose.preload.request";
      moduleId: string;
    } | {
      type: "remote.settled";
      moduleId: string;
      status: "loaded" | "error";
    }, {
      [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<ModuleLoaderInput & {
        module: unknown;
        error: RemoteError | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
      }, {
        src: "load";
        logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
        id: string | undefined;
      }, {
        type: "setError";
        params: {
          error: unknown;
        };
      } | {
        type: "setModule";
        params: {
          module: unknown;
        };
      }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "remote";
        states: {
          readonly loading: {};
          readonly loaded: {};
          readonly error: {};
        };
      }> | import("xstate").StateMachine<ServiceInput & {
        workerUrl: string | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>> | undefined;
      }, {
        src: "loadInterface";
        logic: import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>;
        id: string | undefined;
      } | {
        src: "runWorker";
        logic: import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject>;
        id: string | undefined;
      }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "service";
        states: {
          readonly loading: {};
          readonly running: {};
          readonly error: {};
        };
      }>> | undefined;
    }, {
      src: "moduleLoader";
      logic: import("xstate").StateMachine<ModuleLoaderInput & {
        module: unknown;
        error: RemoteError | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
      }, {
        src: "load";
        logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
        id: string | undefined;
      }, {
        type: "setError";
        params: {
          error: unknown;
        };
      } | {
        type: "setModule";
        params: {
          module: unknown;
        };
      }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "remote";
        states: {
          readonly loading: {};
          readonly loaded: {};
          readonly error: {};
        };
      }>;
      id: string | undefined;
    } | {
      src: "service";
      logic: import("xstate").StateMachine<ServiceInput & {
        workerUrl: string | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>> | undefined;
      }, {
        src: "loadInterface";
        logic: import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>;
        id: string | undefined;
      } | {
        src: "runWorker";
        logic: import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject>;
        id: string | undefined;
      }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "service";
        states: {
          readonly loading: {};
          readonly running: {};
          readonly error: {};
        };
      }>;
      id: string | undefined;
    }, {
      type: "ensureExpose";
      params: import("xstate").NonReducibleUnknown;
    } | {
      type: "preloadExpose";
      params: unknown;
    } | {
      type: "preloadPanels";
      params: unknown;
    } | {
      type: "reconcileServices";
      params: import("xstate").NonReducibleUnknown;
    } | {
      type: "registerSelf";
      params: unknown;
    } | {
      type: "updateApp";
      params: import("xstate").NonReducibleUnknown;
    }, never, never, {}, string, RemoteInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
      id: "remote";
    }>;
    id: string | undefined;
  }, {
    type: "reconcileRemotes";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "routeLoad";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "routePreload";
    params: import("xstate").NonReducibleUnknown;
  }, never, never, {}, string, {
    instance: FederationInstance;
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "remotes";
  }>> | undefined;
  "system-preferences"?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<SystemPreferencesContext & {
    adapter: SystemPreferencesAdapter | undefined;
  }, {
    type: "preferredColorScheme.set";
    preferredColorScheme: "system" | ("dark" | "light");
  } | {
    type: "osColorScheme.set";
    osColorScheme: "dark" | "light";
  } | {
    type: "dockLocked.set";
    dockLocked: boolean;
  }, {
    adapter?: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
      type: "preferredColorScheme.set";
      preferredColorScheme: "system" | ("dark" | "light");
    } | {
      type: "dockLocked.set";
      dockLocked: boolean;
    }, SystemPreferencesAdapter | undefined, SystemPreferencesEvent>> | undefined;
  }, {
    src: "adapterBridge";
    logic: import("xstate").CallbackActorLogic<{
      type: "preferredColorScheme.set";
      preferredColorScheme: "system" | ("dark" | "light");
    } | {
      type: "dockLocked.set";
      dockLocked: boolean;
    }, SystemPreferencesAdapter | undefined, SystemPreferencesEvent>;
    id: "adapter";
  }, {
    type: "publishColorScheme";
    params: unknown;
  } | {
    type: "publishDockLocked";
    params: unknown;
  } | {
    type: "setDockLocked";
    params: {
      dockLocked: boolean;
    };
  } | {
    type: "setOsColorScheme";
    params: {
      osColorScheme: "dark" | "light";
    };
  } | {
    type: "setPreferredColorScheme";
    params: {
      preferredColorScheme: "system" | ("dark" | "light");
    };
  }, never, never, "ready", string, {
    adapter?: SystemPreferencesAdapter;
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "system-preferences";
    states: {
      readonly ready: {};
    };
  }>> | undefined;
  telemetry?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
    instance: SanityInstance;
    store: import("@sanity/telemetry").TelemetryStore<WorkbenchUserProperties> | null;
    userProperties: WorkbenchUserProperties;
  }, {
    type: "telemetry.start";
  } | {
    type: "telemetry.stop";
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
      status: import("@sanity/telemetry").ConsentStatus;
    }, {
      instance: SanityInstance;
    }, import("xstate").EventObject>> | undefined;
  }, {
    src: "checkConsent";
    logic: import("xstate").PromiseActorLogic<{
      status: import("@sanity/telemetry").ConsentStatus;
    }, {
      instance: SanityInstance;
    }, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "createStore";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "teardownStore";
    params: unknown;
  }, {
    type: "isConsentGranted";
    params: {
      status: import("@sanity/telemetry").ConsentStatus;
    };
  }, never, "active" | "checkingConsent" | "denied" | "idle" | "stopped", string, TelemetryInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "telemetry";
    states: {
      readonly idle: {};
      readonly checkingConsent: {};
      readonly active: {};
      readonly stopped: {};
      readonly denied: {};
    };
  }>> | undefined;
}, {
  src: "applications";
  logic: import("xstate").StateMachine<{
    instance: ApplicationStoreInput["instance"];
    organizationId: ApplicationStoreInput["organizationId"];
    localApplications: ApplicationStoreInput["localApplications"];
    appConfigs: ApplicationStoreInput["appConfigs"];
    projects: ApplicationStoreInput["projects"];
    applications: ApplicationList<Exclude<Application, {
      type: "workspace";
    }>> | undefined;
    listError: unknown;
    published: {
      foreground: Application | null;
      mediaLibraryConfig: RemoteModule | null | undefined;
    };
    pathname: string | undefined;
    commits$: Observable<string>;
  }, {
    type: "applications.sync";
    applications: NonNullable<ApplicationList<CanvasApplication | CoreApplication | MediaLibraryApplication | StudioApplication> | undefined>;
    mediaLibraryConfig: RemoteModule | null;
  } | {
    type: "applications.error";
    error?: unknown;
  } | {
    type: "location.updated";
    pathname: string;
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").ObservableActorLogic<string, Observable<string>, import("xstate").EventObject> | import("xstate").ObservableActorLogic<OrganizationApplications, ApplicationStoreInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "applicationStore";
    logic: import("xstate").ObservableActorLogic<OrganizationApplications, ApplicationStoreInput, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "commitFeed";
    logic: import("xstate").ObservableActorLogic<string, Observable<string>, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "publishApplications";
    params: unknown;
  } | {
    type: "publishApplicationsError";
    params: unknown;
  } | {
    type: "publishForeground";
    params: unknown;
  } | {
    type: "publishMediaLibraryConfig";
    params: unknown;
  } | {
    type: "recordPublished";
    params: unknown;
  } | {
    type: "storeApplicationsError";
    params: unknown;
  } | {
    type: "storeLocation";
    params: unknown;
  } | {
    type: "sync";
    params: unknown;
  } | {
    type: "syncRemotes";
    params: unknown;
  }, never, never, "failed" | "loading" | "ready", "applications-resolved" | "error", ApplicationStoreInput & {
    location: NavigationAdapter["location"];
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "applications";
    states: {
      readonly loading: {};
      readonly ready: {};
      readonly failed: {};
    };
  }>;
  id: "applications";
} | {
  src: "auth";
  logic: import("xstate").StateMachine<{
    instance: SanityInstance;
    token: string | null;
    currentUser: import("@sanity/sdk").CurrentUser | null;
    error: unknown;
  }, {
    type: "auth.logout";
  } | {
    type: "token.refresh";
    reply: (token: string) => void;
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").ObservableActorLogic<import("@sanity/sdk").AuthState, OSBaseInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<void, LogoutInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "authState";
    logic: import("xstate").ObservableActorLogic<import("@sanity/sdk").AuthState, OSBaseInput, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "logoutActor";
    logic: import("xstate").PromiseActorLogic<void, LogoutInput, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "tokenRefreshResponder";
    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "clearAuth";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "publishCurrentUser";
    params: unknown;
  } | {
    type: "publishToken";
    params: unknown;
  } | {
    type: "replyToken";
    params: {
      reply: (token: string) => void;
    };
  } | {
    type: "setError";
    params: {
      error: unknown;
    };
  } | {
    type: "setLoggedIn";
    params: {
      token: string;
      currentUser: import("@sanity/sdk").CurrentUser;
    };
  }, {
    type: "isAuthState";
    params: {
      state: import("@sanity/sdk").AuthState | undefined;
      type: import("@sanity/sdk").AuthStateType;
    };
  } | {
    type: "isLoggedInComplete";
    params: {
      state: import("@sanity/sdk").AuthState | undefined;
    };
  }, "authTimeout", "init" | "logging-out" | import("@sanity/sdk").AuthStateType, "authenticated" | "authenticating" | "error", AuthInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "auth";
    states: {
      readonly init: {};
      readonly "logging-in": {};
      readonly "logged-in": {};
      readonly "logging-out": {};
      readonly "logged-out": {};
      readonly error: {};
    };
  }>;
  id: "auth";
} | {
  src: "navigation";
  logic: import("xstate").StateMachine<{
    navigate: NavigationAdapter["navigate"];
    commits$: NavigationAdapter["location"];
    applications$: Observable<ApplicationList<Application> | null>;
    applications: ApplicationList | null;
    href: string | null;
    published: NavigationLocation | null;
    transition: {
      request: {
        payload: PayloadOf<"navigation.location.update">;
        reply: (reply: {
          ok: true;
        } | {
          ok: false;
          reason: "not-navigable" | "interrupted" | "failed";
        }) => void;
        signal: AbortSignal;
      };
      href: string;
      navigationType: "push" | "replace";
    } | null;
    request: {
      payload: PayloadOf<"navigation.location.update">;
      reply: (reply: {
        ok: true;
      } | {
        ok: false;
        reason: "not-navigable" | "interrupted" | "failed";
      }) => void;
      signal: AbortSignal;
    } | null;
  }, {
    type: "applications.changed";
    applications: ApplicationList | null;
  } | {
    type: "navigation.committed";
    href: string;
  } | {
    type: "navigation.request.committed";
  } | {
    type: "navigation.failed";
    error: unknown;
  } | {
    type: "navigation.superseded";
  } | {
    type: "navigation.aborted";
  } | ({
    type: "navigation.requested";
  } & {
    payload: PayloadOf<"navigation.location.update">;
    reply: (reply: {
      ok: true;
    } | {
      ok: false;
      reason: "not-navigable" | "interrupted" | "failed";
    }) => void;
    signal: AbortSignal;
  }), {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").AnyEventObject, {
      navigate: NavigationAdapter["navigate"];
      transition: {
        request: {
          payload: PayloadOf<"navigation.location.update">;
          reply: (reply: {
            ok: true;
          } | {
            ok: false;
            reason: "not-navigable" | "interrupted" | "failed";
          }) => void;
          signal: AbortSignal;
        };
        href: string;
        navigationType: "push" | "replace";
      } | null;
    }, import("xstate").EventObject> | import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").ObservableActorLogic<string, Observable<string>, import("xstate").EventObject> | import("xstate").ObservableActorLogic<ApplicationList<Application> | null, Observable<ApplicationList<Application> | null>, import("xstate").EventObject>> | undefined;
  }, {
    src: "applicationsFeed";
    logic: import("xstate").ObservableActorLogic<ApplicationList<Application> | null, Observable<ApplicationList<Application> | null>, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "commitFeed";
    logic: import("xstate").ObservableActorLogic<string, Observable<string>, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "navigationRequests";
    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "navigationRun";
    logic: import("xstate").CallbackActorLogic<import("xstate").AnyEventObject, {
      navigate: NavigationAdapter["navigate"];
      transition: {
        request: {
          payload: PayloadOf<"navigation.location.update">;
          reply: (reply: {
            ok: true;
          } | {
            ok: false;
            reason: "not-navigable" | "interrupted" | "failed";
          }) => void;
          signal: AbortSignal;
        };
        href: string;
        navigationType: "push" | "replace";
      } | null;
    }, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "beginTransition";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "endTransition";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "holdRequest";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "publish";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "releaseRequest";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "replyCommitted";
    params: unknown;
  } | {
    type: "replyFailed";
    params: unknown;
  } | {
    type: "replyInterrupted";
    params: unknown;
  } | {
    type: "replyWithoutNavigating";
    params: unknown;
  } | {
    type: "reportFailure";
    params: unknown;
  } | {
    type: "storeApplications";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "storeHref";
    params: import("xstate").NonReducibleUnknown;
  }, {
    type: "listPending";
    params: unknown;
  } | {
    type: "needsNavigation";
    params: unknown;
  }, "commitDeadline", "idle" | "navigating", string, NavigationAdapter & {
    applications: Observable<ApplicationList | null>;
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "navigation";
    states: {
      readonly idle: {};
      readonly navigating: {};
    };
  }>;
  id: "navigation";
} | {
  src: "organization";
  logic: import("xstate").StateMachine<{
    instance: SanityInstance;
    organizationId: string;
    currentOrganization: CurrentOrganization | null;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").ObservableActorLogic<CurrentOrganization, OrganizationInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "organizationState";
    logic: import("xstate").ObservableActorLogic<CurrentOrganization, OrganizationInput, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "publishOrganization";
    params: {
      organization: CurrentOrganization | null;
    };
  } | {
    type: "storeOrganization";
    params: {
      organization: CurrentOrganization | null;
    };
  }, never, never, "failed" | "resolved" | "resolving", "error" | "organization-resolved", OrganizationInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "organization";
    states: {
      readonly resolving: {};
      readonly resolved: {};
      readonly failed: {};
    };
  }>;
  id: "organization";
} | {
  src: "panels";
  logic: import("xstate").StateMachine<{
    applications$: Observable<ApplicationList<Application> | null>;
    applications: ApplicationList | null;
    panel: ({
      appId: string;
      name: string;
      mode: "aside";
      size?: number;
    } | {
      appId: string;
      name: string;
      mode: "full";
    }) | null;
    panelSizes: Record<string, number>;
  }, {
    type: "panel.set";
    value: ({
      name: string;
      mode: "aside" | "full";
    } | {
      name: string;
      size: number;
    }) | null;
    appId: string;
  } | {
    type: "applications.changed";
    applications: ApplicationList | null;
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").ObservableActorLogic<ApplicationList<Application> | null, Observable<ApplicationList<Application> | null>, import("xstate").EventObject>> | undefined;
  }, {
    src: "applicationsFeed";
    logic: import("xstate").ObservableActorLogic<ApplicationList<Application> | null, Observable<ApplicationList<Application> | null>, import("xstate").EventObject>;
    id: string | undefined;
  } | {
    src: "panelRequests";
    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "publishPanel";
    params: unknown;
  } | {
    type: "storeApplications";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "storePanel";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "warnUndeclaredPanel";
    params: unknown;
  }, {
    type: "appDeclaresPanel";
    params: unknown;
  } | {
    type: "appOwnsPanel";
    params: unknown;
  }, never, {}, string, {
    applications: Observable<ApplicationList | null>;
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "panels";
  }>;
  id: "panels";
} | {
  src: "projects";
  logic: import("xstate").StateMachine<{
    instance: SanityInstance;
    organizationId: OrganizationId;
    projects: {
      id: string & import("zod").$brand<"ProjectId">;
      displayName: string;
      studioHost: string | null;
      organizationId: string & import("zod").$brand<"OrganizationId">;
      metadata: {
        color?: string | undefined;
        externalStudioHost?: string | null | undefined;
        initialTemplate?: string | undefined;
        cliInitializedAt?: string | undefined;
        integration?: string | undefined;
      };
      isBlocked: boolean;
      isDisabled: boolean;
      isDisabledByUser: boolean;
      activityFeedEnabled: boolean;
      createdAt: string;
      updatedAt: string;
    }[] | undefined;
  }, import("xstate").AnyEventObject, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").ObservableActorLogic<{
      id: string & import("zod").$brand<"ProjectId">;
      displayName: string;
      studioHost: string | null;
      organizationId: string & import("zod").$brand<"OrganizationId">;
      metadata: {
        color?: string | undefined;
        externalStudioHost?: string | null | undefined;
        initialTemplate?: string | undefined;
        cliInitializedAt?: string | undefined;
        integration?: string | undefined;
      };
      isBlocked: boolean;
      isDisabled: boolean;
      isDisabledByUser: boolean;
      activityFeedEnabled: boolean;
      createdAt: string;
      updatedAt: string;
    }[], ProjectsInput, import("xstate").EventObject>> | undefined;
  }, {
    src: "projectsState";
    logic: import("xstate").ObservableActorLogic<{
      id: string & import("zod").$brand<"ProjectId">;
      displayName: string;
      studioHost: string | null;
      organizationId: string & import("zod").$brand<"OrganizationId">;
      metadata: {
        color?: string | undefined;
        externalStudioHost?: string | null | undefined;
        initialTemplate?: string | undefined;
        cliInitializedAt?: string | undefined;
        integration?: string | undefined;
      };
      isBlocked: boolean;
      isDisabled: boolean;
      isDisabledByUser: boolean;
      activityFeedEnabled: boolean;
      createdAt: string;
      updatedAt: string;
    }[], ProjectsInput, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "storeProjects";
    params: {
      projects: {
        id: string & import("zod").$brand<"ProjectId">;
        displayName: string;
        studioHost: string | null;
        organizationId: string & import("zod").$brand<"OrganizationId">;
        metadata: {
          color?: string | undefined;
          externalStudioHost?: string | null | undefined;
          initialTemplate?: string | undefined;
          cliInitializedAt?: string | undefined;
          integration?: string | undefined;
        };
        isBlocked: boolean;
        isDisabled: boolean;
        isDisabledByUser: boolean;
        activityFeedEnabled: boolean;
        createdAt: string;
        updatedAt: string;
      }[] | undefined;
    };
  }, never, never, "failed" | "resolved" | "resolving", "error" | "projects-resolved", ProjectsInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "projects";
    states: {
      readonly resolving: {};
      readonly resolved: {};
      readonly failed: {};
    };
  }>;
  id: "projects";
} | {
  src: "remotes";
  logic: import("xstate").StateMachine<{
    instance: FederationInstance;
    children: Map<string, ActorRefFrom<typeof remoteLogic>>;
  }, {
    type: "remotes.sync";
    applications: ReadonlyArray<Application>;
  } | {
    type: "remote.load.request";
    moduleId: string;
  } | {
    type: "remote.preload.request";
    moduleId: string;
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<{
      app: Application;
      instance: FederationInstance;
      exposes: Map<string, ActorRefFrom<typeof moduleLoaderLogic>>;
      services: Map<string, ActorRefFrom<typeof serviceLogic>>;
    }, {
      type: "app.update";
      app: Application;
    } | {
      type: "expose.load.request";
      moduleId: string;
    } | {
      type: "expose.preload.request";
      moduleId: string;
    } | {
      type: "remote.settled";
      moduleId: string;
      status: "loaded" | "error";
    }, {
      [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<ModuleLoaderInput & {
        module: unknown;
        error: RemoteError | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
      }, {
        src: "load";
        logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
        id: string | undefined;
      }, {
        type: "setError";
        params: {
          error: unknown;
        };
      } | {
        type: "setModule";
        params: {
          module: unknown;
        };
      }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "remote";
        states: {
          readonly loading: {};
          readonly loaded: {};
          readonly error: {};
        };
      }> | import("xstate").StateMachine<ServiceInput & {
        workerUrl: string | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>> | undefined;
      }, {
        src: "loadInterface";
        logic: import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>;
        id: string | undefined;
      } | {
        src: "runWorker";
        logic: import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject>;
        id: string | undefined;
      }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "service";
        states: {
          readonly loading: {};
          readonly running: {};
          readonly error: {};
        };
      }>> | undefined;
    }, {
      src: "moduleLoader";
      logic: import("xstate").StateMachine<ModuleLoaderInput & {
        module: unknown;
        error: RemoteError | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
      }, {
        src: "load";
        logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
        id: string | undefined;
      }, {
        type: "setError";
        params: {
          error: unknown;
        };
      } | {
        type: "setModule";
        params: {
          module: unknown;
        };
      }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "remote";
        states: {
          readonly loading: {};
          readonly loaded: {};
          readonly error: {};
        };
      }>;
      id: string | undefined;
    } | {
      src: "service";
      logic: import("xstate").StateMachine<ServiceInput & {
        workerUrl: string | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>> | undefined;
      }, {
        src: "loadInterface";
        logic: import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>;
        id: string | undefined;
      } | {
        src: "runWorker";
        logic: import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject>;
        id: string | undefined;
      }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "service";
        states: {
          readonly loading: {};
          readonly running: {};
          readonly error: {};
        };
      }>;
      id: string | undefined;
    }, {
      type: "ensureExpose";
      params: import("xstate").NonReducibleUnknown;
    } | {
      type: "preloadExpose";
      params: unknown;
    } | {
      type: "preloadPanels";
      params: unknown;
    } | {
      type: "reconcileServices";
      params: import("xstate").NonReducibleUnknown;
    } | {
      type: "registerSelf";
      params: unknown;
    } | {
      type: "updateApp";
      params: import("xstate").NonReducibleUnknown;
    }, never, never, {}, string, RemoteInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
      id: "remote";
    }>> | undefined;
  }, {
    src: "remote";
    logic: import("xstate").StateMachine<{
      app: Application;
      instance: FederationInstance;
      exposes: Map<string, ActorRefFrom<typeof moduleLoaderLogic>>;
      services: Map<string, ActorRefFrom<typeof serviceLogic>>;
    }, {
      type: "app.update";
      app: Application;
    } | {
      type: "expose.load.request";
      moduleId: string;
    } | {
      type: "expose.preload.request";
      moduleId: string;
    } | {
      type: "remote.settled";
      moduleId: string;
      status: "loaded" | "error";
    }, {
      [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<ModuleLoaderInput & {
        module: unknown;
        error: RemoteError | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
      }, {
        src: "load";
        logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
        id: string | undefined;
      }, {
        type: "setError";
        params: {
          error: unknown;
        };
      } | {
        type: "setModule";
        params: {
          module: unknown;
        };
      }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "remote";
        states: {
          readonly loading: {};
          readonly loaded: {};
          readonly error: {};
        };
      }> | import("xstate").StateMachine<ServiceInput & {
        workerUrl: string | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>> | undefined;
      }, {
        src: "loadInterface";
        logic: import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>;
        id: string | undefined;
      } | {
        src: "runWorker";
        logic: import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject>;
        id: string | undefined;
      }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "service";
        states: {
          readonly loading: {};
          readonly running: {};
          readonly error: {};
        };
      }>> | undefined;
    }, {
      src: "moduleLoader";
      logic: import("xstate").StateMachine<ModuleLoaderInput & {
        module: unknown;
        error: RemoteError | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
      }, {
        src: "load";
        logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
        id: string | undefined;
      }, {
        type: "setError";
        params: {
          error: unknown;
        };
      } | {
        type: "setModule";
        params: {
          module: unknown;
        };
      }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "remote";
        states: {
          readonly loading: {};
          readonly loaded: {};
          readonly error: {};
        };
      }>;
      id: string | undefined;
    } | {
      src: "service";
      logic: import("xstate").StateMachine<ServiceInput & {
        workerUrl: string | null;
      }, import("xstate").AnyEventObject, {
        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject> | import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>> | undefined;
      }, {
        src: "loadInterface";
        logic: import("xstate").StateMachine<ModuleLoaderInput & {
          module: unknown;
          error: RemoteError | null;
        }, import("xstate").AnyEventObject, {
          [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>> | undefined;
        }, {
          src: "load";
          logic: import("xstate").PromiseActorLogic<unknown, ModuleLoaderInput, import("xstate").EventObject>;
          id: string | undefined;
        }, {
          type: "setError";
          params: {
            error: unknown;
          };
        } | {
          type: "setModule";
          params: {
            module: unknown;
          };
        }, never, never, "error" | "loaded" | "loading", "failed" | "loading" | "ready", ModuleLoaderInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
          id: "remote";
          states: {
            readonly loading: {};
            readonly loaded: {};
            readonly error: {};
          };
        }>;
        id: string | undefined;
      } | {
        src: "runWorker";
        logic: import("xstate").CallbackActorLogic<{
          type: string;
        }, {
          key: string;
          serviceName: string;
          workerUrl: string;
        }, import("xstate").EventObject>;
        id: string | undefined;
      }, never, never, never, "error" | "loading" | "running", "failed" | "loading" | "running", ServiceInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
        id: "service";
        states: {
          readonly loading: {};
          readonly running: {};
          readonly error: {};
        };
      }>;
      id: string | undefined;
    }, {
      type: "ensureExpose";
      params: import("xstate").NonReducibleUnknown;
    } | {
      type: "preloadExpose";
      params: unknown;
    } | {
      type: "preloadPanels";
      params: unknown;
    } | {
      type: "reconcileServices";
      params: import("xstate").NonReducibleUnknown;
    } | {
      type: "registerSelf";
      params: unknown;
    } | {
      type: "updateApp";
      params: import("xstate").NonReducibleUnknown;
    }, never, never, {}, string, RemoteInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
      id: "remote";
    }>;
    id: string | undefined;
  }, {
    type: "reconcileRemotes";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "routeLoad";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "routePreload";
    params: import("xstate").NonReducibleUnknown;
  }, never, never, {}, string, {
    instance: FederationInstance;
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "remotes";
  }>;
  id: "remotes";
} | {
  src: "systemPreferences";
  logic: import("xstate").StateMachine<SystemPreferencesContext & {
    adapter: SystemPreferencesAdapter | undefined;
  }, {
    type: "preferredColorScheme.set";
    preferredColorScheme: "system" | ("dark" | "light");
  } | {
    type: "osColorScheme.set";
    osColorScheme: "dark" | "light";
  } | {
    type: "dockLocked.set";
    dockLocked: boolean;
  }, {
    adapter?: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<{
      type: "preferredColorScheme.set";
      preferredColorScheme: "system" | ("dark" | "light");
    } | {
      type: "dockLocked.set";
      dockLocked: boolean;
    }, SystemPreferencesAdapter | undefined, SystemPreferencesEvent>> | undefined;
  }, {
    src: "adapterBridge";
    logic: import("xstate").CallbackActorLogic<{
      type: "preferredColorScheme.set";
      preferredColorScheme: "system" | ("dark" | "light");
    } | {
      type: "dockLocked.set";
      dockLocked: boolean;
    }, SystemPreferencesAdapter | undefined, SystemPreferencesEvent>;
    id: "adapter";
  }, {
    type: "publishColorScheme";
    params: unknown;
  } | {
    type: "publishDockLocked";
    params: unknown;
  } | {
    type: "setDockLocked";
    params: {
      dockLocked: boolean;
    };
  } | {
    type: "setOsColorScheme";
    params: {
      osColorScheme: "dark" | "light";
    };
  } | {
    type: "setPreferredColorScheme";
    params: {
      preferredColorScheme: "system" | ("dark" | "light");
    };
  }, never, never, "ready", string, {
    adapter?: SystemPreferencesAdapter;
  }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "system-preferences";
    states: {
      readonly ready: {};
    };
  }>;
  id: "system-preferences";
} | {
  src: "telemetry";
  logic: import("xstate").StateMachine<{
    instance: SanityInstance;
    store: import("@sanity/telemetry").TelemetryStore<WorkbenchUserProperties> | null;
    userProperties: WorkbenchUserProperties;
  }, {
    type: "telemetry.start";
  } | {
    type: "telemetry.stop";
  }, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
      status: import("@sanity/telemetry").ConsentStatus;
    }, {
      instance: SanityInstance;
    }, import("xstate").EventObject>> | undefined;
  }, {
    src: "checkConsent";
    logic: import("xstate").PromiseActorLogic<{
      status: import("@sanity/telemetry").ConsentStatus;
    }, {
      instance: SanityInstance;
    }, import("xstate").EventObject>;
    id: string | undefined;
  }, {
    type: "createStore";
    params: import("xstate").NonReducibleUnknown;
  } | {
    type: "teardownStore";
    params: unknown;
  }, {
    type: "isConsentGranted";
    params: {
      status: import("@sanity/telemetry").ConsentStatus;
    };
  }, never, "active" | "checkingConsent" | "denied" | "idle" | "stopped", string, TelemetryInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
    id: "telemetry";
    states: {
      readonly idle: {};
      readonly checkingConsent: {};
      readonly active: {};
      readonly stopped: {};
      readonly denied: {};
    };
  }>;
  id: "telemetry";
}, {
  type: "clearSession";
  params: unknown;
} | {
  type: "raiseAuthFailed";
  params: unknown;
} | {
  type: "raiseAuthReady";
  params: unknown;
} | {
  type: "raiseOrganizationFailed";
  params: unknown;
} | {
  type: "raiseOrganizationReady";
  params: unknown;
} | {
  type: "startTelemetry";
  params: unknown;
} | {
  type: "storeResolvedOrganizationId";
  params: {
    id: string | undefined;
  };
}, {
  type: "hasTag";
  params: {
    hasTag: boolean;
  };
}, never, "booting" | "error" | {
  running: "pending" | "ready";
}, string, OSInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
  id: "os";
  states: {
    readonly booting: {};
    readonly running: {
      states: {
        readonly pending: {};
        readonly ready: {};
      };
    };
    readonly error: {};
  };
}>;
/**
 * Creates a set of default options for the OS machine. Forwards the workbench
 * user properties to the machine's input and wires the structured-logging
 * `inspect` callback. Browser-specific concerns (color-scheme seeding,
 * persistence) live in the {@link SystemPreferencesAdapter} the host passes
 * via `systemPreferencesAdapter`.
 * @public
 */
declare function createOSOptions(input: OSInput): {
  id: string;
  input: OSInput;
  inspect: typeof inspect;
};
/**
 * The session context the auth machine establishes.
 * @internal
 */
interface AuthInput extends OSBaseInput {}
/**
 * @internal
 */
interface LogoutInput extends OSBaseInput {}
export { type AuthInput, type FederationInstance, type LoadedRemoteModule, type LogoutInput, type ModuleLoaderInput, ModuleShapeError, type NavigationAdapter, type RemoteError, type RemoteModuleByInterfaceType, type RemoteRenderOptions, type ServiceLoaderModule, type SystemPreferencesAdapter, type SystemPreferencesContext, type SystemPreferencesEvent, type TelemetryInput, type WorkbenchUserProperties, createOSOptions, os };
//# sourceMappingURL=system.d.ts.map