@depup/angular__material 21.2.2-depup.19

package/types/_icon-registry-chunk.d.ts

@@ -0,0 +1,271 @@
+import { HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { OnDestroy, ErrorHandler } from '@angular/core';
+import { SafeResourceUrl, SafeHtml, DomSanitizer } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+
+/**
+ * Returns an exception to be thrown in the case when attempting to
+ * load an icon with a name that cannot be found.
+ * @docs-private
+ */
+declare function getMatIconNameNotFoundError(iconName: string): Error;
+/**
+ * Returns an exception to be thrown when the consumer attempts to use
+ * `<mat-icon>` without including @angular/common/http.
+ * @docs-private
+ */
+declare function getMatIconNoHttpProviderError(): Error;
+/**
+ * Returns an exception to be thrown when a URL couldn't be sanitized.
+ * @param url URL that was attempted to be sanitized.
+ * @docs-private
+ */
+declare function getMatIconFailedToSanitizeUrlError(url: SafeResourceUrl): Error;
+/**
+ * Returns an exception to be thrown when a HTML string couldn't be sanitized.
+ * @param literal HTML that was attempted to be sanitized.
+ * @docs-private
+ */
+declare function getMatIconFailedToSanitizeLiteralError(literal: SafeHtml): Error;
+/** Options that can be used to configure how an icon or the icons in an icon set are presented. */
+interface IconOptions {
+    /** View box to set on the icon. */
+    viewBox?: string;
+    /** Whether or not to fetch the icon or icon set using HTTP credentials. */
+    withCredentials?: boolean;
+}
+/**
+ * Function that will be invoked by the icon registry when trying to resolve the
+ * URL from which to fetch an icon. The returned URL will be used to make a request for the icon.
+ */
+type IconResolver = (name: string, namespace: string) => SafeResourceUrl | SafeResourceUrlWithIconOptions | null;
+/** Object that specifies a URL from which to fetch an icon and the options to use for it. */
+interface SafeResourceUrlWithIconOptions {
+    url: SafeResourceUrl;
+    options: IconOptions;
+}
+/**
+ * Service to register and display icons used by the `<mat-icon>` component.
+ * - Registers icon URLs by namespace and name.
+ * - Registers icon set URLs by namespace.
+ * - Registers aliases for CSS classes, for use with icon fonts.
+ * - Loads icons from URLs and extracts individual icons from icon sets.
+ */
+declare class MatIconRegistry implements OnDestroy {
+    private _httpClient;
+    private _sanitizer;
+    private readonly _errorHandler;
+    private _document;
+    /**
+     * URLs and cached SVG elements for individual icons. Keys are of the format "[namespace]:[icon]".
+     */
+    private _svgIconConfigs;
+    /**
+     * SvgIconConfig objects and cached SVG elements for icon sets, keyed by namespace.
+     * Multiple icon sets can be registered under the same namespace.
+     */
+    private _iconSetConfigs;
+    /** Cache for icons loaded by direct URLs. */
+    private _cachedIconsByUrl;
+    /** In-progress icon fetches. Used to coalesce multiple requests to the same URL. */
+    private _inProgressUrlFetches;
+    /** Map from font identifiers to their CSS class names. Used for icon fonts. */
+    private _fontCssClassesByAlias;
+    /** Registered icon resolver functions. */
+    private _resolvers;
+    /**
+     * The CSS classes to apply when an `<mat-icon>` component has no icon name, url, or font
+     * specified. The default 'material-icons' value assumes that the material icon font has been
+     * loaded as described at https://google.github.io/material-design-icons/#icon-font-for-the-web
+     */
+    private _defaultFontSetClass;
+    constructor(_httpClient: HttpClient, _sanitizer: DomSanitizer, document: any, _errorHandler: ErrorHandler);
+    /**
+     * Registers an icon by URL in the default namespace.
+     * @param iconName Name under which the icon should be registered.
+     * @param url
+     */
+    addSvgIcon(iconName: string, url: SafeResourceUrl, options?: IconOptions): this;
+    /**
+     * Registers an icon using an HTML string in the default namespace.
+     * @param iconName Name under which the icon should be registered.
+     * @param literal SVG source of the icon.
+     */
+    addSvgIconLiteral(iconName: string, literal: SafeHtml, options?: IconOptions): this;
+    /**
+     * Registers an icon by URL in the specified namespace.
+     * @param namespace Namespace in which the icon should be registered.
+     * @param iconName Name under which the icon should be registered.
+     * @param url
+     */
+    addSvgIconInNamespace(namespace: string, iconName: string, url: SafeResourceUrl, options?: IconOptions): this;
+    /**
+     * Registers an icon resolver function with the registry. The function will be invoked with the
+     * name and namespace of an icon when the registry tries to resolve the URL from which to fetch
+     * the icon. The resolver is expected to return a `SafeResourceUrl` that points to the icon,
+     * an object with the icon URL and icon options, or `null` if the icon is not supported. Resolvers
+     * will be invoked in the order in which they have been registered.
+     * @param resolver Resolver function to be registered.
+     */
+    addSvgIconResolver(resolver: IconResolver): this;
+    /**
+     * Registers an icon using an HTML string in the specified namespace.
+     * @param namespace Namespace in which the icon should be registered.
+     * @param iconName Name under which the icon should be registered.
+     * @param literal SVG source of the icon.
+     */
+    addSvgIconLiteralInNamespace(namespace: string, iconName: string, literal: SafeHtml, options?: IconOptions): this;
+    /**
+     * Registers an icon set by URL in the default namespace.
+     * @param url
+     */
+    addSvgIconSet(url: SafeResourceUrl, options?: IconOptions): this;
+    /**
+     * Registers an icon set using an HTML string in the default namespace.
+     * @param literal SVG source of the icon set.
+     */
+    addSvgIconSetLiteral(literal: SafeHtml, options?: IconOptions): this;
+    /**
+     * Registers an icon set by URL in the specified namespace.
+     * @param namespace Namespace in which to register the icon set.
+     * @param url
+     */
+    addSvgIconSetInNamespace(namespace: string, url: SafeResourceUrl, options?: IconOptions): this;
+    /**
+     * Registers an icon set using an HTML string in the specified namespace.
+     * @param namespace Namespace in which to register the icon set.
+     * @param literal SVG source of the icon set.
+     */
+    addSvgIconSetLiteralInNamespace(namespace: string, literal: SafeHtml, options?: IconOptions): this;
+    /**
+     * Defines an alias for CSS class names to be used for icon fonts. Creating an matIcon
+     * component with the alias as the fontSet input will cause the class name to be applied
+     * to the `<mat-icon>` element.
+     *
+     * If the registered font is a ligature font, then don't forget to also include the special
+     * class `mat-ligature-font` to allow the usage via attribute. So register like this:
+     *
+     * ```ts
+     * iconRegistry.registerFontClassAlias('f1', 'font1 mat-ligature-font');
+     * ```
+     *
+     * And use like this:
+     *
+     * ```html
+     * <mat-icon fontSet="f1" fontIcon="home"></mat-icon>
+     * ```
+     *
+     * @param alias Alias for the font.
+     * @param classNames Class names override to be used instead of the alias.
+     */
+    registerFontClassAlias(alias: string, classNames?: string): this;
+    /**
+     * Returns the CSS class name associated with the alias by a previous call to
+     * registerFontClassAlias. If no CSS class has been associated, returns the alias unmodified.
+     */
+    classNameForFontAlias(alias: string): string;
+    /**
+     * Sets the CSS classes to be used for icon fonts when an `<mat-icon>` component does not
+     * have a fontSet input value, and is not loading an icon by name or URL.
+     */
+    setDefaultFontSetClass(...classNames: string[]): this;
+    /**
+     * Returns the CSS classes to be used for icon fonts when an `<mat-icon>` component does not
+     * have a fontSet input value, and is not loading an icon by name or URL.
+     */
+    getDefaultFontSetClass(): string[];
+    /**
+     * Returns an Observable that produces the icon (as an `<svg>` DOM element) from the given URL.
+     * The response from the URL may be cached so this will not always cause an HTTP request, but
+     * the produced element will always be a new copy of the originally fetched icon. (That is,
+     * it will not contain any modifications made to elements previously returned).
+     *
+     * @param safeUrl URL from which to fetch the SVG icon.
+     */
+    getSvgIconFromUrl(safeUrl: SafeResourceUrl): Observable<SVGElement>;
+    /**
+     * Returns an Observable that produces the icon (as an `<svg>` DOM element) with the given name
+     * and namespace. The icon must have been previously registered with addIcon or addIconSet;
+     * if not, the Observable will throw an error.
+     *
+     * @param name Name of the icon to be retrieved.
+     * @param namespace Namespace in which to look for the icon.
+     */
+    getNamedSvgIcon(name: string, namespace?: string): Observable<SVGElement>;
+    ngOnDestroy(): void;
+    /**
+     * Returns the cached icon for a SvgIconConfig if available, or fetches it from its URL if not.
+     */
+    private _getSvgFromConfig;
+    /**
+     * Attempts to find an icon with the specified name in any of the SVG icon sets.
+     * First searches the available cached icons for a nested element with a matching name, and
+     * if found copies the element to a new `<svg>` element. If not found, fetches all icon sets
+     * that have not been cached, and searches again after all fetches are completed.
+     * The returned Observable produces the SVG element if possible, and throws
+     * an error if no icon with the specified name can be found.
+     */
+    private _getSvgFromIconSetConfigs;
+    /**
+     * Searches the cached SVG elements for the given icon sets for a nested icon element whose "id"
+     * tag matches the specified name. If found, copies the nested element to a new SVG element and
+     * returns it. Returns null if no matching element is found.
+     */
+    private _extractIconWithNameFromAnySet;
+    /**
+     * Loads the content of the icon URL specified in the SvgIconConfig and creates an SVG element
+     * from it.
+     */
+    private _loadSvgIconFromConfig;
+    /**
+     * Loads the content of the icon set URL specified in the
+     * SvgIconConfig and attaches it to the config.
+     */
+    private _loadSvgIconSetFromConfig;
+    /**
+     * Searches the cached element of the given SvgIconConfig for a nested icon element whose "id"
+     * tag matches the specified name. If found, copies the nested element to a new SVG element and
+     * returns it. Returns null if no matching element is found.
+     */
+    private _extractSvgIconFromSet;
+    /**
+     * Creates a DOM element from the given SVG string.
+     */
+    private _svgElementFromString;
+    /**
+     * Converts an element into an SVG node by cloning all of its children.
+     */
+    private _toSvgElement;
+    /**
+     * Sets the default attributes for an SVG element to be used as an icon.
+     */
+    private _setSvgAttributes;
+    /**
+     * Returns an Observable which produces the string contents of the given icon. Results may be
+     * cached, so future calls with the same URL may not cause another HTTP request.
+     */
+    private _fetchIcon;
+    /**
+     * Registers an icon config by name in the specified namespace.
+     * @param namespace Namespace in which to register the icon config.
+     * @param iconName Name under which to register the config.
+     * @param config Config to be registered.
+     */
+    private _addSvgIconConfig;
+    /**
+     * Registers an icon set config in the specified namespace.
+     * @param namespace Namespace in which to register the icon config.
+     * @param config Config to be registered.
+     */
+    private _addSvgIconSetConfig;
+    /** Parses a config's text into an SVG element. */
+    private _svgElementFromConfig;
+    /** Tries to create an icon config through the registered resolver functions. */
+    private _getIconConfigFromResolvers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatIconRegistry, [{ optional: true; }, null, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatIconRegistry>;
+}
+
+export { MatIconRegistry, getMatIconFailedToSanitizeLiteralError, getMatIconFailedToSanitizeUrlError, getMatIconNameNotFoundError, getMatIconNoHttpProviderError };
+export type { IconOptions, IconResolver, SafeResourceUrlWithIconOptions };

package/types/_input-harness-chunk.d.ts

@@ -0,0 +1,61 @@
+import { HarnessPredicate } from '@angular/cdk/testing';
+import { MatFormFieldControlHarnessFilters, MatFormFieldControlHarnessBase } from '@angular/material/form-field/testing/control';
+
+/** A set of criteria that can be used to filter a list of `MatInputHarness` instances. */
+interface InputHarnessFilters extends MatFormFieldControlHarnessFilters {
+    /** Filters based on the value of the input. */
+    value?: string | RegExp;
+    /** Filters based on the placeholder text of the input. */
+    placeholder?: string | RegExp;
+}
+
+/** Harness for interacting with a standard Material inputs in tests. */
+declare class MatInputHarness extends MatFormFieldControlHarnessBase {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatInputHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: InputHarnessFilters): HarnessPredicate<MatInputHarness>;
+    /** Whether the input is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the input is required. */
+    isRequired(): Promise<boolean>;
+    /** Whether the input is readonly. */
+    isReadonly(): Promise<boolean>;
+    /** Gets the value of the input. */
+    getValue(): Promise<string>;
+    /** Gets the name of the input. */
+    getName(): Promise<string>;
+    /**
+     * Gets the type of the input. Returns "textarea" if the input is
+     * a textarea.
+     */
+    getType(): Promise<string>;
+    /** Gets the placeholder of the input. */
+    getPlaceholder(): Promise<string>;
+    /** Gets the id of the input. */
+    getId(): Promise<string>;
+    /**
+     * Focuses the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    focus(): Promise<void>;
+    /**
+     * Blurs the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    blur(): Promise<void>;
+    /** Whether the input is focused. */
+    isFocused(): Promise<boolean>;
+    /**
+     * Sets the value of the input. The value will be set by simulating
+     * keypresses that correspond to the given value.
+     */
+    setValue(newValue: string): Promise<void>;
+}
+
+export { MatInputHarness };
+export type { InputHarnessFilters };

package/types/_line-chunk.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from '@angular/core';
+import { QueryList, ElementRef } from '@angular/core';
+import * as i2 from '@angular/cdk/bidi';
+
+/**
+ * Shared directive to count lines inside a text area, such as a list item.
+ * Line elements can be extracted with a @ContentChildren(MatLine) query, then
+ * counted by checking the query list's length.
+ */
+declare class MatLine {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatLine, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatLine, "[mat-line], [matLine]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Helper that takes a query list of lines and sets the correct class on the host.
+ * @docs-private
+ */
+declare function setLines(lines: QueryList<unknown>, element: ElementRef<HTMLElement>, prefix?: string): void;
+declare class MatLineModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatLineModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatLineModule, never, [typeof MatLine], [typeof MatLine, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatLineModule>;
+}
+
+export { MatLine, MatLineModule, setLines };

package/types/_list-option-types-chunk.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Type describing possible positions of a checkbox or radio in a list option
+ * with respect to the list item's text.
+ */
+type MatListOptionTogglePosition = 'before' | 'after';
+/**
+ * Interface describing a list option. This is used to avoid circular
+ * dependencies between the list-option and the styler directives.
+ * @docs-private
+ */
+interface ListOption {
+    _getTogglePosition(): MatListOptionTogglePosition;
+}
+
+export type { ListOption, MatListOptionTogglePosition };

package/types/_option-chunk.d.ts

@@ -0,0 +1,146 @@
+import { FocusableOption, FocusOrigin } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewChecked, OnDestroy, ChangeDetectorRef, EventEmitter, ElementRef, QueryList } from '@angular/core';
+import { Subject } from 'rxjs';
+
+/**
+ * Injection token that can be used to reference instances of `MatOptgroup`. It serves as
+ * alternative token to the actual `MatOptgroup` class which could cause unnecessary
+ * retention of the class and its component metadata.
+ */
+declare const MAT_OPTGROUP: InjectionToken<MatOptgroup>;
+/**
+ * Component that is used to group instances of `mat-option`.
+ */
+declare class MatOptgroup {
+    /** Label for the option group. */
+    label: string;
+    /** whether the option group is disabled. */
+    disabled: boolean;
+    /** Unique id for the underlying label. */
+    _labelId: string;
+    /** Whether the group is in inert a11y mode. */
+    _inert: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatOptgroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatOptgroup, "mat-optgroup", ["matOptgroup"], { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*", "mat-option, ng-container"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Event object emitted by MatOption when selected or deselected. */
+declare class MatOptionSelectionChange<T = any> {
+    /** Reference to the option that emitted the event. */
+    source: MatOption<T>;
+    /** Whether the change in the option's value was a result of a user action. */
+    isUserInput: boolean;
+    constructor(
+    /** Reference to the option that emitted the event. */
+    source: MatOption<T>, 
+    /** Whether the change in the option's value was a result of a user action. */
+    isUserInput?: boolean);
+}
+/**
+ * Single option inside of a `<mat-select>` element.
+ */
+declare class MatOption<T = any> implements FocusableOption, AfterViewChecked, OnDestroy {
+    private _element;
+    _changeDetectorRef: ChangeDetectorRef;
+    private _parent;
+    group: MatOptgroup | null;
+    private _signalDisableRipple;
+    private _selected;
+    private _active;
+    private _mostRecentViewValue;
+    /** Whether the wrapping component is in multiple selection mode. */
+    get multiple(): boolean | null | undefined;
+    /** Whether or not the option is currently selected. */
+    get selected(): boolean;
+    /** The form value of the option. */
+    value: T;
+    /** The unique ID of the option. */
+    id: string;
+    /** Whether the option is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Whether ripples for the option are disabled. */
+    get disableRipple(): boolean;
+    /** Whether to display checkmark for single-selection. */
+    get hideSingleSelectionIndicator(): boolean;
+    /** Event emitted when the option is selected or deselected. */
+    readonly onSelectionChange: EventEmitter<MatOptionSelectionChange<T>>;
+    /** Element containing the option's text. */
+    _text: ElementRef<HTMLElement> | undefined;
+    /** Emits when the state of the option changes and any parents have to be notified. */
+    readonly _stateChanges: Subject<void>;
+    constructor(...args: unknown[]);
+    /**
+     * Whether or not the option is currently active and ready to be selected.
+     * An active option displays styles as if it is focused, but the
+     * focus is actually retained somewhere else. This comes in handy
+     * for components like autocomplete where focus must remain on the input.
+     */
+    get active(): boolean;
+    /**
+     * The displayed value of the option. It is necessary to show the selected option in the
+     * select's trigger.
+     */
+    get viewValue(): string;
+    /** Selects the option. */
+    select(emitEvent?: boolean): void;
+    /** Deselects the option. */
+    deselect(emitEvent?: boolean): void;
+    /** Sets focus onto this option. */
+    focus(_origin?: FocusOrigin, options?: FocusOptions): void;
+    /**
+     * This method sets display styles on the option to make it appear
+     * active. This is used by the ActiveDescendantKeyManager so key
+     * events will display the proper options as active on arrow key events.
+     */
+    setActiveStyles(): void;
+    /**
+     * This method removes display styles on the option that made it appear
+     * active. This is used by the ActiveDescendantKeyManager so key
+     * events will display the proper options as active on arrow key events.
+     */
+    setInactiveStyles(): void;
+    /** Gets the label to be used when determining whether the option should be focused. */
+    getLabel(): string;
+    /** Ensures the option is selected when activated from the keyboard. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * `Selects the option while indicating the selection came from the user. Used to
+     * determine if the select's view -> model callback should be invoked.`
+     */
+    _selectViaInteraction(): void;
+    /** Returns the correct tabindex for the option depending on disabled state. */
+    _getTabIndex(): string;
+    /** Gets the host DOM element. */
+    _getHostElement(): HTMLElement;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /** Emits the selection change event. */
+    private _emitSelectionChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatOption<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatOption<any>, "mat-option", ["matOption"], { "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, never, ["mat-icon", "*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+/**
+ * Counts the amount of option group labels that precede the specified option.
+ * @param optionIndex Index of the option at which to start counting.
+ * @param options Flat list of all of the options.
+ * @param optionGroups Flat list of all of the option groups.
+ * @docs-private
+ */
+declare function _countGroupLabelsBeforeOption(optionIndex: number, options: QueryList<MatOption>, optionGroups: QueryList<MatOptgroup>): number;
+/**
+ * Determines the position to which to scroll a panel in order for an option to be into view.
+ * @param optionOffset Offset of the option from the top of the panel.
+ * @param optionHeight Height of the options.
+ * @param currentScrollPosition Current scroll position of the panel.
+ * @param panelHeight Height of the panel.
+ * @docs-private
+ */
+declare function _getOptionScrollPosition(optionOffset: number, optionHeight: number, currentScrollPosition: number, panelHeight: number): number;
+
+export { MAT_OPTGROUP, MatOptgroup, MatOption, MatOptionSelectionChange, _countGroupLabelsBeforeOption, _getOptionScrollPosition };

package/types/_option-harness-chunk.d.ts

@@ -0,0 +1,35 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+
+interface OptionHarnessFilters extends BaseHarnessFilters {
+    text?: string | RegExp;
+    isSelected?: boolean;
+}
+
+/** Harness for interacting with a `mat-option` in tests. */
+declare class MatOptionHarness extends ContentContainerComponentHarness {
+    /** Selector used to locate option instances. */
+    static hostSelector: string;
+    /** Element containing the option's text. */
+    private _text;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for an option with specific attributes.
+     * @param options Options for filtering which option instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatOptionHarness>(this: ComponentHarnessConstructor<T>, options?: OptionHarnessFilters): HarnessPredicate<T>;
+    /** Clicks the option. */
+    click(): Promise<void>;
+    /** Gets the option's label text. */
+    getText(): Promise<string>;
+    /** Gets whether the option is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets whether the option is selected. */
+    isSelected(): Promise<boolean>;
+    /** Gets whether the option is active. */
+    isActive(): Promise<boolean>;
+    /** Gets whether the option is in multiple selection mode. */
+    isMultiple(): Promise<boolean>;
+}
+
+export { MatOptionHarness };
+export type { OptionHarnessFilters };

package/types/_option-module-chunk.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from '@angular/core';
+import { MatRippleModule } from './_ripple-module-chunk.js';
+import { MatPseudoCheckboxModule } from './_pseudo-checkbox-module-chunk.js';
+import { MatOption, MatOptgroup } from './_option-chunk.js';
+import * as i2 from '@angular/cdk/bidi';
+
+declare class MatOptionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatOptionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatOptionModule, never, [typeof MatRippleModule, typeof MatPseudoCheckboxModule, typeof MatOption, typeof MatOptgroup], [typeof MatOption, typeof MatOptgroup, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatOptionModule>;
+}
+
+export { MatOptionModule };

package/types/_option-parent-chunk.d.ts

@@ -0,0 +1,20 @@
+import { Signal, InjectionToken } from '@angular/core';
+
+/**
+ * Describes a parent component that manages a list of options.
+ * Contains properties that the options can inherit.
+ * @docs-private
+ */
+interface MatOptionParentComponent {
+    disableRipple?: boolean | Signal<boolean>;
+    multiple?: boolean;
+    inertGroups?: boolean;
+    hideSingleSelectionIndicator?: boolean;
+}
+/**
+ * Injection token used to provide the parent component to options.
+ */
+declare const MAT_OPTION_PARENT_COMPONENT: InjectionToken<MatOptionParentComponent>;
+
+export { MAT_OPTION_PARENT_COMPONENT };
+export type { MatOptionParentComponent };