@arcgis/coding-components 5.0.0-next.136 → 5.0.0-next.138

package/dist/utils/sql-expr-monaco/sql-expr-constants.d.ts

@@ -1,67 +0,0 @@
-import { DataTypeNode } from '@arcgis/core/core/sql/types';
-import { MarkerSeverity, languages } from 'monaco-editor';
-export declare enum ChildBearingProperties {
-    ARGS = "args",
-    CLAUSES = "clauses",
-    ELSE = "else",
-    END = "end",
-    EXPR = "expr",
-    LEFT = "left",
-    OPERAND = "operand",
-    QUALIFIER = "qualifier",
-    RIGHT = "right",
-    START = "start",
-    VALUE = "value"
-}
-export declare const ChildBearingNodeTypes: {
-    readonly CASE_EXPRESSION: "case-expression";
-    readonly EXPRESSION_LIST: "expression-list";
-    readonly FUNCTION: "function";
-    readonly INTERVAL: "interval";
-    readonly INTERVAL_QUALIFIER: "interval-qualifier";
-    readonly WHEN_CLAUSE: "when-clause";
-    readonly UNARY_EXPRESSION: "unary-expression";
-    readonly BINARY_EXPRESSION: "binary-expression";
-};
-export type ChildBearingNodeType = (typeof ChildBearingNodeTypes)[keyof typeof ChildBearingNodeTypes];
-export declare const CHILD_BEARING_PROPERTIES: {
-    readonly "case-expression": readonly [ChildBearingProperties.CLAUSES, ChildBearingProperties.OPERAND, ChildBearingProperties.ELSE];
-    readonly "when-clause": readonly [ChildBearingProperties.OPERAND, ChildBearingProperties.VALUE];
-    readonly "expression-list": readonly [ChildBearingProperties.VALUE];
-    readonly "unary-expression": readonly [ChildBearingProperties.EXPR];
-    readonly "binary-expression": readonly [ChildBearingProperties.LEFT, ChildBearingProperties.RIGHT];
-    readonly function: readonly [ChildBearingProperties.ARGS];
-    readonly interval: readonly [ChildBearingProperties.VALUE, ChildBearingProperties.QUALIFIER];
-    readonly "interval-qualifier": readonly [ChildBearingProperties.START, ChildBearingProperties.END];
-};
-export declare const MarkerType: {
-    Hint: MarkerSeverity.Hint;
-    Info: MarkerSeverity.Info;
-    Warning: MarkerSeverity.Warning;
-    Error: MarkerSeverity.Error;
-};
-export declare const InsertTextRules: {
-    InsertAsSnippet: languages.CompletionItemInsertTextRule.InsertAsSnippet;
-};
-export declare const CompletionItemKind: {
-    Function: languages.CompletionItemKind.Function;
-    Keyword: languages.CompletionItemKind.Keyword;
-    Operator: languages.CompletionItemKind.Operator;
-    Variable: languages.CompletionItemKind.Variable;
-    Field: languages.CompletionItemKind.Field;
-    Reference: languages.CompletionItemKind.Reference;
-};
-type UppercaseUnion<T extends string> = T extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${UppercaseUnion<Rest>}` : T;
-export declare const castDataTypesDict: Record<DataTypeNode["value"]["type"], UppercaseUnion<DataTypeNode["value"]["type"]>>;
-export declare const castDataTypes: UppercaseUnion<DataTypeNode["value"]["type"]>[];
-export declare const datePeriods: string[];
-export declare const extractDateParts: string[];
-export declare const dateLiterals: string[];
-export declare const trimKeywords: string[];
-/** This constant is used to constrain values returned in the peggy parser errors.
- *  If a new keyword is introduced, be sure to update this constant.
- */
-export declare const sqlExprKeywords: string[];
-export declare const sqlExprOperators: string[];
-export declare const sqlExprFunctions: readonly ["CAST", "EXTRACT", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "ABS", "ACOS", "ASIN", "ATAN", "CEILING", "COS", "FLOOR", "LOG", "LOG10", "MOD", "NULLIF", "POWER", "ROUND", "SIGN", "SIN", "TAN", "TRUNCATE", "CHAR_LENGTH", "COALESCE", "CONCAT", "LOWER", "POSITION", "SUBSTRING", "TRIM", "UPPER"];
-export {};

package/dist/utils/sql-expr-monaco/sql-expr-contribution.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/sql-expr-monaco/sql-expr-language-features.d.ts

@@ -1,23 +0,0 @@
-import { editor as Editor, Position, languages } from 'monaco-editor';
-import { SqlExprDefaults } from './sql-expr-defaults';
-import { ISqlExprWorkerAccessor } from './types';
-import { SqlExprDiagnosticService } from './sql-expr-mode';
-export declare class SqlExprCompletionProvider implements languages.CompletionItemProvider {
-    private _worker;
-    private _defaults;
-    constructor(_worker: ISqlExprWorkerAccessor, _defaults: SqlExprDefaults);
-    provideCompletionItems(model: Editor.ITextModel, position: Position): Promise<languages.CompletionList | undefined>;
-}
-export declare class SqlExprDiagnosticsAdapter {
-    private _languageId;
-    private _worker;
-    private _disposables;
-    private _modelListeners;
-    private _diagnosticsService;
-    private _defaults;
-    constructor(_languageId: string, _worker: ISqlExprWorkerAccessor, { defaults, diagnosticService, }: {
-        defaults: SqlExprDefaults;
-        diagnosticService: SqlExprDiagnosticService;
-    });
-    private _doValidate;
-}

package/dist/utils/sql-expr-monaco/sql-expr-language-syntax.d.ts

@@ -1,3 +0,0 @@
-import { languages } from '../monaco-importer';
-export declare const sqlExprLanguageConfig: languages.LanguageConfiguration;
-export declare const sqlExprLanguageSyntax: languages.IMonarchLanguage;

package/dist/utils/sql-expr-monaco/sql-expr-mode.d.ts

@@ -1,43 +0,0 @@
-import { IEvent, Uri, editor } from 'monaco-editor';
-import { ISqlExprWorker } from './types';
-import { SqlExprDefaults } from './sql-expr-defaults';
-/**
- * Returns the sql-expression worker for the model uris.
- * @param uris The model uris for which to get the worker.
- * @returns The sql-expression worker.
- */
-export declare function getSqlExprWorker(...uris: Uri[]): Promise<ISqlExprWorker>;
-export interface ISqlExprDiagnosticEvent {
-    /**
-     * The uri of the model for which the diagnostics changed.
-     */
-    uri: Uri;
-    /**
-     * The diagnostics for the model.
-     */
-    diagnostics: editor.IMarkerData[];
-}
-export interface ISqlExprDiagnosticService {
-    onDiagnosticsChange: IEvent<ISqlExprDiagnosticEvent>;
-}
-declare class SqlExprDiagnosticService implements ISqlExprDiagnosticService {
-    private _onDiagnosticsChange;
-    /**
-     * An event to signal changes to the diagnostics.
-     * The event value is the uri string and the diagnostics.
-     */
-    get onDiagnosticsChange(): IEvent<ISqlExprDiagnosticEvent>;
-    /**
-     * Fires the diagnostics change event.
-     * @param uri The uri of the model for which the diagnostics changed.
-     * @param diagnostics The diagnostics for the model.
-     */
-    fireDiagnosticsChange(uri: Uri, diagnostics: editor.IMarkerData[]): void;
-}
-export type { SqlExprDiagnosticService };
-/**
- *
- * @returns The Sql Expression Diagnostic Service.
- */
-export declare function getSqlExprDiagnosticService(): Promise<ISqlExprDiagnosticService>;
-export declare function setupMode(defaults: SqlExprDefaults): void;

package/dist/utils/sql-expr-monaco/sql-expr-parser-utils.d.ts

@@ -1,36 +0,0 @@
-import { SQLSyntaxError, SQLNode } from '@arcgis/core/core/sql/types';
-import { ChildBearingProperties } from './sql-expr-constants';
-export declare function isSqlSyntaxError(err: unknown): err is SQLSyntaxError;
-export declare function isUnexpectedTokenError(error: SQLSyntaxError): boolean;
-export declare function getExpectedTokens(error: SQLSyntaxError): string[] | undefined;
-export declare function formatSyntaxError(error: SQLSyntaxError): string;
-type ExpectedLiteral = {
-    category: "functions" | "keywords" | "operators";
-    text: string;
-};
-/**
- * parses the error from the parser and returns the expected literals, used to provide suggestions.
- * it will only return literals that do not contain special characters or numbers.
- */
-export declare function getExpectedLiterals(error: SQLSyntaxError): ExpectedLiteral[];
-export declare const callerIndexAt = -2;
-/**
- * returns the slot position of the node in the context root
- * @param node the node we want to find the slot position for
- * @param contextRoot the context root of the node, see {@link identifyContextRoot}
- */
-export declare function getSlotPosition(node: SQLNode, contextRoot: SQLNode): ChildBearingProperties | number;
-/**
- * Identifies the context root of the searchNode in the searchTree. The context root is the first "non-terminal" node within the node's parent context (searchTree).
- * see {@link terminalTypes} for the list of terminal types.
- * @param searchNode the node we want to find the context root for
- * @param searchTree all the nodes contained in the searchNode's parent context
- * @returns The context root of the searchNode
- */
-export declare function identifyContextRoot(searchNode: SQLNode, searchTree: SQLNode[]): SQLNode;
-/**
- * Appends the required number of closing parentheses to the model content.
- * This helps when the parsing fails. We try closing the unclosed parentheses, and resubmit the content for parsing.
- */
-export declare function closeUnclosedDelimiters(modelContent: string): string;
-export {};

package/dist/utils/sql-expr-monaco/sql-expr-profile-utils.d.ts

@@ -1,5 +0,0 @@
-import { ApiProfile, ApiVariable } from '@arcgis/languages-api-utils';
-/**
- * util to retrieve fields from the $layer variable in the api context.
- */
-export declare const getFieldsFromLayerVariable: (profile: ApiProfile) => ApiVariable[];

package/dist/utils/sql-expr-monaco/sql-expr-service-accessors.d.ts

@@ -1,19 +0,0 @@
-import { ISqlExprWorker } from './types';
-import { Uri } from 'monaco-editor';
-import type * as sqlExprModeModule from "./sql-expr-mode";
-type SqlExprModeType = typeof sqlExprModeModule;
-/**
- * Returns the sql-expression worker for the model.
- * Example:
- * ```ts
- * const sqlExpressionWorker = await getSqlExpressionWorker(model.uri);
- * ```
- * @returns sql-expression worker
- */
-export declare function getSqlExprWorker(uri: Uri): Promise<ISqlExprWorker>;
-/**
- * Request the sql-expression mode
- * @returns sql-expression mode module
- */
-export declare function getMode(): Promise<SqlExprModeType>;
-export {};

package/dist/utils/sql-expr-monaco/sql-expr-validation-diagnostic-adapter.d.ts

@@ -1,33 +0,0 @@
-export declare enum ValidationDiagnosticCodes {
-    ExpectedDateTimeValue = "ExpectedDateTimeValue",
-    ExpectedNumericalLiteral = "ExpectedNumericalLiteral",
-    ExpectedToken = "ExpectedToken",
-    FunctionNotSupported = "FunctionNotSupported",
-    IncompatibleListDataType = "IncompatibleListDataType",
-    IncorrectArgumentLength = "IncorrectArgumentLength",
-    IncorrectCastParameters = "IncorrectCastParameters",
-    InvalidDateArithmetic = "InvalidDateArithmetic",
-    IncorrectExtractParameters = "IncorrectExtractParameters",
-    IncorrectSubstringParameters = "IncorrectSubstringParameters",
-    IncorrectTrimParameters = "IncorrectTrimParameters",
-    InvalidElseClause = "InvalidElseClause",
-    InvalidThenClause = "InvalidThenClause",
-    InvalidEndOnWhen = "InvalidEndOnWhen",
-    InvalidTrimCharacter = "InvalidTrimCharacter",
-    MismatchedTypes = "MismatchedTypes",
-    MissingValueInCaseClause = "MissingValueInCaseClause",
-    NotCallable = "NotCallable",
-    TypeNotAssignable = "TypeNotAssignable",
-    UnexpectedEnd = "UnexpectedEnd.",
-    UnexpectedIdentifier = "UnexpectedIdentifier",
-    UnexpectedNumber = "UnexpectedNumber",
-    UnexpectedTextLiteral = "UnexpectedTextLiteral",
-    UnexpectedToken = "UnexpectedToken",
-    UnknownField = "UnknownField",
-    UnsupportedOperator = "UnsupportedOperator",
-    UnsupportedSyntax = "UnsupportedSyntax",
-    InvalidIntervalQualifier = "InvalidIntervalQualifier",
-    EmptyCaseExpression = "EmptyCaseExpression"
-}
-export declare const DiagnosticMessages: Record<ValidationDiagnosticCodes, string>;
-export declare const getDiagnosticMessage: (diagnosticCode: ValidationDiagnosticCodes, replacements?: Record<string, number | string>) => string;

package/dist/utils/sql-expr-monaco/sql-expr-validation-utils.d.ts

@@ -1,82 +0,0 @@
-import { IRange, editor } from 'monaco-editor';
-import { ArcGISFieldType, SqlExpressionLiteral } from './types';
-import { ApiVariable } from '@arcgis/languages-api-utils';
-import { SQLSourceLocation, SQLNode } from '@arcgis/core/core/sql/types';
-export interface ValidationSyntaxContext {
-    token: string;
-    range: IRange;
-    startDelimiter?: boolean;
-    content?: ValidationSyntaxContext[];
-}
-export declare enum TokenType {
-    SINGLE = "SINGLE",
-    EMPTY_FIELD = "EMPTY_FIELD",
-    ERROR = "ERROR",
-    FIELD = "FIELD",
-    KEYWORD_IN = "IN",
-    KEYWORD_NOT_IN = "NOT IN",
-    KEYWORD_BETWEEN = "BETWEEN",
-    KEYWORD_NOT_BETWEEN = "NOT BETWEEN",
-    LIST = "LIST",
-    NEGATION = "NOT",
-    NUMBER = "NUMBER",
-    OPERATOR = "OPERATOR",
-    PARENTHESES = "PARENTHESES",
-    STRING = "STRING",
-    UNKNOWN = "UNKNOWN"
-}
-export declare enum Token {
-    CASE = "CASE",
-    CASE_ELSE = "ELSE",
-    CASE_THEN = "THEN",
-    CASE_WHEN = "WHEN",
-    COMMA = ",",
-    DOUBLE_QUOTE = "\"",
-    EMPTY = "",
-    END = "END",
-    INTERVAL = "INTERVAL",
-    LEFT_PARENTHESES = "(",
-    NEW_LINE = "\n",
-    RIGHT_PARENTHESES = ")",
-    SINGLE_QUOTE = "'",
-    WHITE_SPACE = " "
-}
-export declare enum NodeReturnType {
-    BOOLEAN = "BOOLEAN",
-    DOUBLE = "DOUBLE",
-    EXPRESSION_LIST = "EXPRESSION-LIST",
-    FLOAT = "FLOAT",
-    INTEGER = "INTEGER",
-    NULL = "NULL",
-    NUMBER = "NUMBER",
-    REAL = "REAL",
-    STRING = "STRING",
-    SMALL_INT = "SMALLINT",
-    UNKNOWN_FUNCTION = "UNKNOWN_FUNCTION"
-}
-export declare enum CallableExpressionResponse {
-    FUNCTION = "FUNCTION",
-    EXPRESSION_LIST = "EXPRESSION_LIST",
-    SUCCESS = "SUCCESS",
-    NON_CALLABLE = "NON_CALLABLE"
-}
-export declare const isValidIntervalValue: RegExp;
-export declare const relationalTypes: ReturnType<typeof identifyNodeReturnType>[];
-export declare const qualifiers: TokenType[];
-export declare function convertArcgisTypeToSqlReturnType(arcgisType: ArcGISFieldType): SqlExpressionLiteral;
-export declare const identifyNodeReturnType: (node: SQLNode, fields: ApiVariable[]) => SqlExpressionLiteral | "time-only" | "unknown_function";
-/**
- * Helper function to identify if the given type is able to be used in arithmetic operations
- */
-export declare const isArithmeticType: (type: SqlExpressionLiteral | "time-only" | "unknown_function") => boolean;
-export declare const isNumericType: (type: SqlExpressionLiteral) => boolean;
-/**
- * SQL allows arithmetic operations on intervals combined with dates or numbers.
- */
-export declare const isValidIntervalArithmetic: (leftNode: SQLNode, rightNode: SQLNode, fields: ApiVariable[]) => boolean;
-export declare const isValidNumericArithmetic: (leftNode: SQLNode, rightNode: SQLNode, fields: ApiVariable[]) => boolean;
-export declare const formatListToString: (types: ReturnType<typeof identifyNodeReturnType>[], delimiter: string) => string;
-export declare const formatType: (type: string) => string;
-export declare const getValueFromNode: (node: SQLNode) => number | string;
-export declare const addNewMarker: (message: string, range: IRange | SQLSourceLocation, markers: editor.IMarkerData[], isNodeFormat?: boolean) => void;
-export declare const validateTypeMatch: (node: SQLNode, expectedType: NodeReturnType, markers: editor.IMarkerData[], fields: ApiVariable[]) => void;

package/dist/utils/sql-expr-monaco/sql-expr-validation.d.ts

@@ -1,41 +0,0 @@
-import { editor } from 'monaco-editor';
-import { ApiCategory, ApiContext } from '@arcgis/languages-api-utils';
-import { SQLNode } from '@arcgis/core/core/sql/types.js';
-export declare class SQLExpressionValidation {
-    private callStack;
-    private _sdkFunctions;
-    private _fields;
-    markers: editor.IMarkerData[];
-    constructor(sdkLibrary: ApiCategory[], _apiContext: ApiContext);
-    /**
-     * validates the SQL Expression by generating an AST and traversing it
-     * @param modelContent The SQL Expression to validate
-     */
-    validateModel(modelContent: string): Promise<void>;
-    /**
-     * a DFS traversal of the SQL Expression AST
-     * @param node The node to traverse, start with the root node
-     */
-    traverse(node: SQLNode): void;
-    /**
-     * Validates a nodes syntax and types
-     * @param node The node to validate
-     */
-    private _validateNode;
-    private _handleParserFailure;
-    /**
-     * Formats a node's range into a Monaco IRange object.
-     * @param node
-     */
-    private _getRange;
-    /**
-     * finds the function in the SDK library.
-     * @param name name of the function
-     */
-    private _getFunction;
-    /**
-     * looks at the node and finds any children attached to it. If there are children, it will traverse them.
-     * @param node The current node to traverse
-     */
-    private _traverseChildren;
-}

package/dist/utils/sql-expr-monaco/sql-expr-worker-manager.d.ts

@@ -1,22 +0,0 @@
-import { Uri, editor as Editor } from 'monaco-editor';
-import { ISqlExprWorker } from './types';
-import { SqlExprDefaults } from './sql-expr-defaults';
-/**
- * Manager to create our sql-expression worker and client proxy
- */
-export declare class SqlExprWorkerManager {
-    private _defaults;
-    private _worker;
-    private _client;
-    private _configChangeListener;
-    constructor(_defaults: SqlExprDefaults);
-    dispose(): void;
-    stopWorker(): void;
-    /**
-     * Wait for the worker to be ready.
-     * @returns A promise that resolves when the worker is ready.
-     */
-    static waitForWorker(): Promise<Editor.MonacoWebWorker<ISqlExprWorker>>;
-    private _getClientProxy;
-    getLanguageServiceWorker(...resources: Uri[]): Promise<ISqlExprWorker>;
-}

package/dist/utils/sql-expr-monaco/sql-expr.worker.d.ts

@@ -1,22 +0,0 @@
-import { languages, worker, editor, Position, IRange } from 'monaco-editor';
-import { ISqlExprWorker } from './types';
-import { ApiCategory, ApiContext, ApiDatabase } from '@arcgis/languages-api-utils';
-import { WorkerHost } from '../language-defaults-base';
-interface IWorkerData {
-    languageId: string;
-}
-/**
- * The ArcGIS SQL Expression Web Worker is proxied by the Monaco worker server.
- */
-export declare class SqlExprWorker implements ISqlExprWorker {
-    private _ctx;
-    private _languageId;
-    private _apiService;
-    constructor(_ctx: worker.IWorkerContext<WorkerHost>, { languageId }: IWorkerData);
-    doValidation(modelId: string, context: ApiContext): Promise<editor.IMarkerData[]>;
-    doComplete(modelId: string, range: IRange, position: Position, context: ApiContext): Promise<languages.CompletionList>;
-    getApiLibrary(context: ApiContext): Promise<ApiCategory[]>;
-    getApiDatabase(context: ApiContext): Promise<ApiDatabase>;
-    private _getTextDocument;
-}
-export {};

package/dist/utils/sql-expr-monaco/sql-expression-profile-strategy.d.ts

@@ -1,13 +0,0 @@
-import { EditorProfile } from '../profile/editor-profile';
-import { ApiProfile } from '@arcgis/languages-api-utils';
-import { IPredefinedProfile, IEditorProfileDefinition } from '../profile/types';
-/**
- * Converts an editor profile to an api profile.
- * The api profile is an optimized version of the editor profile designed for minimal data transfer between the main thread and the worker.
- */
-export declare const sqlExprEditorToApiProfile: (editorProfile: EditorProfile) => ApiProfile;
-/**
- * converts a predefined editor profile to a IEditorProfileDefinition.
- * This is used to hydrate a profile definition from a predefined profile.
- */
-export declare function convertToEditorProfileDefinition(predefinedProfile: IPredefinedProfile): IEditorProfileDefinition | undefined;

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

@@ -1,96 +0,0 @@
-import { Thenable, Uri, languages, editor, IRange, Position as MonacoPosition, Position } from 'monaco-editor';
-import { ApiCategory, ApiContext } from '@arcgis/languages-api-utils';
-import { SQLNode, DataTypeNode, BinaryNode } from '@arcgis/core/core/sql/types';
-import { default as Field } from '@arcgis/core/layers/support/Field';
-export interface ISqlExprWorker {
-    doValidation: (modelId: string, context: ApiContext) => Thenable<editor.IMarkerData[]>;
-    doComplete: (modelId: string, range: IRange, position: Position, context: ApiContext) => Thenable<languages.CompletionList>;
-    getApiLibrary: (context: ApiContext) => Thenable<ApiCategory[]>;
-}
-export type ISqlExprWorkerAccessor = (...more: Uri[]) => Thenable<ISqlExprWorker>;
-export interface ApiContextType {
-    description: string;
-    parameters: {
-        name: string;
-        type: string[] | string;
-        description: string;
-    }[];
-    returnValue: string[] | string;
-    examples: {
-        code: string;
-        description: string;
-    }[];
-    snippet: string[] | string;
-    name: string;
-    bundle: string;
-}
-export interface ICompletionContext {
-    range: IRange;
-    modelContent: string;
-    position: MonacoPosition;
-    lowestNode: SQLNode | undefined;
-    subTree: SQLNode[];
-    completionItems: languages.CompletionItem[];
-}
-/**
- * SQL Expression Literal. These are the types that occur within nodes of the AST generated by the peggy parser.
- **/
-export type SqlExpressionLiteral = 
-/**
- * "date"
- * "float"
- * "integer"
- * "real"
- * "smallint"
- * "time"
- * "timestamp"
- * "varchar"
- */
-DataTypeNode["value"]["type"]
-/**
- * "binary-expression"
- * "boolean"
- * "case-expression"
- * "column-reference"
- * "current-time"
- * "data-type"
- * "date"
- * "expression-list"
- * "function"
- * "interval"
- * "interval-period"
- * "interval-qualifier"
- * "null"
- * "number"
- * "parameter"
- * "string"
- * "time"
- * "timestamp"
- * "unary-expression"
- * "when-clause"
- */
- | SQLNode["type"];
-export type NodeReturnType = SqlExpressionLiteral | "time-only" | "unknown_function";
-export type ArcGISFieldType = 
-/**
- * "string"
- * "date"
- * "integer"
- * "small-integer"
- * "big-integer"
- * "single"
- * "double"
- * "long"
- * "date-only"
- * "time-only"
- * "timestamp-offset"
- * "oid"
- * "geometry"
- * "blob"
- * "raster"
- * "guid"
- * "global-id"
- * "xml"
- */
-Field["type"];
-export type SqlExpOperator = BinaryNode["operator"];

package/dist/utils/utilities.d.ts

@@ -1,16 +0,0 @@
-import { editor } from 'monaco-editor';
-import { default as PortalItem } from '@arcgis/core/portal/PortalItem';
-type KeysOfType<T, U> = {
-    [P in keyof T]: T[P] extends U ? P : never;
-}[keyof T];
-/**
- * Filters a collection of items by the given keys and filter word.
- */
-export declare function filterCollection<T, U extends KeysOfType<T, string | undefined>>(collection: T[], keys: U | U[], filterWord: string, beforeFilteringFn?: (item: T) => boolean | undefined): T[];
-/**
- * Returns the url to the portal item.
- */
-export declare function portalItemPageUrl(portalItem: PortalItem | null | undefined): string;
-export declare function editModel(editorInstance: editor.IStandaloneCodeEditor | undefined, script: string, insertMode?: "add" | "replace", disclaimer?: string): void;
-export declare function formatResult(script: string): string;
-export {};