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

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;
-}

package/dist/types/utils/language-defaults-base.d.ts

@@ -0,0 +1,69 @@
+import { Emitter, type IEvent, Uri } from "monaco-editor";
+import type { EditorProfile } from "./profile/editor-profile";
+import type { ApiCategory, ApiContext, ApiSnippet, LanguageServiceSettings } from "@arcgis/arcade-languageservice";
+import type { IEditorProfileDefinition, IPredefinedProfile } from "./profile/types";
+type DefaultLanguageServiceSettings = Pick<LanguageServiceSettings, "assetsPath">;
+export declare abstract class LanguageDefaultsBase<TApiContext extends ApiContext = ApiContext> {
+    protected abstract _languageId: string;
+    protected abstract _languageOptions?: DefaultLanguageServiceSettings;
+    protected _onDidChange: Emitter<this>;
+    protected _profileMap: Map<string, EditorProfile>;
+    protected _apiContextMap: Map<string, TApiContext>;
+    protected _onModelContextDidChange: Emitter<string>;
+    protected _onDidModelContextChangeTimeout: number;
+    protected _fireModelContextDidChange(key: string): void;
+    protected _getApiKey(modelId: Uri | string): string;
+    get onDidChange(): IEvent<this>;
+    get languageOptions(): typeof this._languageOptions | null;
+    /**
+     * Dispose any cached resources for the model
+     */
+    disposeForModel(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): TApiContext;
+    /**
+     * 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: TApiContext): void;
+    get onModelContextDidChange(): IEvent<string>;
+    get languageId(): string;
+    /**
+     * Create an EditorProfile for the given model id using the given definition and locale.
+     * The EditorProfile is used by the the Language service as well by the components.
+     * The definition can be a pre-defined profile or an editor profile definition.
+     * If the locale is not provided then the 'en' locale is used.
+     * @param modelId The model id for which to create the context.
+     * @param definition The definition to use for the model context.
+     * @param locale The locale to use for the model context.
+     * @returns The EditorProfile for the model.
+     */
+    abstract setProfileForModel(modelId: Uri | string, definition: IEditorProfileDefinition | IPredefinedProfile | undefined, apiContext: {
+        locale: string;
+        snippets?: ApiSnippet[];
+    }): Promise<void>;
+    /**
+     * Set or update the language service options.
+     * @param languageOptions The language options to set.
+     */
+    abstract setLanguageOptions(languageOptions: DefaultLanguageServiceSettings): 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.
+     */
+    abstract getApiLibrary(modelId: string): Promise<ApiCategory[]>;
+}
+export {};

package/dist/types/utils/profile/predefined-profile.d.ts

@@ -1,2 +1,4 @@
-import type { IEditorProfileDefinition, IPredefinedProfile } from "./types";
+import type { FeatureDefinition, FeatureSetDefinition, IEditorProfileDefinition, IPredefinedProfile } from "./types";
+export declare function isFeatureDefinition(item: unknown): item is FeatureDefinition;
+export declare function isFeatureSetDefinition(item: unknown): item is FeatureSetDefinition;
 export declare function convertToEditorProfileDefinition(predefinedProfile: IPredefinedProfile, locale?: string): Promise<IEditorProfileDefinition | undefined>;

package/dist/types/utils/profile/types.d.ts

@@ -13,7 +13,7 @@ export interface IEditorProfileDefinition {
     label?: string;
     /**
      * The collection of variables that will be passed to the expression at execution time.
-     * The variable declartions are used to help the editor provide validation and completion.
+     * The variable declarations are used to help the editor provide validation and completion.
      */
     variables: IProfileVariable[];
     /**
@@ -165,12 +165,7 @@ export interface IUrlDefinition {
 /**
  * The most basic way to define a feature or feature set is by passing a collection of fields
  */
-export interface IFieldsDefinition {
-    /**
-     * An array of fields.
-     */
-    fields: __esri.Field[];
-}
+export type IFieldsDefinition = Pick<__esri.FeatureLayer, "fields">;
 /**
  * FeatureDefinition represents various ways a Feature variable could be defined.
  * Layer instance is the most common way to define a feature,
@@ -218,30 +213,15 @@ export type SupportedSource = IFieldsDefinition;
 /**
  * Layer that supports title.
  */
-export interface ITitleCapableSource {
-    /**
-     * The title of the source.
-     */
-    title: string;
-}
+export type ITitleCapableSource = Pick<__esri.Layer, "title">;
 /**
  * Layer that supports url.
  */
-export interface IUrlCapableSource {
-    /**
-     * The url of the source.
-     */
-    url: string;
-}
+export type IUrlCapableSource = Pick<__esri.FeatureLayer, "url">;
 /**
  * Layer that supports layer id.
  */
-export interface ILayerIdCapableSource {
-    /**
-     * The layer id of the source.
-     */
-    layerId: number;
-}
+export type ILayerIdCapableSource = Pick<__esri.FeatureLayer, "layerId">;
 /**
  * Layer that supports queryFeatures
  */
@@ -279,62 +259,39 @@ export interface IDomainsCapableSource {
 /**
  * Layer that implements types
  */
-export interface IFeatureTypesCapableSource extends IDomainsCapableSource {
-    /**
-     * The name of the field holding the type ID or subtypes for the features.
-     */
-    typeIdField: string;
-    /**
-     * An array of subtypes defined in the feature service exposed by ArcGIS REST API.
-     */
-    types: __esri.FeatureType[];
-}
+export type IFeatureTypesCapableSource = IDomainsCapableSource & Pick<__esri.FeatureLayer, "typeIdField" | "types">;
 /**
  * Layer that has a subtype field
  */
-export interface ISubtypeFieldCapableSource extends IDomainsCapableSource {
-    /**
-     * The name of the field which holds the id of the subtypes.
-     */
-    subtypeField: string;
-}
+export type ISubtypeFieldCapableSource = IDomainsCapableSource & Pick<__esri.FeatureLayer, "subtypeField">;
 /**
  * Layer that exposes subtypes.
  */
-export interface ISubtypesCapableSource extends ISubtypeFieldCapableSource {
-    /**
-     * An array of subtypes defined in the layer.
-     */
-    subtypes: __esri.Subtype[];
-}
+export type ISubtypesCapableSource = ISubtypeFieldCapableSource & Pick<__esri.FeatureLayer, "subtypes">;
 /**
  * Layer that supports relationships.
  */
-export interface IRelationshipsCapableSource extends ILayerIdCapableSource {
-    /**
-     * Array of relationships set up for the layer.
-     */
-    relationships: __esri.Relationship[];
-    /**
-     * The absolute URL of the REST endpoint of the layer, non-spatial table or service.
-     */
-    url: string;
-}
+export type IRelationshipsCapableSource = ILayerIdCapableSource & IUrlCapableSource & Pick<__esri.FeatureLayer, "relationships">;
 /**
  * Layer that is capable of being npn-spatial.
  */
-export interface ITableCapableSource {
-    /**
-     * Returns `true` if the layer is loaded from a non-spatial table in a service.
-     */
-    isTable: boolean;
-}
-export interface ILoadableSource {
-    /**
-     * Loads the resources referenced by the layer.
-     */
-    load: (signal?: AbortSignal) => Promise<any>;
-}
+export type ITableCapableSource = Pick<__esri.FeatureLayer, "isTable">;
+/**
+ * An instance that requires a load operation to be performed.
+ */
+export type ILoadableSource = Pick<__esri.Layer, "load">;
+/**
+ * An instance that requires a loadAll operation to be performed.
+ */
+export type ILoadAllCapable = Pick<__esri.WebMap | __esri.WebScene, "loadAll">;
+/**
+ * An instance that is based on a portal item.
+ */
+export type IPortalItemCapable = Pick<__esri.PortalItemResource, "portalItem">;
+/**
+ * An instance that exposes all layers and tables collections.
+ */
+export type IGroupLayerCapable = Pick<__esri.Map, "allLayers" | "allTables">;
 /**
  * Represents a string that will have to be manufactured from a Intl strings resource.
  */
@@ -351,6 +308,9 @@ export interface IIntlString {
      */
     formatValues?: Record<string, string>;
 }
+/**
+ * The bare minimum interface for layer information coming from the rest API.
+ */
 export interface LayerInfo {
     id: number;
     type: string;

package/dist/types/utils/profile/utils.d.ts

@@ -1,12 +1,8 @@
 import type * as types from "./types";
 export declare function isFeatureLayerLikeInstance(item: unknown): item is types.IFeatureLayerLikeInstance;
-export declare function isSubtypeSublayerInstance(item: unknown): item is __esri.SubtypeSublayer;
-export declare function isGroupLayerInstance(item: unknown): item is __esri.GroupLayer;
-export declare function isMapImageLayerInstance(item: unknown): item is __esri.MapImageLayer;
-export declare function isMapInstance(item: unknown): item is __esri.Map | __esri.WebMap | __esri.WebScene;
-export declare function isWebMapInstance(item: __esri.Map | __esri.WebMap | __esri.WebScene): item is __esri.WebMap;
-export declare function isWebSceneInstance(item: __esri.Map | __esri.WebMap | __esri.WebScene): item is __esri.WebScene;
-export declare function isLoadableMapInstance(item: __esri.Map | __esri.WebMap | __esri.WebScene): item is __esri.WebMap | __esri.WebScene;
+export declare function isGroupLayerCapable(item: unknown): item is types.IGroupLayerCapable;
+export declare function isMapInstance(item: unknown): item is __esri.Map;
+export declare function isLoadAllCapable(item: unknown): item is types.ILoadAllCapable;
 export declare function isPortalItemDefinition(item: unknown): item is types.IPortalItemDefinition;
 export declare function isFeatureLayerItemDefinition(item: unknown): item is types.IFeatureLayerItemDefinition;
 export declare function isFieldsDefinition(item: unknown): item is types.IFieldsDefinition;
@@ -23,6 +19,7 @@ export declare function isFeatureTypesCapableLayer(item: unknown): item is types
 export declare function isDomainsCapableLayer(item: unknown): item is types.IDomainsCapableSource;
 export declare function isSubtypeFieldCapableLayer(item: unknown): item is types.ISubtypeFieldCapableSource;
 export declare function isSubtypesCapableLayer(item: unknown): item is types.ISubtypesCapableSource;
+export declare function isPortalItemCapable(item: unknown): item is types.IPortalItemCapable;
 export declare function isRelationshipsCapableLayer(item: unknown): item is types.IRelationshipsCapableSource;
 export declare function isTableCapableLayer(item: unknown): item is types.ITableCapableSource;
 export declare function isLoadableSource(item: unknown): item is types.ILoadableSource;

package/dist/types/utils/sql-expr-monaco/DependentFiles/DateOnly.d.ts

@@ -0,0 +1,41 @@
+import type { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import { ArcadeDate } from "./support";
+import type { Zone } from "luxon";
+import { DateTime } from "luxon";
+export declare function standardiseDateOnlyFormat(format: string): string;
+export declare class DateOnly {
+    protected _year: number;
+    protected _month: number;
+    protected _day: number;
+    private constructor();
+    readonly declaredRootClass: string;
+    get month(): number;
+    get monthJS(): number;
+    get year(): number;
+    get day(): number;
+    get isValid(): boolean;
+    equals(v: any): boolean;
+    clone(): DateOnly;
+    toDateTime(timeZone: Zone | string): DateTime;
+    toDateTimeLuxon(timeZone: Zone | string): DateTime;
+    toString(): string;
+    toFormat(format?: string | null): string;
+    toArcadeDate(): ArcadeDate;
+    toNumber(): number;
+    toJSDate(): Date;
+    toStorageFormat(): string;
+    toSQLValue(): string;
+    toSQLWithKeyword(): string;
+    plus(format: string, amount: number): DateOnly | null;
+    toUTCDateTime(): DateTime;
+    difference(dateonly: DateOnly, format: string): number;
+    static fromMilliseconds(ms: number): DateOnly | null;
+    static fromSeconds(seconds: number): DateOnly | null;
+    static fromReader(v: string | null): DateOnly | null;
+    static fromParts(year: number, month: number, day: number): DateOnly | null;
+    static fromDateJS(date: Date): DateOnly;
+    static fromDateTime(date: DateTime): DateOnly;
+    static fromSqlTimeStampOffset(date: SqlTimeStampOffset): DateOnly;
+    static fromString(datestring: string, format?: string | null): DateOnly | null;
+    static fromNow(timeReferenceZone?: string): DateOnly;
+}

package/dist/types/utils/sql-expr-monaco/DependentFiles/SqlInterval.d.ts

@@ -0,0 +1,16 @@
+import type { IntervalPeriodNode, IntervalQualifierNode } from "./support";
+export declare class SqlInterval {
+    private static _fixDefaults;
+    static _parseSecondsComponent(destination: SqlInterval, seconds: string): void;
+    static createFromMilliseconds(vo: number): SqlInterval;
+    static createFromValueAndQualifer(value: string, qualifier: IntervalPeriodNode | IntervalQualifierNode, op: "-" | "" | "+"): SqlInterval;
+    op: "-" | "+";
+    day: number;
+    second: number;
+    hour: number;
+    month: number;
+    year: number;
+    minute: number;
+    millis: number;
+    valueInMilliseconds(): number;
+}

package/dist/types/utils/sql-expr-monaco/DependentFiles/SqlTimestampOffset.d.ts

@@ -0,0 +1,26 @@
+import { DateTime } from "luxon";
+export declare class SqlTimeStampOffset {
+    private _timeStampOffset;
+    constructor(_timeStampOffset: string);
+    private _date;
+    toDateTime(): DateTime;
+    get isValid(): boolean;
+    get timezoneOffsetHour(): number;
+    get timezoneOffsetMinutes(): number;
+    toMilliseconds(): number;
+    get hour(): number;
+    get minute(): number;
+    get second(): number;
+    get day(): number;
+    get month(): number;
+    get year(): number;
+    startOfDay(): SqlTimeStampOffset;
+    static fromJSDate(value: Date): SqlTimeStampOffset;
+    static fromDateTime(value: DateTime): SqlTimeStampOffset;
+    static fromParts(year: number, month: number, day?: number, hour?: number, minute?: number, second?: number, millisecond?: number, negativeOffset?: boolean, offseth?: number, offsetm?: number): SqlTimeStampOffset;
+    toStorageFormat(): string;
+    toString(): string;
+    toSQLValue(): string;
+    toSQLWithKeyword(): string;
+    addMilliseconds(mills: number): SqlTimeStampOffset;
+}

package/dist/types/utils/sql-expr-monaco/DependentFiles/TimeOnly.d.ts

@@ -0,0 +1,37 @@
+import type { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import { DateTime } from "luxon";
+export declare function standardiseTimeFormat(format: string | null): string;
+/**
+ * TimeOnly: Arcade type for defining a Time value
+ */
+export declare class TimeOnly {
+    protected _hour: number;
+    protected _minute: number;
+    protected _second: number;
+    protected _millisecond: number;
+    constructor(_hour: number, _minute: number, _second: number, _millisecond: number);
+    readonly declaredRootClass: string;
+    get hour(): number;
+    get minute(): number;
+    get second(): number;
+    get millisecond(): number;
+    equals(v: any): boolean;
+    clone(): TimeOnly;
+    isValid(): boolean;
+    toString(): string;
+    toSQLValue(): string;
+    toSQLWithKeyword(): string;
+    toStorageString(): string;
+    toFormat(format?: string | null): string;
+    toNumber(): number;
+    static fromParts(hour: number, minute: number, second: number, millisecond: number): TimeOnly | null;
+    static fromReader(value: string | null): TimeOnly | null;
+    static fromMilliseconds(ms: number): TimeOnly | null;
+    static fromDateJS(date: Date): TimeOnly;
+    static fromDateTime(date: DateTime): TimeOnly;
+    static fromSqlTimeStampOffset(date: SqlTimeStampOffset): TimeOnly;
+    static fromString(timestring: string, format?: string | null): TimeOnly | null;
+    plus(format: string, amount: number): TimeOnly | null;
+    toUTCDateTime(): DateTime;
+    difference(time: TimeOnly, format: string): number;
+}

package/dist/types/utils/sql-expr-monaco/DependentFiles/UnknownTimeZone.d.ts

@@ -0,0 +1,11 @@
+import { IANAZone, Zone, DateTime } from "luxon";
+/**
+ * A zone with a fixed offset (meaning no DST)
+ * @implements {Zone}
+ */
+export declare class UnknownTimeZone {
+    static instance: IANAZone;
+}
+export declare function isUnknownTimeZone(zone: Zone | string): boolean;
+export declare function substituteUnknownTimezone(zone: Zone | string): Zone | string;
+export declare function adoptTimeZone(date: DateTime, zone: Zone): DateTime;

package/dist/types/utils/sql-expr-monaco/DependentFiles/WhereGrammar.d.ts

@@ -0,0 +1,122 @@
+import type { DateTime } from "luxon";
+import type { SQLDates } from "./sqlDateParsingUtils";
+import type { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import type { FileRange } from "../PeggyGrammar/sql92grammar";
+type PeggyLocation = FileRange;
+type WithRange<T> = {
+    [P in keyof T]: T[P];
+} & {
+    range: PeggyLocation;
+};
+export type SQLNode = WithRange<BinaryNode | BoolNode | ColumnNode | CurrentTimeNode | DataTypeNode | DateNode | FunctionNode | IntervalNode | IntervalPeriodNode | IntervalQualifierNode | ListNode | NullNode | NumberNode | ParamNode | SearchedCaseNode | SimpleCaseNode | StringNode | TimeNode | TimeStampNode | UnaryNode | WhenNode>;
+export interface SimpleCaseNode {
+    type: "case-expression";
+    format: "simple";
+    clauses: WithRange<WhenNode>[];
+    operand: SQLNode;
+    else: SQLNode;
+    elseRange: PeggyLocation;
+}
+export interface SearchedCaseNode {
+    type: "case-expression";
+    format: "searched";
+    clauses: WithRange<WhenNode>[];
+    else: SQLNode;
+    elseRange: PeggyLocation;
+}
+export interface WhenNode {
+    type: "when-clause";
+    operand: SQLNode;
+    value: SQLNode;
+}
+export interface ParamNode {
+    type: "parameter";
+    value: "string";
+}
+export interface ListNode {
+    type: "expression-list";
+    value: SQLNode[];
+}
+export interface UnaryNode {
+    type: "unary-expression";
+    expr: SQLNode;
+}
+export interface BinaryNode {
+    type: "binary-expression";
+    operator: BinaryOperator;
+    left: SQLNode;
+    right: SQLNode;
+    escape?: string;
+}
+export interface NullNode {
+    type: "null";
+    value: null;
+}
+export interface BoolNode {
+    type: "boolean";
+    value: boolean;
+}
+export interface StringNode {
+    type: "string";
+    value: string;
+}
+export interface NumberNode {
+    type: "number";
+    value: number;
+}
+export interface DateNode {
+    type: "date";
+    value: string;
+    parsedValue?: SQLDates;
+}
+export interface TimeNode {
+    type: "time";
+    value: string;
+}
+export interface TimeStampNode {
+    type: "timestamp";
+    value: string;
+    withtimezone?: boolean;
+    parsedValue?: DateTime | SqlTimeStampOffset;
+}
+export interface ColumnNode {
+    type: "column-reference";
+    column: string;
+    delimited?: boolean;
+}
+export interface CurrentTimeNode {
+    type: "current-time";
+    mode: "date" | "timestamp";
+}
+export interface IntervalNode {
+    type: "interval";
+    value: WithRange<ParamNode | StringNode>;
+    op: "-" | "" | "+";
+    qualifier: WithRange<IntervalPeriodNode | IntervalQualifierNode>;
+}
+export interface IntervalQualifierNode {
+    type: "interval-qualifier";
+    start: WithRange<IntervalPeriodNode>;
+    end: WithRange<IntervalPeriodNode>;
+}
+export interface IntervalPeriodNode {
+    type: "interval-period";
+    period: "day" | "hour" | "minute" | "month" | "second" | "year";
+    precision: number;
+    secondary: number;
+}
+export interface FunctionNode {
+    type: "function";
+    name: string;
+    args: WithRange<ListNode>;
+}
+export type BinaryOperator = "-" | "*" | "/" | "+" | "<" | "<=" | "<>" | "=" | ">" | ">=" | "||" | "AND" | "BETWEEN" | "IN" | "IS" | "ISNOT" | "LIKE" | "NOT IN" | "NOT LIKE" | "NOTBETWEEN" | "OR";
+export interface DataTypeNode {
+    type: "data-type";
+    value: {
+        type: "date" | "float" | "integer" | "real" | "smallint" | "time" | "timestamp" | "varchar";
+        size?: number;
+        withtimezone?: boolean;
+    };
+}
+export {};

package/dist/types/utils/sql-expr-monaco/DependentFiles/sqlCompareUtils.d.ts

@@ -0,0 +1,5 @@
+export type SqlComparisonOperator = "<" | "<=" | "<>" | "=" | ">" | ">=";
+export declare function isDateTimeComparableValue(dt: any): boolean;
+export declare function isDateOrTimeValue(dt: any): boolean;
+export declare function dateValueInMilliseconds(dt: any): number;
+export declare function sqlCompare(left: any, right: any, operator: SqlComparisonOperator, _defaultTimeZone: string): boolean | null;

package/dist/types/utils/sql-expr-monaco/DependentFiles/sqlDateParsingUtils.d.ts

@@ -0,0 +1,18 @@
+import { DateOnly } from "./DateOnly";
+import { SqlInterval } from "./SqlInterval";
+import { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import { TimeOnly } from "./TimeOnly";
+import { DateTime } from "luxon";
+export type SQLDates = DateOnly | DateTime | SqlTimeStampOffset;
+export declare function convertToExecutingTimeZone(dt: Date, timeReferenceZone: string): DateTime;
+export declare function isNumber(value: any): value is number;
+export declare function isString(value: any): value is string;
+export declare function isSqlInterval(value: any): value is SqlInterval;
+export declare function isDate(v: any): v is Date;
+export declare function isDateTime(v: any): v is DateTime;
+export declare function isDateOnly(v: any): v is DateOnly;
+export declare function isTimeOnly(v: any): v is TimeOnly;
+export declare function isTimestampOffset(v: any): v is SqlTimeStampOffset;
+export declare function parseTime(v: string): TimeOnly;
+export declare function parseTimestamp(v: string, timeReferenceZone: string, _withtimezoneexplicit?: boolean): DateTime | SqlTimeStampOffset;
+export declare function parseDate(v: string, timeReferenceZone: string): SQLDates;

package/dist/types/utils/sql-expr-monaco/DependentFiles/sqlUtils.d.ts

@@ -0,0 +1,6 @@
+import type { IntervalPeriodNode, IntervalQualifierNode } from "./support";
+import { FeatureServiceDatabaseType } from "./support";
+export declare function evaluateNodeToWhereClause(node: any, dbtype: FeatureServiceDatabaseType): string[] | string;
+export declare function translateFunctionToDatabaseSpecific(functionname: string, params: any[], dbtype: FeatureServiceDatabaseType): string;
+export declare function makeToday(justdate: boolean, dbtype: FeatureServiceDatabaseType): string;
+export declare function convertIntervalToSql(value: string, qualifier: IntervalQualifierNode | IntervalPeriodNode, op: "+" | "-" | ""): string;