@arcgis/coding-components 4.31.0-next.0 → 4.31.0-next.3

package/dist/types/components.d.ts

@@ -8,30 +8,22 @@ 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.
@@ -160,7 +152,7 @@ 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;
         /**
@@ -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,34 +327,60 @@ 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).
@@ -465,7 +496,7 @@ declare namespace LocalJSX {
          */
         "editorInstance"?: editor.IStandaloneCodeEditor | undefined;
         /**
-          * 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;
         /**
@@ -492,25 +523,72 @@ declare namespace LocalJSX {
          */
         "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;
         };
@@ -21,13 +22,13 @@ export declare class DiagnosticsAdapter {
 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 {};

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

@@ -1,39 +1,10 @@
-import type { Thenable, Uri, IEvent } from "monaco-editor";
-import type { ApiCategory, ArcadeLanguageServiceSettings, ApiContext, Diagnostic } from "@arcgis/arcade-languageservice";
+import type { Thenable, Uri } from "monaco-editor";
+import type { ApiCategory, ArcadeApiContext, Diagnostic } from "@arcgis/arcade-languageservice";
 import type { CompletionList, Position, TextEdit } from "vscode-languageserver-types";
 export interface IArcadeWorker {
-    doValidation: (modelId: string, context: ApiContext) => Thenable<Diagnostic[]>;
-    doComplete: (modelId: string, position: Position, context: ApiContext) => Thenable<CompletionList>;
-    doFormat: (modelId: string, context: ApiContext) => Thenable<TextEdit[]>;
-    getApiLibrary: (context: ApiContext) => Thenable<ApiCategory[]>;
+    doValidation: (modelId: string, context: ArcadeApiContext) => Thenable<Diagnostic[]>;
+    doComplete: (modelId: string, position: Position, context: ArcadeApiContext) => Thenable<CompletionList>;
+    doFormat: (modelId: string, context: ArcadeApiContext) => Thenable<TextEdit[]>;
+    getApiLibrary: (context: ArcadeApiContext) => Thenable<ApiCategory[]>;
 }
 export type IArcadeWorkerAccessor = (...more: Uri[]) => Thenable<IArcadeWorker>;
-/**
- * The Arcade Language Service Defaults interface.
- */
-export interface IArcadeLanguageServiceDefaults {
-    /**
-     * The language id for which the settings are valid.
-     */
-    readonly languageId: string;
-    /**
-     * The language options for the arcade language service.
-     */
-    readonly languageOptions: ArcadeLanguageServiceSettings | null;
-    /**
-     * An event to signal changes to the settings.
-     */
-    readonly onDidChange: IEvent<IArcadeLanguageServiceDefaults>;
-    /**
-     * An event to signal changes to a model context.
-     * The event value is the uri string.
-     */
-    readonly onModelContextDidChange: IEvent<string>;
-    /**
-     * Get the api context for a model.
-     * If the model has no context, then the default context is returned.
-     * @param modelId The model id for which to get the context.
-     * @returns The api context for the model.
-     */
-    getApiContextForModel: (modelId: Uri | string) => ApiContext;
-}