@itwin/core-common 3.6.0-dev.65 → 3.6.0-dev.66

package/lib/esm/FeatureSymbology.d.ts

@@ -1,445 +1,445 @@
-/** @packageDocumentation
- * @module Rendering
- */
-import { Id64, Id64String } from "@itwin/core-bentley";
-import { BatchType, Feature } from "./FeatureTable";
-import { ColorDef } from "./ColorDef";
-import { GeometryClass } from "./GeometryParams";
-import { LinePixels } from "./LinePixels";
-import { RgbColor, RgbColorProps } from "./RgbColor";
-import { SubCategoryOverride } from "./SubCategoryOverride";
-/** JSON representation of a [[FeatureAppearance]].
- * @public
- * @extensions
- */
-export interface FeatureAppearanceProps {
-    /** See [[FeatureAppearance.rgb]]. */
-    rgb?: RgbColorProps;
-    /** See [[FeatureAppearance.weight]]. */
-    weight?: number;
-    /** See [[FeatureAppearance.transparency]]. */
-    transparency?: number;
-    /** See [[FeatureAppearance.viewDependentTransparency]]. */
-    viewDependentTransparency?: true;
-    /** See [[FeatureAppearance.linePixels]]. */
-    linePixels?: LinePixels;
-    /** See [[FeatureAppearance.ignoresMaterial]]. */
-    ignoresMaterial?: true;
-    /** See [[FeatureAppearance.nonLocatable]]. */
-    nonLocatable?: true;
-    /** See [[FeatureAppearance.emphasized]]. */
-    emphasized?: true;
-}
-/** Defines overrides for selected aspects of a [[Feature]]'s symbology.
- * Any member defined in the appearance overrides that aspect of symbology for all [[Feature]]s to which the appearance is applied.
- * @see [[FeatureOverrides]] to customize the appearance of multiple features.
- * @public
- */
-export declare class FeatureAppearance {
-    /** Overrides the feature's color. */
-    readonly rgb?: RgbColor;
-    /** The width of lines and edges in pixels as an integer in [1, 31]. */
-    readonly weight?: number;
-    /** The transparency in the range [0, 1] where 0 indicates fully opaque and 1 indicates fully transparent.
-     * @see [[viewDependentTransparency]] for details on how this override interacts with the [DisplayStyle]($backend).
-     */
-    readonly transparency?: number;
-    /** The pixel pattern applied to lines and edges. */
-    readonly linePixels?: LinePixels;
-    /** If true, don't apply the [[RenderMaterial]] to the feature's surfaces. */
-    readonly ignoresMaterial?: true;
-    /** If true, the feature will not be drawn when using [Viewport.readPixels]($frontend), meaning [Tool]($frontend)s will not be able to interact with it. */
-    readonly nonLocatable?: true;
-    /** If true, the feature will be rendered using the [[Hilite.Settings]] defined by [Viewport.emphasisSettings]($frontend) to make it stand out. */
-    readonly emphasized?: true;
-    /** If true, then [[transparency]] will only be applied if [[ViewFlags.transparency]] is enabled and the current [[RenderMode]] supports transparency.
-     * Default: false, meaning the transparency will be applied regardless of view flags or render mode.
-     * This property has no effect if [[transparency]] is `undefined`.
-     */
-    readonly viewDependentTransparency?: true;
-    /** An appearance that overrides nothing. */
-    static readonly defaults: FeatureAppearance;
-    static fromJSON(props?: FeatureAppearanceProps): FeatureAppearance;
-    /** Create a FeatureAppearance that overrides only the RGB color.
-     * @note The transparency component of the ColorDef is ignored.
-     */
-    static fromRgb(color: ColorDef): FeatureAppearance;
-    /** Create a FeatureAppearance that overrides the RGB and transparency.
-     * The appearance's transparency is derived from the transparency component of the ColorDef.
-     */
-    static fromRgba(color: ColorDef, viewDependentTransparency?: boolean): FeatureAppearance;
-    /** Create a FeatureAppearance that overrides only the transparency */
-    static fromTransparency(transparencyValue: number, viewDependent?: boolean): FeatureAppearance;
-    /** Create a FeatureAppearance with overrides corresponding to those defined by the supplied SubCategoryOverride.
-     * @note Subcategory overrides set [[viewDependentTransparency]] to `true`.
-     */
-    static fromSubCategoryOverride(ovr: SubCategoryOverride): FeatureAppearance;
-    /** Returns true if this appearance does not override any aspects of symbology. */
-    get matchesDefaults(): boolean;
-    get overridesRgb(): boolean;
-    get overridesTransparency(): boolean;
-    get overridesLinePixels(): boolean;
-    get overridesWeight(): boolean;
-    get overridesSymbology(): boolean;
-    get overridesNonLocatable(): boolean;
-    get isFullyTransparent(): boolean;
-    /** Returns true if any aspect of the appearance is overridden (i.e., if any member is not undefined). */
-    get anyOverridden(): boolean;
-    equals(other: FeatureAppearance): boolean;
-    toJSON(): FeatureAppearanceProps;
-    /** Convert this appearance to JSON, and override any properties explicitly specified by `changedProps` in the result.
-     * Example:
-     * ```ts
-     *  const base = FeatureAppearance.fromRgba(ColorDef.white); // transparency=0, rgb=white
-     *  const clone = base.cloneProps({ transparency: undefined, weight: 5 }); // transparency=undefined, rgb=white, weight=5
-     * ```
-     * @see [[FeatureAppearance.clone]].
-     */
-    cloneProps(changedProps: FeatureAppearanceProps): FeatureAppearanceProps;
-    /** Create a copy of this appearance, overriding any properties explicitly specified by `changedProps`.
-     * Example:
-     * ```ts
-     *  const base = FeatureAppearance.fromRgba(ColorDef.white); // transparency=0, rgb=white
-     *  const clone = base.clone({ transparency: undefined, weight: 5 }); // transparency=undefined, rgb=white, weight=5
-     * ```
-     * @see [[FeatureAppearance.cloneProps]].
-     */
-    clone(changedProps: FeatureAppearanceProps): FeatureAppearance;
-    /** Produce a FeatureAppearance from the supplied appearance in which any aspect not defined by the base appearance is overridden by this appearance. */
-    extendAppearance(base: FeatureAppearance): FeatureAppearance;
-    protected constructor(props: FeatureAppearanceProps);
-    private rgbIsEqual;
-    private transparencyIsEqual;
-}
-/** Interface adopted by an object that can supply a [[FeatureAppearance]] given a low-level description of a [[Feature]].
- * @see [[FeatureOverrides]] for the commonly-used implementation.
- * @see [[FeatureAppearanceProvider]] to supplement the appearance supplied by this interface.
- * @public
- * @extensions
- */
-export interface FeatureAppearanceSource {
-    /** Supplies the desired appearance overrides for the specified [[Feature]], or `undefined` if the feature should not be drawn.
-     * The feature is described by its components for efficiency reasons.
-     * @param elemLo The lower 32 bits of the feature's element Id.
-     * @param elemHi The upper 32 bits of the feature's element Id.
-     * @param subcatLo The lower 32 bits of the feature's subcategory Id.
-     * @param subcatHi The upper 32 bits of the feature's subcategory Id.
-     * @param geomClass The geometry class of the feature.
-     * @param modelLo The lower 32 bits of the feature's model Id.
-     * @param modelHi The upper 32 bits of the feature's model Id.
-     * @param type The type of batch to which the feature belongs.
-     * @param animationNodeId The Id of the corresponding node in the [[RenderSchedule]], or `0` if none.
-     * @returns The desired appearance overrides, or `undefined` to indicate the feature should not be displayed.
-     * @see [Id64.isValidUint32Pair]($core-bentley) to determine if the components of an [Id64String]($core-bentley) represent a valid Id.
-     */
-    getAppearance(elemLo: number, elemHi: number, subcatLo: number, subcatHi: number, geomClass: GeometryClass, modelLo: number, modelHi: number, type: BatchType, animationNodeId: number): FeatureAppearance | undefined;
-}
-/** Common options for [[FeatureOverrides.override]].
- * @public
- */
-export interface OverrideFeatureAppearanceOptions {
-    /** Specifies the aspects of the [[Feature]]'s appearance to be overridden. */
-    appearance: FeatureAppearance;
-    /** Specifies what to do if a [[FeatureAppearance]] has already been configured for the specified element, model, or subcategory by a previous call to [[FeatureOverrides.override]].
-     *  - "subsume" (the default): Merge the two appearances using the logic described by [[FeatureAppearance.extendAppearance]] such that any aspect overridden by the existing appearance will be overwritten
-     *    if also overridden by [[appearance]].
-     *    - The resulting appearance is computed as `existingAppearance.extendAppearance(newAppearance)`.
-     *  - "extend": Merge the two appearances using the logic described by [[FeatureAppearance.extendAppearance]] such that any aspect overridden by [[appearance]] will only
-     *    apply if that aspect is not already overridden by a previous appearance.
-     *    - The resulting appearance is computed as `newAppearance.extendAppearance(existingAppearance)`.
-     *  - "replace": Completely replace the existing appearance with [[appearance]].
-     *  - "skip": Keep the existing appearance.
-     */
-    onConflict?: "extend" | "subsume" | "replace" | "skip";
-}
-/** Options for using [[FeatureOverrides.override]] to override the appearance of a [GeometricModel]($backend).
- * @public
- */
-export interface OverrideModelAppearanceOptions extends OverrideFeatureAppearanceOptions {
-    /** The Id of the model whose appearance is to be overridden. */
-    modelId: Id64String;
-    /** @internal */
-    elementId?: never;
-    /** @internal */
-    subCategoryId?: never;
-}
-/** Options for using [[FeatureOverrides.override]] to override the appearance of a [GeometricElement]($backend).
- * @public
- */
-export interface OverrideElementAppearanceOptions extends OverrideFeatureAppearanceOptions {
-    /** The Id of the element whose appearance is to be overridden. */
-    elementId: Id64String;
-    /** @internal */
-    modelId?: never;
-    /** @internal */
-    subCategoryId?: never;
-}
-/** Options for using [[FeatureOverrides.override]] to override the appearance of a [SubCategory]($backend).
- * @public
- */
-export interface OverrideSubCategoryAppearanceOptions extends OverrideFeatureAppearanceOptions {
-    /** The Id of the subcategory whose appearance is to be overridden. */
-    subCategoryId: Id64String;
-    /** @internal */
-    modelId?: never;
-    /** @internal */
-    elementId?: never;
-}
-/** Arguments supplied to [[FeatureOverrides.override]].
- * @public
- */
-export declare type OverrideFeatureAppearanceArgs = OverrideElementAppearanceOptions | OverrideModelAppearanceOptions | OverrideSubCategoryAppearanceOptions;
-/** Arguments provided to a function of type [[IgnoreAnimationOverrides]].
- * @see [[FeatureOverrides.ignoreAnimationOverrides]] to register such a function.
- * @public
- */
-export interface IgnoreAnimationOverridesArgs {
-    /** The Id of the element under consideration.
-     * @see [Id64.fromUint32Pair]($bentley) to convert a Uint32Pair into an [Id64String]($bentley), if needed.
-     */
-    readonly elementId: Readonly<Id64.Uint32Pair>;
-    /** The [[RenderSchedule.ElementTimeline.batchId]] identifying the [[RenderSchedule.ElementTimeline]] to which the element under consideration belongs. */
-    readonly animationNodeId: number;
-}
-/** A function that can be supplied to [[FeatureOverrides.ignoreAnimationOverrides]] to indicate whether the color or transparency overrides defined
- * by the view's [[RenderSchedule.Script]] should be ignored. The arguments describe the element under consideration. The function should return true if that
- * element should not have its color or transparency modified by the schedule script.
- * @public
- */
-export declare type IgnoreAnimationOverrides = (args: IgnoreAnimationOverridesArgs) => boolean;
-/** Specifies how to customize the appearance of individual [[Feature]]s, typically within the context of a [Viewport]($frontend).
- * Individual aspects of a feature's appearance - like visibility, color, and transparency - are overridden by supplying a [[FeatureAppearance]].
- * Those overrides can be specified on the basis of the feature's model, element, and/or subcategory. A default set of overrides can also be specified to
- * apply to the appearance of any feature not otherwise overridden.
- *
- * It is possible to override multiple aspects of a feature on different bases. For example, you might specify that all features belonging to subcategory "A" should be drawn in red,
- * and that all features belonging to model "B" should be drawn 50% transparent. In this case, a feature belonging to both subcategory "A" and model "B" will be drawn as 50% transparent red -
- * the separate overrides are combined to produce the feature's overall appearance.
- *
- * In the case of conflicts, there is an order of precedence:
- *  - Model overrides take highest precedence.
- *  - Element overrides are of higher precedence than subcategory and animation overrides.
- *  - Overrides applied by a [[RenderSchedule.Script]]'s [[RenderSchedule.ElementTimeline]] are of higher precedence than subcategory overrides, but can be suppressed on a per-element basis via [[ignoreAnimationOverrides]].
- *  - Subcategory overrides have lowest precedence.
- *
- * For example, you might specify that all features belonging to subcategory "A" should be drawn in red, and all those belonging to model "B" should be drawn in green.
- * Then a feature belonging to subcategory "A" and model "B" will be drawn in green, because the model overrides take precedence.
- *
- * Instances of this class are not typically instantiated by an application directly; instead, an application can implement a [FeatureOverrideProvider]($frontend)
- * that augments the overrides supplied by a viewport.
- *
- * @see [FeatureSymbology.Overrides]($frontend) to create overrides specific to a [Viewport]($frontend) or [ViewState]($frontend).
- * @see [FeatureOverrideProvider]($frontend) to customize the appearance of features within a [Viewport]($frontend).
- * @public
- */
-export declare class FeatureOverrides implements FeatureAppearanceSource {
-    /** @internal */
-    protected readonly _ignoreAnimationOverrides: IgnoreAnimationOverrides[];
-    /** Ids of elements that should never be drawn. This takes precedence over [[alwaysDrawn]]. @internal */
-    protected readonly _neverDrawn: Id64.Uint32Set;
-    /** Ids of elements that should always be drawn. [[neverDrawn]] takes precedence over this set. @internal */
-    protected readonly _alwaysDrawn: Id64.Uint32Set;
-    /** If true, no elements *except* those defined in the "always drawn" set will be drawn.
-     * @see [[setAlwaysDrawn]]
-     */
-    isAlwaysDrawnExclusive: boolean;
-    /** If true, the always-drawn elements are drawn even if their subcategories are not visible.
-     * @see [[setAlwaysDrawn]]
-     */
-    alwaysDrawnIgnoresSubCategory: boolean;
-    /** If true, all subcategories are considered visible. This is used for drawing sheets via section callouts in the absence of an actual sheet view.
-     * @internal
-     */
-    ignoreSubCategory: boolean;
-    /** Overrides applied to any feature not explicitly overridden. @internal */
-    protected _defaultOverrides: FeatureAppearance;
-    /** Whether construction geometry should be drawn. @internal */
-    protected _constructions: boolean;
-    /** Whether dimensions should be drawn. @internal */
-    protected _dimensions: boolean;
-    /** Whether area patterns should be drawn. @internal */
-    protected _patterns: boolean;
-    /** Whether line weights should be applied. If false, all lines are rendered 1-pixel wide. @internal */
-    protected _lineWeights: boolean;
-    /** Overrides applied to all elements belonging to each model. @internal */
-    protected readonly _modelOverrides: Id64.Uint32Map<FeatureAppearance>;
-    /** Overrides applied to specific elements. @internal */
-    protected readonly _elementOverrides: Id64.Uint32Map<FeatureAppearance>;
-    /** Overrides applied to geometry belonging to each subcategory. @internal */
-    protected readonly _subCategoryOverrides: Id64.Uint32Map<FeatureAppearance>;
-    /** The set of displayed subcategories. Geometry belonging to subcategories not included in this set will not be drawn. @internal */
-    protected readonly _visibleSubCategories: Id64.Uint32Set;
-    /** Display priorities assigned to subcategories, possibly overridden by display style. Only applicable for plan projection models. @internal */
-    protected readonly _subCategoryPriorities: Id64.Uint32Map<number>;
-    /** Per-model, a set of subcategories whose visibility should be inverted for elements within that model.
-     * Populated by Viewport.
-     * @internal
-     */
-    protected readonly _modelSubCategoryOverrides: Id64.Uint32Map<Id64.Uint32Set>;
-    /** Ids of animation nodes that should never be drawn.
-     * @internal
-     */
-    readonly neverDrawnAnimationNodes: Set<number>;
-    /** Mapping of animation node Ids to overrides applied to the corresponding animation nodes.
-     * @internal
-     */
-    readonly animationNodeOverrides: Map<number, FeatureAppearance>;
-    /** Accepts a criterion that determines whether color and transparency overrides originating from the view's [[RenderSchedule.Script]] should be ignored for a given element.
-     * The function receives a description of the element in question and returns `true` if the script's overrides should be ignored.
-     * Any number of such functions can be registered; if any one of them returns `true`, the script's overrides are not applied to the specified element.
-     *
-     * For example, applications commonly emphasize a set of elements by applying a [[FeatureAppearance.emphasized]] override to them, and specifying a highly-transparent
-     * default appearance to de-emphasize the rest of the elements in the view. If some of the de-emphasized elements' appearances are also being overridden by the schedule script, then
-     * they won't appear de-emphasized, making it difficult for the emphasized elements to stand out. In situations like this, [FeatureOverrideProvider]($frontend)s like [EmphasizeElements]($frontend) can register an [[IgnoreAnimationOverrides]] function that returns true if the element in question is not in the set of emphasized elements.
-     */
-    ignoreAnimationOverrides(ignore: IgnoreAnimationOverrides): void;
-    /** Overrides applied to features for which no other overrides are defined */
-    get defaultOverrides(): FeatureAppearance;
-    /** Whether or not line weights are applied. If false, all lines are drawn with a weight of 1. */
-    get lineWeights(): boolean;
-    /** @internal */
-    get neverDrawn(): Id64.Uint32Set;
-    /** @internal */
-    get alwaysDrawn(): Id64.Uint32Set;
-    /** @internal */
-    protected isNeverDrawn(elemIdLo: number, elemIdHi: number, animationNodeId: number): boolean;
-    /** @internal */
-    protected isAlwaysDrawn(idLo: number, idHi: number): boolean;
-    /** Returns true if the [SubCategory]($backend) specified by Id is in the set of visible subcategories. @internal */
-    isSubCategoryVisible(idLo: number, idHi: number): boolean;
-    /** @internal */
-    isSubCategoryVisibleInModel(subcatLo: number, subcatHi: number, modelLo: number, modelHi: number): boolean;
-    /** @internal */
-    protected getModelOverrides(idLo: number, idHi: number): FeatureAppearance | undefined;
-    private getElementAnimationOverrides;
-    /** @internal */
-    protected getElementOverrides(idLo: number, idHi: number, animationNodeId: number): FeatureAppearance | undefined;
-    /** @internal */
-    protected getSubCategoryOverrides(idLo: number, idHi: number): FeatureAppearance | undefined;
-    /** Add a [SubCategory]($backend) to the set of visible subcategories. */
-    setVisibleSubCategory(id: Id64String): void;
-    /** Specify the Id of an element that should never be drawn. */
-    setNeverDrawn(id: Id64String): void;
-    /** Specify the Id of an element that should always be drawn. */
-    setAlwaysDrawn(id: Id64String): void;
-    /** Specify the Id of a animation node that should never be drawn. */
-    setAnimationNodeNeverDrawn(id: number): void;
-    /** Specify the Ids of elements that should never be drawn. */
-    setNeverDrawnSet(ids: Iterable<Id64String>): void;
-    /** Specify the Ids of elements that should always be drawn. */
-    setAlwaysDrawnSet(ids: Iterable<Id64String>, exclusive: boolean, ignoreSubCategory?: boolean): void;
-    /** Returns the feature's appearance overrides, or undefined if the feature is not visible. */
-    getFeatureAppearance(feature: Feature, modelId: Id64String, type?: BatchType, animationNodeId?: number): FeatureAppearance | undefined;
-    private static readonly _weight1Appearance;
-    /** Returns a feature's appearance overrides, or undefined if the feature is not visible.
-     * Takes Id64s as pairs of unsigned 32-bit integers for efficiency, because that is how they are stored by the PackedFeatureTable associated with each batch of graphics.
-     * @see [[getFeatureAppearance]] for an equivalent function that accepts [Id64String]($core-bentley)s instead of integer pairs.
-     */
-    getAppearance(elemLo: number, elemHi: number, subcatLo: number, subcatHi: number, geomClass: GeometryClass, modelLo: number, modelHi: number, type: BatchType, animationNodeId: number): FeatureAppearance | undefined;
-    /** Classifiers behave totally differently...in particular they are never invisible unless fully-transparent.
-     * @internal
-     */
-    protected getClassifierAppearance(elemLo: number, elemHi: number, subcatLo: number, subcatHi: number, modelLo: number, modelHi: number, animationNodeId: number): FeatureAppearance | undefined;
-    /** Return whether geometry of the specified class should be drawn.
-     * @see [[ViewFlags.constructions]], [[ViewFlags.dimensions]], and [[ViewFlags.patterns]].
-     */
-    isClassVisible(geomClass: GeometryClass): boolean;
-    /** Specify overrides for all elements belonging to a specified [GeometricModel]($backend), or all geometry belonging to a specified [GeometricElement]($backend) or [SubCategory]($backend). */
-    override(args: OverrideFeatureAppearanceArgs): void;
-    /** Specify overrides for all elements within the specified model.
-     * @param id The Id of the model.
-     * @param app The symbology overrides.
-     * @param replaceExisting Specifies whether to replace a pre-existing override for the same model.
-     * @note These overrides take priority over all other overrides.
-     * @note If [[defaultOverrides]] are defined, they will not apply to any element within this model, even if the supplied appearance overrides nothing.
-     * @deprecated in 3.x. Use [[FeatureOverrides.override]].
-     */
-    overrideModel(id: Id64String, app: FeatureAppearance, replaceExisting?: boolean): void;
-    /** Specify overrides for all geometry belonging to the specified [SubCategory]($backend).
-     * @param id The Id of the subcategory.
-     * @param app The symbology overrides.
-     * @param replaceExisting Specifies whether to replace a pre-existing override for the same subcategory.
-     * @note These overrides have lower priority than element and model overrides.
-     * @note If [[defaultOverrides]] are defined, they will not apply to any geometry within this subcategory, even if the supplied appearance overrides nothing.
-     * @deprecated in 3.x. Use [[FeatureOverrides.override]].
-     */
-    overrideSubCategory(id: Id64String, app: FeatureAppearance, replaceExisting?: boolean): void;
-    /** Specify overrides for all geometry originating from the specified element.
-     * @param id The Id of the element.
-     * @param app The symbology overrides.
-     * @param replaceExisting Specifies whether to replace a pre-existing override for the same element.
-     * @note These overrides take precedence over subcategory overrides, but not over model overrides.
-     * @note If [[defaultOverrides]] are defined, they will not apply to this element, even if the supplied appearance overrides nothing.
-     * @deprecated in 3.x. Use [[FeatureOverrides.override]].
-     */
-    overrideElement(id: Id64String, app: FeatureAppearance, replaceExisting?: boolean): void;
-    /** Specify overrides for all geometry originating from the specified animation node.
-     * @param id The Id of the animation node.
-     * @param app The symbology overrides.
-     * @note These overrides do not take precedence over element overrides.
-     */
-    overrideAnimationNode(id: number, app: FeatureAppearance): void;
-    /** Defines a default appearance to be applied to any [[Feature]] *not* explicitly overridden.
-     * @param appearance The symbology overrides.
-     * @param replaceExisting Specifies whether to replace the current default overrides if they are already defined.
-     */
-    setDefaultOverrides(appearance: FeatureAppearance, replaceExisting?: boolean): void;
-    /** Get the display priority of a subcategory. This is only relevant when using [[PlanProjectionSettings]].
-     * @internal
-     */
-    getSubCategoryPriority(idLo: number, idHi: number): number;
-    /** Construct a new Overrides that overrides nothing.
-     * @see [FeatureSymbology.Overrides]($frontend) to construct overrides based on a [ViewState]($frontend) or [Viewport]($frontend).
-     */
-    constructor();
-    /** Returns true if geometry belonging to the specified subcategory will be drawn. */
-    isSubCategoryIdVisible(id: Id64String): boolean;
-    /** Returns the overrides applied to geometry belonging to the specified model, if any such are defined. */
-    getModelOverridesById(id: Id64String): FeatureAppearance | undefined;
-    /** Returns the overrides applied to geometry belonging to the specified element, if any such are defined. */
-    getElementOverridesById(id: Id64String): FeatureAppearance | undefined;
-    /** Returns the overrides applied to geometry belonging to the specified subcategory, if any such are defined. */
-    getSubCategoryOverridesById(id: Id64String): FeatureAppearance | undefined;
-    /** Returns true if the specified Feature will be drawn. */
-    isFeatureVisible(feature: Feature): boolean;
-}
-/** Interface adopted by an object that can supply the [[FeatureAppearance]] supplied by a [[FeatureAppearanceSource]].
- * This is useful for selectively overriding or agumenting a [Viewport]($frontend)'s symbology overrides.
- * A typical implementation will invoke [[FeatureAppearanceSource.getAppeaprance]] and customize the returned appearance.
- * @see [[FeatureAppearanceProvider.chain]] to chain two providers together.
- * @public
- * @extensions
- */
-export interface FeatureAppearanceProvider {
-    /** Supply the desired appearance overrides for the specified [[Feature]], or `undefined` if the feature should not be drawn.
-     * The feature is described by its components for efficiency reasons.
-     * @param source The base symbology overrides, e.g., typically defined by a [Viewport]($frontend).
-     * @param elemLo The lower 32 bits of the feature's element Id.
-     * @param elemHi The upper 32 bits of the feature's element Id.
-     * @param subcatLo The lower 32 bits of the feature's subcategory Id.
-     * @param subcatHi The upper 32 bits of the feature's subcategory Id.
-     * @param geomClass The geometry class of the feature.
-     * @param modelLo The lower 32 bits of the feature's model Id.
-     * @param modelHi The upper 32 bits of the feature's model Id.
-     * @param type The type of batch to which the feature belongs.
-     * @param animationNodeId The Id of the corresponding node in the [[RenderSchedule]], or `0` if none.
-     * @returns The desired appearance overrides, or `undefined` to indicate the feature should not be displayed.
-     * @see [[FeatureAppearanceSource.getAppearance]] to forward the request to the source.
-     * @see [Id64.isValidUint32Pair]($core-bentley) to determine if the components of an [Id64String]($core-bentley) represent a valid Id.
-     */
-    getFeatureAppearance(source: FeatureAppearanceSource, elemLo: number, elemHi: number, subcatLo: number, subcatHi: number, geomClass: GeometryClass, modelLo: number, modelHi: number, type: BatchType, animationNodeId: number): FeatureAppearance | undefined;
-}
-/** @public */
-export declare namespace FeatureAppearanceProvider {
-    /** Create a provider that obtains each feature's appearance from the source, and if the feature is visible, modifies the appearance.
-     * @param supplementAppearance A function accepting the feature's base appearance and returning a supplemental appearance.
-     * @public
-     */
-    function supplement(supplementAppearance: (appearance: FeatureAppearance) => FeatureAppearance): FeatureAppearanceProvider;
-    /** Chain two FeatureAppearanceProviders together such that `first`'s `getFeatureAppearance` function is applied before `second`'s.
-     * If `second` invokes `source.getAppearance()`, the returned appearance will include any modifications applied by `first`.
-     * @public
-     */
-    function chain(first: FeatureAppearanceProvider, second: FeatureAppearanceProvider): FeatureAppearanceProvider;
-}
+/** @packageDocumentation
+ * @module Rendering
+ */
+import { Id64, Id64String } from "@itwin/core-bentley";
+import { BatchType, Feature } from "./FeatureTable";
+import { ColorDef } from "./ColorDef";
+import { GeometryClass } from "./GeometryParams";
+import { LinePixels } from "./LinePixels";
+import { RgbColor, RgbColorProps } from "./RgbColor";
+import { SubCategoryOverride } from "./SubCategoryOverride";
+/** JSON representation of a [[FeatureAppearance]].
+ * @public
+ * @extensions
+ */
+export interface FeatureAppearanceProps {
+    /** See [[FeatureAppearance.rgb]]. */
+    rgb?: RgbColorProps;
+    /** See [[FeatureAppearance.weight]]. */
+    weight?: number;
+    /** See [[FeatureAppearance.transparency]]. */
+    transparency?: number;
+    /** See [[FeatureAppearance.viewDependentTransparency]]. */
+    viewDependentTransparency?: true;
+    /** See [[FeatureAppearance.linePixels]]. */
+    linePixels?: LinePixels;
+    /** See [[FeatureAppearance.ignoresMaterial]]. */
+    ignoresMaterial?: true;
+    /** See [[FeatureAppearance.nonLocatable]]. */
+    nonLocatable?: true;
+    /** See [[FeatureAppearance.emphasized]]. */
+    emphasized?: true;
+}
+/** Defines overrides for selected aspects of a [[Feature]]'s symbology.
+ * Any member defined in the appearance overrides that aspect of symbology for all [[Feature]]s to which the appearance is applied.
+ * @see [[FeatureOverrides]] to customize the appearance of multiple features.
+ * @public
+ */
+export declare class FeatureAppearance {
+    /** Overrides the feature's color. */
+    readonly rgb?: RgbColor;
+    /** The width of lines and edges in pixels as an integer in [1, 31]. */
+    readonly weight?: number;
+    /** The transparency in the range [0, 1] where 0 indicates fully opaque and 1 indicates fully transparent.
+     * @see [[viewDependentTransparency]] for details on how this override interacts with the [DisplayStyle]($backend).
+     */
+    readonly transparency?: number;
+    /** The pixel pattern applied to lines and edges. */
+    readonly linePixels?: LinePixels;
+    /** If true, don't apply the [[RenderMaterial]] to the feature's surfaces. */
+    readonly ignoresMaterial?: true;
+    /** If true, the feature will not be drawn when using [Viewport.readPixels]($frontend), meaning [Tool]($frontend)s will not be able to interact with it. */
+    readonly nonLocatable?: true;
+    /** If true, the feature will be rendered using the [[Hilite.Settings]] defined by [Viewport.emphasisSettings]($frontend) to make it stand out. */
+    readonly emphasized?: true;
+    /** If true, then [[transparency]] will only be applied if [[ViewFlags.transparency]] is enabled and the current [[RenderMode]] supports transparency.
+     * Default: false, meaning the transparency will be applied regardless of view flags or render mode.
+     * This property has no effect if [[transparency]] is `undefined`.
+     */
+    readonly viewDependentTransparency?: true;
+    /** An appearance that overrides nothing. */
+    static readonly defaults: FeatureAppearance;
+    static fromJSON(props?: FeatureAppearanceProps): FeatureAppearance;
+    /** Create a FeatureAppearance that overrides only the RGB color.
+     * @note The transparency component of the ColorDef is ignored.
+     */
+    static fromRgb(color: ColorDef): FeatureAppearance;
+    /** Create a FeatureAppearance that overrides the RGB and transparency.
+     * The appearance's transparency is derived from the transparency component of the ColorDef.
+     */
+    static fromRgba(color: ColorDef, viewDependentTransparency?: boolean): FeatureAppearance;
+    /** Create a FeatureAppearance that overrides only the transparency */
+    static fromTransparency(transparencyValue: number, viewDependent?: boolean): FeatureAppearance;
+    /** Create a FeatureAppearance with overrides corresponding to those defined by the supplied SubCategoryOverride.
+     * @note Subcategory overrides set [[viewDependentTransparency]] to `true`.
+     */
+    static fromSubCategoryOverride(ovr: SubCategoryOverride): FeatureAppearance;
+    /** Returns true if this appearance does not override any aspects of symbology. */
+    get matchesDefaults(): boolean;
+    get overridesRgb(): boolean;
+    get overridesTransparency(): boolean;
+    get overridesLinePixels(): boolean;
+    get overridesWeight(): boolean;
+    get overridesSymbology(): boolean;
+    get overridesNonLocatable(): boolean;
+    get isFullyTransparent(): boolean;
+    /** Returns true if any aspect of the appearance is overridden (i.e., if any member is not undefined). */
+    get anyOverridden(): boolean;
+    equals(other: FeatureAppearance): boolean;
+    toJSON(): FeatureAppearanceProps;
+    /** Convert this appearance to JSON, and override any properties explicitly specified by `changedProps` in the result.
+     * Example:
+     * ```ts
+     *  const base = FeatureAppearance.fromRgba(ColorDef.white); // transparency=0, rgb=white
+     *  const clone = base.cloneProps({ transparency: undefined, weight: 5 }); // transparency=undefined, rgb=white, weight=5
+     * ```
+     * @see [[FeatureAppearance.clone]].
+     */
+    cloneProps(changedProps: FeatureAppearanceProps): FeatureAppearanceProps;
+    /** Create a copy of this appearance, overriding any properties explicitly specified by `changedProps`.
+     * Example:
+     * ```ts
+     *  const base = FeatureAppearance.fromRgba(ColorDef.white); // transparency=0, rgb=white
+     *  const clone = base.clone({ transparency: undefined, weight: 5 }); // transparency=undefined, rgb=white, weight=5
+     * ```
+     * @see [[FeatureAppearance.cloneProps]].
+     */
+    clone(changedProps: FeatureAppearanceProps): FeatureAppearance;
+    /** Produce a FeatureAppearance from the supplied appearance in which any aspect not defined by the base appearance is overridden by this appearance. */
+    extendAppearance(base: FeatureAppearance): FeatureAppearance;
+    protected constructor(props: FeatureAppearanceProps);
+    private rgbIsEqual;
+    private transparencyIsEqual;
+}
+/** Interface adopted by an object that can supply a [[FeatureAppearance]] given a low-level description of a [[Feature]].
+ * @see [[FeatureOverrides]] for the commonly-used implementation.
+ * @see [[FeatureAppearanceProvider]] to supplement the appearance supplied by this interface.
+ * @public
+ * @extensions
+ */
+export interface FeatureAppearanceSource {
+    /** Supplies the desired appearance overrides for the specified [[Feature]], or `undefined` if the feature should not be drawn.
+     * The feature is described by its components for efficiency reasons.
+     * @param elemLo The lower 32 bits of the feature's element Id.
+     * @param elemHi The upper 32 bits of the feature's element Id.
+     * @param subcatLo The lower 32 bits of the feature's subcategory Id.
+     * @param subcatHi The upper 32 bits of the feature's subcategory Id.
+     * @param geomClass The geometry class of the feature.
+     * @param modelLo The lower 32 bits of the feature's model Id.
+     * @param modelHi The upper 32 bits of the feature's model Id.
+     * @param type The type of batch to which the feature belongs.
+     * @param animationNodeId The Id of the corresponding node in the [[RenderSchedule]], or `0` if none.
+     * @returns The desired appearance overrides, or `undefined` to indicate the feature should not be displayed.
+     * @see [Id64.isValidUint32Pair]($core-bentley) to determine if the components of an [Id64String]($core-bentley) represent a valid Id.
+     */
+    getAppearance(elemLo: number, elemHi: number, subcatLo: number, subcatHi: number, geomClass: GeometryClass, modelLo: number, modelHi: number, type: BatchType, animationNodeId: number): FeatureAppearance | undefined;
+}
+/** Common options for [[FeatureOverrides.override]].
+ * @public
+ */
+export interface OverrideFeatureAppearanceOptions {
+    /** Specifies the aspects of the [[Feature]]'s appearance to be overridden. */
+    appearance: FeatureAppearance;
+    /** Specifies what to do if a [[FeatureAppearance]] has already been configured for the specified element, model, or subcategory by a previous call to [[FeatureOverrides.override]].
+     *  - "subsume" (the default): Merge the two appearances using the logic described by [[FeatureAppearance.extendAppearance]] such that any aspect overridden by the existing appearance will be overwritten
+     *    if also overridden by [[appearance]].
+     *    - The resulting appearance is computed as `existingAppearance.extendAppearance(newAppearance)`.
+     *  - "extend": Merge the two appearances using the logic described by [[FeatureAppearance.extendAppearance]] such that any aspect overridden by [[appearance]] will only
+     *    apply if that aspect is not already overridden by a previous appearance.
+     *    - The resulting appearance is computed as `newAppearance.extendAppearance(existingAppearance)`.
+     *  - "replace": Completely replace the existing appearance with [[appearance]].
+     *  - "skip": Keep the existing appearance.
+     */
+    onConflict?: "extend" | "subsume" | "replace" | "skip";
+}
+/** Options for using [[FeatureOverrides.override]] to override the appearance of a [GeometricModel]($backend).
+ * @public
+ */
+export interface OverrideModelAppearanceOptions extends OverrideFeatureAppearanceOptions {
+    /** The Id of the model whose appearance is to be overridden. */
+    modelId: Id64String;
+    /** @internal */
+    elementId?: never;
+    /** @internal */
+    subCategoryId?: never;
+}
+/** Options for using [[FeatureOverrides.override]] to override the appearance of a [GeometricElement]($backend).
+ * @public
+ */
+export interface OverrideElementAppearanceOptions extends OverrideFeatureAppearanceOptions {
+    /** The Id of the element whose appearance is to be overridden. */
+    elementId: Id64String;
+    /** @internal */
+    modelId?: never;
+    /** @internal */
+    subCategoryId?: never;
+}
+/** Options for using [[FeatureOverrides.override]] to override the appearance of a [SubCategory]($backend).
+ * @public
+ */
+export interface OverrideSubCategoryAppearanceOptions extends OverrideFeatureAppearanceOptions {
+    /** The Id of the subcategory whose appearance is to be overridden. */
+    subCategoryId: Id64String;
+    /** @internal */
+    modelId?: never;
+    /** @internal */
+    elementId?: never;
+}
+/** Arguments supplied to [[FeatureOverrides.override]].
+ * @public
+ */
+export declare type OverrideFeatureAppearanceArgs = OverrideElementAppearanceOptions | OverrideModelAppearanceOptions | OverrideSubCategoryAppearanceOptions;
+/** Arguments provided to a function of type [[IgnoreAnimationOverrides]].
+ * @see [[FeatureOverrides.ignoreAnimationOverrides]] to register such a function.
+ * @public
+ */
+export interface IgnoreAnimationOverridesArgs {
+    /** The Id of the element under consideration.
+     * @see [Id64.fromUint32Pair]($bentley) to convert a Uint32Pair into an [Id64String]($bentley), if needed.
+     */
+    readonly elementId: Readonly<Id64.Uint32Pair>;
+    /** The [[RenderSchedule.ElementTimeline.batchId]] identifying the [[RenderSchedule.ElementTimeline]] to which the element under consideration belongs. */
+    readonly animationNodeId: number;
+}
+/** A function that can be supplied to [[FeatureOverrides.ignoreAnimationOverrides]] to indicate whether the color or transparency overrides defined
+ * by the view's [[RenderSchedule.Script]] should be ignored. The arguments describe the element under consideration. The function should return true if that
+ * element should not have its color or transparency modified by the schedule script.
+ * @public
+ */
+export declare type IgnoreAnimationOverrides = (args: IgnoreAnimationOverridesArgs) => boolean;
+/** Specifies how to customize the appearance of individual [[Feature]]s, typically within the context of a [Viewport]($frontend).
+ * Individual aspects of a feature's appearance - like visibility, color, and transparency - are overridden by supplying a [[FeatureAppearance]].
+ * Those overrides can be specified on the basis of the feature's model, element, and/or subcategory. A default set of overrides can also be specified to
+ * apply to the appearance of any feature not otherwise overridden.
+ *
+ * It is possible to override multiple aspects of a feature on different bases. For example, you might specify that all features belonging to subcategory "A" should be drawn in red,
+ * and that all features belonging to model "B" should be drawn 50% transparent. In this case, a feature belonging to both subcategory "A" and model "B" will be drawn as 50% transparent red -
+ * the separate overrides are combined to produce the feature's overall appearance.
+ *
+ * In the case of conflicts, there is an order of precedence:
+ *  - Model overrides take highest precedence.
+ *  - Element overrides are of higher precedence than subcategory and animation overrides.
+ *  - Overrides applied by a [[RenderSchedule.Script]]'s [[RenderSchedule.ElementTimeline]] are of higher precedence than subcategory overrides, but can be suppressed on a per-element basis via [[ignoreAnimationOverrides]].
+ *  - Subcategory overrides have lowest precedence.
+ *
+ * For example, you might specify that all features belonging to subcategory "A" should be drawn in red, and all those belonging to model "B" should be drawn in green.
+ * Then a feature belonging to subcategory "A" and model "B" will be drawn in green, because the model overrides take precedence.
+ *
+ * Instances of this class are not typically instantiated by an application directly; instead, an application can implement a [FeatureOverrideProvider]($frontend)
+ * that augments the overrides supplied by a viewport.
+ *
+ * @see [FeatureSymbology.Overrides]($frontend) to create overrides specific to a [Viewport]($frontend) or [ViewState]($frontend).
+ * @see [FeatureOverrideProvider]($frontend) to customize the appearance of features within a [Viewport]($frontend).
+ * @public
+ */
+export declare class FeatureOverrides implements FeatureAppearanceSource {
+    /** @internal */
+    protected readonly _ignoreAnimationOverrides: IgnoreAnimationOverrides[];
+    /** Ids of elements that should never be drawn. This takes precedence over [[alwaysDrawn]]. @internal */
+    protected readonly _neverDrawn: Id64.Uint32Set;
+    /** Ids of elements that should always be drawn. [[neverDrawn]] takes precedence over this set. @internal */
+    protected readonly _alwaysDrawn: Id64.Uint32Set;
+    /** If true, no elements *except* those defined in the "always drawn" set will be drawn.
+     * @see [[setAlwaysDrawn]]
+     */
+    isAlwaysDrawnExclusive: boolean;
+    /** If true, the always-drawn elements are drawn even if their subcategories are not visible.
+     * @see [[setAlwaysDrawn]]
+     */
+    alwaysDrawnIgnoresSubCategory: boolean;
+    /** If true, all subcategories are considered visible. This is used for drawing sheets via section callouts in the absence of an actual sheet view.
+     * @internal
+     */
+    ignoreSubCategory: boolean;
+    /** Overrides applied to any feature not explicitly overridden. @internal */
+    protected _defaultOverrides: FeatureAppearance;
+    /** Whether construction geometry should be drawn. @internal */
+    protected _constructions: boolean;
+    /** Whether dimensions should be drawn. @internal */
+    protected _dimensions: boolean;
+    /** Whether area patterns should be drawn. @internal */
+    protected _patterns: boolean;
+    /** Whether line weights should be applied. If false, all lines are rendered 1-pixel wide. @internal */
+    protected _lineWeights: boolean;
+    /** Overrides applied to all elements belonging to each model. @internal */
+    protected readonly _modelOverrides: Id64.Uint32Map<FeatureAppearance>;
+    /** Overrides applied to specific elements. @internal */
+    protected readonly _elementOverrides: Id64.Uint32Map<FeatureAppearance>;
+    /** Overrides applied to geometry belonging to each subcategory. @internal */
+    protected readonly _subCategoryOverrides: Id64.Uint32Map<FeatureAppearance>;
+    /** The set of displayed subcategories. Geometry belonging to subcategories not included in this set will not be drawn. @internal */
+    protected readonly _visibleSubCategories: Id64.Uint32Set;
+    /** Display priorities assigned to subcategories, possibly overridden by display style. Only applicable for plan projection models. @internal */
+    protected readonly _subCategoryPriorities: Id64.Uint32Map<number>;
+    /** Per-model, a set of subcategories whose visibility should be inverted for elements within that model.
+     * Populated by Viewport.
+     * @internal
+     */
+    protected readonly _modelSubCategoryOverrides: Id64.Uint32Map<Id64.Uint32Set>;
+    /** Ids of animation nodes that should never be drawn.
+     * @internal
+     */
+    readonly neverDrawnAnimationNodes: Set<number>;
+    /** Mapping of animation node Ids to overrides applied to the corresponding animation nodes.
+     * @internal
+     */
+    readonly animationNodeOverrides: Map<number, FeatureAppearance>;
+    /** Accepts a criterion that determines whether color and transparency overrides originating from the view's [[RenderSchedule.Script]] should be ignored for a given element.
+     * The function receives a description of the element in question and returns `true` if the script's overrides should be ignored.
+     * Any number of such functions can be registered; if any one of them returns `true`, the script's overrides are not applied to the specified element.
+     *
+     * For example, applications commonly emphasize a set of elements by applying a [[FeatureAppearance.emphasized]] override to them, and specifying a highly-transparent
+     * default appearance to de-emphasize the rest of the elements in the view. If some of the de-emphasized elements' appearances are also being overridden by the schedule script, then
+     * they won't appear de-emphasized, making it difficult for the emphasized elements to stand out. In situations like this, [FeatureOverrideProvider]($frontend)s like [EmphasizeElements]($frontend) can register an [[IgnoreAnimationOverrides]] function that returns true if the element in question is not in the set of emphasized elements.
+     */
+    ignoreAnimationOverrides(ignore: IgnoreAnimationOverrides): void;
+    /** Overrides applied to features for which no other overrides are defined */
+    get defaultOverrides(): FeatureAppearance;
+    /** Whether or not line weights are applied. If false, all lines are drawn with a weight of 1. */
+    get lineWeights(): boolean;
+    /** @internal */
+    get neverDrawn(): Id64.Uint32Set;
+    /** @internal */
+    get alwaysDrawn(): Id64.Uint32Set;
+    /** @internal */
+    protected isNeverDrawn(elemIdLo: number, elemIdHi: number, animationNodeId: number): boolean;
+    /** @internal */
+    protected isAlwaysDrawn(idLo: number, idHi: number): boolean;
+    /** Returns true if the [SubCategory]($backend) specified by Id is in the set of visible subcategories. @internal */
+    isSubCategoryVisible(idLo: number, idHi: number): boolean;
+    /** @internal */
+    isSubCategoryVisibleInModel(subcatLo: number, subcatHi: number, modelLo: number, modelHi: number): boolean;
+    /** @internal */
+    protected getModelOverrides(idLo: number, idHi: number): FeatureAppearance | undefined;
+    private getElementAnimationOverrides;
+    /** @internal */
+    protected getElementOverrides(idLo: number, idHi: number, animationNodeId: number): FeatureAppearance | undefined;
+    /** @internal */
+    protected getSubCategoryOverrides(idLo: number, idHi: number): FeatureAppearance | undefined;
+    /** Add a [SubCategory]($backend) to the set of visible subcategories. */
+    setVisibleSubCategory(id: Id64String): void;
+    /** Specify the Id of an element that should never be drawn. */
+    setNeverDrawn(id: Id64String): void;
+    /** Specify the Id of an element that should always be drawn. */
+    setAlwaysDrawn(id: Id64String): void;
+    /** Specify the Id of a animation node that should never be drawn. */
+    setAnimationNodeNeverDrawn(id: number): void;
+    /** Specify the Ids of elements that should never be drawn. */
+    setNeverDrawnSet(ids: Iterable<Id64String>): void;
+    /** Specify the Ids of elements that should always be drawn. */
+    setAlwaysDrawnSet(ids: Iterable<Id64String>, exclusive: boolean, ignoreSubCategory?: boolean): void;
+    /** Returns the feature's appearance overrides, or undefined if the feature is not visible. */
+    getFeatureAppearance(feature: Feature, modelId: Id64String, type?: BatchType, animationNodeId?: number): FeatureAppearance | undefined;
+    private static readonly _weight1Appearance;
+    /** Returns a feature's appearance overrides, or undefined if the feature is not visible.
+     * Takes Id64s as pairs of unsigned 32-bit integers for efficiency, because that is how they are stored by the PackedFeatureTable associated with each batch of graphics.
+     * @see [[getFeatureAppearance]] for an equivalent function that accepts [Id64String]($core-bentley)s instead of integer pairs.
+     */
+    getAppearance(elemLo: number, elemHi: number, subcatLo: number, subcatHi: number, geomClass: GeometryClass, modelLo: number, modelHi: number, type: BatchType, animationNodeId: number): FeatureAppearance | undefined;
+    /** Classifiers behave totally differently...in particular they are never invisible unless fully-transparent.
+     * @internal
+     */
+    protected getClassifierAppearance(elemLo: number, elemHi: number, subcatLo: number, subcatHi: number, modelLo: number, modelHi: number, animationNodeId: number): FeatureAppearance | undefined;
+    /** Return whether geometry of the specified class should be drawn.
+     * @see [[ViewFlags.constructions]], [[ViewFlags.dimensions]], and [[ViewFlags.patterns]].
+     */
+    isClassVisible(geomClass: GeometryClass): boolean;
+    /** Specify overrides for all elements belonging to a specified [GeometricModel]($backend), or all geometry belonging to a specified [GeometricElement]($backend) or [SubCategory]($backend). */
+    override(args: OverrideFeatureAppearanceArgs): void;
+    /** Specify overrides for all elements within the specified model.
+     * @param id The Id of the model.
+     * @param app The symbology overrides.
+     * @param replaceExisting Specifies whether to replace a pre-existing override for the same model.
+     * @note These overrides take priority over all other overrides.
+     * @note If [[defaultOverrides]] are defined, they will not apply to any element within this model, even if the supplied appearance overrides nothing.
+     * @deprecated in 3.x. Use [[FeatureOverrides.override]].
+     */
+    overrideModel(id: Id64String, app: FeatureAppearance, replaceExisting?: boolean): void;
+    /** Specify overrides for all geometry belonging to the specified [SubCategory]($backend).
+     * @param id The Id of the subcategory.
+     * @param app The symbology overrides.
+     * @param replaceExisting Specifies whether to replace a pre-existing override for the same subcategory.
+     * @note These overrides have lower priority than element and model overrides.
+     * @note If [[defaultOverrides]] are defined, they will not apply to any geometry within this subcategory, even if the supplied appearance overrides nothing.
+     * @deprecated in 3.x. Use [[FeatureOverrides.override]].
+     */
+    overrideSubCategory(id: Id64String, app: FeatureAppearance, replaceExisting?: boolean): void;
+    /** Specify overrides for all geometry originating from the specified element.
+     * @param id The Id of the element.
+     * @param app The symbology overrides.
+     * @param replaceExisting Specifies whether to replace a pre-existing override for the same element.
+     * @note These overrides take precedence over subcategory overrides, but not over model overrides.
+     * @note If [[defaultOverrides]] are defined, they will not apply to this element, even if the supplied appearance overrides nothing.
+     * @deprecated in 3.x. Use [[FeatureOverrides.override]].
+     */
+    overrideElement(id: Id64String, app: FeatureAppearance, replaceExisting?: boolean): void;
+    /** Specify overrides for all geometry originating from the specified animation node.
+     * @param id The Id of the animation node.
+     * @param app The symbology overrides.
+     * @note These overrides do not take precedence over element overrides.
+     */
+    overrideAnimationNode(id: number, app: FeatureAppearance): void;
+    /** Defines a default appearance to be applied to any [[Feature]] *not* explicitly overridden.
+     * @param appearance The symbology overrides.
+     * @param replaceExisting Specifies whether to replace the current default overrides if they are already defined.
+     */
+    setDefaultOverrides(appearance: FeatureAppearance, replaceExisting?: boolean): void;
+    /** Get the display priority of a subcategory. This is only relevant when using [[PlanProjectionSettings]].
+     * @internal
+     */
+    getSubCategoryPriority(idLo: number, idHi: number): number;
+    /** Construct a new Overrides that overrides nothing.
+     * @see [FeatureSymbology.Overrides]($frontend) to construct overrides based on a [ViewState]($frontend) or [Viewport]($frontend).
+     */
+    constructor();
+    /** Returns true if geometry belonging to the specified subcategory will be drawn. */
+    isSubCategoryIdVisible(id: Id64String): boolean;
+    /** Returns the overrides applied to geometry belonging to the specified model, if any such are defined. */
+    getModelOverridesById(id: Id64String): FeatureAppearance | undefined;
+    /** Returns the overrides applied to geometry belonging to the specified element, if any such are defined. */
+    getElementOverridesById(id: Id64String): FeatureAppearance | undefined;
+    /** Returns the overrides applied to geometry belonging to the specified subcategory, if any such are defined. */
+    getSubCategoryOverridesById(id: Id64String): FeatureAppearance | undefined;
+    /** Returns true if the specified Feature will be drawn. */
+    isFeatureVisible(feature: Feature): boolean;
+}
+/** Interface adopted by an object that can supply the [[FeatureAppearance]] supplied by a [[FeatureAppearanceSource]].
+ * This is useful for selectively overriding or agumenting a [Viewport]($frontend)'s symbology overrides.
+ * A typical implementation will invoke [[FeatureAppearanceSource.getAppeaprance]] and customize the returned appearance.
+ * @see [[FeatureAppearanceProvider.chain]] to chain two providers together.
+ * @public
+ * @extensions
+ */
+export interface FeatureAppearanceProvider {
+    /** Supply the desired appearance overrides for the specified [[Feature]], or `undefined` if the feature should not be drawn.
+     * The feature is described by its components for efficiency reasons.
+     * @param source The base symbology overrides, e.g., typically defined by a [Viewport]($frontend).
+     * @param elemLo The lower 32 bits of the feature's element Id.
+     * @param elemHi The upper 32 bits of the feature's element Id.
+     * @param subcatLo The lower 32 bits of the feature's subcategory Id.
+     * @param subcatHi The upper 32 bits of the feature's subcategory Id.
+     * @param geomClass The geometry class of the feature.
+     * @param modelLo The lower 32 bits of the feature's model Id.
+     * @param modelHi The upper 32 bits of the feature's model Id.
+     * @param type The type of batch to which the feature belongs.
+     * @param animationNodeId The Id of the corresponding node in the [[RenderSchedule]], or `0` if none.
+     * @returns The desired appearance overrides, or `undefined` to indicate the feature should not be displayed.
+     * @see [[FeatureAppearanceSource.getAppearance]] to forward the request to the source.
+     * @see [Id64.isValidUint32Pair]($core-bentley) to determine if the components of an [Id64String]($core-bentley) represent a valid Id.
+     */
+    getFeatureAppearance(source: FeatureAppearanceSource, elemLo: number, elemHi: number, subcatLo: number, subcatHi: number, geomClass: GeometryClass, modelLo: number, modelHi: number, type: BatchType, animationNodeId: number): FeatureAppearance | undefined;
+}
+/** @public */
+export declare namespace FeatureAppearanceProvider {
+    /** Create a provider that obtains each feature's appearance from the source, and if the feature is visible, modifies the appearance.
+     * @param supplementAppearance A function accepting the feature's base appearance and returning a supplemental appearance.
+     * @public
+     */
+    function supplement(supplementAppearance: (appearance: FeatureAppearance) => FeatureAppearance): FeatureAppearanceProvider;
+    /** Chain two FeatureAppearanceProviders together such that `first`'s `getFeatureAppearance` function is applied before `second`'s.
+     * If `second` invokes `source.getAppearance()`, the returned appearance will include any modifications applied by `first`.
+     * @public
+     */
+    function chain(first: FeatureAppearanceProvider, second: FeatureAppearanceProvider): FeatureAppearanceProvider;
+}
 //# sourceMappingURL=FeatureSymbology.d.ts.map