@agimon-ai/doompi-extension-contracts 0.0.1-alpha.0

package/dist/config.d.cts

@@ -0,0 +1,517 @@
+import { EventBusLike, NotificationDefinition, ProtocolRuntime } from "./protocol.cjs";
+import { Static, Type } from "typebox";
+//#region src/config.d.ts
+/** Matches the leader contract's source rule: package names, addressable and spoof-checkable. */
+declare const ConfigSourceSchema: Type.TString;
+/**
+ * How ready a value is to be used, as opposed to whether it is merely set.
+ * `blocked` covers a choice that needs something else first, such as a model
+ * whose engine is not installed.
+ */
+declare const ConfigStatusSchema: Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>;
+type ConfigStatus = Static<typeof ConfigStatusSchema>;
+declare const ConfigFieldKindSchema: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+type ConfigFieldKind = Static<typeof ConfigFieldKindSchema>;
+/**
+ * A key the renderer offers on the focused field, sent back verbatim as an
+ * action. Owners use this for confirmations, so the pending question survives a
+ * panel that is closed and reopened.
+ */
+declare const ConfigActionSchema: Type.TObject<{
+  key: Type.TString;
+  label: Type.TString;
+  action: Type.TString;
+}>;
+type ConfigAction = Static<typeof ConfigActionSchema>;
+declare const ConfigChoiceSchema: Type.TObject<{
+  id: Type.TString;
+  label: Type.TString;
+  /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+  detail: Type.TOptional<Type.TString>;
+  /** Groups entries under a heading the cursor skips over. */
+  group: Type.TOptional<Type.TString>;
+  status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+  statusText: Type.TOptional<Type.TString>;
+  /**
+   * What enter does on this entry. Carrying it per-entry is what lets one list
+   * hold both an installed model that only needs selecting and an absent one
+   * that needs fetching, without the renderer knowing the difference.
+   */
+  action: Type.TOptional<Type.TString>;
+}>;
+type ConfigChoice = Static<typeof ConfigChoiceSchema>;
+/**
+ * One line of a multi-step operation.
+ *
+ * Published as a list rather than a single "current step" string so the panel can
+ * show what already ran alongside what is left. During an install that is the
+ * difference between "something is happening" and knowing a package manager
+ * already finished and a download is now underway.
+ */
+declare const ConfigStepSchema: Type.TObject<{
+  label: Type.TString;
+  state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+  detail: Type.TOptional<Type.TString>;
+}>;
+type ConfigStep = Static<typeof ConfigStepSchema>;
+declare const ConfigProgressSchema: Type.TObject<{
+  label: Type.TString;
+  /** 0 to 1. Omitted when the work has no measurable total. */
+  ratio: Type.TOptional<Type.TNumber>;
+}>;
+type ConfigProgress = Static<typeof ConfigProgressSchema>;
+declare const ConfigFieldSchema: Type.TObject<{
+  id: Type.TString;
+  label: Type.TString;
+  kind: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+  /** Absent means unset; the renderer shows `placeholder` instead. */
+  value: Type.TOptional<Type.TString>;
+  placeholder: Type.TOptional<Type.TString>;
+  /** One line of help for the focused field. */
+  detail: Type.TOptional<Type.TString>;
+  /** The config key this writes, shown under the focused field so the file stays legible. */
+  keyPath: Type.TOptional<Type.TString>;
+  status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+  /** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+  statusText: Type.TOptional<Type.TString>;
+  choices: Type.TOptional<Type.TArray<Type.TObject<{
+    id: Type.TString;
+    label: Type.TString;
+    /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+    detail: Type.TOptional<Type.TString>;
+    /** Groups entries under a heading the cursor skips over. */
+    group: Type.TOptional<Type.TString>;
+    status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+    statusText: Type.TOptional<Type.TString>;
+    /**
+     * What enter does on this entry. Carrying it per-entry is what lets one list
+     * hold both an installed model that only needs selecting and an absent one
+     * that needs fetching, without the renderer knowing the difference.
+     */
+    action: Type.TOptional<Type.TString>;
+  }>>>;
+  actions: Type.TOptional<Type.TArray<Type.TObject<{
+    key: Type.TString;
+    label: Type.TString;
+    action: Type.TString;
+  }>>>;
+  /** Work is running; the renderer dims the field and offers abort. */
+  busy: Type.TOptional<Type.TBoolean>;
+  progress: Type.TOptional<Type.TObject<{
+    label: Type.TString;
+    /** 0 to 1. Omitted when the work has no measurable total. */
+    ratio: Type.TOptional<Type.TNumber>;
+  }>>;
+  steps: Type.TOptional<Type.TArray<Type.TObject<{
+    label: Type.TString;
+    state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+    detail: Type.TOptional<Type.TString>;
+  }>>>;
+  /**
+   * The tail of a running command's terminal output.
+   *
+   * A tail rather than the whole scrollback: the field is a few rows of a
+   * shared pane, and what matters is the question a package manager just
+   * asked, not what it printed a minute ago.
+   */
+  output: Type.TOptional<Type.TArray<Type.TString>>;
+  /**
+   * The command is waiting on the user. The renderer offers a line to type
+   * into, which comes back as an owner-defined action carrying the text.
+   */
+  awaitingInput: Type.TOptional<Type.TBoolean>;
+}>;
+type ConfigField = Static<typeof ConfigFieldSchema>;
+declare const ConfigSectionSchema: Type.TObject<{
+  id: Type.TString;
+  title: Type.TString;
+  detail: Type.TOptional<Type.TString>;
+  order: Type.TInteger;
+  /** Section-wide state: readiness, or why a write failed. */
+  notice: Type.TOptional<Type.TString>;
+  noticeLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"error">]>>;
+  fields: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    label: Type.TString;
+    kind: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+    /** Absent means unset; the renderer shows `placeholder` instead. */
+    value: Type.TOptional<Type.TString>;
+    placeholder: Type.TOptional<Type.TString>;
+    /** One line of help for the focused field. */
+    detail: Type.TOptional<Type.TString>;
+    /** The config key this writes, shown under the focused field so the file stays legible. */
+    keyPath: Type.TOptional<Type.TString>;
+    status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+    /** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+    statusText: Type.TOptional<Type.TString>;
+    choices: Type.TOptional<Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+      detail: Type.TOptional<Type.TString>;
+      /** Groups entries under a heading the cursor skips over. */
+      group: Type.TOptional<Type.TString>;
+      status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+      statusText: Type.TOptional<Type.TString>;
+      /**
+       * What enter does on this entry. Carrying it per-entry is what lets one list
+       * hold both an installed model that only needs selecting and an absent one
+       * that needs fetching, without the renderer knowing the difference.
+       */
+      action: Type.TOptional<Type.TString>;
+    }>>>;
+    actions: Type.TOptional<Type.TArray<Type.TObject<{
+      key: Type.TString;
+      label: Type.TString;
+      action: Type.TString;
+    }>>>;
+    /** Work is running; the renderer dims the field and offers abort. */
+    busy: Type.TOptional<Type.TBoolean>;
+    progress: Type.TOptional<Type.TObject<{
+      label: Type.TString;
+      /** 0 to 1. Omitted when the work has no measurable total. */
+      ratio: Type.TOptional<Type.TNumber>;
+    }>>;
+    steps: Type.TOptional<Type.TArray<Type.TObject<{
+      label: Type.TString;
+      state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+      detail: Type.TOptional<Type.TString>;
+    }>>>;
+    /**
+     * The tail of a running command's terminal output.
+     *
+     * A tail rather than the whole scrollback: the field is a few rows of a
+     * shared pane, and what matters is the question a package manager just
+     * asked, not what it printed a minute ago.
+     */
+    output: Type.TOptional<Type.TArray<Type.TString>>;
+    /**
+     * The command is waiting on the user. The renderer offers a line to type
+     * into, which comes back as an owner-defined action carrying the text.
+     */
+    awaitingInput: Type.TOptional<Type.TBoolean>;
+  }>>;
+}>;
+type ConfigSection = Static<typeof ConfigSectionSchema>;
+declare const ConfigSourceRefSchema: Type.TObject<{
+  source: Type.TString;
+  generation: Type.TString;
+}>;
+declare const ConfigSnapshotSchema: Type.TObject<{
+  sections: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    title: Type.TString;
+    detail: Type.TOptional<Type.TString>;
+    order: Type.TInteger;
+    /** Section-wide state: readiness, or why a write failed. */
+    notice: Type.TOptional<Type.TString>;
+    noticeLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"error">]>>;
+    fields: Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      kind: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+      /** Absent means unset; the renderer shows `placeholder` instead. */
+      value: Type.TOptional<Type.TString>;
+      placeholder: Type.TOptional<Type.TString>;
+      /** One line of help for the focused field. */
+      detail: Type.TOptional<Type.TString>;
+      /** The config key this writes, shown under the focused field so the file stays legible. */
+      keyPath: Type.TOptional<Type.TString>;
+      status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+      /** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+      statusText: Type.TOptional<Type.TString>;
+      choices: Type.TOptional<Type.TArray<Type.TObject<{
+        id: Type.TString;
+        label: Type.TString;
+        /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+        detail: Type.TOptional<Type.TString>;
+        /** Groups entries under a heading the cursor skips over. */
+        group: Type.TOptional<Type.TString>;
+        status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+        statusText: Type.TOptional<Type.TString>;
+        /**
+         * What enter does on this entry. Carrying it per-entry is what lets one list
+         * hold both an installed model that only needs selecting and an absent one
+         * that needs fetching, without the renderer knowing the difference.
+         */
+        action: Type.TOptional<Type.TString>;
+      }>>>;
+      actions: Type.TOptional<Type.TArray<Type.TObject<{
+        key: Type.TString;
+        label: Type.TString;
+        action: Type.TString;
+      }>>>;
+      /** Work is running; the renderer dims the field and offers abort. */
+      busy: Type.TOptional<Type.TBoolean>;
+      progress: Type.TOptional<Type.TObject<{
+        label: Type.TString;
+        /** 0 to 1. Omitted when the work has no measurable total. */
+        ratio: Type.TOptional<Type.TNumber>;
+      }>>;
+      steps: Type.TOptional<Type.TArray<Type.TObject<{
+        label: Type.TString;
+        state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+        detail: Type.TOptional<Type.TString>;
+      }>>>;
+      /**
+       * The tail of a running command's terminal output.
+       *
+       * A tail rather than the whole scrollback: the field is a few rows of a
+       * shared pane, and what matters is the question a package manager just
+       * asked, not what it printed a minute ago.
+       */
+      output: Type.TOptional<Type.TArray<Type.TString>>;
+      /**
+       * The command is waiting on the user. The renderer offers a line to type
+       * into, which comes back as an owner-defined action carrying the text.
+       */
+      awaitingInput: Type.TOptional<Type.TBoolean>;
+    }>>;
+  }>>;
+  source: Type.TString;
+  generation: Type.TString;
+}>;
+type ConfigSnapshot = Static<typeof ConfigSnapshotSchema>;
+type ConfigSourceRef = Static<typeof ConfigSourceRefSchema>;
+declare const ConfigDiscovery: NotificationDefinition<Type.TObject<{}>>;
+declare const ConfigRegistration: NotificationDefinition<Type.TObject<{
+  sections: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    title: Type.TString;
+    detail: Type.TOptional<Type.TString>;
+    order: Type.TInteger;
+    /** Section-wide state: readiness, or why a write failed. */
+    notice: Type.TOptional<Type.TString>;
+    noticeLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"error">]>>;
+    fields: Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      kind: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+      /** Absent means unset; the renderer shows `placeholder` instead. */
+      value: Type.TOptional<Type.TString>;
+      placeholder: Type.TOptional<Type.TString>;
+      /** One line of help for the focused field. */
+      detail: Type.TOptional<Type.TString>;
+      /** The config key this writes, shown under the focused field so the file stays legible. */
+      keyPath: Type.TOptional<Type.TString>;
+      status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+      /** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+      statusText: Type.TOptional<Type.TString>;
+      choices: Type.TOptional<Type.TArray<Type.TObject<{
+        id: Type.TString;
+        label: Type.TString;
+        /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+        detail: Type.TOptional<Type.TString>;
+        /** Groups entries under a heading the cursor skips over. */
+        group: Type.TOptional<Type.TString>;
+        status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+        statusText: Type.TOptional<Type.TString>;
+        /**
+         * What enter does on this entry. Carrying it per-entry is what lets one list
+         * hold both an installed model that only needs selecting and an absent one
+         * that needs fetching, without the renderer knowing the difference.
+         */
+        action: Type.TOptional<Type.TString>;
+      }>>>;
+      actions: Type.TOptional<Type.TArray<Type.TObject<{
+        key: Type.TString;
+        label: Type.TString;
+        action: Type.TString;
+      }>>>;
+      /** Work is running; the renderer dims the field and offers abort. */
+      busy: Type.TOptional<Type.TBoolean>;
+      progress: Type.TOptional<Type.TObject<{
+        label: Type.TString;
+        /** 0 to 1. Omitted when the work has no measurable total. */
+        ratio: Type.TOptional<Type.TNumber>;
+      }>>;
+      steps: Type.TOptional<Type.TArray<Type.TObject<{
+        label: Type.TString;
+        state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+        detail: Type.TOptional<Type.TString>;
+      }>>>;
+      /**
+       * The tail of a running command's terminal output.
+       *
+       * A tail rather than the whole scrollback: the field is a few rows of a
+       * shared pane, and what matters is the question a package manager just
+       * asked, not what it printed a minute ago.
+       */
+      output: Type.TOptional<Type.TArray<Type.TString>>;
+      /**
+       * The command is waiting on the user. The renderer offers a line to type
+       * into, which comes back as an owner-defined action carrying the text.
+       */
+      awaitingInput: Type.TOptional<Type.TBoolean>;
+    }>>;
+  }>>;
+  source: Type.TString;
+  generation: Type.TString;
+}>>;
+/** Also the reply channel: every invoked action is answered by one of these. */
+declare const ConfigChanged: NotificationDefinition<Type.TObject<{
+  sections: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    title: Type.TString;
+    detail: Type.TOptional<Type.TString>;
+    order: Type.TInteger;
+    /** Section-wide state: readiness, or why a write failed. */
+    notice: Type.TOptional<Type.TString>;
+    noticeLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"error">]>>;
+    fields: Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      kind: Type.TUnion<[Type.TLiteral<"text">, Type.TLiteral<"enum">, Type.TLiteral<"choice">, Type.TLiteral<"info">]>;
+      /** Absent means unset; the renderer shows `placeholder` instead. */
+      value: Type.TOptional<Type.TString>;
+      placeholder: Type.TOptional<Type.TString>;
+      /** One line of help for the focused field. */
+      detail: Type.TOptional<Type.TString>;
+      /** The config key this writes, shown under the focused field so the file stays legible. */
+      keyPath: Type.TOptional<Type.TString>;
+      status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+      /** Doubles as the error line: a rejected edit comes back as the old value plus this. */
+      statusText: Type.TOptional<Type.TString>;
+      choices: Type.TOptional<Type.TArray<Type.TObject<{
+        id: Type.TString;
+        label: Type.TString;
+        /** Right-aligned by the renderer. Sizes, ids, anything narrow. */
+        detail: Type.TOptional<Type.TString>;
+        /** Groups entries under a heading the cursor skips over. */
+        group: Type.TOptional<Type.TString>;
+        status: Type.TOptional<Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"available">, Type.TLiteral<"blocked">]>>;
+        statusText: Type.TOptional<Type.TString>;
+        /**
+         * What enter does on this entry. Carrying it per-entry is what lets one list
+         * hold both an installed model that only needs selecting and an absent one
+         * that needs fetching, without the renderer knowing the difference.
+         */
+        action: Type.TOptional<Type.TString>;
+      }>>>;
+      actions: Type.TOptional<Type.TArray<Type.TObject<{
+        key: Type.TString;
+        label: Type.TString;
+        action: Type.TString;
+      }>>>;
+      /** Work is running; the renderer dims the field and offers abort. */
+      busy: Type.TOptional<Type.TBoolean>;
+      progress: Type.TOptional<Type.TObject<{
+        label: Type.TString;
+        /** 0 to 1. Omitted when the work has no measurable total. */
+        ratio: Type.TOptional<Type.TNumber>;
+      }>>;
+      steps: Type.TOptional<Type.TArray<Type.TObject<{
+        label: Type.TString;
+        state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"satisfied">, Type.TLiteral<"running">, Type.TLiteral<"done">, Type.TLiteral<"failed">]>;
+        detail: Type.TOptional<Type.TString>;
+      }>>>;
+      /**
+       * The tail of a running command's terminal output.
+       *
+       * A tail rather than the whole scrollback: the field is a few rows of a
+       * shared pane, and what matters is the question a package manager just
+       * asked, not what it printed a minute ago.
+       */
+      output: Type.TOptional<Type.TArray<Type.TString>>;
+      /**
+       * The command is waiting on the user. The renderer offers a line to type
+       * into, which comes back as an owner-defined action carrying the text.
+       */
+      awaitingInput: Type.TOptional<Type.TBoolean>;
+    }>>;
+  }>>;
+  source: Type.TString;
+  generation: Type.TString;
+}>>;
+declare const ConfigUnregistration: NotificationDefinition<Type.TObject<{
+  source: Type.TString;
+  generation: Type.TString;
+}>>;
+/**
+ * A keystroke handed back to the field's owner.
+ *
+ * A notification rather than a request/reply because every owner listens on one
+ * channel: with request/reply each `provide` would answer, and a non-addressed
+ * owner's reply would race the real one. Owners answer with `ConfigChanged`
+ * instead, on success and on failure alike, which is also what carries progress
+ * while long work runs.
+ *
+ * `set` and `clear` are the two the renderer originates on its own. Everything
+ * else is an owner-defined name the renderer read off a choice or an action and
+ * hands back verbatim.
+ */
+declare const ConfigInvoked: NotificationDefinition<Type.TObject<{
+  /** The addressed owner. Checked against the envelope source by the receiver. */
+  source: Type.TString;
+  sectionId: Type.TString;
+  fieldId: Type.TString;
+  action: Type.TString;
+  /** The typed text for `set`, or the chosen entry's id for a choice action. */
+  value: Type.TOptional<Type.TString>;
+}>>;
+declare const CONFIG_ACTION: {
+  readonly set: "set";
+  readonly clear: "clear";
+};
+interface ConfigProvider {
+  source: string;
+  listSections(): readonly ConfigSection[];
+}
+interface ConfigProviderHandle {
+  update(): void;
+  dispose(): void;
+}
+declare function registerConfigProvider(runtime: ProtocolRuntime, provider: ConfigProvider): ConfigProviderHandle;
+interface DoomExtensionContext {
+  sessionManager: {
+    getSessionId(): string;
+  };
+}
+interface DoomExtensionHost {
+  events: EventBusLike;
+  on(event: string, handler: (event: unknown, context: DoomExtensionContext) => void): void;
+}
+interface DoomConfigSectionView extends ConfigSection {
+  source: string;
+}
+interface DoomConfigInvocation {
+  source: string;
+  sectionId: string;
+  fieldId: string;
+  action: string;
+  value?: string;
+}
+declare class DoomConfigRegistry {
+  private readonly sources;
+  private readonly listeners;
+  private runtime;
+  bind(runtime: ProtocolRuntime): () => void;
+  getSections(): DoomConfigSectionView[];
+  invoke(invocation: DoomConfigInvocation): void;
+  subscribe(listener: () => void): () => void;
+  reset(): void;
+  private register;
+  private update;
+  private unregister;
+  private notify;
+}
+interface DoomConfigActionInput {
+  ctx: DoomExtensionContext;
+  sectionId: string;
+  fieldId: string;
+  value?: string;
+}
+interface DoomConfigContributionOptions {
+  source: string;
+  listSections: () => readonly ConfigSection[];
+  handlers: Readonly<Record<string, (input: DoomConfigActionInput) => void | Promise<void>>>;
+  onError: (error: unknown, actionName: string, ctx: DoomExtensionContext) => void;
+}
+interface DoomConfigContributionHandle {
+  update(): void;
+  dispose(): void;
+}
+declare function registerDoomConfigContribution(pi: DoomExtensionHost, options: DoomConfigContributionOptions): DoomConfigContributionHandle;
+//#endregion
+export { CONFIG_ACTION, ConfigAction, ConfigActionSchema, ConfigChanged, ConfigChoice, ConfigChoiceSchema, ConfigDiscovery, ConfigField, ConfigFieldKind, ConfigFieldKindSchema, ConfigFieldSchema, ConfigInvoked, ConfigProgress, ConfigProgressSchema, ConfigProvider, ConfigProviderHandle, ConfigRegistration, ConfigSection, ConfigSectionSchema, ConfigSnapshot, ConfigSourceRef, ConfigSourceSchema, ConfigStatus, ConfigStatusSchema, ConfigStep, ConfigStepSchema, ConfigUnregistration, DoomConfigActionInput, DoomConfigContributionHandle, DoomConfigContributionOptions, DoomConfigInvocation, DoomConfigRegistry, DoomConfigSectionView, DoomExtensionContext, DoomExtensionHost, registerConfigProvider, registerDoomConfigContribution };
+//# sourceMappingURL=config.d.cts.map

package/dist/config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"mappings":";;;;cAuBa,oBAAkB,KAAA;;;;;;cAalB,oBAAkB,KAAA,QAAA,KAAA,mBAAA,KAAA,uBAAA,KAAA;KAKnB,eAAe,cAAc;cAE5B,uBAAqB,KAAA,QAAA,KAAA,kBAAA,KAAA,kBAAA,KAAA,oBAAA,KAAA;KAUtB,kBAAkB,cAAc;;;;;;cAO/B,oBAAkB,KAAA;;;;;KAQnB,eAAe,cAAc;cAE5B,oBAAkB,KAAA;;;;;;;;;;;;;;;;KAmBnB,eAAe,cAAc;;;;;;;;;cAU5B,kBAAgB,KAAA;;;;;KAejB,aAAa,cAAc;cAE1B,sBAAoB,KAAA;;;;;KAQrB,iBAAiB,cAAc;cAE9B,mBAAiB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqClB,cAAc,cAAc;cAE3B,qBAAmB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAapB,gBAAgB,cAAc;cAEpC,uBAAqB,KAAA;;;;cAKrB,sBAAoB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAId,iBAAiB,cAAc;KAC/B,kBAAkB,cAAc;cAE/B,iBAAe,uBAAA,KAAA;cAMf,oBAAkB,uBAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAOlB,eAAa,uBAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAMb,sBAAoB,uBAAA,KAAA;;;;;;;;;;;;;;;;;cAmBpB,eAAa,uBAAA,KAAA;;;;;;;;;cAiBb;WAAA;WAAA;;UAKI;EACf;EACA,yBAAyB;;UAGV;EACf;EACA;;iBAGc,uBAAuB,SAAS,iBAAiB,UAAU,iBAAiB;UAiC3E;EACf;IAAkB;;;UAGH;EACf,QAAQ;EACR,GAAG,eAAe,UAAU,gBAAgB,SAAS;;UAGtC,8BAA8B;EAC7C;;UAGe;EACf;EACA;EACA;EACA;EACA;;cAQW;mBACM;mBACA;UACT;EAER,KAAK,SAAS;EA0Bd,eAAe;EASf,OAAO,YAAY;EAUnB,UAAU;EAKV;UAMQ;UAKA;UAMA;UAMA;;UASO;EACf,KAAK;EACL;EACA;EACA;;UAGe;EACf;EACA,6BAA6B;EAC7B,UAAU,SAAS,gBAAgB,OAAO,iCAAiC;EAC3E,UAAU,gBAAgB,oBAAoB,KAAK;;UAGpC;EACf;EACA;;iBAGc,+BACd,IAAI,mBACJ,SAAS,gCACR"}