@arcgis/coding-components 4.30.0 → 4.31.0-next.10

package/dist/types/components.d.ts

@@ -8,38 +8,30 @@ import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
 import { IEditorProfileDefinition, IPredefinedProfile } from "./utils/profile/types";
 import { ArcadeResult, IEditorTestContext } from "./utils/arcade-executor";
 import { IEditorCodeSuggestion, IEditorCodeSuggestionGroup } from "./utils/editor-suggestions";
-import { ApiSnippet, Diagnostic } from "@arcgis/arcade-languageservice";
+import { ApiCategory, ApiSnippet, Diagnostic } from "@arcgis/arcade-languageservice";
 import { SidePanelName } from "./components/arcade-editor/arcade-editor";
 import { editor, Selection } from "monaco-editor";
 import { IColorRules } from "./utils/arcade-monaco/arcade-theme";
 import { ResultPanelName } from "./components/arcade-results/arcade-results";
+import { IPredefinedProfile as IPredefinedProfile1 } from "./components";
 export { IEditorProfileDefinition, IPredefinedProfile } from "./utils/profile/types";
 export { ArcadeResult, IEditorTestContext } from "./utils/arcade-executor";
 export { IEditorCodeSuggestion, IEditorCodeSuggestionGroup } from "./utils/editor-suggestions";
-export { ApiSnippet, Diagnostic } from "@arcgis/arcade-languageservice";
+export { ApiCategory, ApiSnippet, Diagnostic } from "@arcgis/arcade-languageservice";
 export { SidePanelName } from "./components/arcade-editor/arcade-editor";
 export { editor, Selection } from "monaco-editor";
 export { IColorRules } from "./utils/arcade-monaco/arcade-theme";
 export { ResultPanelName } from "./components/arcade-results/arcade-results";
+export { IPredefinedProfile as IPredefinedProfile1 } from "./components";
 export namespace Components {
-    interface ArcgisArcadeApi {
-        /**
-          * Should the documentation action be hidden
-         */
-        "hideDocumentationActions": boolean;
-        /**
-          * The model id used by the component to retrieve the api library
-         */
-        "modelId": string | undefined;
-    }
     interface ArcgisArcadeEditor {
         /**
-          * The instance of the Monaco Editor.
+          * The instance of the Monaco Editor after the component has been rendered. To determine when a component is rendered, you can use componentOnReady() method. The method returns a Promise that resolves after the component rendered for the first time.
           * @readonly
          */
         "editorInstance": editor.IStandaloneCodeEditor | undefined;
         /**
-          * The options for the editor (see Monaco Editor options documentation for more details).
+          * Options to update on the editor. For example: ```json {   "fontSize": 18 } ```  To get the full list of available options, see the Monaco Editor options documentation for more details.
          */
         "editorOptions": (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
@@ -135,10 +127,14 @@ export namespace Components {
     }
     interface ArcgisCodeEditor {
         /**
-          * The instance of the Monaco Editor.
+          * The instance of the Monaco Editor after the component has been rendered. To determine when a component is rendered, you can use componentOnReady() method. The method returns a Promise that resolves after the component rendered for the first time.
           * @readonly
          */
         "editorInstance": editor.IStandaloneCodeEditor | undefined;
+        /**
+          * Options to update on the editor. For example: ```json {   "fontSize": 18 } ```  To get the full list of options set on the editor, use the editorInstance property and see Monaco Editor options documentation for more details.
+         */
+        "editorOptions": (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
           * @deprecated Use `editorInstance` property instead.
          */
@@ -160,17 +156,13 @@ export namespace Components {
          */
         "insertText": (text: string | null | undefined) => Promise<void>;
         /**
-          * The language for the editor. Currently supported language: arcade, json, css, html, javascript, typescript, and text.
+          * The language for the editor. Currently supported language: arcade, arcgis-sql-expression, json, css, html, javascript, typescript, and text.
          */
         "language": string | undefined;
         /**
           * A unique identifier for the model. The unique identifier is sometimes used by language defaults to store model metadata. For example, with arcade, the model id is used to store the arcade profile and other metadata. The unique identifier is especially useful when there are multiple editors on the same page.
          */
         "modelId": string;
-        /**
-          * The options for the editor (see Monaco Editor options documentation for more details).
-         */
-        "options": (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
           * Sets the focus on the editor.
           * @returns
@@ -185,10 +177,33 @@ export namespace Components {
          */
         "value": string;
     }
-}
-export interface ArcgisArcadeApiCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLArcgisArcadeApiElement;
+    interface ArcgisLanguageApiPanel {
+        /**
+          * The api library to display
+         */
+        "apiLibrary": ApiCategory[] | undefined;
+        /**
+          * Should the documentation action be hidden
+         */
+        "hideDocumentationActions": boolean;
+        /**
+          * When true, a busy indicator is displayed
+         */
+        "loading": boolean;
+    }
+    interface ArcgisSqlExpressionEditor {
+        "profile": IPredefinedProfile1 | undefined;
+    }
+    interface ArcgisSqlExpressionFields {
+        /**
+          * Loading state
+         */
+        "loading": boolean;
+        /**
+          * The model id
+         */
+        "modelId": string | undefined;
+    }
 }
 export interface ArcgisArcadeEditorCustomEvent<T> extends CustomEvent<T> {
     detail: T;
@@ -210,25 +225,15 @@ export interface ArcgisCodeEditorCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLArcgisCodeEditorElement;
 }
+export interface ArcgisLanguageApiPanelCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLArcgisLanguageApiPanelElement;
+}
+export interface ArcgisSqlExpressionFieldsCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLArcgisSqlExpressionFieldsElement;
+}
 declare global {
-    interface HTMLArcgisArcadeApiElementEventMap {
-        "arcgisClose": void;
-        "arcgisItemSelected": string;
-    }
-    interface HTMLArcgisArcadeApiElement extends Components.ArcgisArcadeApi, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLArcgisArcadeApiElementEventMap>(type: K, listener: (this: HTMLArcgisArcadeApiElement, ev: ArcgisArcadeApiCustomEvent<HTMLArcgisArcadeApiElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
-        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLArcgisArcadeApiElementEventMap>(type: K, listener: (this: HTMLArcgisArcadeApiElement, ev: ArcgisArcadeApiCustomEvent<HTMLArcgisArcadeApiElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
-        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-    }
-    var HTMLArcgisArcadeApiElement: {
-        prototype: HTMLArcgisArcadeApiElement;
-        new (): HTMLArcgisArcadeApiElement;
-    };
     interface HTMLArcgisArcadeEditorElementEventMap {
         "arcgisScriptChange": string;
         "arcgisDiagnosticsChange": Diagnostic[];
@@ -322,37 +327,63 @@ declare global {
         prototype: HTMLArcgisCodeEditorElement;
         new (): HTMLArcgisCodeEditorElement;
     };
+    interface HTMLArcgisLanguageApiPanelElementEventMap {
+        "arcgisClose": void;
+        "arcgisItemSelected": string;
+    }
+    interface HTMLArcgisLanguageApiPanelElement extends Components.ArcgisLanguageApiPanel, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLArcgisLanguageApiPanelElementEventMap>(type: K, listener: (this: HTMLArcgisLanguageApiPanelElement, ev: ArcgisLanguageApiPanelCustomEvent<HTMLArcgisLanguageApiPanelElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLArcgisLanguageApiPanelElementEventMap>(type: K, listener: (this: HTMLArcgisLanguageApiPanelElement, ev: ArcgisLanguageApiPanelCustomEvent<HTMLArcgisLanguageApiPanelElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLArcgisLanguageApiPanelElement: {
+        prototype: HTMLArcgisLanguageApiPanelElement;
+        new (): HTMLArcgisLanguageApiPanelElement;
+    };
+    interface HTMLArcgisSqlExpressionEditorElement extends Components.ArcgisSqlExpressionEditor, HTMLStencilElement {
+    }
+    var HTMLArcgisSqlExpressionEditorElement: {
+        prototype: HTMLArcgisSqlExpressionEditorElement;
+        new (): HTMLArcgisSqlExpressionEditorElement;
+    };
+    interface HTMLArcgisSqlExpressionFieldsElementEventMap {
+        "arcgisClose": void;
+        "arcgisFieldSelected": string;
+    }
+    interface HTMLArcgisSqlExpressionFieldsElement extends Components.ArcgisSqlExpressionFields, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLArcgisSqlExpressionFieldsElementEventMap>(type: K, listener: (this: HTMLArcgisSqlExpressionFieldsElement, ev: ArcgisSqlExpressionFieldsCustomEvent<HTMLArcgisSqlExpressionFieldsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLArcgisSqlExpressionFieldsElementEventMap>(type: K, listener: (this: HTMLArcgisSqlExpressionFieldsElement, ev: ArcgisSqlExpressionFieldsCustomEvent<HTMLArcgisSqlExpressionFieldsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLArcgisSqlExpressionFieldsElement: {
+        prototype: HTMLArcgisSqlExpressionFieldsElement;
+        new (): HTMLArcgisSqlExpressionFieldsElement;
+    };
     interface HTMLElementTagNameMap {
-        "arcgis-arcade-api": HTMLArcgisArcadeApiElement;
         "arcgis-arcade-editor": HTMLArcgisArcadeEditorElement;
         "arcgis-arcade-results": HTMLArcgisArcadeResultsElement;
         "arcgis-arcade-suggestions": HTMLArcgisArcadeSuggestionsElement;
         "arcgis-arcade-variables": HTMLArcgisArcadeVariablesElement;
         "arcgis-code-editor": HTMLArcgisCodeEditorElement;
+        "arcgis-language-api-panel": HTMLArcgisLanguageApiPanelElement;
+        "arcgis-sql-expression-editor": HTMLArcgisSqlExpressionEditorElement;
+        "arcgis-sql-expression-fields": HTMLArcgisSqlExpressionFieldsElement;
     }
 }
 declare namespace LocalJSX {
-    interface ArcgisArcadeApi {
-        /**
-          * Should the documentation action be hidden
-         */
-        "hideDocumentationActions"?: boolean;
-        /**
-          * The model id used by the component to retrieve the api library
-         */
-        "modelId"?: string | undefined;
-        /**
-          * Raised when the close action has been requested
-         */
-        "onArcgisClose"?: (event: ArcgisArcadeApiCustomEvent<void>) => void;
-        /**
-          * Raised when an item has been selected
-         */
-        "onArcgisItemSelected"?: (event: ArcgisArcadeApiCustomEvent<string>) => void;
-    }
     interface ArcgisArcadeEditor {
         /**
-          * The options for the editor (see Monaco Editor options documentation for more details).
+          * Options to update on the editor. For example: ```json {   "fontSize": 18 } ```  To get the full list of available options, see the Monaco Editor options documentation for more details.
          */
         "editorOptions"?: (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
@@ -460,12 +491,16 @@ declare namespace LocalJSX {
     }
     interface ArcgisCodeEditor {
         /**
-          * The instance of the Monaco Editor.
+          * The instance of the Monaco Editor after the component has been rendered. To determine when a component is rendered, you can use componentOnReady() method. The method returns a Promise that resolves after the component rendered for the first time.
           * @readonly
          */
         "editorInstance"?: editor.IStandaloneCodeEditor | undefined;
         /**
-          * The language for the editor. Currently supported language: arcade, json, css, html, javascript, typescript, and text.
+          * Options to update on the editor. For example: ```json {   "fontSize": 18 } ```  To get the full list of options set on the editor, use the editorInstance property and see Monaco Editor options documentation for more details.
+         */
+        "editorOptions"?: (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
+        /**
+          * The language for the editor. Currently supported language: arcade, arcgis-sql-expression, json, css, html, javascript, typescript, and text.
          */
         "language"?: string | undefined;
         /**
@@ -483,34 +518,77 @@ declare namespace LocalJSX {
           * Emitted when the value has changed (script, code, css, json, etc.)
          */
         "onArcgisValueChange"?: (event: ArcgisCodeEditorCustomEvent<string>) => void;
-        /**
-          * The options for the editor (see Monaco Editor options documentation for more details).
-         */
-        "options"?: (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
           * The initial value for the editor. The value is the script, code, css, json, etc.
          */
         "value"?: string;
     }
+    interface ArcgisLanguageApiPanel {
+        /**
+          * The api library to display
+         */
+        "apiLibrary"?: ApiCategory[] | undefined;
+        /**
+          * Should the documentation action be hidden
+         */
+        "hideDocumentationActions"?: boolean;
+        /**
+          * When true, a busy indicator is displayed
+         */
+        "loading"?: boolean;
+        /**
+          * Raised when the close action has been requested
+         */
+        "onArcgisClose"?: (event: ArcgisLanguageApiPanelCustomEvent<void>) => void;
+        /**
+          * Raised when an item has been selected
+         */
+        "onArcgisItemSelected"?: (event: ArcgisLanguageApiPanelCustomEvent<string>) => void;
+    }
+    interface ArcgisSqlExpressionEditor {
+        "profile"?: IPredefinedProfile1 | undefined;
+    }
+    interface ArcgisSqlExpressionFields {
+        /**
+          * Loading state
+         */
+        "loading"?: boolean;
+        /**
+          * The model id
+         */
+        "modelId"?: string | undefined;
+        /**
+          * Emitted when close action has been activated
+         */
+        "onArcgisClose"?: (event: ArcgisSqlExpressionFieldsCustomEvent<void>) => void;
+        /**
+          * Emitted when a field has been selected
+         */
+        "onArcgisFieldSelected"?: (event: ArcgisSqlExpressionFieldsCustomEvent<string>) => void;
+    }
     interface IntrinsicElements {
-        "arcgis-arcade-api": ArcgisArcadeApi;
         "arcgis-arcade-editor": ArcgisArcadeEditor;
         "arcgis-arcade-results": ArcgisArcadeResults;
         "arcgis-arcade-suggestions": ArcgisArcadeSuggestions;
         "arcgis-arcade-variables": ArcgisArcadeVariables;
         "arcgis-code-editor": ArcgisCodeEditor;
+        "arcgis-language-api-panel": ArcgisLanguageApiPanel;
+        "arcgis-sql-expression-editor": ArcgisSqlExpressionEditor;
+        "arcgis-sql-expression-fields": ArcgisSqlExpressionFields;
     }
 }
 export { LocalJSX as JSX };
 declare module "@stencil/core" {
     export namespace JSX {
         interface IntrinsicElements {
-            "arcgis-arcade-api": LocalJSX.ArcgisArcadeApi & JSXBase.HTMLAttributes<HTMLArcgisArcadeApiElement>;
             "arcgis-arcade-editor": LocalJSX.ArcgisArcadeEditor & JSXBase.HTMLAttributes<HTMLArcgisArcadeEditorElement>;
             "arcgis-arcade-results": LocalJSX.ArcgisArcadeResults & JSXBase.HTMLAttributes<HTMLArcgisArcadeResultsElement>;
             "arcgis-arcade-suggestions": LocalJSX.ArcgisArcadeSuggestions & JSXBase.HTMLAttributes<HTMLArcgisArcadeSuggestionsElement>;
             "arcgis-arcade-variables": LocalJSX.ArcgisArcadeVariables & JSXBase.HTMLAttributes<HTMLArcgisArcadeVariablesElement>;
             "arcgis-code-editor": LocalJSX.ArcgisCodeEditor & JSXBase.HTMLAttributes<HTMLArcgisCodeEditorElement>;
+            "arcgis-language-api-panel": LocalJSX.ArcgisLanguageApiPanel & JSXBase.HTMLAttributes<HTMLArcgisLanguageApiPanelElement>;
+            "arcgis-sql-expression-editor": LocalJSX.ArcgisSqlExpressionEditor & JSXBase.HTMLAttributes<HTMLArcgisSqlExpressionEditorElement>;
+            "arcgis-sql-expression-fields": LocalJSX.ArcgisSqlExpressionFields & JSXBase.HTMLAttributes<HTMLArcgisSqlExpressionFieldsElement>;
         }
     }
 }

package/dist/types/data/actions-runner-1/_work/arcgis-web-components/arcgis-web-components/packages/coding-packages/coding-components/.stencil/stories/internal/sql-expression-editor/sql-expression-editor.stories.d.ts

@@ -0,0 +1,13 @@
+import type { Meta, StoryObj } from "@storybook/web-components";
+import { type Components } from "../../../src/components";
+declare const meta: Meta<Components.ArcgisSqlExpressionEditor>;
+export default meta;
+interface Configuration {
+    portalKey: "devext" | "qaext" | "www";
+    itemId: string;
+    sublayerId?: number;
+}
+type StoryType = Components.ArcgisArcadeEditor & {
+    configuration: Configuration;
+};
+export declare const SimpleStory: StoryObj<StoryType>;

package/dist/types/dependencies.d.ts

@@ -0,0 +1,21 @@
+/**
+ * This is a workaround for missing JSX typing for components authored in Stencil.
+ * @see https://github.com/maxpatiiuk/web-component-framework-benchmarks/tree/stencil-calcite-no-typing/stencil
+ */
+import type { JSX as CalciteJsx } from "@esri/calcite-components/dist/types/components";
+import type { JSXBase } from "./stencil-public-runtime";
+/**
+ * The "JSX" type exported from @esri/calcite-components includes only component
+ * props, without HTMLElement props. This type re-maps the Calcite JSX type to
+ * add HTMLElement props
+ */
+type ReMappedCalciteJsx = {
+    [Key in keyof CalciteJsx.IntrinsicElements]: JSXBase.HTMLAttributes<HTMLElementTagNameMap[Key]>;
+};
+declare module "@stencil/core" {
+    namespace JSX {
+        interface IntrinsicElements extends ReMappedCalciteJsx {
+        }
+    }
+}
+export {};

package/dist/types/utils/arcade-monaco/arcade-contribution.d.ts

@@ -1,24 +1 @@
-import type { IArcadeWorker } from "./types";
-import type { Uri } from "monaco-editor";
-import type * as arcadeModeModule from "./arcade-mode";
-/**
- * Returns the arcade diagnostic service.
- * Example:
- * ```ts
- * const diagnosticService = await getArcadeDiagnosticService();
- * diagnosticService.onDidChangeDiagnostics(({uri, diaganostics }) => {
- *  // Filter the diagnostics for the uri of interest
- *  // Do something with the diagnostics
- * });
- * ```
- */
-export declare function getArcadeDiagnosticService(): Promise<arcadeModeModule.IDiagnosticService>;
-/**
- * Returns the arcade worker for the model.
- * Example:
- * ```ts
- * const arcadeWorker = await getArcadeWorker(model.uri);
- * ```
- * @returns arcade worker
- */
-export declare function getArcadeWorker(uri: Uri): Promise<IArcadeWorker>;
+export {};

package/dist/types/utils/arcade-monaco/arcade-defaults.d.ts

@@ -1,23 +1,10 @@
-import type { IArcadeLanguageServiceDefaults } from "./types";
-import type { ApiContext, ApiSnippet, ArcadeLanguageServiceSettings } from "@arcgis/arcade-languageservice";
-import type { IEvent } from "monaco-editor";
+import type { ApiCategory, ApiSnippet, ArcadeApiContext, ArcadeLanguageServiceSettings } from "@arcgis/arcade-languageservice";
 import { Uri } from "monaco-editor";
-import { EditorProfile } from "../profile/editor-profile";
 import type { IEditorProfileDefinition, IPredefinedProfile } from "../profile/types";
-declare class ArcadeLanguageServiceDefaults implements IArcadeLanguageServiceDefaults {
-    private _languageId;
-    private _languageOptions;
-    private _onDidChange;
-    private _profileMap;
-    private _apiContextMap;
-    private _onModelContextDidChange;
-    private _onDidModelContextChangeTimeout;
-    get onDidChange(): IEvent<IArcadeLanguageServiceDefaults>;
-    get onModelContextDidChange(): IEvent<string>;
-    get languageId(): string;
-    get languageOptions(): ArcadeLanguageServiceSettings | null;
-    private _fireModelContextDidChange;
-    private _getApiKey;
+import { LanguageDefaultsBase } from "../language-defaults-base";
+declare class ArcadeLanguageServiceDefaults extends LanguageDefaultsBase<ArcadeApiContext> {
+    protected _languageId: string;
+    protected _languageOptions: ArcadeLanguageServiceSettings;
     /**
      * Create an EditorProfile for the given model id using the given definition and locale.
      * The EditorProfile is used by the the Arcade Language service as well by the cosing components.
@@ -32,41 +19,17 @@ declare class ArcadeLanguageServiceDefaults implements IArcadeLanguageServiceDef
         locale: string;
         snippets?: ApiSnippet[];
     }): Promise<void>;
-    /**
-     * Dispose the editor profile for the given model id.
-     * It is the responsibility of the caller that created the editor profile to dispose it.
-     * @param modelId The model id for which to dispose the editor profile.
-     */
-    disposeEditorProfileForModel(modelId: Uri | string): void;
-    /**
-     * Dispose the api context for the given model id.
-     * @param modelId The model id for which to dispose the api context.
-     */
-    disposeApiContextForModel(modelId: Uri | string): void;
-    /**
-     * Returns the editor profile for the given model id.
-     * @param modelId The model id for which to get the editor profile.
-     * @returns The editor profile for the model.
-     */
-    getEditorProfileForModel(modelId: Uri | string): EditorProfile | undefined;
-    /**
-     * Returns the API context for the given model id.
-     * Returns the default context if the model has no context.
-     * @param modelId The model id for which to get the API context.
-     * @returns The API context for the model.
-     */
-    getApiContextForModel(contextId: Uri | string): ApiContext;
-    /**
-     * Set or update api context for the given model id.
-     * @param modelId The model id for which to set the context.
-     * @param apiContext The api context to set.
-     */
-    updateApiContextForModel(modelId: Uri | string, apiContext: ApiContext): void;
     /**
      * Set or update the Arcade language service options.
      * @param languageOptions The language options to set.
      */
     setLanguageOptions(languageOptions?: ArcadeLanguageServiceSettings): void;
+    /**
+     * Gets the API library for the given model id.
+     * @param modelId The model id for which to get the API library.
+     * @returns The API library for the model.
+     */
+    getApiLibrary(modelId: string): Promise<ApiCategory[]>;
 }
 export declare const arcadeDefaults: ArcadeLanguageServiceDefaults;
 export declare const arcade: {
@@ -75,4 +38,4 @@ export declare const arcade: {
         snippets?: ApiSnippet[];
     }) => Promise<void>;
 };
-export {};
+export type { ArcadeLanguageServiceDefaults };

package/dist/types/utils/arcade-monaco/arcade-language-features.d.ts

@@ -1,7 +1,8 @@
 import type { Diagnostic } from "@arcgis/arcade-languageservice";
 import type { Uri, Position } from "monaco-editor";
 import { editor, languages } from "monaco-editor";
-import type { IArcadeLanguageServiceDefaults, IArcadeWorkerAccessor } from "./types";
+import type { IArcadeWorkerAccessor } from "./types";
+import type { ArcadeLanguageServiceDefaults } from "./arcade-defaults";
 export declare class DiagnosticsAdapter {
     private _languageId;
     private _worker;
@@ -10,7 +11,7 @@ export declare class DiagnosticsAdapter {
     private _diagnosticsService;
     private _defaults;
     constructor(_languageId: string, _worker: IArcadeWorkerAccessor, { defaults, diagnosticsService, }: {
-        defaults: IArcadeLanguageServiceDefaults;
+        defaults: ArcadeLanguageServiceDefaults;
         diagnosticsService: {
             fireDiagnosticsChange: (uri: Uri, diagnostics: Diagnostic[]) => void;
         };
@@ -18,16 +19,17 @@ export declare class DiagnosticsAdapter {
     dispose(): void;
     private _doValidate;
 }
+export declare function toCompletionItemKind(kind: number | undefined): languages.CompletionItemKind;
 export declare class CompletionProvider implements languages.CompletionItemProvider {
     private _worker;
     private _defaults;
-    constructor(_worker: IArcadeWorkerAccessor, _defaults: IArcadeLanguageServiceDefaults);
+    constructor(_worker: IArcadeWorkerAccessor, _defaults: ArcadeLanguageServiceDefaults);
     triggerCharacters: string[];
     provideCompletionItems(model: editor.ITextModel, position: Position): Promise<languages.CompletionList | undefined>;
 }
 export declare class FormattingProvider implements languages.DocumentFormattingEditProvider {
     private _worker;
     private _defaults;
-    constructor(_worker: IArcadeWorkerAccessor, _defaults: IArcadeLanguageServiceDefaults);
+    constructor(_worker: IArcadeWorkerAccessor, _defaults: ArcadeLanguageServiceDefaults);
     provideDocumentFormattingEdits(model: editor.ITextModel): Promise<languages.TextEdit[]>;
 }

package/dist/types/utils/arcade-monaco/arcade-mode.d.ts

@@ -1,6 +1,7 @@
 import type { IEvent, Uri } from "monaco-editor";
-import type { IArcadeLanguageServiceDefaults, IArcadeWorker } from "./types";
+import type { IArcadeWorker } from "./types";
 import type { Diagnostic } from "@arcgis/arcade-languageservice";
+import type { ArcadeLanguageServiceDefaults } from "./arcade-defaults";
 /**
  * Returns the arcade worker for the model uris.
  * @param uris The model uris for which to get the worker.
@@ -25,4 +26,4 @@ export interface IDiagnosticService {
  * @returns The Arcade Language Diagnostic Service.
  */
 export declare function getArcadeDiagnosticService(): IDiagnosticService;
-export declare function setupMode(arcadeDefaults: IArcadeLanguageServiceDefaults): void;
+export declare function setupMode(arcadeDefaults: ArcadeLanguageServiceDefaults): void;

package/dist/types/utils/arcade-monaco/arcade-service-accessors.d.ts

@@ -0,0 +1,31 @@
+import type { IArcadeWorker } from "./types";
+import type { Uri } from "monaco-editor";
+import type * as arcadeModeModule from "./arcade-mode";
+type ArcadeModeType = typeof arcadeModeModule;
+/**
+ * Returns the arcade diagnostic service.
+ * Example:
+ * ```ts
+ * const diagnosticService = await getArcadeDiagnosticService();
+ * diagnosticService.onDidChangeDiagnostics(({uri, diaganostics }) => {
+ *  // Filter the diagnostics for the uri of interest
+ *  // Do something with the diagnostics
+ * });
+ * ```
+ */
+export declare function getArcadeDiagnosticService(): Promise<arcadeModeModule.IDiagnosticService>;
+/**
+ * Returns the arcade worker for the model.
+ * Example:
+ * ```ts
+ * const arcadeWorker = await getArcadeWorker(model.uri);
+ * ```
+ * @returns arcade worker
+ */
+export declare function getArcadeWorker(uri: Uri): Promise<IArcadeWorker>;
+/**
+ * Request the arcade mode
+ * @returns arcade mode module
+ */
+export declare function getMode(): Promise<ArcadeModeType>;
+export {};

package/dist/types/utils/arcade-monaco/arcade-worker-manager.d.ts

@@ -1,5 +1,6 @@
 import type { Uri } from "monaco-editor";
-import type { IArcadeLanguageServiceDefaults, IArcadeWorker } from "./types";
+import type { IArcadeWorker } from "./types";
+import type { ArcadeLanguageServiceDefaults } from "./arcade-defaults";
 /**
  * Manager to create our arcade worker and client proxy
  */
@@ -8,7 +9,7 @@ export declare class WorkerManager {
     private _worker;
     private _client;
     private _configChangeListener;
-    constructor(_defaults: IArcadeLanguageServiceDefaults);
+    constructor(_defaults: ArcadeLanguageServiceDefaults);
     dispose(): void;
     stopWorker(): void;
     private _getClientProxy;

package/dist/types/utils/arcade-monaco/arcade.worker.d.ts

@@ -1,6 +1,6 @@
 import type { worker } from "monaco-editor";
 import type { IArcadeWorker } from "./types";
-import type { ArcadeLanguageServiceSettings, ApiCategory, ApiContext, Diagnostic } from "@arcgis/arcade-languageservice";
+import type { ArcadeLanguageServiceSettings, ApiCategory, Diagnostic, ArcadeApiContext } from "@arcgis/arcade-languageservice";
 import type { CompletionList, Position, TextEdit } from "vscode-languageserver-types";
 interface IArcadeWorkerData {
     languageId: string;
@@ -15,10 +15,10 @@ export declare class ArcadeWorker implements IArcadeWorker {
     private _languageId;
     private _languageService;
     constructor(_ctx: worker.IWorkerContext, { languageId, languageOptions }: IArcadeWorkerData);
-    doValidation(modelId: string, context: ApiContext): Promise<Diagnostic[]>;
-    doComplete(modelId: string, position: Position, context: ApiContext): Promise<CompletionList>;
-    doFormat(modelId: string, context: ApiContext): Promise<TextEdit[]>;
-    getApiLibrary(context: ApiContext): Promise<ApiCategory[]>;
+    doValidation(modelId: string, context: ArcadeApiContext): Promise<Diagnostic[]>;
+    doComplete(modelId: string, position: Position, context: ArcadeApiContext): Promise<CompletionList>;
+    doFormat(modelId: string, context: ArcadeApiContext): Promise<TextEdit[]>;
+    getApiLibrary(context: ArcadeApiContext): Promise<ApiCategory[]>;
     private _getTextDocument;
 }
 export {};