import { type IAuditable, type IAuditableDates, type IAuditableUsers, type IObjectCertification } from "../base/metadata.js";
import { type DateFilterGranularity, type IAbsoluteDateFilterPreset, type IRelativeDateFilterPreset } from "../dateFilterConfig/index.js";
import { type IDataSetMetadataObject } from "../ldm/metadata/dataSet/index.js";
import { type Identifier, type ObjRef } from "../objRef/index.js";
import { type IDashboardObjectIdentity } from "./common.js";
import { type IFilterContext, type IFilterContextDefinition, type ITempFilterContext } from "./filterContext.js";
import { type IDashboardLayout, type IDashboardWidget } from "./layout.js";
/**
 * Date filter configuration mode
 * @alpha
 */
export type DashboardDateFilterConfigMode = "readonly" | "hidden" | "active";
/**
 * Represent the values of DashboardDateFilterConfigMode
 *
 * @internal
 */
export declare const DashboardDateFilterConfigModeValues: Record<Uppercase<DashboardDateFilterConfigMode>, DashboardDateFilterConfigMode>;
/**
 * Attribute filter configuration mode
 * @alpha
 */
export type DashboardAttributeFilterConfigMode = "readonly" | "hidden" | "active";
/**
 * Represent the values of DashboardAttributeFilterConfigMode
 *
 * @internal
 */
export declare const DashboardAttributeFilterConfigModeValues: Record<Uppercase<DashboardAttributeFilterConfigMode>, DashboardAttributeFilterConfigMode>;
/**
 * Attribute filter available mode — controls which filter presentation modes
 * (list-based, text-based, or both) are available to the user in Dashboard View mode.
 * @alpha
 */
export type DashboardAttributeFilterSelectionType = "list" | "text" | "listOrText";
/**
 * Represent the values of DashboardAttributeFilterSelectionType
 *
 * @internal
 */
export declare const DashboardAttributeFilterSelectionTypeValues: Record<Uppercase<Exclude<DashboardAttributeFilterSelectionType, "listOrText">> | "LIST_OR_TEXT", DashboardAttributeFilterSelectionType>;
/**
 * Date filter presets to add to the date filter for the current dashboard
 * @alpha
 */
export interface IDashboardDateFilterAddedPresets {
    /**
     * Absolute date filter presets to include in the date filter for the current dashboard
     */
    absolutePresets?: IAbsoluteDateFilterPreset[];
    /**
     * Relative date filter presets to include in the date filter for the current dashboard
     */
    relativePresets?: IRelativeDateFilterPreset[];
}
/**
 * Extended date filter config
 * @alpha
 */
export interface IDashboardDateFilterConfig {
    /**
     * Customized name of the date filter to display
     */
    filterName: string;
    /**
     * Extended date filter config mode
     */
    mode: DashboardDateFilterConfigMode;
    /**
     * Local identifiers of the date filter options to hide for the current dashboard
     */
    hideOptions?: Identifier[];
    /**
     * Date filter granularities to hide in the date filter dropdown for the current dashboard
     */
    hideGranularities?: DateFilterGranularity[];
    /**
     * Date filter presets to add to the date filter dropdown specific for the current dashboard
     */
    addPresets?: IDashboardDateFilterAddedPresets;
}
/**
 * Extended attribute filter config
 * @alpha
 */
export interface IDashboardAttributeFilterConfig {
    /**
     * Local identifier of the attribute filter to configure
     */
    localIdentifier: string;
    /**
     * Control visibility mode of the attribute filter
     */
    mode?: DashboardAttributeFilterConfigMode;
    /**
     * Display form to use to show elements of attribute filter in UI. Used only for attribute filters with elements selection. For text filters (arbitrary, match) it is not used.
     */
    displayAsLabel?: ObjRef;
    /**
     * Controls which filter presentation modes are available to the user in Dashboard View mode.
     * - "list" — only elements/list selection
     * - "text" — only text-based filtering (arbitrary/match)
     * - "listOrText" — both modes available, user can switch
     *
     * When not set, the default is derived from the current filter type:
     * elements filters default to "list", text filters default to "text".
     */
    selectionType?: DashboardAttributeFilterSelectionType;
}
/**
 * Extended measure value filter config
 * @alpha
 */
export interface IDashboardMeasureValueFilterConfig {
    /**
     * Local identifier of the measure value filter to configure
     */
    localIdentifier: string;
    /**
     * Control visibility mode of the measure value filter
     */
    mode?: DashboardAttributeFilterConfigMode;
}
/**
 * Dashboard filter groups config.
 * There can be multiple groups defined.
 * Group is displayed in a filter bar beside other filters.
 * Order is defined by the first filter in the group.
 * Meaning the group is displayed in the place of the first filter hwo defined in filter context.
 * If there are no filters in the group, the group is not displayed.
 * If there are no groups defined, filters are displayed ungrouped.
 * @alpha
 */
export interface IDashboardFilterGroupsConfig {
    groups: IDashboardFilterGroup[];
}
/**
 * Single dashboard filter group configuration.
 * Title is displayed in the filter bar.
 * Filters are removed from the filter bar and displayed under the group.
 * There is no way to have single filter in multiple groups or in a group and in the filter bar directly.
 * If you want such behavior, you need to define multiple fitlers with specific local identifiers.
 * @alpha
 */
export interface IDashboardFilterGroup {
    title: string;
    localIdentifier?: string;
    filters: IDashboardFilterGroupItem[];
}
/**
 * Single filter in a group.
 * It does not contain any filter configuration. It is just a reference to a dashboard filter context.
 * Filter is referenced by its local identifier which is defined in filter context.
 * If the filter does not exists it is ignored.
 * @alpha
 */
export interface IDashboardFilterGroupItem {
    filterLocalIdentifier: string;
}
/**
 * Extended date filter config item for date filters fully specified including date data set
 * @alpha
 */
export interface IDashboardDateFilterConfigItem {
    dateDataSet: ObjRef;
    config: IDashboardDateFilterConfig;
}
/**
 * Dashboard tab definition.
 *
 * @remarks
 * Each tab can have its own layout and its own filter context. Tabs are optional and
 * dashboards without tabs continue to work using the root layout and filter context.
 *
 * @alpha
 */
export interface IDashboardTab<TWidget = IDashboardWidget> {
    /**
     * Unique identifier of the tab (stable within dashboard).
     */
    localIdentifier: string;
    /**
     * Display title of the tab.
     */
    title: string;
    /**
     * Complete layout definition for this tab.
     */
    layout?: IDashboardLayout<TWidget>;
    /**
     * Tab-specific filter context.
     */
    filterContext?: IFilterContext | ITempFilterContext;
    /**
     * Dashboard tab common date filter config
     */
    dateFilterConfig?: IDashboardDateFilterConfig;
    /**
     * Dashboard tab date filters with date data set/dimension configs
     */
    dateFilterConfigs?: IDashboardDateFilterConfigItem[];
    /**
     * Dashboard extended attribute filter configs
     */
    attributeFilterConfigs?: IDashboardAttributeFilterConfig[];
    /**
     * Dashboard extended measure value filter configs
     */
    measureValueFilterConfigs?: IDashboardMeasureValueFilterConfig[];
    /**
     * Dashboard filter groups config.
     * It allows to group some filters from filter context into a group.
     * It groups them only visually. Does not affect a computation.
     * This is usually used on dashboards with many filters to improve readability.
     * If not defined, filters are displayed ungrouped as defined in single context.
     */
    filterGroupsConfig?: IDashboardFilterGroupsConfig;
}
/**
 * Dashboard common properties
 * @alpha
 */
export interface IDashboardBase {
    /**
     * Dashboard title
     */
    readonly title: string;
    /**
     * Dashboard description
     */
    readonly description: string;
    /**
     * Dashboard tags.
     *
     * @remarks
     * This property is optional for backwards compatibility reasons, but for newly created dashboards,
     * you can expect this to always be defined (an empty array in case there are no tags).
     *
     * Since 8.6.0
     */
    readonly tags?: string[];
    /**
     * Certification metadata.
     * @internal
     */
    readonly certification?: IObjectCertification;
}
/**
 * @alpha
 */
export interface IDashboardPluginBase {
    readonly type: "IDashboardPlugin";
    /**
     * Plugin name.
     */
    readonly name: string;
    /**
     * Plugin description. This is optional and may provide additional information about what
     * the plugin does.
     */
    readonly description?: string;
    /**
     * Plugins may be tagged using arbitrary tags for additional categorization.
     */
    readonly tags: string[];
    /**
     * Fully qualified URL where the plugin entry point is hosted.
     */
    readonly url: string;
}
/**
 * @alpha
 */
export interface IDashboardPlugin extends IDashboardPluginBase, IDashboardObjectIdentity, IAuditable {
}
/**
 * @alpha
 */
export interface IDashboardPluginDefinition extends IDashboardPluginBase, Partial<IDashboardObjectIdentity> {
}
/**
 * A link between dashboard and a plugin that it uses. Optionally contains parameters that should
 * be passed to the plugin at load time.
 *
 * @alpha
 */
export interface IDashboardPluginLink {
    readonly type: "IDashboardPluginLink";
    /**
     * Linked plugin.
     */
    readonly plugin: ObjRef;
    /**
     * Contains parameters that should be passed to the plugin at load time. The format
     * and content of the parameters are fully dependent on the implementation of the plugin. If the
     * plugin parameterization is possible, then the plugin documentation should contain the detail.
     */
    readonly parameters?: string;
}
/**
 * Object share status
 *
 * @remarks
 * private - object accessible only by its creator
 * shared - object shared with closed set of users/groups
 * public - accessible by everyone in project
 *
 * @alpha
 */
export type ShareStatus = "private" | "shared" | "public";
/**
 * Share permission.
 *
 * Hierarchy (highest → lowest): EDIT ⊃ SHARE ⊃ VIEW.
 *
 * - VIEW: Open and read a dashboard.
 * - SHARE: Includes VIEW; grant/revoke access for others.
 * - EDIT: Includes SHARE; modify content (layout, widgets, filters) and save changes.
 *
 *
 * @alpha
 */
export type SharePermission = "EDIT" | "SHARE" | "VIEW";
/**
 * Common properties for objects with controlled access
 * @alpha
 */
export interface IAccessControlAware {
    /**
     * Current object share status. This prop is affecting listing of object and access to it for different users
     */
    readonly shareStatus: ShareStatus;
    /**
     * Dashboard share permissions
     */
    readonly sharePermissions?: SharePermission[];
    /**
     * For backends NOT forcing strict access this prop reflects its current setting of strict access
     * If set to true then object is not accessible via its URI for people without access rights.
     * Otherwise object is accessible by its URI, eg. when drilling to it.
     */
    readonly isUnderStrictControl?: boolean;
    /**
     * When object is locked, no one other than the administrator can edit it
     */
    readonly isLocked?: boolean;
}
/**
 * Analytical dashboard consists of widgets
 * (widgets are kpis or insights with additional settings - drilling and alerting),
 * layout (which defines rendering and ordering of these widgets),
 * and filter context (configured attribute and date filters).
 * It's also possible to setup scheduled emails for the dashboard
 * (user will receive an email with the exported dashboard attached at the specified time interval),
 * and optionally extended date filter config.
 * @alpha
 */
export interface IDashboard<TWidget = IDashboardWidget> extends IDashboardBase, IDashboardObjectIdentity, Readonly<Required<IAuditableDates>>, Readonly<IAuditableUsers>, IAccessControlAware {
    readonly type: "IDashboard";
    /**
     * The layout of the dashboard determines the dashboard widgets {@link IWidget} and where they are rendered
     */
    readonly layout?: IDashboardLayout<TWidget>;
    /**
     * Dashboard filter context, or temporary filter context
     * (temporary filter context is used to override original filter context during the export)
     */
    readonly filterContext?: IFilterContext | ITempFilterContext;
    /**
     * Dashboard extended common date filter config
     */
    readonly dateFilterConfig?: IDashboardDateFilterConfig;
    /**
     * Dashboard extended date filters with date data set/dimension configs
     */
    readonly dateFilterConfigs?: IDashboardDateFilterConfigItem[];
    /**
     * Dashboard extended attribute filter configs
     */
    readonly attributeFilterConfigs?: IDashboardAttributeFilterConfig[];
    /**
     * Dashboard extended measure value filter configs
     */
    readonly measureValueFilterConfigs?: IDashboardMeasureValueFilterConfig[];
    /**
     * Date dataset to use for filtering metrics in section header rich text.
     * @alpha
     */
    readonly sectionHeadersDateDataSet?: ObjRef;
    /**
     * Plugins used on this dashboard.
     */
    readonly plugins?: IDashboardPluginLink[];
    /**
     * Disables cross filtering for this dashboard.
     */
    readonly disableCrossFiltering?: boolean;
    /**
     * Disables reset of user filters for this dashboard.
     */
    readonly disableUserFilterReset?: boolean;
    /**
     * Disables save of user filters for this dashboard.
     */
    readonly disableUserFilterSave?: boolean;
    /**
     * Disables listing and saving of filter views for this dashboard.
     */
    readonly disableFilterViews?: boolean;
    /**
     * Data sets related to the dashboard, as defined by the includes directive
     */
    readonly dataSets?: IDataSetMetadataObject[];
    /**
     * Override the default evaluation frequency for the dashboard.
     */
    readonly evaluationFrequency?: string;
    /**
     * Optional tabs configuration; when defined, the dashboard renders as a tabbed interface.
     * Each tab has its own layout, filter context and filter configs.
     *
     * @alpha
     */
    readonly tabs?: IDashboardTab<TWidget>[];
}
/**
 * Dashboard definition represents modified or created dashboard
 *
 * @alpha
 */
export interface IDashboardDefinition<TWidget = IDashboardWidget> extends IDashboardBase, IAccessControlAware, Partial<IDashboardObjectIdentity> {
    readonly type: "IDashboard";
    /**
     * The layout of the dashboard determines the dashboard widgets {@link IWidget} and where they are rendered
     */
    readonly layout?: IDashboardLayout<TWidget>;
    /**
     * Dashboard filter context, or temporary filter context
     */
    readonly filterContext?: IFilterContext | IFilterContextDefinition;
    /**
     * Dashboard extended common date filter config
     */
    readonly dateFilterConfig?: IDashboardDateFilterConfig;
    /**
     * Dashboard extended date filters with date data set/dimension configs
     */
    readonly dateFilterConfigs?: IDashboardDateFilterConfigItem[];
    /**
     * Dashboard extended attribute filter configs
     */
    readonly attributeFilterConfigs?: IDashboardAttributeFilterConfig[];
    /**
     * Dashboard extended measure value filter configs
     */
    readonly measureValueFilterConfigs?: IDashboardMeasureValueFilterConfig[];
    /**
     * Date dataset to use for filtering metrics in section header rich text.
     * @alpha
     */
    readonly sectionHeadersDateDataSet?: ObjRef;
    /**
     * Plugins to use on this dashboard.
     */
    readonly plugins?: IDashboardPluginLink[];
    /**
     * Disables cross filtering for this dashboard.
     */
    readonly disableCrossFiltering?: boolean;
    /**
     * Disables reset of user filters for this dashboard.
     */
    readonly disableUserFilterReset?: boolean;
    /**
     * Disables save of user filters for this dashboard.
     */
    readonly disableUserFilterSave?: boolean;
    /**
     * Disables listing and saving of filter views for this dashboard.
     */
    readonly disableFilterViews?: boolean;
    /**
     * Evaluation frequency of alerts for the dashboard.
     */
    readonly evaluationFrequency?: string;
    /**
     * Optional tabs configuration; when defined, the dashboard renders as a tabbed interface.
     * Each tab has its own layout, filter context and filter configs.
     *
     * @alpha
     */
    readonly tabs?: IDashboardTab<TWidget>[];
}
/**
 * Tests whether the provided object is an instance of {@link IDashboard}.
 *
 * @param obj - object to test
 * @alpha
 */
export declare function isDashboard(obj: unknown): obj is IDashboard;
/**
 * Tests whether the provided object is an instance of {@link IDashboardDefinition}.
 *
 * @param obj - object to test
 * @alpha
 */
export declare function isDashboardDefinition(obj: unknown): obj is IDashboardDefinition;
/**
 * Availability of {@link IListedDashboard}.
 * Either full (the listed dashboard is also available as a fully accessible metadata object) or
 * only via link (full metadata object is not accessible, only the listed dashboard record).
 * @alpha
 */
export type ListedDashboardAvailability = "full" | "viaLink";
/**
 * Listed dashboard - to display the dashboard in the list
 * Only a subset of dashboard data is available,
 * for the full definition see {@link IDashboard}
 * @alpha
 */
export interface IListedDashboard extends Readonly<Required<IAuditableDates>>, Readonly<IAuditableUsers>, IAccessControlAware {
    /**
     * Dashboard object ref
     */
    readonly ref: ObjRef;
    /**
     * Dashboard uri
     */
    readonly uri: string;
    /**
     * Dashboard identifier
     */
    readonly identifier: string;
    /**
     * Dashboard title
     */
    readonly title: string;
    /**
     * Dashboard description
     */
    readonly description: string;
    /**
     * Certification metadata.
     * @internal
     */
    readonly certification?: IObjectCertification;
    /**
     * AI-generated summary of the dashboard content.
     *
     * @remarks
     * Optional for backward compatibility as not all backends/sources provide it.
     */
    readonly summary?: string;
    /**
     * Dashboard tags.
     *
     * @remarks
     * This property is optional for backwards compatibility reasons, but for newly created dashboards,
     * you can expect this to always be defined (an empty array in case there are no tags).
     *
     * Since 8.6.0
     */
    readonly tags?: string[];
    /**
     * States if dashboard is shared with the user and fully accessible or if it is hidden but accessible via link if user knows it.
     */
    readonly availability: ListedDashboardAvailability;
    /**
     * Tabs configuration for multi-tabbed dashboards.
     *
     * @remarks
     * When present, indicates the dashboard supports tabbed navigation with each tab having its own
     * layout and filter context. This property is only populated when querying dashboard listings,
     * providing quick access to tab metadata without loading the full dashboard definition.
     *
     * @alpha
     */
    readonly tabs?: IDashboardTab[];
}
/**
 * Tests whether the provided object is an instance of {@link IListedDashboard}.
 *
 * @param obj - object to test
 * @alpha
 */
export declare function isListedDashboard(obj: unknown): obj is IListedDashboard;
/**
 * Tests whether the provided object is an instance of {@link IDashboardTab}.
 *
 * @param obj - object to test
 * @alpha
 */
export declare function isDashboardTab(obj: unknown): obj is IDashboardTab;
/**
 * Dashboard permissions.
 *
 * @alpha
 */
export type IDashboardPermissions = {
    [permission in "canEditDashboard" | "canEditLockedDashboard" | "canShareLockedDashboard" | "canShareDashboard" | "canViewDashboard"]: boolean;
};
/**
 * Object describing minimal properties of existing dashboard.
 *
 * @alpha
 */
export interface IExistingDashboard extends IDashboardObjectIdentity {
    /**
     * Dashboard title
     */
    title?: string;
}
//# sourceMappingURL=dashboard.d.ts.map