@ckeditor/ckeditor5-list 41.1.0 → 41.3.0-alpha.0

package/dist/types/list/utils/model.d.ts

@@ -0,0 +1,202 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/list/utils/model
+ */
+import type { DocumentFragment, Element, Model, Node, Writer, Item, Schema } from 'ckeditor5/src/engine.js';
+import { type ArrayOrItem } from 'ckeditor5/src/utils.js';
+/**
+ * The list item ID generator.
+ *
+ * @internal
+ */
+export declare class ListItemUid {
+    /**
+     * Returns the next ID.
+     *
+     * @internal
+     */
+    static next(): string;
+}
+/**
+ * An {@link module:engine/model/element~Element} that is known to be a list element.
+ *
+ * @internal
+ */
+export interface ListElement extends Element {
+    getAttribute(key: 'listItemId'): string;
+    getAttribute(key: 'listIndent'): number;
+    getAttribute(key: 'listType'): 'numbered' | 'bulleted' | 'todo';
+    getAttribute(key: string): unknown;
+}
+/**
+ * Returns true if the given model node is a list item block.
+ *
+ * @internal
+ */
+export declare function isListItemBlock(node: Item | DocumentFragment | null): node is ListElement;
+/**
+ * Returns an array with all elements that represents the same list item.
+ *
+ * It means that values for `listIndent`, and `listItemId` for all items are equal.
+ *
+ * @internal
+ * @param listItem Starting list item element.
+ * @param options.higherIndent Whether blocks with a higher indent level than the start block should be included
+ * in the result.
+ */
+export declare function getAllListItemBlocks(listItem: Node, options?: {
+    higherIndent?: boolean;
+}): Array<ListElement>;
+/**
+ * Returns an array with elements that represents the same list item in the specified direction.
+ *
+ * It means that values for `listIndent` and `listItemId` for all items are equal.
+ *
+ * **Note**: For backward search the provided item is not included, but for forward search it is included in the result.
+ *
+ * @internal
+ * @param listItem Starting list item element.
+ * @param options.direction Walking direction.
+ * @param options.higherIndent Whether blocks with a higher indent level than the start block should be included in the result.
+ */
+export declare function getListItemBlocks(listItem: Node, options?: {
+    direction?: 'forward' | 'backward';
+    higherIndent?: boolean;
+}): Array<ListElement>;
+/**
+ * Returns a list items nested inside the given list item.
+ *
+ * @internal
+ */
+export declare function getNestedListBlocks(listItem: Element): Array<ListElement>;
+/**
+ * Returns array of all blocks/items of the same list as given block (same indent, same type and properties).
+ *
+ * @internal
+ * @param listItem Starting list item element.
+ */
+export declare function getListItems(listItem: Element): Array<ListElement>;
+/**
+ * Check if the given block is the first in the list item.
+ *
+ * @internal
+ * @param listBlock The list block element.
+ */
+export declare function isFirstBlockOfListItem(listBlock: Node): boolean;
+/**
+ * Check if the given block is the last in the list item.
+ *
+ * @internal
+ */
+export declare function isLastBlockOfListItem(listBlock: Element): boolean;
+/**
+ * Expands the given list of selected blocks to include the leading and tailing blocks of partially selected list items.
+ *
+ * @internal
+ * @param blocks The list of selected blocks.
+ * @param options.withNested Whether should include nested list items.
+ */
+export declare function expandListBlocksToCompleteItems(blocks: ArrayOrItem<Element>, options?: {
+    withNested?: boolean;
+}): Array<ListElement>;
+/**
+ * Expands the given list of selected blocks to include all the items of the lists they're in.
+ *
+ * @internal
+ * @param blocks The list of selected blocks.
+ */
+export declare function expandListBlocksToCompleteList(blocks: ArrayOrItem<Element>): Array<ListElement>;
+/**
+ * Splits the list item just before the provided list block.
+ *
+ * @internal
+ * @param listBlock The list block element.
+ * @param writer The model writer.
+ * @returns The array of updated blocks.
+ */
+export declare function splitListItemBefore(listBlock: Element, writer: Writer): Array<ListElement>;
+/**
+ * Merges the list item with the parent list item.
+ *
+ * @internal
+ * @param listBlock The list block element.
+ * @param parentBlock The list block element to merge with.
+ * @param writer The model writer.
+ * @returns The array of updated blocks.
+ */
+export declare function mergeListItemBefore(listBlock: Node, parentBlock: Element, writer: Writer): Array<ListElement>;
+/**
+ * Increases indentation of given list blocks.
+ *
+ * @internal
+ * @param blocks The block or iterable of blocks.
+ * @param writer The model writer.
+ * @param options.expand Whether should expand the list of blocks to include complete list items.
+ * @param options.indentBy The number of levels the indentation should change (could be negative).
+ */
+export declare function indentBlocks(blocks: ArrayOrItem<ListElement>, writer: Writer, { expand, indentBy }?: {
+    expand?: boolean;
+    indentBy?: number;
+}): Array<ListElement>;
+/**
+ * Decreases indentation of given list of blocks. If the indentation of some blocks matches the indentation
+ * of surrounding blocks, they get merged together.
+ *
+ * @internal
+ * @param blocks The block or iterable of blocks.
+ * @param writer The model writer.
+ */
+export declare function outdentBlocksWithMerge(blocks: ArrayOrItem<ListElement>, writer: Writer): Array<ListElement>;
+/**
+ * Removes all list attributes from the given blocks.
+ *
+ * @internal
+ * @param blocks The block or iterable of blocks.
+ * @param writer The model writer.
+ * @returns Array of altered blocks.
+ */
+export declare function removeListAttributes(blocks: ArrayOrItem<Element>, writer: Writer): Array<Element>;
+/**
+ * Checks whether the given blocks are related to a single list item.
+ *
+ * @internal
+ * @param blocks The list block elements.
+ */
+export declare function isSingleListItem(blocks: Array<Node>): boolean;
+/**
+ * Modifies the indents of list blocks following the given list block so the indentation is valid after
+ * the given block is no longer a list item.
+ *
+ * @internal
+ * @param lastBlock The last list block that has become a non-list element.
+ * @param writer The model writer.
+ * @returns Array of altered blocks.
+ */
+export declare function outdentFollowingItems(lastBlock: Element, writer: Writer): Array<ListElement>;
+/**
+ * Returns the array of given blocks sorted by model indexes (document order).
+ *
+ * @internal
+ */
+export declare function sortBlocks<T extends Element>(blocks: Iterable<T>): Array<T>;
+/**
+ * Returns a selected block object. If a selected object is inline or when there is no selected
+ * object, `null` is returned.
+ *
+ * @internal
+ * @param model The instance of editor model.
+ * @returns Selected block object or `null`.
+ */
+export declare function getSelectedBlockObject(model: Model): Element | null;
+/**
+ * Checks whether the given block can be replaced by a listItem.
+ *
+ * Note that this is possible only when multiBlock = false option is set in feature config.
+ *
+ * @param block A block to be tested.
+ * @param schema The schema of the document.
+ */
+export declare function canBecomeSimpleListItem(block: Element, schema: Schema): boolean;

package/dist/types/list/utils/postfixers.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/list/utils/postfixers
+ */
+import type { Position, Writer } from 'ckeditor5/src/engine.js';
+import { type ListIteratorValue } from './listwalker.js';
+import { type ListElement } from './model.js';
+/**
+ * Based on the provided positions looks for the list head and stores it in the provided map.
+ *
+ * @internal
+ * @param position The search starting position.
+ * @param itemToListHead The map from list item element to the list head element.
+ */
+export declare function findAndAddListHeadToMap(position: Position, itemToListHead: Map<ListElement, ListElement>): void;
+/**
+ * Scans the list starting from the given list head element and fixes items' indentation.
+ *
+ * @internal
+ * @param listNodes The iterable of list nodes.
+ * @param writer The model writer.
+ * @returns Whether the model was modified.
+ */
+export declare function fixListIndents(listNodes: Iterable<ListIteratorValue>, writer: Writer): boolean;
+/**
+ * Scans the list starting from the given list head element and fixes items' types.
+ *
+ * @internal
+ * @param listNodes The iterable of list nodes.
+ * @param seenIds The set of already known IDs.
+ * @param writer The model writer.
+ * @returns Whether the model was modified.
+ */
+export declare function fixListItemIds(listNodes: Iterable<ListIteratorValue>, seenIds: Set<string>, writer: Writer): boolean;

package/dist/types/list/utils/view.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/list/utils/view
+ */
+import type { DowncastWriter, ViewAttributeElement, ViewDocumentFragment, ViewElement, ViewNode } from 'ckeditor5/src/engine.js';
+/**
+ * Checks if view element is a list type (ul or ol).
+ *
+ * @internal
+ */
+export declare function isListView(viewElement: ViewNode | ViewDocumentFragment): viewElement is ViewElement & {
+    name: 'ul' | 'ol';
+};
+/**
+ * Checks if view element is a list item (li).
+ *
+ * @internal
+ */
+export declare function isListItemView(viewElement: ViewNode | ViewDocumentFragment): viewElement is ViewElement & {
+    name: 'li';
+};
+/**
+ * Calculates the indent value for a list item. Handles HTML compliant and non-compliant lists.
+ *
+ * Also, fixes non HTML compliant lists indents:
+ *
+ * ```
+ * before:                                     fixed list:
+ * OL                                          OL
+ * |-> LI (parent LIs: 0)                      |-> LI     (indent: 0)
+ *     |-> OL                                  |-> OL
+ *         |-> OL                                  |
+ *         |   |-> OL                              |
+ *         |       |-> OL                          |
+ *         |           |-> LI (parent LIs: 1)      |-> LI (indent: 1)
+ *         |-> LI (parent LIs: 1)                  |-> LI (indent: 1)
+ *
+ * before:                                     fixed list:
+ * OL                                          OL
+ * |-> OL                                      |
+ *     |-> OL                                  |
+ *          |-> OL                             |
+ *              |-> LI (parent LIs: 0)         |-> LI        (indent: 0)
+ *
+ * before:                                     fixed list:
+ * OL                                          OL
+ * |-> LI (parent LIs: 0)                      |-> LI         (indent: 0)
+ * |-> OL                                          |-> OL
+ *     |-> LI (parent LIs: 0)                          |-> LI (indent: 1)
+ * ```
+ *
+ * @internal
+ */
+export declare function getIndent(listItem: ViewElement): number;
+/**
+ * Creates a list attribute element (ol or ul).
+ *
+ * @internal
+ */
+export declare function createListElement(writer: DowncastWriter, indent: number, type: 'bulleted' | 'numbered' | 'todo', id?: string): ViewAttributeElement;
+/**
+ * Creates a list item attribute element (li).
+ *
+ * @internal
+ */
+export declare function createListItemElement(writer: DowncastWriter, indent: number, id: string): ViewAttributeElement;
+/**
+ * Returns a view element name for the given list type.
+ *
+ * @internal
+ */
+export declare function getViewElementNameForListType(type?: 'bulleted' | 'numbered' | 'todo'): 'ol' | 'ul';
+/**
+ * Returns a view element ID for the given list type and indent.
+ *
+ * @internal
+ */
+export declare function getViewElementIdForListType(type?: 'bulleted' | 'numbered' | 'todo', indent?: number): string;

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

@@ -0,0 +1,18 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/list/utils
+ */
+import type { Editor } from 'ckeditor5/src/core.js';
+/**
+ * Helper method for creating a UI button and linking it with an appropriate command.
+ *
+ * @internal
+ * @param editor The editor instance to which the UI component will be added.
+ * @param commandName The name of the command.
+ * @param label The button label.
+ * @param icon The source of the icon.
+ */
+export declare function createUIComponent(editor: Editor, commandName: 'bulletedList' | 'numberedList' | 'todoList', label: string, icon: string): void;

package/dist/types/list.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/list
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import ListEditing from './list/listediting.js';
+import ListUI from './list/listui.js';
+/**
+ * The list feature.
+ *
+ * This is a "glue" plugin that loads the {@link module:list/list/listediting~ListEditing  list
+ * editing feature} and {@link module:list/list/listui~ListUI list UI feature}.
+ */
+export default class List extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof ListEditing, typeof ListUI];
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "List";
+}

package/dist/types/listconfig.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/listconfig
+ */
+/**
+ * The configuration of the {@link module:list/list~List list} feature
+ * and the {@link module:list/legacylist~LegacyList legacy list} feature.
+ *
+ * ```ts
+ * ClassicEditor
+ * 	.create( editorElement, {
+ * 		list:  ... // The list feature configuration.
+ * 	} )
+ * 	.then( ... )
+ * 	.catch( ... );
+ * ```
+ *
+ * See {@link module:core/editor/editorconfig~EditorConfig all editor options}.
+ *
+ * @interface ListConfig
+ */
+export interface ListConfig {
+    /**
+     * The configuration of the {@link module:list/listproperties~ListProperties} feature and the
+     * {@link module:list/legacylistproperties~LegacyListProperties legacy list properties} feature.
+     *
+     * Read more in {@link module:list/listconfig~ListPropertiesConfig}.
+     */
+    properties?: ListPropertiesConfig;
+    /**
+     * Allows multiple blocks in single list item.
+     *
+     * With this option enabled you can have block widgets, for example images or even tables, within a list item.
+     *
+     * **Note:** This is enabled by default.
+     *
+     * @default true
+     */
+    multiBlock?: boolean;
+}
+/**
+ * The configuration of the {@link module:list/listproperties~ListProperties list properties} feature and the
+ * {@link module:list/legacylistproperties~LegacyListProperties legacy list properties} feature.
+ *
+ * This configuration controls the individual list properties. For instance, it enables or disables specific editor commands
+ * operating on lists ({@link module:list/listproperties/liststylecommand~ListStyleCommand `'listStyle'`},
+ * {@link module:list/listproperties/liststartcommand~ListStartCommand `'listStart'`},
+ * {@link module:list/listproperties/listreversedcommand~ListReversedCommand `'listReversed'`}, or on the legacy lists
+ * {@link module:list/legacylistproperties/legacyliststylecommand~LegacyListStyleCommand `'listStyle'`},
+ * {@link module:list/legacylistproperties/legacyliststartcommand~LegacyListStartCommand `'listStart'`},
+ * {@link module:list/legacylistproperties/legacylistreversedcommand~LegacyListReversedCommand `'listReversed'`}), the look of the UI
+ * (`'numberedList'` and `'bulletedList'` dropdowns), and the editor data pipeline (allowed HTML attributes).
+ *
+ * ```ts
+ * ClassicEditor
+ * 	.create( editorElement, {
+ * 		list: {
+ * 			properties: {
+ * 				styles: true,
+ * 				startIndex: true,
+ * 				reversed: true
+ * 			}
+ * 		}
+ * 	} )
+ * 	.then( ... )
+ * 	.catch( ... );
+ * ```
+ */
+export interface ListPropertiesConfig {
+    /**
+     * When set, the list style feature will be enabled.
+     * It allows changing the `list-style-type` style or the `type` HTML attribute of a list.
+     *
+     * **Note**: Styling using the `type` HTML attribute is only available in
+     * {@link module:list/listproperties~ListProperties list properties}
+     * ({@link module:list/listconfig~ListPropertiesStyleConfig learn more}).
+     *
+     * @default true
+     */
+    styles?: boolean | ListPropertiesStyleConfig;
+    /**
+     * When set, the list start index feature will be enabled. It allows changing the `start` HTML attribute of the numbered lists. As a
+     * result, it will be possible to specify the start value of the first item in an ordered list.
+     *
+     * **Note**: This configuration does not affect bulleted and to-do lists.
+     *
+     * @default false
+     */
+    startIndex?: boolean;
+    /**
+     * When set, the reversed list feature will be enabled. It allows changing the `reversed` HTML attribute of the numbered lists. As a
+     * result, it will be possible to make the list order descending instead of ascending.
+     *
+     * **Note**: This configuration does not affect bulleted and to-do lists.
+     *
+     * @default false
+     */
+    reversed?: boolean;
+}
+export interface ListPropertiesStyleConfig {
+    /**
+     * When set `true`, the list style feature will use the `type` attribute of `<ul>` and `<ol>` elements instead of the `list-style-type`
+     * style.
+     *
+     * ```ts
+     * {
+     * 	list: {
+     * 		properties: {
+     * 			styles: {
+     * 				useAttribute: true
+     * 			},
+     *
+     * 			// ...
+     * 		}
+     * 	},
+     *
+     * 	// ...
+     * }
+     * ```
+     *
+     * **Note**: Due to limitations of HTML, the "Decimal with leading zero" style is impossible to set using the `type` attribute.
+     *
+     * **Note**: This configuration works only with
+     * {@link module:list/listproperties~ListProperties list properties}.
+     *
+     * @default false
+     */
+    useAttribute?: boolean;
+}

package/dist/types/listproperties/converters.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/listproperties/converters
+ */
+import type { UpcastElementEvent } from 'ckeditor5/src/engine.js';
+import type { GetCallback } from 'ckeditor5/src/utils.js';
+import type { AttributeStrategy } from './listpropertiesediting.js';
+/**
+ * Returns a converter that consumes the `style`, `reversed`, and `start` attributes.
+ * In `style`, it searches for the `list-style-type` definition.
+ * If not found, the `"default"` value will be used.
+ *
+ * @internal
+ * @param strategy
+ */
+export declare function listPropertiesUpcastConverter(strategy: AttributeStrategy): GetCallback<UpcastElementEvent>;

package/dist/types/listproperties/listpropertiesediting.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/listproperties/listpropertiesediting
+ */
+import { Plugin, type Editor } from 'ckeditor5/src/core.js';
+import type { Consumables, DowncastWriter, Element, Item, ViewElement } from 'ckeditor5/src/engine.js';
+import ListEditing, { type ListItemAttributesMap } from '../list/listediting.js';
+import ListPropertiesUtils from './listpropertiesutils.js';
+/**
+ * The document list properties engine feature.
+ *
+ * It registers the `'listStyle'`, `'listReversed'` and `'listStart'` commands if they are enabled in the configuration.
+ * Read more in {@link module:list/listconfig~ListPropertiesConfig}.
+ */
+export default class ListPropertiesEditing extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof ListEditing, typeof ListPropertiesUtils];
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "ListPropertiesEditing";
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+}
+/**
+ * Strategy for dealing with `listItem` attributes supported by this plugin.
+ *
+ * @internal
+ */
+export interface AttributeStrategy {
+    /**
+     * The model attribute name.
+     */
+    attributeName: keyof ListItemAttributesMap;
+    /**
+     * The model attribute default value.
+     */
+    defaultValue: unknown;
+    /**
+     * The view consumable as expected by {@link module:engine/conversion/viewconsumable~ViewConsumable#consume `ViewConsumable`}.
+     */
+    viewConsumables: Consumables;
+    /**
+     * Registers an editor command.
+     */
+    addCommand(editor: Editor): void;
+    /**
+     * Verifies whether the strategy is applicable for the specified model element.
+     */
+    appliesToListItem(element: Item): boolean;
+    /**
+     * Verifies whether the model attribute value is valid.
+     */
+    hasValidAttribute(element: Element): boolean;
+    /**
+     * Sets the property on the view element.
+     */
+    setAttributeOnDowncast(writer: DowncastWriter, value: unknown, element: ViewElement): void;
+    /**
+     * Retrieves the property value from the view element.
+     */
+    getAttributeOnUpcast(element: ViewElement): unknown;
+}
+declare module '../list/listediting' {
+    interface ListItemAttributesMap {
+        listStyle?: string;
+        listStart?: number;
+        listReversed?: boolean;
+    }
+}
+declare module '../list/utils/model' {
+    interface ListElement {
+        getAttribute(key: 'listStyle'): string;
+        getAttribute(key: 'listStart'): number;
+        getAttribute(key: 'listReversed'): boolean;
+    }
+}

package/dist/types/listproperties/listpropertiesui.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/listproperties/listpropertiesui
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import '../../theme/liststyles.css';
+/**
+ * The list properties UI plugin. It introduces the extended `'bulletedList'` and `'numberedList'` toolbar
+ * buttons that allow users to control such aspects of list as the marker, start index or order.
+ *
+ * **Note**: Buttons introduced by this plugin override implementations from the {@link module:list/list/listui~ListUI}
+ * (because they share the same names).
+ */
+export default class ListPropertiesUI extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "ListPropertiesUI";
+    init(): void;
+}

package/dist/types/listproperties/listpropertiesutils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module list/listproperties/listpropertiesutils
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+/**
+ * A set of helpers related to document lists.
+ */
+export default class ListPropertiesUtils extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "ListPropertiesUtils";
+    /**
+     * Gets all the style types supported by given list type.
+     */
+    getAllSupportedStyleTypes(): Array<string>;
+    /**
+     * Checks whether the given list-style-type is supported by numbered or bulleted list.
+     */
+    getListTypeFromListStyleType(listStyleType: string): 'bulleted' | 'numbered' | null;
+    /**
+     * Converts `type` attribute of `<ul>` or `<ol>` elements to `list-style-type` equivalent.
+     */
+    getListStyleTypeFromTypeAttribute(value: string): string | null;
+    /**
+     * Converts `list-style-type` style to `type` attribute of `<ul>` or `<ol>` elements.
+     */
+    getTypeAttributeFromListStyleType(value: string): string | null;
+}