@rockrms/obsidian-framework 17.6.1 → 18.2.4

package/types/Controls/rockAttributeFilter.obs.d.ts

@@ -1,6 +1,6 @@
 import { PropType } from "vue";
 import { ComparisonValue } from "@Obsidian/Types/Reporting/comparisonValue";
-import { FilterMode } from "@Obsidian/Core/Reporting/filterMode";
+import { FilterMode } from "@Obsidian/Enums/Reporting/filterMode";
 import { PublicAttributeBag } from "@Obsidian/ViewModels/Utility/publicAttributeBag";
 declare const _default: import("vue").DefineComponent<{
     modelValue: {
@@ -19,7 +19,7 @@ declare const _default: import("vue").DefineComponent<{
     };
     filterMode: {
         type: PropType<FilterMode>;
-        default: FilterMode;
+        default: 0;
     };
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: ComparisonValue) => void;
@@ -40,7 +40,7 @@ declare const _default: import("vue").DefineComponent<{
     };
     filterMode: {
         type: PropType<FilterMode>;
-        default: FilterMode;
+        default: 0;
     };
 }>> & {
     "onUpdate:modelValue"?: ((value: ComparisonValue) => any) | undefined;

package/types/Controls/rockFormField.obs.d.ts

@@ -8,11 +8,6 @@ declare const _default: import("vue").DefineComponent<{
         default: false;
     };
     help: {
-        type: import("vue").PropType<string>;
-        default: "";
-    };
-    rules: import("@Obsidian/ValidationRules").RulesPropType;
-    formGroupClasses: {
         type: import("vue").PropType<string>; /**
          * If the modelValue is an object or array and its properties get changed, normally
          * that doesn't trigger a re-validation. If you enable this, it'll watch more deeply for
@@ -22,6 +17,11 @@ declare const _default: import("vue").DefineComponent<{
          */
         default: "";
     };
+    rules: import("@Obsidian/ValidationRules").RulesPropType;
+    formGroupClasses: {
+        type: import("vue").PropType<string>;
+        default: "";
+    };
     validationTitle: {
         type: import("vue").PropType<string>;
         default: "";
@@ -64,11 +64,6 @@ declare const _default: import("vue").DefineComponent<{
         default: false;
     };
     help: {
-        type: import("vue").PropType<string>;
-        default: "";
-    };
-    rules: import("@Obsidian/ValidationRules").RulesPropType;
-    formGroupClasses: {
         type: import("vue").PropType<string>; /**
          * If the modelValue is an object or array and its properties get changed, normally
          * that doesn't trigger a re-validation. If you enable this, it'll watch more deeply for
@@ -78,6 +73,11 @@ declare const _default: import("vue").DefineComponent<{
          */
         default: "";
     };
+    rules: import("@Obsidian/ValidationRules").RulesPropType;
+    formGroupClasses: {
+        type: import("vue").PropType<string>;
+        default: "";
+    };
     validationTitle: {
         type: import("vue").PropType<string>;
         default: "";

package/types/Controls/scheduleBuilder.obs.d.ts

@@ -30,6 +30,11 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<string | null>;
         required: false;
     };
+    /** Whether the control is disabled. */
+    disabled: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
     /** Whether to hide the start date/time fields. */
     hideStartDateTime: {
         type: PropType<boolean>;
@@ -73,6 +78,11 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<string | null>;
         required: false;
     };
+    /** Whether the control is disabled. */
+    disabled: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
     /** Whether to hide the start date/time fields. */
     hideStartDateTime: {
         type: PropType<boolean>;
@@ -87,6 +97,7 @@ declare const _default: import("vue").DefineComponent<{
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }, {
     label: string;
+    disabled: boolean;
     help: string;
     disableLabel: boolean;
     rules: import("@Obsidian/ValidationRules").ValidationRule | import("@Obsidian/ValidationRules").ValidationRule[];

package/types/Controls/slidingDateRangePicker.obs.d.ts

@@ -14,9 +14,13 @@ declare const _default: import("vue").DefineComponent<{
         default: null;
     };
     previewLocation: {
-        type: PropType<"None" | "Right" | "Top">;
+        type: PropType<"None" | "Top" | "Right">;
         default: string;
     };
+    isRangeClearable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (v: SlidingDateRange | null) => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
@@ -33,14 +37,19 @@ declare const _default: import("vue").DefineComponent<{
         default: null;
     };
     previewLocation: {
-        type: PropType<"None" | "Right" | "Top">;
+        type: PropType<"None" | "Top" | "Right">;
         default: string;
     };
+    isRangeClearable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
 }>> & {
     "onUpdate:modelValue"?: ((v: SlidingDateRange | null) => any) | undefined;
 }, {
     enabledSlidingDateRangeUnits: number[] | null;
     enabledTimeUnits: TimeUnit[] | null;
-    previewLocation: "None" | "Right" | "Top";
+    previewLocation: "None" | "Top" | "Right";
+    isRangeClearable: boolean;
 }, {}>;
 export default _default;

package/types/Controls/stepProgramPicker.obs.d.ts

@@ -20,6 +20,10 @@ declare const _default: import("vue").DefineComponent<{
     };
     validationTitle: {
         type: PropType<string>;
+        /**
+         * The actual items to make available to the picker. This allows us to do any
+         * post-processing, such as adding additional items, and still be lazy loaded as well.
+         */
         default: "";
     };
     isRequiredIndicatorHidden: {
@@ -80,6 +84,10 @@ declare const _default: import("vue").DefineComponent<{
     };
     validationTitle: {
         type: PropType<string>;
+        /**
+         * The actual items to make available to the picker. This allows us to do any
+         * post-processing, such as adding additional items, and still be lazy loaded as well.
+         */
         default: "";
     };
     isRequiredIndicatorHidden: {

package/types/Controls/stepProgramStepTypePicker.obs.d.ts

@@ -1,5 +1,6 @@
 import { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
 import { PropType } from "vue";
+import { ValidationRule } from "@Obsidian/ValidationRules";
 declare const _default: import("vue").DefineComponent<{
     modelValue: {
         type: PropType<ListItemBag | null | undefined>;
@@ -18,6 +19,15 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    rules: {
+        type: PropType<ValidationRule | ValidationRule[]>;
+        default: string;
+    };
+    /** Enhance the picker for dealing with long lists by providing a search mechanism. */
+    enhanceForLongLists: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: ListItemBag | ListItemBag[] | null) => void;
     "update:stepProgram": (value: ListItemBag | ListItemBag[] | null) => void;
@@ -39,11 +49,22 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    rules: {
+        type: PropType<ValidationRule | ValidationRule[]>;
+        default: string;
+    };
+    /** Enhance the picker for dealing with long lists by providing a search mechanism. */
+    enhanceForLongLists: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
 }>> & {
     "onUpdate:modelValue"?: ((value: ListItemBag | ListItemBag[] | null) => any) | undefined;
     "onUpdate:stepProgram"?: ((value: ListItemBag | ListItemBag[] | null) => any) | undefined;
 }, {
     disabled: boolean;
+    rules: ValidationRule | ValidationRule[];
+    enhanceForLongLists: boolean;
     defaultStepProgramGuid: string | null;
 }, {}>;
 export default _default;

package/types/Controls/stepStatusPicker.obs.d.ts

@@ -26,9 +26,6 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<boolean>;
         default: false;
     };
-    /**
-     * Loads the items from the server.
-     */
     enhanceForLongLists: {
         type: PropType<boolean>;
         default: false;
@@ -93,9 +90,6 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<boolean>;
         default: false;
     };
-    /**
-     * Loads the items from the server.
-     */
     enhanceForLongLists: {
         type: PropType<boolean>;
         default: false;

package/types/Controls/streakTypePicker.obs.d.ts

@@ -20,8 +20,16 @@ declare const _default: import("vue").DefineComponent<{
     };
     validationTitle: {
         type: PropType<string>;
+        /**
+         * The actual items to make available to the picker. This allows us to do any
+         * post-processing, such as adding additional items, and still be lazy loaded as well.
+         */
         default: "";
     };
+    /**
+     * The actual items to make available to the picker. This allows us to do any
+     * post-processing, such as adding additional items, and still be lazy loaded as well.
+     */
     isRequiredIndicatorHidden: {
         type: PropType<boolean>;
         default: false;
@@ -80,8 +88,16 @@ declare const _default: import("vue").DefineComponent<{
     };
     validationTitle: {
         type: PropType<string>;
+        /**
+         * The actual items to make available to the picker. This allows us to do any
+         * post-processing, such as adding additional items, and still be lazy loaded as well.
+         */
         default: "";
     };
+    /**
+     * The actual items to make available to the picker. This allows us to do any
+     * post-processing, such as adding additional items, and still be lazy loaded as well.
+     */
     isRequiredIndicatorHidden: {
         type: PropType<boolean>;
         default: false;

package/types/Controls/tabbedContent.obs.d.ts

@@ -56,8 +56,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
 }>> & {
     "onUpdate:selectedTab"?: ((value: string) => any) | undefined;
 }, {
-    lazyLoad: boolean;
     selectedTab: string;
+    lazyLoad: boolean;
     tabBarClass: string | string[] | Record<string, boolean>;
 }, {}>, {
     tabpane?(_: {

package/types/Controls/textBox.obs.d.ts

@@ -83,6 +83,10 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         type: PropType<boolean>;
         default: boolean;
     };
+    isReadOnly: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
     /**
      * If `true`, then the max length can be exceeded; i.e., the max length is not enforced.
      *
@@ -178,6 +182,10 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         type: PropType<boolean>;
         default: boolean;
     };
+    isReadOnly: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
     /**
      * If `true`, then the max length can be exceeded; i.e., the max length is not enforced.
      *
@@ -211,6 +219,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     size: "small" | "medium" | "large";
     allowHtml: boolean;
     isClearable: boolean;
+    isReadOnly: boolean;
     canExceedMaxLength: boolean;
 }, {}>, {
     prepend?(_: {

package/types/Controls/wordCloud.obs.d.ts

@@ -216,6 +216,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     width: string | number;
     height: string | number;
+    colors: string[];
     words: string[];
     angleCount: number;
     minimumAngle: number;
@@ -223,7 +224,6 @@ declare const _default: import("vue").DefineComponent<{
     fontName: string;
     minimumFontSize: number;
     maximumFontSize: number;
-    colors: string[];
     wordPadding: number;
     autoClear: boolean;
     animationDuration: number;

package/types/Controls/workflowBasePicker.obs.d.ts

@@ -30,9 +30,6 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<boolean>;
         default: false;
     };
-    /**
-     * Loads the items from the server.
-     */
     lazyMode: {
         type: PropType<import("@Obsidian/Enums/Controls/controlLazyMode").ControlLazyMode>;
         default: "onDemand";
@@ -97,9 +94,6 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<boolean>;
         default: false;
     };
-    /**
-     * Loads the items from the server.
-     */
     lazyMode: {
         type: PropType<import("@Obsidian/Enums/Controls/controlLazyMode").ControlLazyMode>;
         default: "onDemand";

package/types/Core/Controls/chart.d.ts

@@ -0,0 +1,221 @@
+import { Enumerable } from "@Obsidian/Utility/linq";
+import { RockDateTime } from "@Obsidian/Utility/rockDateTime";
+export declare const LabelDateFormat: {
+    readonly Auto: "auto";
+    readonly Day: "day";
+    readonly Week: "week";
+    readonly Month: "month";
+    readonly Year: "year";
+};
+export declare const LabelDateFormatDescription: Record<string, string>;
+export type LabelDateFormat = typeof LabelDateFormat[keyof typeof LabelDateFormat];
+export declare const LegendPosition: {
+    readonly Top: "top";
+    readonly Bottom: "bottom";
+    readonly Left: "left";
+    readonly Right: "right";
+};
+export declare const LegendPositionDescription: Record<string, string>;
+export type LegendPosition = typeof LegendPosition[keyof typeof LegendPosition];
+export declare const LegendAlign: {
+    readonly Start: "start";
+    readonly Center: "center";
+    readonly End: "end";
+};
+export declare const LegendAlignDescription: Record<string, string>;
+export type LegendAlign = typeof LegendAlign[keyof typeof LegendAlign];
+export type Legend = {
+    hidden?: boolean | undefined;
+    position?: LegendPosition | undefined;
+    align?: LegendAlign | undefined;
+};
+export type TimeInput = string | number | RockDateTime;
+export type XYPoint = {
+    x: TimeInput;
+    y: number | null;
+};
+export type AlignDataResult = {
+    labels: string[];
+    values: (number | null)[][];
+};
+export type TooltipContext = {
+    label: string;
+    formattedLabel: string;
+    value: number | null;
+    formattedValue: string;
+    seriesLabel: string;
+};
+export type TooltipCallback = (context: TooltipContext) => string;
+export type LineSeries = {
+    label: string;
+    data: (number | null)[];
+    color?: string | undefined;
+    isUnfilled?: boolean | undefined;
+    isLinear?: boolean | undefined;
+    lineStyle?: LineStyle | undefined;
+};
+export declare const LineStyle: {
+    readonly Solid: "solid";
+    readonly Dashed: "dashed";
+    readonly Dotted: "dotted";
+};
+export declare const LineStyleDescription: Record<string, string>;
+export type LineStyle = typeof LineStyle[keyof typeof LineStyle];
+export type BarSeries = {
+    label: string;
+    data: (number | null)[];
+    /** Color of the bars. Can be a single value or an array for each data point. */
+    color?: string | string[] | undefined;
+    isUnfilled?: boolean | undefined;
+    /** Opacity of the bars (0-1). Can be a single value or an array for each data point. */
+    opacity?: number | number[] | undefined;
+    /** Configuration for the bar labels. */
+    barLabels?: BarLabelsConfig | undefined;
+};
+export type BarChartClickEvent = {
+    targets: {
+        seriesIndex: number;
+        labelIndex: number;
+        label: string;
+        series: BarSeries;
+        value: number | null;
+    }[];
+};
+export type BarLabelPosition = "inside" | "outside";
+export type BarLabelContext = {
+    /** Dataset (series) label, e.g. “Revenue”. */
+    seriesName: string;
+    /** Category label on the cross-axis, e.g. “Jan”. */
+    label: string;
+    /** Formatted version of the label (may be `undefined`). */
+    formattedLabel: string | undefined;
+    /** Numeric value that determines bar length. */
+    value: number;
+    /** Formatted version of the value (may be `undefined`). */
+    formattedValue: string | undefined;
+};
+export type BarLabelAlignment = "start" | "center" | "end";
+export type BarLabelSpec = {
+    /** Build the text for this line. Supports multiline with \n. */
+    formatter: (ctx: BarLabelContext) => string;
+    /** Color of the label text. */
+    color?: string | undefined;
+};
+export type BarLabelsConfig = Partial<Record<BarLabelPosition, BarLabelSpec>>;
+/** Represents a pie chart series where each data + color combination is a slice of the pie. */
+export type PieSeries = {
+    label: string;
+    data: number[];
+    colors?: string[] | undefined;
+};
+/** Represents a doughnut chart series where each data + color combination is a slice of the doughnut. */
+export type DoughnutSeries = {
+    label: string;
+    data: number[];
+    colors?: string[] | undefined;
+};
+export declare class XYPointEnumerable extends Enumerable<XYPoint> {
+    /**
+     * Creates an XYPointEnumerable from a regular iterable (e.g., Array, Set).
+     * @param iterableFactory - A factory function that produces an Iterable<XYPoint>.
+     */
+    constructor(iterableFactory: () => Iterable<XYPoint>);
+    /**
+     * Creates an XYPointEnumerable from a regular iterable (e.g., Array, Set).
+     * @param iterable - An iterable to create the XYPointEnumerable from.
+     * @returns A new XYPointEnumerable instance.
+     */
+    static fromData(iterable: Iterable<XYPoint>): XYPointEnumerable;
+    /**
+     * Creates an XYPointEnumerable from a generator function.
+     * @param generator - A function that produces an IterableIterator.
+     * @returns A new XYPointEnumerable instance.
+     */
+    static fromData(generator: () => IterableIterator<XYPoint>): XYPointEnumerable;
+    /**
+     * Selects points as a decimal percentage [0-1] of the total.
+     *
+     * @param total The total value to calculate percentages against.
+     * @returns A new XYPointEnumerable instance with points represented as percentages.
+     *
+     * @example
+     * const data = XYPointEnumerable.fromData([
+     *     { x: "2023-01-01T00:00:00", y: 3 },
+     *     { x: "2023-01-02T00:00:00", y: 6 },
+     *     { x: "2023-01-03T00:00:00", y: 10 },
+     * ]);
+     * const total = 10;
+     * const percentages = data.selectAsPercent(total).toArray();
+     * console.log(percentages);
+     * // [
+     * //    { x: "2023-01-01T00:00:00", y: 0.3 },
+     * //    { x: "2023-01-02T00:00:00", y: 0.6 },
+     * //    { x: "2023-01-03T00:00:00", y: 1.0 },
+     * // ];
+     */
+    selectAsDecimalPercentage(total: number): XYPointEnumerable;
+    /**
+     * Squish data points by day, grouping them by the date part of the timestamp.
+     * @example
+     * const data = XYPointEnumerable.fromData([
+     *     { x: "2023-01-01T09:00:00", y: 0 },
+     *     { x: "2023-01-01T09:00:00", y: 1 },
+     *     { x: "2023-01-01T10:00:00", y: 2 },
+     *     { x: "2023-01-02T11:00:00", y: 3 },
+     *     { x: "2023-01-03T12:00:00", y: 4 },
+     * ]);
+     * const squished = data.squishByDate().toArray();
+     * console.log(squished);
+     * // [
+     * //    { x: "2023-01-01T00:00:00", y: 3 },
+     * //    { x: "2023-01-02T00:00:00", y: 3 },
+     * //    { x: "2023-01-03T00:00:00", y: 4 },
+     * // ];
+     */
+    selectSquishedByDate(): XYPointEnumerable;
+    /**
+     * Squish data points by date and time.
+     * @example
+     * const data = XYPointEnumerable.fromData([
+     *     { x: "2023-01-01T09:00:00", y: 0 },
+     *     { x: "2023-01-01T09:00:00", y: 1 },
+     *     { x: "2023-01-01T10:00:00", y: 2 },
+     *     { x: "2023-01-02T11:00:00", y: 3 },
+     *     { x: "2023-01-03T12:00:00", y: 4 },
+     * ]);
+     * const squished = data.squishByDate().toArray();
+     * console.log(squished);
+     * // [
+     * //    { x: "2023-01-01T09:00:00", y: 1 },
+     * //    { x: "2023-01-01T10:00:00", y: 2 },
+     * //    { x: "2023-01-02T11:00:00", y: 3 },
+     * //    { x: "2023-01-03T12:00:00", y: 4 },
+     * // ];
+     */
+    selectSquishedByDateTime(): XYPointEnumerable;
+    /**
+     * Select accumulated data points, where each point's Y value is the cumulative sum of all previous Y values.
+     *
+     * @example
+     * const data = XYPointEnumerable.fromData([
+     *     { x: "2023-01-01T00:00:00", y: 3 },
+     *     { x: "2023-01-02T00:00:00", y: 3 },
+     *     { x: "2023-01-03T00:00:00", y: 4 },
+     * ]);
+     * const accumulated = data.selectAccumulated().toArray();
+     * console.log(accumulated);
+     * // [
+     * //    { x: "2023-01-01T00:00:00", y: 3 },
+     * //    { x: "2023-01-02T00:00:00", y: 6 },
+     * //    { x: "2023-01-03T00:00:00", y: 10 },
+     * // ];
+     */
+    selectAccumulated(): XYPointEnumerable;
+    selectWithStartingPoint(startingPoint: XYPoint, predicate: (a: XYPoint, b: XYPoint) => boolean): XYPointEnumerable;
+}
+/**
+ * Aligns data points by date, returning shared labels and per-series values (with nulls for gaps).
+ */
+export declare function alignDataPointsByDate(dataPoints: XYPoint[][], { fillWith }?: {
+    fillWith: number | null | "previousValueOrNull" | "previousValueOrZero";
+}): AlignDataResult;

package/types/Core/Controls/contentSection.d.ts

@@ -0,0 +1,62 @@
+import { Ref } from "vue";
+/**
+ * Interface for a content section. This provides access to details about the
+ * section and allows modification of its state.
+ *
+ * This is an internal interface used by the content section components to manage
+ * state. It is not intended for use outside of the content section components.
+ */
+export interface IContentSectionHolder {
+    /** The title of the section. */
+    readonly title: Readonly<Ref<string | undefined>>;
+    /** The icon for the section, if any. */
+    readonly icon: Readonly<Ref<string | undefined>>;
+    /** The anchor for the section, if any. This is used to link to the section. */
+    readonly anchor: Ref<string | undefined>;
+    /**
+     * Indicates whether the section is collapsed or expanded.
+     * This is used to control the visibility of the section content.
+     */
+    readonly isCollapsed: Ref<boolean>;
+}
+/**
+ * Interface for a content section container. This is used to manage the collection
+ * of content sections in a content section container.
+ *
+ * This is an internal interface used by the content section components to manage
+ * state. It is not intended for use outside of the content section components.
+ */
+export interface IContentSectionContainerHolder {
+    addSection: (section: IContentSectionHolder) => void;
+    removeSection: (section: IContentSectionHolder) => void;
+}
+/**
+ * Provides a content section container holder to child components.
+ *
+ * This is an internal function used by the content section components to manage
+ * state. It is not intended for use outside of the content section components.
+ *
+ * @param holder The content section container holder to provide.
+ */
+export declare function provideSectionContainer(holder: IContentSectionContainerHolder): void;
+/**
+ * Retrieves the content section container holder from the current context.
+ *
+ * This is an internal function used by the content section components to manage
+ * state. It is not intended for use outside of the content section components.
+ *
+ * @returns The content section container holder, or a default implementation if not found.
+ */
+export declare function useSectionContainer(): IContentSectionContainerHolder;
+/**
+ * Creates a new content section holder with the specified title and icon.
+ *
+ * This is an internal function used by the content section components to manage
+ * state. It is not intended for use outside of the content section components.
+ *
+ * @param title The title of the section.
+ * @param icon The icon for the section, if any.
+ *
+ * @returns A new content section holder to be registered with the content section container.
+ */
+export declare function createSection(title: Readonly<Ref<string | undefined>>, icon: Readonly<Ref<string | undefined>>, isCollapsed: Readonly<Ref<boolean>>): IContentSectionHolder;

package/types/Core/Core/Automation/component.d.ts

@@ -0,0 +1,15 @@
+import { StandardDynamicComponentProps } from "@Obsidian/Utility/component";
+import { AutomationValueDefinitionBag } from "@Obsidian/ViewModels/Core/Automation/automationValueDefinitionBag";
+import { PropType } from "vue";
+type AutomationEventComponentProps = StandardDynamicComponentProps & {
+    mergeFields: {
+        type: PropType<AutomationValueDefinitionBag[]>;
+        required: true;
+    };
+};
+/**
+ * The standard props that are available to an instantiated component by the
+ * dynamicComponent.obs component.
+ */
+export declare const automationEventComponentProps: AutomationEventComponentProps;
+export {};

package/types/Core/Reporting/comparisonType.d.ts

@@ -1,4 +1,4 @@
-import { FilterMode } from "./filterMode";
+import { FilterMode } from "@Obsidian/Enums/Reporting/filterMode";
 import { ComparisonType } from "@Obsidian/Enums/Reporting/comparisonType";
 /** The comparison types typically used for simple binary comparison. */
 export declare const binaryComparisonTypes: ComparisonType;