@compas-oscd/open-scd 0.34.1 → 0.34.3

package/dist/foundation/dai.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Determine which part of the Template Structure still needs to be initialized.
+ * With the first call the parent will normally be the LN(0) Element to start from.
+ * It will use the list to pop the first element and look if there is a DOI/SDI/DAI
+ * Element available with the same name.
+ *
+ * @param parentElement     - The element to search from for a DOI/SDI/DAI
+ * @param templateStructure - The templates structure with DO/DA/BDA Elements.
+ * @returns The last element initialized element or LN(0) if nothing is initialized. This Element can be used to
+ *          add the new element to. And the list of Template Elements that still need to be initialized.
+ */
+export declare function determineUninitializedStructure(parentElement: Element, templateStructure: Element[]): [Element, Element[]];
+/**
+ * Create a new instance structure defined by the array of template elements passed.
+ *
+ * @param uninitializedTemplateStructure - The Array of Template Elements for which new instance elements need to be
+ * created.
+ * @returns The Element created from the last Template Element in the Array.
+ */
+export declare function initializeElements(uninitializedTemplateStructure: Element[]): Element;
+/**
+ * Use the path configuration of a Common Data Class to search for all DO/SDO/DA/BDA Elements to create
+ * a structure for which DOI/SDI/DAI Elements should be created later. Null will be returned when an invalid
+ * Template Structure is described by the path.
+ *
+ * @param lnElement - The LN Element to use for searching the starting DO Element.
+ * @param path    - The (S)DO/(B)DA Elements to find in the template structure.
+ * @returns List of Elements starting with the DO Element followed by one or more SDO or (B)DA Elements describing the structure.
+ */
+export declare function createTemplateStructure(lnElement: Element, path: string[]): Element[] | null;

package/dist/foundation/generators.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param doc - project xml document
+ * @param serviceType - SampledValueControl (SMV) or GSEControl (GSE)
+ * @returns a function generating increasing unused `MAC-Address` within `doc` on subsequent invocations
+ */
+export declare function mACAddressGenerator(doc: XMLDocument, serviceType: 'SMV' | 'GSE'): () => string;
+/**
+ * @param doc - project xml document
+ * @param serviceType - SampledValueControl (SMV) or GSEControl (GSE)
+ * @param type1A - whether the GOOSE is a Trip GOOSE resulting in different APPID range - default false
+ * @returns a function generating increasing unused `APPID` within `doc` on subsequent invocations
+ */
+export declare function appIdGenerator(doc: XMLDocument, serviceType: 'SMV' | 'GSE', type1A?: boolean): () => string;

package/dist/foundation/ied.d.ts

@@ -0,0 +1,22 @@
+import { Delete } from '@openscd/core/foundation/deprecated/editor.js';
+/**
+ * Get all the FCDA attributes containing values from a specific element.
+ *
+ * @param elementContainingFcdaReferences - The element to use
+ * @returns FCDA references
+ */
+export declare function getFcdaReferences(elementContainingFcdaReferences: Element): string;
+/**
+ * Get all the Control attributes containing values from a specific element.
+ *
+ * @param extRef - The element to use
+ * @returns Control references
+ */
+export declare function getControlReferences(extRef: Element): string;
+/**
+ * Creating Delete actions in case Inputs elements are empty.
+ *
+ * @param extRefDeleteActions - All Delete actions for ExtRefs.
+ * @returns Possible delete actions for empty Inputs elements.
+ */
+export declare function emptyInputsDeleteActions(extRefDeleteActions: Delete[]): Delete[];

package/dist/foundation/nsd.d.ts

@@ -0,0 +1,4 @@
+export declare const iec6185074: Promise<Document>;
+export declare const iec6185073: Promise<Document>;
+export declare const iec6185072: Promise<Document>;
+export declare const iec6185081: Promise<Document>;

package/dist/foundation/nsdoc.d.ts

@@ -0,0 +1,14 @@
+export interface Nsdoc {
+    nsdoc72?: XMLDocument;
+    nsdoc73?: XMLDocument;
+    nsdoc74?: XMLDocument;
+    nsdoc81?: XMLDocument;
+    getDataDescription: (element: Element, ancestors?: Element[]) => {
+        label: string;
+    };
+}
+/**
+ * Initialize the full Nsdoc object.
+ * @returns A fully initialized Nsdoc object for wizards/editors to use.
+ */
+export declare function initializeNsdoc(): Nsdoc;

package/dist/foundation/scl.d.ts

@@ -0,0 +1 @@
+export declare function existFcdaReference(fcda: Element, ied: Element): boolean;

package/dist/foundation.d.ts

@@ -0,0 +1,230 @@
+import { LitElement, TemplateResult } from 'lit-element';
+import { Part } from 'lit-html';
+import { List } from '@material/mwc-list';
+import { Select } from '@material/mwc-select';
+import { TextField } from '@material/mwc-textfield';
+import AceEditor from 'ace-custom-element';
+import { WizardTextField } from './wizard-textfield.js';
+import { WizardSelect } from './wizard-select.js';
+import { EditorAction } from '@openscd/core/foundation/deprecated/editor.js';
+export declare const wizardInputSelector = "wizard-textfield, mwc-textfield, ace-editor, mwc-select, wizard-select, wizard-checkbox";
+export type WizardInputElement = WizardTextField | TextField | (AceEditor & {
+    checkValidity: () => boolean;
+    validityTransform: (newValue: string, nativeValidity: ValidityState) => ValidityState;
+    validationMessage: string;
+    validity: ValidityState;
+    label: string;
+    requestUpdate(name?: PropertyKey, oldValue?: unknown): Promise<unknown>;
+}) | Select | WizardSelect;
+export type WizardAction = EditorAction | WizardFactory;
+/** @returns [[`EditorAction`]]s to dispatch on [[`WizardDialog`]] commit. */
+export type WizardActor = (inputs: WizardInputElement[], wizard: Element, list?: List | null) => WizardAction[];
+export declare function isWizardFactory(maybeFactory: WizardAction | Wizard | null): maybeFactory is WizardFactory;
+/** @returns the validity of `input` depending on type. */
+export declare function checkValidity(input: WizardInputElement): boolean;
+/** reports the validity of `input` depending on type. */
+export declare function reportValidity(input: WizardInputElement): boolean;
+/** @returns the `value` or `maybeValue` of `input` depending on type. */
+export declare function getValue(input: WizardInputElement): string | null;
+/** @returns the `multiplier` of `input` if available. */
+export declare function getMultiplier(input: WizardInputElement): string | null;
+/** Inputs as `TextField`, `Select` or `Checkbox `used in`wizard-dialog` */
+export type WizardInput = WizardInputTextField | WizardInputSelect | WizardInputCheckbox;
+interface WizardInputBase {
+    /** maps attribute key */
+    label: string;
+    /** maps attribute value */
+    maybeValue: string | null;
+    /** whether attribute is optional */
+    nullable?: boolean;
+    /** whether the input shall be disabled */
+    disabled?: boolean;
+    /** helper text */
+    helper?: string;
+    /** initial focused element in `wizard-dialog` (once per dialog) */
+    dialogInitialFocus?: boolean;
+}
+interface WizardInputTextField extends WizardInputBase {
+    kind: 'TextField';
+    /** wether the input might be empty string */
+    required?: boolean;
+    /** pattern definition from schema */
+    pattern?: string;
+    /** minimal characters allowed */
+    minLength?: number;
+    /** maximal characters allowed */
+    maxLength?: number;
+    /** message text explaining invalid inputs */
+    validationMessage?: string;
+    /** suffix definition - overwrites unit multiplier definition */
+    suffix?: string;
+    /** SI unit for specific suffix definition */
+    unit?: string;
+    /** in comibination with unit defines specific suffix */
+    multiplier?: string | null;
+    /** array of multipliers allowed for the input */
+    multipliers?: (string | null)[];
+    /** used for specific input type e.g. number */
+    type?: string;
+    /** minimal valid number in combination with type number */
+    min?: number;
+    /** maximal valid number in combination with type number */
+    max?: number;
+    /** value displaxed when input is nulled */
+    default?: string;
+}
+interface WizardInputSelect extends WizardInputBase {
+    kind: 'Select';
+    /** selectabled values */
+    values: string[];
+    /** value displayed with input is nulled */
+    default?: string;
+    /** message explaining invalid inputs */
+    valadationMessage?: string;
+}
+interface WizardInputCheckbox extends WizardInputBase {
+    kind: 'Checkbox';
+    /** wether checkbox is checked with nulled input */
+    default?: boolean;
+}
+/** @returns [[`WizardAction`]]s to dispatch on [[`WizardDialog`]] menu action. */
+export type WizardMenuActor = (wizard: Element) => void;
+/** User interactions rendered in the wizard-dialog menu */
+export interface MenuAction {
+    label: string;
+    icon?: string;
+    action: WizardMenuActor;
+}
+/** Represents a page of a wizard dialog */
+export interface WizardPage {
+    title: string;
+    content?: (TemplateResult | WizardInput)[];
+    primary?: {
+        icon: string;
+        label: string;
+        action: WizardActor;
+        auto?: boolean;
+    };
+    secondary?: {
+        icon: string;
+        label: string;
+        action: WizardActor;
+    };
+    initial?: boolean;
+    element?: Element;
+    menuActions?: MenuAction[];
+}
+export type Wizard = WizardPage[];
+export type WizardFactory = () => Wizard;
+/** If `wizard === null`, close the current wizard, else queue `wizard`. */
+export interface WizardDetail {
+    wizard: WizardFactory | null;
+    subwizard?: boolean;
+}
+export type WizardEvent = CustomEvent<WizardDetail>;
+export declare function newWizardEvent(wizardOrFactory?: Wizard | WizardFactory, eventInitDict?: CustomEventInit<Partial<WizardDetail>>): WizardEvent;
+export declare function newSubWizardEvent(wizardOrFactory?: Wizard | WizardFactory): WizardEvent;
+/** @returns a reference to `element` with segments delimited by '/'. */
+export declare function referencePath(element: Element): string;
+export type SclEdition = '2003' | '2007B' | '2007B4';
+export declare function getSclSchemaVersion(doc: Document): SclEdition;
+/**
+ * Extract the 'name' attribute from the given XML element.
+ * @param element - The element to extract name from.
+ * @returns the name, or undefined if there is no name.
+ */
+export declare function getNameAttribute(element: Element): string | undefined;
+/**
+ * Extract the 'ldName' attribute from the given XML element.
+ * @param element - The element to extract ldName from.
+ * @returns the ldName, or undefined if there is no ldName.
+ */
+export declare function getLdNameAttribute(element: Element): string | undefined;
+/**
+ * Extract the 'desc' attribute from the given XML element.
+ * @param element - The element to extract description from.
+ * @returns the name, or undefined if there is no description.
+ */
+export declare function getDescriptionAttribute(element: Element): string | undefined;
+/**
+ * Extract the 'pathName' attribute from the given XML element.
+ * @param element - The element to extract path name from.
+ * @returns the name, or undefined if there is no path name.
+ */
+export declare function getPathNameAttribute(element: Element): string | undefined;
+/**
+ * Extract the 'inst' attribute from the given XML element.
+ * @param element - The element to extract instance from.
+ * @returns the instance, or undefined if there is no instance.
+ */
+export declare function getInstanceAttribute(element: Element): string | undefined;
+export declare function pathParts(identity: string): [string, string];
+type IdentityFunction = (e: Element) => string | number;
+type SelectorFunction = (tagName: SCLTag, identity: string) => string;
+declare const sCLTags: readonly ["SCL", "SubNetwork", "GOOSESecurity", "SMVSecurity", "ConnectivityNode", "SubFunction", "Function", "TapChanger", "SubEquipment", "GeneralEquipment", "PowerTransformer", "TransformerWinding", "ConductingEquipment", "Substation", "VoltageLevel", "Bay", "Process", "Line", "EqSubFunction", "EqFunction", "ConnectedAP", "PhysConn", "SDO", "DO", "DAI", "SDI", "DOI", "Inputs", "RptEnabled", "Server", "ServerAt", "SettingControl", "Communication", "Log", "LDevice", "DataSet", "AccessPoint", "IED", "NeutralPoint", "SampledValueControl", "GSEControl", "LogControl", "ReportControl", "GSE", "SMV", "BDA", "DA", "LNodeType", "DOType", "DAType", "EnumType", "Text", "Private", "Hitem", "AccessControl", "Header", "LNode", "Val", "Voltage", "Services", "Subject", "IssuerName", "MinTime", "MaxTime", "Association", "FCDA", "ClientLN", "IEDName", "ExtRef", "Protocol", "LN0", "LN", "FileHandling", "TimeSyncProt", "CommProt", "SGEdit", "ConfSG", "GetDirectory", "GetDataObjectDefinition", "DataObjectDirectory", "GetDataSetValue", "SetDataSetValue", "DataSetDirectory", "ReadWrite", "TimerActivatedControl", "GetCBValues", "GSEDir", "ConfLdName", "DynAssociation", "SettingGroups", "GSSE", "GOOSE", "ConfReportControl", "SMVsc", "DynDataSet", "ConfDataSet", "ConfLogControl", "ConfSigRef", "ReportSettings", "LogSettings", "GSESettings", "SMVSettings", "ConfLNs", "ClientServices", "SupSubscription", "ValueHandling", "RedProt", "McSecurity", "KDC", "Address", "P", "ProtNs", "EnumVal", "Terminal", "BitRate", "Authentication", "DataTypeTemplates", "History", "OptFields", "SmvOpts", "TrgOps", "SamplesPerSec", "SmpRate", "SecPerSamples"];
+export type SCLTag = (typeof sCLTags)[number];
+export declare const tags: Record<SCLTag, {
+    identity: IdentityFunction;
+    selector: SelectorFunction;
+    parents: SCLTag[];
+    children: SCLTag[];
+}>;
+export declare function getReference(parent: Element, tag: SCLTag): Element | null;
+export declare function find(root: XMLDocument | Element | DocumentFragment, tagName: string, identity: string | number): Element | null;
+/** @returns a string uniquely identifying `e` in its document, or NaN if `e`
+ * is unidentifiable. */
+export declare function identity(e: Element | null): string | number;
+/** @returns whether `a` and `b` are considered identical by IEC-61850 */
+export declare function isSame(a: Element, b: Element): boolean;
+export declare function isEqual(a: Element, b: Element): boolean;
+/** A directive rendering its argument `rendered` only if `rendered !== {}`. */
+export declare const ifImplemented: (rendered: any) => (part: Part) => void;
+/** Constructor type for defining `LitElement` mixins. */
+export type LitElementConstructor = new (...args: any[]) => LitElement;
+/** The type returned by `MyMixin(...)` is `Mixin<typeof MyMixin>`. */
+export type Mixin<T extends (...args: any[]) => any> = InstanceType<ReturnType<T>>;
+export declare const patterns: {
+    string: string;
+    normalizedString: string;
+    name: string;
+    nmToken: string;
+    names: string;
+    nmTokens: string;
+    decimal: string;
+    unsigned: string;
+    integer: string;
+    alphanumericFirstUpperCase: string;
+    alphanumericFirstLowerCase: string;
+    lnClass: string;
+};
+/** Sorts selected `ListItem`s to the top and disabled ones to the bottom. */
+export declare function compareNames(a: Element | string, b: Element | string): number;
+/** @returns the cartesian product of `arrays` */
+export declare function crossProduct<T>(...arrays: T[][]): T[][];
+/** @returns the depth of `t` if it is an object or array, zero otherwise. */
+export declare function depth(t: Record<string, unknown>, mem?: WeakSet<object>): number;
+export declare function findFCDAs(extRef: Element): Element[];
+export declare function findControlBlocks(extRef: Element): Set<Element>;
+export declare function isPublic(element: Element): boolean;
+/** @returns the version of the SCL project */
+export declare function getVersion(element: Element): string;
+/**
+ * @param parent - The LNodes' parent element to be scanned once for `lnInst`
+ * values already in use. Be sure to create a new generator every time the
+ * children of this element change.
+ * @returns a function generating increasing unused `lnInst` values for
+ * `lnClass` LNodes within `parent` on subsequent invocations
+ */
+export declare function newLnInstGenerator(parent: Element): (lnClass: string) => string | undefined;
+/**
+ * @param lnElements - The LN elements to be scanned for `inst`
+ * values already in use.
+ * @returns first available inst value for LN or undefined if no inst is available
+ */
+export declare function minAvailableLogicalNodeInstance(lnElements: Element[]): string | undefined;
+declare global {
+    interface ElementEventMap {
+        ['wizard']: WizardEvent;
+    }
+}
+export {};

package/dist/icons/compare.d.ts

@@ -0,0 +1,3 @@
+export declare const elementIcon: import("lit-html").SVGTemplateResult;
+export declare const attributeIcon: import("lit-html").SVGTemplateResult;
+export declare const contentIcon: import("lit-html").SVGTemplateResult;

package/dist/icons/icons.d.ts

@@ -0,0 +1,41 @@
+import { SVGTemplateResult, TemplateResult } from 'lit-element';
+export type iconType = 'action' | 'dAIcon' | 'dOIcon' | 'enumIcon' | 'info' | 'warning' | 'error' | 'reset' | 'reportIcon' | 'smvIcon' | 'gooseIcon' | 'lNIcon' | 'logIcon';
+export declare const editIcon: TemplateResult;
+export declare const gooseIcon: SVGTemplateResult;
+export declare const reportIcon: SVGTemplateResult;
+export declare const smvIcon: SVGTemplateResult;
+export declare const logIcon: SVGTemplateResult;
+export declare const controlBlockIcons: Partial<Record<string, SVGTemplateResult>>;
+export declare const inputIcon: SVGTemplateResult;
+export declare const clientIcon: SVGTemplateResult;
+export declare const disconnect: SVGTemplateResult;
+export type iconProperty = {
+    width: number;
+    height: number;
+};
+export declare const iconProperties: Partial<Record<iconType, iconProperty>>;
+export declare const dataTypeTemplateIcons: Partial<Record<string, SVGTemplateResult>>;
+export declare const iconColors: {
+    [key: string]: string;
+};
+export declare function getIcon(type: iconType): TemplateResult;
+export declare function getFilterIcon(type: iconType, state: boolean): TemplateResult;
+export declare const networkConfigIcon: TemplateResult;
+export declare const zeroLineIcon: TemplateResult;
+export declare const voltageLevelIcon: TemplateResult;
+export declare const bayIcon: TemplateResult;
+export declare const disconnectorIcon: TemplateResult;
+export declare const circuitBreakerIcon: TemplateResult;
+export declare const currentTransformerIcon: TemplateResult;
+export declare const voltageTransformerIcon: TemplateResult;
+export declare const earthSwitchIcon: TemplateResult;
+export declare const generalConductingEquipmentIcon: TemplateResult;
+export declare const connectivityNodeIcon: TemplateResult;
+export declare const powerTransformerTwoWindingIcon: TemplateResult;
+export declare const openSCDIcon: TemplateResult;
+export declare const sizableSmvIcon: SVGTemplateResult;
+export declare const sizableGooseIcon: SVGTemplateResult;
+export declare const substationIcon: SVGTemplateResult;
+export declare const lineIcon: SVGTemplateResult;
+export declare const processIcon: SVGTemplateResult;
+export declare const transformerWindingIcon: SVGTemplateResult;

package/dist/icons/ied-icons.d.ts

@@ -0,0 +1,3 @@
+export declare const accessPointIcon: import("lit-element").SVGTemplateResult;
+export declare const serverIcon: import("lit-element").SVGTemplateResult;
+export declare const logicalDeviceIcon: import("lit-element").SVGTemplateResult;

package/dist/icons/lnode.d.ts

@@ -0,0 +1,16 @@
+export declare const systemLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const automationLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const controlLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const functionalLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const generalLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const interfacingLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const nonElectricalLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const measurementLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const protectionLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const qualityLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const protectionRelatedLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const supervisionLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const transformerLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const switchgearLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const powerTransformerLogicalNode: import("lit-element").SVGTemplateResult;
+export declare const furtherPowerSystemEquipmentLogicalNode: import("lit-element").SVGTemplateResult;

package/dist/open-scd.d.ts

@@ -0,0 +1,131 @@
+import { LitElement, TemplateResult } from 'lit-element';
+import '@material/mwc-icon';
+import '@material/mwc-icon-button';
+import '@material/mwc-linear-progress';
+import '@material/mwc-list';
+import '@material/mwc-list/mwc-list-item';
+import '@material/mwc-tab';
+import '@material/mwc-tab-bar';
+import '@material/mwc-top-app-bar-fixed';
+import '@material/mwc-drawer';
+import '@material/mwc-button';
+import '@material/mwc-dialog';
+import '@material/mwc-formfield';
+import '@material/mwc-list/mwc-check-list-item';
+import '@material/mwc-list/mwc-radio-list-item';
+import '@material/mwc-select';
+import '@material/mwc-switch';
+import '@material/mwc-textfield';
+import './addons/Settings.js';
+import './addons/Waiter.js';
+import './addons/Wizards.js';
+import './addons/Editor.js';
+import './addons/History.js';
+import './addons/Layout.js';
+import { ActionDetail } from '@material/mwc-list';
+import { Nsdoc } from './foundation/nsdoc.js';
+import type { PluginSet, Plugin as CorePlugin } from '@openscd/core';
+import { XMLEditor } from '@openscd/core';
+import { MenuPosition, PluginKind, Plugin } from "./plugin.js";
+import { ConfigurePluginEvent } from './plugin.events.js';
+/** The `<open-scd>` custom element is the main entry point of the
+ * Open Substation Configuration Designer. */
+export declare class OpenSCD extends LitElement {
+    render(): TemplateResult;
+    doc: XMLDocument | null;
+    /** The name of the current [[`doc`]] */
+    docName: string;
+    /** The UUID of the current [[`doc`]] */
+    docId: string;
+    editor: XMLEditor;
+    /** Object containing all *.nsdoc files and a function extracting element's label form them*/
+    nsdoc: Nsdoc;
+    private currentSrc;
+    /** The current file's URL. `blob:` URLs are *revoked after parsing*! */
+    get src(): string;
+    set src(value: string);
+    private storedPlugins;
+    private editCount;
+    private unsubscribers;
+    /** Loads and parses an `XMLDocument` after [[`src`]] has changed. */
+    private loadDoc;
+    /**
+     *
+     * @deprecated Use `handleConfigurationPluginEvent` instead
+     */
+    handleAddExternalPlugin(e: AddExternalPluginEvent): void;
+    handleConfigurationPluginEvent(e: ConfigurePluginEvent): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     *
+     * @param name
+     * @param kind
+     * @returns the index of the plugin in the stored plugin list
+     */
+    private findPluginIndex;
+    private hasPlugin;
+    private removePlugin;
+    private addPlugin;
+    /**
+     *
+     * @param plugin
+     * @throws if the plugin is not found
+     */
+    private changePlugin;
+    private resetPlugins;
+    /**
+     * @prop {PluginSet} plugins - Set of plugins that are used by OpenSCD
+     */
+    plugins: PluginSet;
+    get parsedPlugins(): Plugin[];
+    private updateStoredPlugins;
+    private storePlugins;
+    private getPluginConfigsFromLocalStorage;
+    protected get locale(): string;
+    get docs(): Record<string, XMLDocument>;
+    private setPlugins;
+    private loadPlugins;
+    private addExternalPlugin;
+    protected getBuiltInPlugins(): CorePlugin[];
+    private addContent;
+    private loadedPlugins;
+    private pluginTags;
+    private pluginTag;
+}
+declare global {
+    interface ElementEventMap {
+        'reset-plugins': CustomEvent;
+        'add-external-plugin': CustomEvent<AddExternalPluginDetail>;
+        'set-plugins': CustomEvent<SetPluginsDetail>;
+    }
+}
+export interface MenuItem {
+    icon: string;
+    name: string;
+    src?: string;
+    hint?: string;
+    actionItem?: boolean;
+    action?: (event: CustomEvent<ActionDetail>) => void;
+    disabled?: () => boolean;
+    content: () => TemplateResult;
+    kind: string;
+}
+export interface Validator {
+    validate: () => Promise<void>;
+}
+export interface MenuPlugin {
+    run: () => Promise<void>;
+}
+export declare function newResetPluginsEvent(): CustomEvent;
+export interface AddExternalPluginDetail {
+    plugin: Omit<Plugin, 'content'>;
+}
+export type AddExternalPluginEvent = CustomEvent<AddExternalPluginDetail>;
+export declare function newAddExternalPluginEvent(plugin: Omit<Plugin, 'content'>): AddExternalPluginEvent;
+export interface SetPluginsDetail {
+    selectedPlugins: Plugin[];
+}
+export type SetPluginsEvent = CustomEvent<SetPluginsDetail>;
+export declare function newSetPluginsEvent(selectedPlugins: Plugin[]): SetPluginsEvent;
+export declare const pluginIcons: Record<PluginKind | MenuPosition, string>;

package/dist/oscd-filter-button.d.ts

@@ -0,0 +1,27 @@
+import { TemplateResult } from 'lit-element';
+import '@material/mwc-icon-button';
+import '@material/mwc-dialog';
+import './filtered-list.js';
+import { FilteredList } from './filtered-list.js';
+/**
+ * A mwc-list with mwc-textfield that filters the list items for given or separated terms
+ */
+export declare class FilterButton extends FilteredList {
+    header: TemplateResult | string;
+    icon: string;
+    disabled: boolean;
+    private filterDialog;
+    private toggleList;
+    private onClosing;
+    render(): TemplateResult;
+    static styles: import("lit-element").CSSResult;
+}
+export interface SelectedItemsChangedDetail {
+    selectedItems: string[];
+}
+export type SelectedItemsChangedEvent = CustomEvent<SelectedItemsChangedDetail>;
+declare global {
+    interface ElementEventMap {
+        ['selected-items-changed']: SelectedItemsChangedEvent;
+    }
+}

package/dist/plain-compare-list.d.ts

@@ -0,0 +1,36 @@
+import { LitElement, TemplateResult } from 'lit-element';
+import { DiffFilter } from './foundation/compare.js';
+export declare class PlainCompareList extends LitElement {
+    /**
+     * The title of the left list
+     */
+    leftHandTitle: string;
+    /**
+     * The title of the right list
+     */
+    rightHandTitle: string;
+    /**
+     * The left Element that should be compared
+     */
+    leftHandObject: Element;
+    /**
+     * The right element that should be compared against
+     */
+    rightHandObject: Element;
+    /**
+     * Optional filter to ignore differences
+     */
+    filterToIgnore?: DiffFilter<Element>;
+    /**
+     * The subtitle of the left list (optional)
+     */
+    leftHandSubtitle: string;
+    /**
+     * The subtitle of the right list (optional)
+     */
+    rightHandSubtitle: string;
+    filterMutables: boolean;
+    render(): TemplateResult;
+    protected renderFilterCheckbox(): TemplateResult;
+    static styles: import("lit-element").CSSResult;
+}

package/dist/plugin-tag.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hashes `uri` using cyrb64 analogous to
+ * https://github.com/bryc/code/blob/master/jshash/experimental/cyrb53.js .
+ * @returns a valid customElement tagName containing the URI hash.
+ */
+export declare function pluginTag(uri: string): string;

package/dist/plugin.d.ts

@@ -0,0 +1,23 @@
+import { TemplateResult } from 'lit-element';
+import { Plugin as CorePlugin } from "@openscd/core";
+export type Plugin = CorePlugin & {
+    official?: boolean;
+    active: boolean;
+    content?: () => TemplateResult;
+};
+export type PluginConfig = PluginConfigNotMenu | PluginConfigMenu;
+export type PluginConfigNotMenu = Omit<Plugin, "position" | "active"> & {
+    kind: 'editor' | 'validator';
+};
+export type PluginConfigMenu = Omit<Plugin, "active"> & {
+    kind: 'menu';
+    position: MenuPosition;
+};
+export type InstalledOfficialPlugin = Plugin & {
+    src: string;
+    official: true;
+    installed: boolean;
+};
+export type PluginKind = 'editor' | 'menu' | 'validator';
+export declare const menuPosition: readonly ["top", "middle", "bottom"];
+export type MenuPosition = (typeof menuPosition)[number];

package/dist/plugin.events.d.ts

@@ -0,0 +1,15 @@
+import { Plugin, PluginKind } from './plugin.js';
+/**
+ * The configure plugin event allows the plugin to request that OpenSCD core add, remove, or reconfigure a plugin.
+ */
+export type ConfigurePluginDetail = {
+    name: string;
+    kind: PluginKind;
+    config: Plugin | null;
+};
+export type ConfigurePluginEvent = CustomEvent<ConfigurePluginDetail>;
+/**
+ * The combination of name and kind uniquely identifies the plugin to be configured.
+ * If config is null, the plugin is removed. Otherwise, the plugin is added or reconfigured.
+ */
+export declare function newConfigurePluginEvent(name: string, kind: PluginKind, config: Plugin | null): ConfigurePluginEvent;

package/dist/plugins.d.ts

@@ -0,0 +1,3 @@
+import { PluginConfig } from './plugin.js';
+export declare function generatePluginPath(plugin: string): string;
+export declare const officialPlugins: PluginConfig[];