@geoscene/ai-components 0.0.0-stage → 5.1.14

package/dist/components/geoscene-assistant/customElement.d.ts

@@ -0,0 +1,541 @@
+/// <reference path="../../index.d.ts" />
+import type Collection from "@geoscene/core/core/Collection.js";
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+import type { AssistantMessage, AssistantPromptSelectDetail, AssistantSlottableRequestDetail, ChatMessage, Interrupt } from "./types.js";
+import type { T9nMeta } from "@geoscene/lumina/controllers";
+import type { GeosceneMap as GeosceneMap } from "@geoscene/map-components/components/geoscene-map";
+
+/**
+ * The GeoScene Assistant component provides a chat-based natural language interface for interacting with
+ * web map data via agents. This component uses an orchestrator, which relies on a large language model (LLM)
+ * for determining user intent. Once the intent is determined, the assistant routes the user's request
+ * to an agent that uses an LLM to generate text and structured responses.
+ *
+ * By default, the `geoscene-assistant` component does not include any agents. You must register at least one
+ * agent for the assistant to function. You can register agents declaratively using any of the
+ * available agent components, or you can register custom agents.
+ *
+ * ## Register agents
+ *
+ * To register agents declaratively, include one or more agent components as children
+ * of the `geoscene-assistant` component. This can be done in HTML or programmatically using JavaScript.
+ *
+ * ```html
+ * <geoscene-map id="my-map"></geoscene-map>
+ * <geoscene-assistant reference-element="#my-map">
+ *   <geoscene-assistant-navigation-agent></geoscene-assistant-navigation-agent>
+ *   <geoscene-assistant-data-exploration-agent></geoscene-assistant-data-exploration-agent>
+ *   <geoscene-assistant-help-agent></geoscene-assistant-help-agent>
+ * </geoscene-assistant>
+ * ```
+ *
+ * ```js
+ * const assistant = document.querySelector("geoscene-assistant");
+ * const navigationAgent = document.createElement("geoscene-assistant-navigation-agent");
+ * const dataExplorationAgent = document.createElement("geoscene-assistant-data-exploration-agent");
+ * assistant.appendChild(navigationAgent);
+ * assistant.appendChild(dataExplorationAgent);
+ * ```
+ *
+ * Note that the `reference-element` property on the `geoscene-assistant` component must point to a valid `geoscene-map` element
+ * for the included GeoScene agents to function properly, as they rely on the map context to perform their tasks. This is not
+ * a requirement for [custom agents](https://doc.geoscene.cn/javascript/5.1/agentic-apps/ai-custom-agents/).
+ *
+ * ## Application Identification
+ * For applications that use the geoscene-assistant component, setting the [`applicationName`](https://doc.geoscene.cn/javascript/5.1/references/core/config/#Config-applicationName) property on the GeoScene config object [`geosceneConfig`](https://doc.geoscene.cn/javascript/5.1/references/core/config/) is recommended.
+ * When provided, this value can help associate assistant activity and feedback with a specific application, where supported.
+ * This can make it easier to understand usage patterns and troubleshoot feedback.
+ *
+ * ## Context
+ *
+ * Use the [referenceElement](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#referenceElement) property to provide a web map as context to the assistant and its agents.
+ * This should be a reference to the map that the assistant will interact with, and is required for the included GeoScene
+ * agents to function properly.
+ *
+ * To learn more about this component, try out the [demo](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#demos)
+ *
+ * ## Important considerations and best practices
+ *
+ * Due to the non-deterministic nature of generative AI, there may be inaccuracies or unexpected behavior when using the
+ * out-of-the-box agents. Therefore, it is important to set clear expectations
+ * for end users and provide guidance on how to interact with the assistant to help mitigate these issues. Some ways to do this include:
+ *
+ * - Provide [suggestedPrompts](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#suggestedPrompts). This helps users understand the bounds of the assistant
+ * and gives them an idea of how to phrase questions to get the best results.
+ * - Use the [entryMessage](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#entryMessage) property to provide an entry message with instructions and guidance.
+ *
+ * @slot [header-actions-start] - Slot for adding actions to the start of the header.
+ * @slot [header-actions-end] - Slot for adding actions to the end of the header.
+ * @slot [message-starter] - Slot for adding content before the message list.
+ * @slot [messages] - Slot for customizing the rendered message list.
+ * @slot [message-loading] - Slot for customizing the in-progress assistant loading state.
+ * @slot [entry-message] - Slot for adding a welcome or entry message on load.
+ * @slot [interrupt] - Slot for customizing the interrupt UI.
+ * @slot [chat-entry] - Slot for customizing the chat entry UI.
+ * @slot [entry-actions-start] - Slot for adding actions to the start of the chat entry.
+ * @slot [entry-actions-end] - Slot for adding actions to the end of the chat entry.
+ * @slot [footer-content] - Slot for adding content below the chat entry.
+ * @since 5.0
+ * @beta
+ * @see [Intro to building agentic mapping applications](https://doc.geoscene.cn/javascript/5.1/agentic-apps/ai-introduction/)
+ * @see [AI Assistant component sample](https://doc.geoscene.cn/javascript/5.1/sample-code/ai-assistant/)
+ * @see [geoscene-assistant-data-exploration-agent](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant-data-exploration-agent/)
+ * @see [geoscene-assistant-navigation-agent](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant-navigation-agent/)
+ * @see [geoscene-assistant-help-agent](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant-help-agent/)
+ */
+export abstract class GeosceneAssistant extends LitElement {
+  /** @internal */
+  protected _messages: {
+      assistantLabel: string;
+      stopButtonLabel: string;
+      askButtonLabel: string;
+  } & T9nMeta<{
+      assistantLabel: string;
+      stopButtonLabel: string;
+      askButtonLabel: string;
+  }>;
+  /**
+   * When `true`, disables the assistant avatar in the chat interface.
+   *
+   * @default false
+   * @since 5.1
+   */
+  accessor assistantAvatarEnabled: boolean;
+  /**
+   * Indicates whether the assistant is currently processing a user message.
+   * This value is `true` while the assistant is generating a response and `false` when idle.
+   *
+   * @default false
+   * @since 5.1
+   */
+  get awaitingResponse(): boolean;
+  /**
+   * The current processing status message shown while the assistant is generating a response.
+   * This can be used to display progress details such as the current step in processing.
+   *
+   * @since 5.1
+   */
+  get awaitingResponseStep(): string;
+  /**
+   * When `true`, enables the copy action that, when clicked, copies the content of the message to the clipboard. This can be helpful for users to easily copy and share
+   * information provided by the assistant, such as a summary of findings, a set of instructions, or any other relevant details. Enabling this property can enhance the user experience by providing a convenient way for users to capture and utilize the information generated by the assistant.
+   *
+   * @default false
+   * @since 5.0
+   * @example
+   * ```html
+   * <geoscene-assistant copy-enabled></geoscene-assistant>
+   * ```
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.copyEnabled = true;
+   * ```
+   */
+  accessor copyEnabled: boolean;
+  /**
+   * The description text displayed below the heading in the assistant. This text provides additional
+   * context about the assistant's capabilities and how users can interact with it.
+   *
+   * @since 5.0
+   * @example
+   * ```html
+   * <geoscene-assistant description="Explore parcel data ownership, zoning designations, and other relevant information."></geoscene-assistant>
+   * ```
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.description = "Explore parcel data ownership, zoning designations, and other relevant information.";
+   * ```
+   */
+  accessor description: string | undefined;
+  /**
+   * The instructions to display when the assistant is first loaded. This is intended to be a welcome or entry message that
+   * provides guidance to users on how to interact with the assistant. Once the user submits their first message,
+   * the entry message will be closed and replaced with the chat interface. You can use this property to provide
+   * instructions, suggest prompts, or simply welcome users to the assistant.
+   *
+   * @since 5.0
+   * @example
+   * ```html
+   * <geoscene-assistant entry-message="I can answer questions about parcel ownership, zoning, and other relevant information."></geoscene-assistant>
+   * ```
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.entryMessage = "I can answer questions about parcel ownership, zoning, and other relevant information.";
+   * ```
+   */
+  accessor entryMessage: string | undefined;
+  /**
+   * When `true`, enables the feedback action in the chat interface, allowing developers to capture user feedback on the assistant's responses.
+   * The action simply provides a thumbs up and thumbs down experience for users to indicate whether a response was helpful or not. When the
+   * user submits feedback, the [@geosceneFeedback](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#event-geosceneFeedback) event is emitted allowing the app developer to capture additional feedback
+   * through a custom interface and log it to a database or service for later analysis.
+   *
+   * @default false
+   * @since 5.0
+   * @example
+   * ```html
+   * <geoscene-assistant feedback-enabled></geoscene-assistant>
+   * ```
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.feedbackEnabled = true;
+   * assistant.addEventListener("geosceneFeedback", (event) => {
+   *   const feedback = event.detail;
+   *   // Capture additional feedback from the user and log it to a database or service for later analysis
+   * });
+   * ```
+   */
+  accessor feedbackEnabled: boolean;
+  /**
+   * The heading text displayed at the top of the assistant. This name should be concise and
+   * descriptive of the assistant's purpose.
+   *
+   * For applications where the primary interface is the assistant, this heading could also be used as the
+   * application title. In cases where the assistant could be collapsed or is a secondary interface to a standard
+   * GUI, the heading should be more specific to the assistant's function to avoid confusion with the overall
+   * application title.
+   *
+   * @since 5.0
+   * @example
+   * ```html
+   * <geoscene-assistant heading="Parcel Viewer"></geoscene-assistant>
+   * ```
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.heading = "Zoning Assistant";
+   * ```
+   */
+  accessor heading: string | undefined;
+  /**
+   * The active interrupt, if the assistant is waiting for additional user input.
+   * Applications rendering custom interrupt UI through the `interrupt` slot can read this value
+   * and call [submitInterrupt()](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#submitInterrupt) or [cancelInterrupt()](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#cancelInterrupt)
+   * to respond.
+   *
+   * @since 5.1
+   */
+  get interrupt(): Interrupt | null;
+  /**
+   * When `true`, keeps suggested prompts displayed in the UI after the user submits a message. By default, suggested prompts are cleared,
+   * when the user submits a message.
+   *
+   * @default false
+   * @since 5.0
+   * @example
+   * ```html
+   * <geoscene-assistant keep-suggested-prompts></geoscene-assistant>
+   * ```
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.keepSuggestedPrompts = true;
+   * ```
+   */
+  accessor keepSuggestedPrompts: boolean;
+  /**
+   * When `true`, enables the log action that when clicked displays log messages in the chat interface. Log messages provide detailed messages including
+   * which agents or tools were invoked, the parameters generated by the LLM, and any relevant details about how the assistant arrived at its response.
+   * Enabling logs can be helpful for developers for debugging during the development of an assistant or agentic web application.
+   * It may also be useful to end users for transparency purposes, allowing them to understand the assistant's behavior and decision-making process.
+   *
+   * Enabling this property for a production app depends on the role of the audience. More technical audiences may benefit from having access to these
+   * logs while non-technical audiences may find them overwhelming or confusing.
+   *
+   * @default false
+   * @since 5.0
+   * @example
+   * ```html
+   * <geoscene-assistant log-enabled></geoscene-assistant>
+   * ```
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.logEnabled = true;
+   * ```
+   */
+  accessor logEnabled: boolean;
+  /**
+   * The collection of messages exchanged between the user and the assistant. Each message includes the role
+   * (user or assistant), along with any relevant logs or errors. These messages are rendered in the chat interface
+   * and are used to provide context for the conversation. When a user submits a message, it is added to this
+   * collection with the role of "user". When the assistant generates a response, it is added to this collection
+   * with the role of "assistant", along with any logs or errors that occurred during processing.
+   *
+   * @since 5.0
+   */
+  accessor messages: Collection<ChatMessage>;
+  /**
+   * The reference element to the map that provides context for the assistant and its agents. Currently,
+   * this is only scoped to `geoscene-map` elements. This is required when GeoScene agents are registered to the assistant.
+   * For example, this allows the navigation agent to execute a map navigation tool for a specific map.
+   *
+   * @since 5.0
+   * @example
+   * ```html
+   * <geoscene-map id="my-map"></geoscene-map>
+   * <geoscene-assistant reference-element="my-map"></geoscene-assistant>
+   * ```
+   */
+  accessor referenceElement: GeosceneMap | string | null;
+  /**
+   * When `true`, assistant text responses render after completion instead of streaming progressively.
+   *
+   * @default false
+   * @since 5.1
+   */
+  accessor streamingDisabled: boolean;
+  /**
+   * Prompts to suggest to the end user on load. These are intended to help users understand which questions they can ask.
+   * This property should be set to establish boundaries for the end user. As all agents have limitations and LLMs can
+   * be unpredictable, it's important to set clear expectations for users to give them a better chance to succeed.
+   * By providing suggested prompts, you can guide users towards asking questions that are relevant to the data being
+   * used and the capabilities of the registered agents, which can help to ensure that the assistant provides accurate
+   * and helpful responses.
+   *
+   * You should typically provide 2-3 suggested prompts.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.suggestedPrompts = [
+   *   "What city has the highest population?",
+   *   "What is the highest point in this area?"
+   * ];
+   * ```
+   */
+  accessor suggestedPrompts: string[];
+  /**
+   * Cancels the active interrupt, if one is pending.
+   *
+   * @since 5.1
+   */
+  cancelInterrupt(): void;
+  /**
+   * Clears the chat history between the user and the assistant. This method can be used to programmatically reset the conversation,
+   * removing all messages from the chat interface.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.clearChatHistory();
+   * ```
+   */
+  clearChatHistory(): Promise<void>;
+  /**
+   * Submits a response for the active interrupt.
+   *
+   * @param response - The response payload expected by the active interrupt type.
+   * @since 5.1
+   */
+  submitInterrupt(response: string[] | boolean | string): void;
+  /**
+   * Programmatically submits a message to the assistant. This method can be used to submit messages from outside the component,
+   * such as from another component or from custom JavaScript code. When a message is submitted using this method, it is added
+   * to the messages collection with the role of "user", and then processed by the assistant in the same way as if it were submitted
+   * through the chat interface. This allows for greater flexibility in how messages are sent to the assistant and can enable more
+   * complex interactions and integrations with other components or services.
+   *
+   * @param message - The message to submit to the assistant. This should be a string containing the user's input or question they want to ask the assistant.
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.submitMessage("What is the population of New York City?");
+   * ```
+   */
+  submitMessage(message: string): Promise<void>;
+  /**
+   * Emitted when the user cancels a message. This is typically invoked when a user submits a question while a previous question is still being processed.
+   * This allows app developers to capture messages cancelled by the user and respond to them in custom ways, such as by providing additional information,
+   * triggering other actions in the app, or logging them for analysis.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneCancel", (event) => {
+   *   // Handle the cancelled message
+   * });
+   * ```
+   */
+  readonly geosceneCancel: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /**
+   * Emitted when the assistant encounters an error. The event detail includes an Error object with information about the error that occurred.
+   * This allows app developers to capture errors that occur within the assistant and respond to them in custom ways, such as by displaying an
+   * error message to the user, logging the error for analysis, or triggering other actions in the app.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneError", (event) => {
+   *   const error = event.detail;
+   *   // Handle the error, such as by displaying an error message to the user or logging it for analysis
+   * });
+   * ```
+   */
+  readonly geosceneError: import("@geoscene/lumina").TargetedEvent<this, Error>;
+  /**
+   * Emitted when the user clicks the thumbs up or thumbs down feedback action that is displayed when [feedbackEnabled](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#feedbackEnabled) is `true`.
+   * The event detail includes an AssistantMessage object that includes a feedback property with an object indicating whether the feedback is positive or negative.
+   * This allows the application to capture user feedback on the assistant's responses and respond to it in custom ways, such as by providing additional
+   * information, adjusting the assistant's behavior, logging the feedback for analysis, or triggering other actions in the app.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneFeedback", (event) => {
+   *   const feedback = event.detail;
+   *   // Handle the feedback, such as by providing additional information, adjusting the assistant's behavior, or logging it for analysis
+   * });
+   * ```
+   */
+  readonly geosceneFeedback: import("@geoscene/lumina").TargetedEvent<this, AssistantMessage>;
+  /**
+   * Emitted when an agent triggers an interrupt. An interrupt is a human-in-the-loop mechanism that provides a UI component prompting
+   * the user for additional information.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneInterrupt", (event) => {
+   *   const interrupt = event.detail;
+   *   // Handle the interrupt
+   * });
+   * ```
+   */
+  readonly geosceneInterrupt: import("@geoscene/lumina").TargetedEvent<this, Interrupt>;
+  /**
+   * Emitted when the user cancels an interrupt. This is typically invoked when a user clicks the cancel button displayed in an interrupt message
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneInterruptCancel", (event) => {
+   *   // Handle the interrupt cancellation such as logging it for analysis
+   * });
+   * ```
+   */
+  readonly geosceneInterruptCancel: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /**
+   * Emitted when the user submits a message during an interrupt. For example, this will be invoked if the user clicks the submit button
+   * in an interrupt message asking for confirmation, or when the user submits additional text or selects an option provided in an interrupt.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneInterruptSubmit", (event) => {
+   *   const message = event.detail; // The message or option selected by the user for the interrupt
+   *   // Do something with the interrupt submission
+   * });
+   * ```
+   */
+  readonly geosceneInterruptSubmit: import("@geoscene/lumina").TargetedEvent<this, string[] | boolean | string>;
+  /**
+   * Emitted when a suggested prompt is selected from the assistant UI.
+   * Applications that provide a custom `chat-entry` slot can listen for this event to sync
+   * the selected prompt into their own entry implementation.
+   *
+   * @since 5.1
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geoscenePromptSelect", (event) => {
+   *   const { prompt } = event.detail;
+   *   // Sync prompt into a custom chat entry
+   * });
+   * ```
+   */
+  readonly geoscenePromptSelect: import("@geoscene/lumina").TargetedEvent<this, AssistantPromptSelectDetail>;
+  /**
+   * Emitted when the assistant is ready to receive messages from the end user. This indicates that the assistant has been successfully
+   * initialized and is ready to process user input.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneReady", (event) => {
+   *   // Handle the assistant being ready, such as by hiding a loading indicator,
+   *   // displaying a welcome message, or enabling certain UI elements for user interaction
+   * });
+   * ```
+   */
+  readonly geosceneReady: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /**
+   * Emitted when the assistant generates a response to a user message. The event detail includes an AssistantMessage object that contains the assistant's response,
+   * along with any relevant logs or errors. This allows app developers to capture the assistant's responses.
+   *
+   * @since 5.1
+   */
+  readonly geosceneResponse: import("@geoscene/lumina").TargetedEvent<this, AssistantMessage>;
+  /**
+   * Emitted when the assistant requests custom slotted content for an assistant message.
+   *
+   * Use this event to render app-provided content into dynamic slot targets created at runtime
+   * for assistant responses. The event detail includes:
+   * - name: conceptual request type
+   * - slotName: concrete slot target to render into
+   * - data: payload needed to render or update content
+   *
+   * Dynamic slot name formats:
+   * - name = "message" -> slotName = "message-{messageId}"
+   * - name = "block" -> slotName = "block-{messageId}-{index}"
+   *
+   * @since 5.1
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneSlottableRequest", (event) => {
+   *   const { name, slotName, data } = event.detail;
+   *
+   *   if (!data) {
+   *     // Remove previously rendered slotted content for this slotName.
+   *     return;
+   *   }
+   *
+   *   // Render or update app-provided content and set slot=slotName.
+   *   // Optionally branch on name ("message" or "block") for different rendering.
+   * });
+   * ```
+   */
+  readonly geosceneSlottableRequest: import("@geoscene/lumina").TargetedEvent<this, AssistantSlottableRequestDetail>;
+  /**
+   * Emitted when the user submits a message. This is typically invoked when a user clicks the submit button in the chat interface or hits the Enter key.
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * const assistant = document.querySelector("geoscene-assistant");
+   * assistant.addEventListener("geosceneSubmit", (event) => {
+   *   const message = event.detail;
+   *   // Do something with the submitted message, such as logging it for analysis or triggering other actions in the app
+   * });
+   * ```
+   */
+  readonly geosceneSubmit: import("@geoscene/lumina").TargetedEvent<this, string>;
+  readonly "@eventTypes": {
+    geosceneCancel: GeosceneAssistant["geosceneCancel"]["detail"];
+    geosceneError: GeosceneAssistant["geosceneError"]["detail"];
+    geosceneFeedback: GeosceneAssistant["geosceneFeedback"]["detail"];
+    geosceneInterrupt: GeosceneAssistant["geosceneInterrupt"]["detail"];
+    geosceneInterruptCancel: GeosceneAssistant["geosceneInterruptCancel"]["detail"];
+    geosceneInterruptSubmit: GeosceneAssistant["geosceneInterruptSubmit"]["detail"];
+    geoscenePromptSelect: GeosceneAssistant["geoscenePromptSelect"]["detail"];
+    geosceneReady: GeosceneAssistant["geosceneReady"]["detail"];
+    geosceneResponse: GeosceneAssistant["geosceneResponse"]["detail"];
+    geosceneSlottableRequest: GeosceneAssistant["geosceneSlottableRequest"]["detail"];
+    geosceneSubmit: GeosceneAssistant["geosceneSubmit"]["detail"];
+  };
+}