@acorex/platform 21.0.0-next.85 → 21.0.0-next.88

package/types/acorex-platform-contracts.d.ts

@@ -1,44 +1,799 @@
-import { AXPProperty, AXPOptionsData, AXPMetaData, AXPEntityOp, AXPMultiLanguageString, AXPCategoryEntity } from '@acorex/platform/core';
-import { AXPWidgetNode } from '@acorex/platform/layout/widget-core';
-
 /**
- * Address mode type - determines the display mode of the address widget
- * - simple: single text input for full address (one line)
- * - popup: readonly summary + button to edit in popup dialog
- * - expandable: expandable panel — collapsed shows full address, expanded shows inline form
+ * Plain or rich text that may be localized: a single string or a map of locale code to string.
  */
-type AXPAddressMode = 'simple' | 'popup' | 'expandable';
+type AXPMultiLanguageString = string | Record<string, string>;
+type AXPExpression = string;
+type AXPMetaData = Record<string, any>;
+type AXPOptionsData<T extends Record<string, unknown> = Record<string, any>> = T;
+interface AXPEntityReference {
+    id: string;
+    type: string;
+    title?: string;
+    metadata?: AXPMetaData;
+}
+interface AXPUserReference {
+    id: string;
+    type?: 'user';
+    fullName?: string;
+    username?: string;
+}
+type AXPContentType = 'text' | 'image' | 'file' | 'video' | 'link';
+interface AXPContent {
+    content: string;
+    contentType: AXPContentType;
+}
+type AXPFileStatus = 'attached' | 'uploading' | 'uploaded' | 'deleted' | 'remote' | 'editing';
+interface AXPFileSource {
+    kind: 'blob' | 'url' | 'preview' | 'none' | 'fileId' | 'reference';
+    value?: Blob | string | {
+        id: string;
+        type: string;
+        title?: string;
+        metadata?: AXPMetaData;
+    };
+}
+interface AXPFileListItem {
+    id?: string;
+    name: string;
+    size?: number;
+    status: AXPFileStatus;
+    source?: AXPFileSource;
+    meta?: AXPMetaData;
+    readOnly?: boolean;
+    title?: string;
+    description?: string;
+}
+type AXPDataType = 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array' | 'blob';
+type AXPWidgetTrigger = {
+    event: string;
+    action: string | string[];
+    disabled?: boolean;
+};
+type AXPWidgetTriggers = AXPWidgetTrigger[];
+type AXPValidationRule = {
+    rule: string;
+    message?: string;
+    options?: any;
+    disabled?: boolean | AXPExpression;
+};
+type AXPValidationRules = AXPValidationRule[];
+interface AXPGridPlacement {
+    colStart?: number;
+    colEnd?: number;
+    colSpan?: number;
+    rowStart?: number;
+    rowEnd?: number;
+    rowSpan?: number;
+    order?: string | number;
+}
+interface AXPGridLayoutOptions {
+    positions?: {
+        sm?: AXPGridPlacement;
+        md?: AXPGridPlacement;
+        lg?: AXPGridPlacement;
+        xl?: AXPGridPlacement;
+        xxl?: AXPGridPlacement;
+        xxxl?: AXPGridPlacement;
+    };
+}
+type AXPValueTransformerFunction = (value: any) => any;
+type AXPValueTransformerFunctions = {
+    getter?: AXPValueTransformerFunction;
+    setter?: AXPValueTransformerFunction;
+};
+type AXPPartialNested<T> = {
+    [K in keyof T]?: T[K] extends object ? AXPPartialNested<T[K]> : T[K];
+};
+/** Returns dot-path keys for a nested plain object. */
+declare function getNestedKeys(obj: Record<string, unknown>, prefix?: string): string[];
 /**
- * Address label option
+ * Shared category descriptor for widgets, query catalog tooling, and other definition groupings.
  */
-interface AXPAddressLabel {
+interface AXPDefinitionCategory {
+    name: string;
+    title: AXPMultiLanguageString;
+    order: number;
+    icon?: string;
+}
+/** Normalizes definition categories to an array for iteration and serialization. */
+declare function normalizeDefinitionCategories(categories?: AXPDefinitionCategory | AXPDefinitionCategory[]): AXPDefinitionCategory[];
+interface AXPValueUnit {
+    name: string;
+    title: string;
+    ratio: number;
+    order: number;
+}
+interface AXPValueUnits {
+    name: string;
+    title: string;
+    items: AXPValueUnit[];
+    default: string;
+}
+interface AXPApplicationUserReference {
     id: string;
     name: string;
+    title: string;
+}
+type AXPMaybePromise<T = unknown> = T | Promise<T>;
+type AXPFlowDirection = 'vertical' | 'horizontal';
+type AXPContentDirection = 'rtl' | 'ltr';
+interface AXPSystemAction {
+    key: string;
+    title: string;
+    icon?: string;
+    color?: string;
+    critical?: boolean;
+    descriptions: {
+        title: string;
+        tooltip: string;
+        permission: string;
+        audit: string;
+    };
+}
+declare enum AXPSystemActionType {
+    View = "view",
+    Create = "create",
+    Update = "update",
+    Delete = "delete",
+    Approve = "approve",
+    Reject = "reject",
+    Submit = "submit",
+    Export = "export",
+    Import = "import",
+    Print = "print",
+    Assign = "assign",
+    Lock = "lock",
+    Unlock = "unlock",
+    Share = "share",
+    Configure = "configure",
+    Reorder = "reorder",
+    Preview = "preview",
+    Duplicate = "duplicate",
+    Archive = "archive",
+    Publish = "publish",
+    Unpublish = "unpublish",
+    Upload = "upload",
+    Download = "download",
+    Copy = "copy",
+    Move = "move",
+    Rename = "rename",
+    Restore = "restore",
+    Manage = "manage",
+    Info = "info",
+    Confirm = "confirm",
+    Design = "design",
+    VersionHistory = "version-history",
+    Compare = "compare",
+    Comments = "comments",
+    Sign = "sign",
+    Setup = "setup",
+    Send = "send",
+    Report = "report",
+    Sent = "sent",
+    Review = "review",
+    Generate = "generate",
+    Refresh = "refresh",
+    Reload = "reload",
+    Search = "search",
+    Filter = "filter",
+    Sort = "sort",
+    Start = "start",
+    Stop = "stop",
+    Pause = "pause",
+    Cancel = "cancel",
+    Close = "close",
+    Complete = "complete",
+    Save = "save",
+    SaveAs = "save-as",
+    Sync = "sync",
+    Reset = "reset",
+    Clear = "clear",
+    Distribution = "distribution"
 }
+
+type AXDataSourceOperatorType = 'endsWith' | 'startsWith' | 'in' | 'equal' | 'isNull' | 'isEmpty' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains';
+interface AXDataSourceOperator {
+    type: AXDataSourceOperatorType;
+    negative?: boolean;
+}
+type AXStyleColorType = string;
+type AXPopupSizeType = string;
+type AXFilterLogic = 'and' | 'or';
+interface AXDataSourceFilterOption {
+    field?: string;
+    operator?: AXDataSourceOperator;
+    value?: unknown;
+    logic?: AXFilterLogic;
+    filters?: AXDataSourceFilterOption[];
+}
+interface AXDataSourceSortOption {
+    field: string;
+    dir?: 'asc' | 'desc';
+}
+
+type AXPPlatformScopeKey = 'P' | 'T' | 'U';
+declare enum AXPPlatformScope {
+    Platform = "P",
+    Tenant = "T",
+    User = "U"
+}
+declare function resolvePlatformScopeKey(name: string): AXPPlatformScopeKey;
+declare function resolvePlatformScopeName(scope: AXPPlatformScopeKey): string;
+
 /**
- * Address data structure
+ * Structural logo configuration shared by url, icon, and component-based logos.
+ * Runtime classes live in `@acorex/platform/core` (`AXPImageUrlLogoConfig`, etc.).
  */
-interface AXPAddressData {
-    street1: string;
-    street2?: string;
-    postalCode?: string;
-    coordinates?: string;
-    full: string;
-    label?: string;
-    country?: {
-        id?: string;
-        title?: string;
+interface AXPLogoConfig {
+    width?: number;
+    height?: number;
+    url?: string;
+    icon?: string;
+    color?: string;
+    component?: unknown;
+}
+
+interface AXPMiddlewareErrorResponse {
+    success: false;
+    error: {
+        code?: string;
+        message: string;
+        status?: number;
+        details?: unknown;
     };
-    state?: {
-        id?: string;
-        title?: string;
+}
+
+interface AXPPagedListResult<T = unknown> {
+    items: T[];
+    total: number;
+}
+interface AXPQueryRequest {
+    skip: number;
+    take: number;
+    sort?: AXDataSourceSortOption[];
+    filter?: AXDataSourceFilterOption;
+    params?: Record<string, string>;
+}
+interface AXPCategoryEntity<TKey = string> {
+    id: TKey;
+    title: AXPMultiLanguageString;
+    description?: AXPMultiLanguageString;
+    parentId?: TKey;
+    childrenCount: number;
+    itemsCount?: number;
+    totalChildrenCount?: number;
+    totalItemsCount?: number;
+}
+interface AXPCategoryListItem<TKey extends string = string> {
+    id: TKey;
+    title: AXPMultiLanguageString;
+}
+interface AXPCategoryEntityWithItems<T> extends AXPCategoryEntity {
+    items: T[];
+    children?: AXPCategoryEntityWithItems<T>[];
+}
+interface AXPCategorizedEntity {
+    categoryIds: string[];
+}
+interface AXPCategorizedEntityDto {
+    categoryIds: string[];
+    categories: AXPCategoryListItem[];
+}
+type AXPEntityOp = 'initial' | 'create' | 'update' | 'delete' | 'getOne' | 'getAll' | 'query' | 'count' | 'queryAll' | 'getMany' | 'exists' | 'upsertOne' | 'aggregate';
+
+interface AXPFilterTriggerDefinition {
+    event: string;
+    action: string;
+    disabled?: boolean;
+}
+interface AXPFilterClause extends AXDataSourceFilterOption {
+    id?: string;
+    order?: number;
+    filters?: AXPFilterClause[];
+}
+interface AXPFilterDefinition extends AXPFilterClause {
+    title: string;
+    isParametric?: boolean;
+    icon?: string;
+    widget: {
+        type: string;
+        options?: AXPOptionsData;
     };
-    city?: {
-        id?: string;
-        title?: string;
+    filterType: {
+        advance: boolean;
+        inline: boolean;
+        preload?: {
+            enabled?: boolean;
+            required?: boolean;
+        };
+    };
+    hidden?: boolean;
+    /**
+     * When true, the filter is not selectable. When a string, it is evaluated as an expression (e.g. `{{ ... }}`)
+     * using the current filters context.
+     */
+    disabled?: boolean | string;
+    /** Expression-driven triggers (events/actions); same semantics as entity `schema.interface.triggers`. */
+    triggers?: AXPFilterTriggerDefinition[];
+}
+interface AXPFilterQuery extends Pick<AXPFilterDefinition, 'field' | 'value' | 'operator' | 'logic' | 'hidden'> {
+    filters?: AXPFilterQuery[];
+    displayText?: string;
+}
+
+interface AXPSortDefinition {
+    name: string;
+    title: string;
+    dir?: 'asc' | 'desc';
+}
+interface AXPSortQuery extends Pick<AXPSortDefinition, 'name' | 'dir'> {
+}
+
+interface AXPColumnQuery {
+    name: string;
+    title: string;
+    visible: boolean | string;
+}
+
+interface AXPExportOptions {
+    fileNameTemplate?: string;
+    pdf?: AXPExportPdfOptions;
+    excel?: AXPExportExcelOptions;
+    csv?: AXPExportCsvOptions;
+    print?: AXPExportPrintOptions;
+}
+interface AXPExportPdfOptions {
+    enabled: boolean;
+    pageSize?: 'A4' | 'A3' | 'Letter' | 'Legal';
+    orientation?: 'portrait' | 'landscape';
+    margin?: number | {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
     };
+    font?: string;
+    fontSize?: number;
+    headerEnabled?: boolean;
+    footerEnabled?: boolean;
+    showPageNumbers?: boolean;
+    watermarkText?: string;
+    watermarkOpacity?: number;
+    compression?: boolean;
+    embedImages?: boolean;
+}
+interface AXPExportExcelOptions {
+    enabled: boolean;
+    sheetName?: string;
+    includeFilters?: boolean;
+    freezeHeader?: boolean;
+    autoFitColumns?: boolean;
+    style?: {
+        headerColor?: string;
+        font?: string;
+        fontSize?: number;
+        numberFormat?: 'auto' | 'currency' | 'percent' | 'decimal';
+    };
+    summaryRowEnabled?: boolean;
+    exportHiddenColumns?: boolean;
+}
+interface AXPExportCsvOptions {
+    enabled: boolean;
+    delimiter?: ',' | ';' | '\t';
+    includeHeaders?: boolean;
+    quoteValues?: boolean;
+    encoding?: 'utf-8' | 'utf-16' | 'iso-8859-1';
+}
+interface AXPExportPrintOptions {
+    enabled: boolean;
+    includeHeader?: boolean;
+    includeFooter?: boolean;
+    showPageBreaks?: boolean;
+    customCssUrl?: string;
+}
+declare enum AXPExportTemplateToken {
+    Date = "{date}",
+    Time = "{time}",
+    User = "{user}",
+    ReportTitle = "{title}",
+    UUID = "{uuid}"
+}
+
+interface AXPMultiSourceRef {
+    sourceKey: string;
+    refId?: string;
+    displayName: string;
+    data?: unknown;
+    meta?: Record<string, unknown>;
+}
+
+interface AXPPropertyGroup {
+    name: string;
+    title: AXPMultiLanguageString;
+    icon?: string;
+    description?: AXPMultiLanguageString;
+    order?: number;
+}
+interface AXPPropertyInterface {
+    type: string;
+    options: AXPOptionsData;
+    triggers?: AXPWidgetTriggers;
+}
+interface AXPProperty {
+    name: string;
+    title: AXPMultiLanguageString;
+    description?: AXPMultiLanguageString;
+    dataType: AXPDataType;
+    validations?: AXPValidationRules;
+    group?: AXPPropertyGroup | string;
+    order?: number;
+    interface: AXPPropertyInterface;
+}
+
+interface AXPRequiredValidationRule extends AXPValidationRule {
+    rule: 'required';
+}
+interface AXPMinLengthValidationRule extends AXPValidationRule {
+    rule: 'minLength';
+    options: {
+        minLength: number | AXPExpression;
+    };
+}
+interface AXPMaxLengthValidationRule extends AXPValidationRule {
+    rule: 'maxLength';
+    options: {
+        maxLength: number | AXPExpression;
+    };
+}
+interface AXPEqualValidationRule<T> extends AXPValidationRule {
+    rule: 'equal';
+    options: {
+        value: T | AXPExpression;
+    };
+}
+interface AXPReqexValidationRule extends AXPValidationRule {
+    rule: 'regex';
+    options: {
+        value: string;
+    };
+}
+type AXPStringValidationRules = (AXPRequiredValidationRule | AXPMinLengthValidationRule | AXPMaxLengthValidationRule | AXPEqualValidationRule<string> | AXPReqexValidationRule)[];
+
+type AXPActionMenuItem = {
+    name?: string;
+    title: AXPMultiLanguageString;
+    icon?: string;
+    iconOnly?: boolean;
+    color?: string;
+    look?: string;
+    break?: boolean;
+    items?: AXPActionMenuItem[];
+    command?: AXPExecuteCommand;
+    disabled?: boolean | string;
+    visible?: boolean | string;
+    policy?: string;
+};
+type AXPBackButton = {
+    title: AXPMultiLanguageString;
+};
+type AXPBreadcrumbItem = {
+    name?: string;
+    title: AXPMultiLanguageString;
+    icon?: string;
+    command?: AXPExecuteCommand;
+};
+type AXPBadge = {
+    title: string;
+    description?: string;
+    color?: 'primary' | 'success' | 'warning' | 'danger';
+};
+type AXPPageStatus = {
+    definitionKey: string;
+    value: string;
+    dataPath?: string;
+    readonly?: boolean;
+};
+interface AXPCommandMessage {
+    type?: 'info' | 'success' | 'warning' | 'error';
+    code?: string;
+    text: AXPMultiLanguageString;
+    details?: unknown;
+}
+type AXPExecuteCommand = {
+    name: string;
+    options?: AXPMetaData;
+    metadata?: AXPMetaData;
+};
+interface AXPExecuteCommandResult<T = any> {
+    success: boolean;
+    data?: T;
+    message?: AXPCommandMessage;
+    metadata?: AXPMetaData;
+}
+interface AXPQueryFetchResult<T = any> {
+    success: boolean;
+    data?: {
+        items?: T[];
+        total?: number;
+    };
+    message?: {
+        code?: string;
+        text?: AXPMultiLanguageString;
+        details?: unknown;
+    };
+}
+
+interface AXPViewDefinition {
+    key: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    blocks: AXPViewBlockDefinition[];
+    layout?: 'vertical' | 'horizontal' | 'grid' | 'custom';
+    actions?: {
+        primary?: AXPActionMenuItem[];
+        secondary?: AXPActionMenuItem[];
+    };
+}
+interface AXPViewBlockDefinition {
+    key: string;
+    type: 'form' | 'table' | 'tabs' | 'list' | 'card' | 'custom';
+    title?: string;
+    description?: string;
+    icon?: string;
+    actions?: {
+        primary?: AXPActionMenuItem[];
+        secondary?: AXPActionMenuItem[];
+    };
+    fields?: AXPViewFieldDefinition[];
+    blocks?: AXPViewBlockDefinition[];
+}
+interface AXPViewFieldDefinition {
+    key: string;
+    title?: string;
+    description?: string;
+    icon?: string;
+    widget?: string;
+}
+
+interface AXPViewQuery {
+    name: string;
+    fixed: boolean;
+    title: string;
+    columns: string[];
+    conditions: AXPFilterQuery[];
+    sorts: AXPSortQuery[];
+}
+
+type AXPWidgetRenderMode = 'view' | 'edit' | 'designer' | 'print' | 'column' | 'filter';
+interface AXPWidgetNode {
+    type: string;
+    mode?: AXPWidgetRenderMode;
+    path?: string;
+    name?: string;
+    visible?: boolean | AXPExpression;
+    defaultValue?: unknown;
+    children?: AXPWidgetNode[];
+    options?: AXPOptionsData;
+    triggers?: AXPWidgetTriggers;
+    meta?: AXPMetaData;
+    valueTransforms?: AXPValueTransformerFunctions;
 }
 
+declare const AXPWidgetsList: {
+    Editors: {
+        DocumentAttachment: string;
+        TagEditor: string;
+        CheckBox: string;
+        ColorBox: string;
+        ColorPalette: string;
+        DateTimeBox: string;
+        AddressBox: string;
+        Direction: string;
+        LargeTextBox: string;
+        NumberBox: string;
+        UnitValueBox: string;
+        PasswordBox: string;
+        QueryBuilder: string;
+        RichText: string;
+        SelectBox: string;
+        SelectionList: string;
+        TextBox: string;
+        InlineDataTable: string;
+        ToggleSwitch: string;
+        FileTypeExtension: string;
+        MapBox: string;
+        MediaGallery: string;
+        SignatureBox: string;
+        LookupBox: string;
+        MultiSourceSelector: string;
+        EntityCategory: string;
+        ContactBox: string;
+        MetaDataBox: string;
+        TemplateBox: string;
+        TemplateContentEditor: string;
+        TimeDuration: string;
+        DocumentUploader: string;
+        MetaSelector: string;
+        MetaDataForm: string;
+        ColumnFilterSelector: string;
+        DataListFilter: string;
+        ListEditor: string;
+        ConnectedListsEditor: string;
+        SkillMatrix: string;
+        ResponsibilitiesMatrix: string;
+        RiskMatrix: string;
+        ProgressBox: string;
+        RatePicker: string;
+        ActivityCommandConfigurator: string;
+        WorkflowConfigurator: string;
+    };
+    Layouts: {
+        AlertBox: string;
+        BadgeLayout: string;
+        BlockLayout: string;
+        RepeaterLayout: string;
+        TextBlockLayout: string;
+        FormField: string;
+        PanelLayout: string;
+        PageLayout: string;
+        DocumentLayout: string;
+        GridRowLayout: string;
+        GridItemLayout: string;
+        GridLayout: string;
+        FlexLayout: string;
+        FlexItemLayout: string;
+        AdvancedGridLayout: string;
+        AdvancedGridItemLayout: string;
+        FieldsetLayout: string;
+        TabsetLayout: string;
+        TabsetItemLayout: string;
+    };
+    Actions: {
+        ActionButton: string;
+    };
+    Advanced: {
+        CodeEditor: string;
+        JsonViewer: string;
+        OutcomeResultsViewer: string;
+        QRCode: string;
+        schedulerPicker: string;
+        Signature: string;
+        Map: string;
+        Gallery: string;
+        Image: string;
+        ImageMarker: string;
+        Avatar: string;
+        Attachments: string;
+        DataList: string;
+        ListToolbar: string;
+        CronJob: string;
+        Status: string;
+        WidgetFieldConfigurator: string;
+        AnswersViewer: string;
+        IntegrationConnectionsPanel: string;
+    };
+    Templates: {
+        Designer: string;
+        Template: string;
+    };
+    Entity: {
+        EntityList: string;
+        SelectorStructure: string;
+    };
+    Providers: {
+        EntityDefinition: string;
+    };
+    ExpressionBuilders: {
+        ConditionBuilder: string;
+    };
+    Theme: {
+        ThemeColorChooser: string;
+        IconChooser: string;
+        FontSizeChooser: string;
+        FontStyleChooser: string;
+    };
+};
+
+declare const AXPWidgetsCatalog: {
+    readonly timeDuration: "time-duration";
+    readonly timeDurationFilter: "time-duration-filter";
+    readonly checkbox: "checkbox-editor";
+    readonly color: "color-editor";
+    readonly connectedLists: "connected-lists-editor";
+    readonly contact: "contact-editor";
+    readonly dateTime: "date-time-editor";
+    readonly largeText: "large-text-editor";
+    readonly number: "number-editor";
+    readonly numberUnit: "number-unit-editor";
+    readonly password: "password-editor";
+    readonly richText: "rich-text-editor";
+    readonly select: "select-editor";
+    readonly selectionList: "selection-list-editor";
+    readonly text: "text-editor";
+    readonly table: "table-editor";
+    readonly toggle: "toggle-editor";
+    readonly blockLayout: "block-layout";
+    readonly pageLayout: "page-layout";
+    readonly repeaterLayout: "repeater-layout";
+    readonly textBlockLayout: "text-block-layout";
+    readonly alertBoxLayout: "alert-box-layout";
+    readonly badgeLayout: "badge-layout";
+    readonly attachments: "attachments";
+    readonly fileTypeExtension: "file-type-extension";
+    readonly map: "map";
+    readonly imageMarker: "image-marker";
+    readonly image: "image";
+    readonly gallery: "gallery";
+    readonly signature: "signature";
+    readonly buttonAction: "button-action";
+    readonly document: "document-layout";
+    readonly lookup: "lookup-editor";
+    readonly formField: "form-field";
+    readonly qrcode: "qrcode";
+    readonly schedulerPicker: "scheduler-picker";
+    readonly advancedGrid: "advanced-grid-layout";
+    readonly advancedGridItem: "advanced-grid-item-layout";
+    readonly grid: "grid-layout";
+    readonly gridItem: "grid-item-layout";
+    readonly template: "template";
+    readonly templateDesigner: "template-designer";
+    readonly cronJob: "cron-job";
+    readonly spacing: "spacing";
+    readonly direction: "direction";
+    readonly border: "border";
+    readonly flexLayout: "flex-layout";
+    readonly flexItem: "flex-item-layout";
+    readonly tableLayout: "table-layout";
+    readonly tableItem: "table-item-layout";
+    readonly avatar: "avatar";
+    readonly themeModeChooser: "theme-mode-chooser";
+    readonly menuOrientationChooser: "menu-orientation-chooser";
+    readonly fontStyleChooser: "font-style-chooser";
+    readonly fontSizeChooser: "font-size-chooser";
+    readonly iconChooser: "icon-chooser";
+    readonly icon: "icon";
+    readonly themeColorChooser: "theme-color-chooser";
+    readonly gridOptions: "grid-options";
+    readonly gridItemOptions: "grid-item-options";
+    readonly advancedGridOptions: "advanced-grid-options";
+    readonly stringFilter: "string-filter";
+    readonly numberFilter: "number-filter";
+    readonly dateTimeFilter: "datetime-filter";
+    readonly booleanFilter: "boolean-filter";
+    readonly lookupFilter: "lookup-filter";
+    readonly flexOptions: "flex-options";
+    readonly flexItemOptions: "flex-item-options";
+    readonly selectFilter: "select-filter";
+    readonly requiredValidation: "required-validation";
+    readonly regularExpressionValidation: "regular-expression-validation";
+    readonly minLengthValidation: "min-length-validation";
+    readonly maxLengthValidation: "max-length-validation";
+    readonly lessThanValidation: "less-than-validation";
+    readonly greaterThanValidation: "greater-than-validation";
+    readonly betweenValidation: "between-validation";
+    readonly equalValidation: "equal-validation";
+    readonly callbackValidation: "callback-validation";
+    readonly metaData: "meta-data-editor";
+    readonly templateEditor: "template-box-editor";
+    readonly templateContentEditor: "template-content-editor";
+    readonly panel: "panel";
+    readonly notification: "notification";
+    readonly comment: "comment";
+    readonly list: "list-editor";
+    readonly dataList: "data-list";
+    readonly listToolbar: "list-toolbar";
+    readonly entityList: "entity-list";
+    readonly pageComponent: "page-component";
+    readonly editorJs: "editor-js-editor";
+    readonly documentUploader: "document-uploader";
+    readonly stepWizard: "step-wizard";
+    readonly progressBar: "progress-bar-editor";
+    readonly rate: "rate-picker-editor";
+    readonly documentFileTypeFilter: "document-file-type-filter";
+    readonly entityDefinitionProvider: "entity-definition-provider-editor";
+};
+
 interface AXPWorkflowDefinition {
     schemaVersion: 'acorex-platform-workflow/v1';
     name: string;
@@ -57,6 +812,21 @@ interface AXPWorkflowDefinition {
      */
     bindings?: AXPWorkflowBinding[];
 }
+/**
+ * Workflow Category - Extends AXPCategoryEntity for consistency and performance
+ *
+ * Inherited properties from AXPCategoryEntity:
+ * - id: string                   - Unique identifier
+ * - title: string                - Display name
+ * - description?: string         - Category description
+ * - parentId?: string            - Parent category ID
+ * - childrenCount: number        - Direct child categories count (enables lazy loading)
+ * - itemsCount?: number          - Direct workflows count
+ * - totalChildrenCount?: number  - Total nested categories (optional, for analytics)
+ * - totalItemsCount?: number     - Total workflows in tree (optional, for analytics)
+ */
+interface AXPWorkflowCategory extends AXPCategoryEntity {
+}
 interface AXPWorkflowGraph {
     startActivityId: string;
     activities: AXPWorkflowActivityInstance[];
@@ -157,184 +927,52 @@ interface AXPWorkflowExtensions {
 interface AXPElsaWorkflowExtensions {
     /**
      * Elsa schema URL (if you want to round-trip exact docs).
-     * Example: "https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json"
-     */
-    schema?: string;
-    toolVersion?: string;
-    materializerName?: string;
-    /**
-     * Elsa strategy/options (engine-level concerns).
-     */
-    options?: {
-        activationStrategyType?: string | null;
-        incidentStrategyType?: string | null;
-        commitStrategyName?: string | null;
-        autoUpdateConsumingWorkflows?: boolean;
-        usableAsActivity?: boolean | null;
-        activityCategory?: string | null;
-    };
-    /**
-     * If you want lossless Elsa round-trip, keep the raw Elsa definition here.
-     */
-    rawDefinition?: any;
-}
-/**
- * Workflow binding configuration.
- * Defines which entities and events should trigger a workflow.
- */
-interface AXPWorkflowBinding {
-    /**
-     * Entity types this workflow applies to (e.g., ['ContentManagement.Promotion', 'ContentManagement.Article'])
-     * Empty array means applies to all entities with workflow-run plugin enabled.
-     */
-    entityTypes: string[];
-    /**
-     * Event types that trigger this workflow (e.g., ['create', 'update'])
-     * Uses AXPEntityOp directly (create, update, delete, etc.)
-     */
-    eventTypes: AXPEntityOp[];
-    /**
-     * Whether this binding is enabled
-     */
-    enabled: boolean;
-    /**
-     * Optional conditions for when to trigger (future enhancement)
-     */
-    conditions?: any;
-}
-
-/**
- * Type of task for inbox handling.
- * - 'human-task': Requires inbox - needs human interaction
- * - 'ui-activity': UI-only activity (no inbox) - immediate execution
- * - 'system-activity': System/backend activity (no inbox) - automated execution
- */
-type AXPTaskType = 'human-task' | 'ui-activity' | 'system-activity';
-/**
- * How the workflow engine should offer "continue to next step?" before an inline frontend activity.
- * Declared on {@link AXPActivityDefinition} and copied onto {@link AXPWorkflowTask} at runtime.
- */
-type AXPWorkflowContinuationBeforeInteractive = 'default'
-/** Skip when opened from a task-board human-task primary action (e.g. start-fill, review). */
- | 'skip-when-chained-from-human-task'
-/** Skip for the natural assignee; initiator / reassign users still get the prompt (workflow-management). */
- | 'skip-for-assignee';
-/** Optional continuation UX metadata for an activity definition. */
-interface AXPWorkflowContinuationMetadata {
-    beforeInteractive?: AXPWorkflowContinuationBeforeInteractive;
-}
-/**
- * Activity Category - Extends AXPCategoryEntity for consistency and performance
- *
- * Inherited properties from AXPCategoryEntity:
- * - id: string                   - Unique identifier
- * - title: string                - Display name
- * - description?: string         - Category description
- * - parentId?: string            - Parent category ID
- * - childrenCount: number        - Direct child categories count (enables lazy loading)
- * - itemsCount?: number          - Direct activities count
- * - totalChildrenCount?: number  - Total nested categories (optional, for analytics)
- * - totalItemsCount?: number     - Total activities in tree (optional, for analytics)
- */
-interface AXPActivityCategory extends AXPCategoryEntity {
-}
-/**
- * Lightweight category snapshot embedded in activity-definition records.
- */
-interface AXPActivityDefinitionCategoryRef {
-    id: string;
-    name: string;
-    title: AXPMultiLanguageString;
-}
-/**
- * Activity Definition - Metadata for UI and tooling.
- * Contains all metadata needed for displaying activities in toolbox and designer.
- * The `name` property is used as the command key for execution.
- */
-interface AXPActivityDefinition {
-    /**
-     * Activity name - used as command key for execution.
-     * This is the unique identifier for the activity.
-     */
-    name: string;
-    /**
-     * Activity type (e.g., "workflow-activity:check-permission").
-     */
-    type: string;
-    /**
-     * Display name for UI (plain or per-locale map).
-     */
-    title?: AXPMultiLanguageString;
-    instanceTitle?: string;
-    /**
-     * Description of what the activity does (plain or per-locale map).
-     */
-    description?: AXPMultiLanguageString;
-    /**
-     * Category for grouping in toolbox.
-     */
-    category?: AXPActivityDefinitionCategoryRef;
-    /**
-     * Icon name or class.
-     */
-    icon?: string;
-    /**
-     * Where this activity should be executed.
-     * - 'frontend': Execute in browser (UI activities, console, events)
-     * - 'backend': Execute in backend (business logic, API calls)
-     * - 'both': Execute in both frontend and backend (hybrid activities)
-     *
-     * Default: 'frontend'
-     */
-    executionMode?: 'frontend' | 'backend' | 'both';
-    /**
-     * Type of task for inbox handling.
-     * - 'human-task': Requires inbox - needs human interaction
-     * - 'ui-activity': UI-only activity (no inbox) - immediate execution
-     * - 'system-activity': System/backend activity (no inbox) - automated execution
-     *
-     * Default: 'ui-activity' (for backward compatibility)
+     * Example: "https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json"
      */
-    taskType?: AXPTaskType;
+    schema?: string;
+    toolVersion?: string;
+    materializerName?: string;
     /**
-     * Input properties (form/schema for activity parameters).
+     * Elsa strategy/options (engine-level concerns).
      */
-    inputs?: AXPProperty[];
+    options?: {
+        activationStrategyType?: string | null;
+        incidentStrategyType?: string | null;
+        commitStrategyName?: string | null;
+        autoUpdateConsumingWorkflows?: boolean;
+        usableAsActivity?: boolean | null;
+        activityCategory?: string | null;
+    };
     /**
-     * Output properties (result shape + optional path/metadata).
+     * If you want lossless Elsa round-trip, keep the raw Elsa definition here.
      */
-    outputs?: AXPWorkflowOutputProperty[];
+    rawDefinition?: any;
+}
+/**
+ * Workflow binding configuration.
+ * Defines which entities and events should trigger a workflow.
+ */
+interface AXPWorkflowBinding {
     /**
-     * Static outcomes (exit points).
-     * Example: ['Done', 'Success', 'Failed']
+     * Entity types this workflow applies to (e.g., ['ContentManagement.Promotion', 'ContentManagement.Article'])
+     * Empty array means applies to all entities with workflow-run plugin enabled.
      */
-    outcomes?: string[];
+    entityTypes: string[];
     /**
-     * Whether this activity is browsable in the toolbox.
-     * Default: true
+     * Event types that trigger this workflow (e.g., ['create', 'update'])
+     * Uses AXPEntityOp directly (create, update, delete, etc.)
      */
-    isBrowsable?: boolean;
+    eventTypes: AXPEntityOp[];
     /**
-     * Whether this activity is a container (can have children).
-     * Default: false
+     * Whether this binding is enabled
      */
-    isContainer?: boolean;
+    enabled: boolean;
     /**
-     * Continuation prompt behavior when this activity runs inline in the workflow manager.
+     * Optional conditions for when to trigger (future enhancement)
      */
-    workflowContinuation?: AXPWorkflowContinuationMetadata;
-}
-/**
- * Query result shape for activity-definition catalog endpoints.
- */
-interface AXPActivityDefinitionQueryResult {
-    total: number;
-    items: AXPActivityDefinition[];
+    conditions?: any;
 }
 
-/** Registration key for {@link AXPPreviewWidgetFieldCommand}; lives in contracts so consumers can reference it without importing the command implementation. */
-declare const AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY = "Widget:Preview";
-
 /**
  * Workflow status.
  */
@@ -579,135 +1217,716 @@ interface AXPWorkflowState {
      */
     correlationId?: string | null;
     /**
-     * Workflow status.
+     * Workflow status.
+     */
+    status: AXPWorkflowStatus;
+    /**
+     * Workflow sub-status.
+     */
+    subStatus: AXPWorkflowSubStatus;
+    /**
+     * Bookmarks.
+     */
+    bookmarks: AXPBookmark[];
+    /**
+     * Incidents.
+     */
+    incidents: AXPActivityIncident[];
+    /**
+     * Fault (nullable).
+     */
+    fault?: AXPWorkflowFaultState | null;
+    /**
+     * Completion callbacks.
+     */
+    completionCallbacks: AXPCompletionCallbackState[];
+    /**
+     * Activity execution contexts.
+     */
+    activityExecutionContexts: AXPActivityExecutionContextState[];
+    /**
+     * Input data.
+     */
+    input: Record<string, any>;
+    /**
+     * Output data.
+     */
+    output: Record<string, any>;
+    /**
+     * Properties bag.
+     */
+    properties: Record<string, any>;
+    /**
+     * Created at timestamp (ISO date-time).
+     */
+    createdAt: string;
+    /**
+     * Updated at timestamp (ISO date-time).
+     */
+    updatedAt: string;
+    /**
+     * Finished at timestamp (ISO date-time, nullable).
+     */
+    finishedAt?: string | null;
+    /**
+     * Total number of activities/steps in the workflow (for progress display).
+     */
+    totalSteps?: number;
+}
+/**
+ * Workflow instance (stored in database).
+ * This matches the Elsa Workflow Instance schema for backend compatibility.
+ */
+interface AXPWorkflowInstance {
+    /**
+     * Schema reference.
+     */
+    $schema?: string;
+    /**
+     * Unique instance ID.
+     */
+    id: string;
+    /**
+     * Workflow definition ID.
+     */
+    definitionId: string;
+    /**
+     * Workflow definition version ID.
+     */
+    definitionVersionId: string;
+    /**
+     * Workflow definition version number.
+     */
+    version: number;
+    /**
+     * Parent workflow instance ID (nullable, for child workflows).
+     */
+    parentWorkflowInstanceId?: string | null;
+    /**
+     * Workflow state (internal execution state).
+     */
+    workflowState: AXPWorkflowState;
+    /**
+     * Workflow status.
+     */
+    status: AXPWorkflowStatus;
+    /**
+     * Workflow sub-status.
+     */
+    subStatus: AXPWorkflowSubStatus;
+    /**
+     * Correlation ID (nullable).
+     */
+    correlationId?: string | null;
+    /**
+     * Instance name (nullable).
+     */
+    name?: string | null;
+    /**
+     * Incident count.
+     */
+    incidentCount: number;
+    /**
+     * Created at timestamp (ISO date-time).
+     */
+    createdAt: string;
+    /**
+     * Updated at timestamp (ISO date-time).
+     */
+    updatedAt: string;
+    /**
+     * Finished at timestamp (ISO date-time, nullable).
+     */
+    finishedAt?: string | null;
+    /**
+     * Entity reference ID (for linking workflow instances to business entities).
+     */
+    entityRefId?: string | null;
+    /**
+     * Entity reference type (e.g., 'HumanCapitalManagement.LeaveRequest').
+     */
+    entityRefType?: string | null;
+}
+
+/**
+ * Type of task for inbox handling.
+ * - 'human-task': Requires inbox - needs human interaction
+ * - 'ui-activity': UI-only activity (no inbox) - immediate execution
+ * - 'system-activity': System/backend activity (no inbox) - automated execution
+ */
+type AXPTaskType = 'human-task' | 'ui-activity' | 'system-activity';
+/**
+ * How the workflow engine should offer "continue to next step?" before an inline frontend activity.
+ * Declared on {@link AXPActivityDefinition} and copied onto {@link AXPWorkflowTask} at runtime.
+ */
+type AXPWorkflowContinuationBeforeInteractive = 'default'
+/** Skip when opened from a task-board human-task primary action (e.g. start-fill, review). */
+ | 'skip-when-chained-from-human-task'
+/** Skip for the natural assignee; initiator / reassign users still get the prompt (workflow-management). */
+ | 'skip-for-assignee';
+/** Optional continuation UX metadata for an activity definition. */
+interface AXPWorkflowContinuationMetadata {
+    beforeInteractive?: AXPWorkflowContinuationBeforeInteractive;
+}
+/**
+ * Activity Category - Extends AXPCategoryEntity for consistency and performance
+ *
+ * Inherited properties from AXPCategoryEntity:
+ * - id: string                   - Unique identifier
+ * - title: string                - Display name
+ * - description?: string         - Category description
+ * - parentId?: string            - Parent category ID
+ * - childrenCount: number        - Direct child categories count (enables lazy loading)
+ * - itemsCount?: number          - Direct activities count
+ * - totalChildrenCount?: number  - Total nested categories (optional, for analytics)
+ * - totalItemsCount?: number     - Total activities in tree (optional, for analytics)
+ */
+interface AXPActivityCategory extends AXPCategoryEntity {
+}
+/**
+ * Lightweight category snapshot embedded in activity-definition records.
+ */
+interface AXPActivityDefinitionCategoryRef {
+    id: string;
+    name: string;
+    title: AXPMultiLanguageString;
+}
+/**
+ * Activity Definition - Metadata for UI and tooling.
+ * Contains all metadata needed for displaying activities in toolbox and designer.
+ * The `name` property is used as the command key for execution.
+ */
+interface AXPActivityDefinition {
+    /**
+     * Activity name - used as command key for execution.
+     * This is the unique identifier for the activity.
+     */
+    name: string;
+    /**
+     * Activity type (e.g., "workflow-activity:check-permission").
+     */
+    type: string;
+    /**
+     * Display name for UI (plain or per-locale map).
+     */
+    title?: AXPMultiLanguageString;
+    instanceTitle?: string;
+    /**
+     * Description of what the activity does (plain or per-locale map).
+     */
+    description?: AXPMultiLanguageString;
+    /**
+     * Category for grouping in toolbox.
      */
-    status: AXPWorkflowStatus;
+    category?: AXPActivityDefinitionCategoryRef;
     /**
-     * Workflow sub-status.
+     * Icon name or class.
      */
-    subStatus: AXPWorkflowSubStatus;
+    icon?: string;
     /**
-     * Bookmarks.
+     * Where this activity should be executed.
+     * - 'frontend': Execute in browser (UI activities, console, events)
+     * - 'backend': Execute in backend (business logic, API calls)
+     * - 'both': Execute in both frontend and backend (hybrid activities)
+     *
+     * Default: 'frontend'
      */
-    bookmarks: AXPBookmark[];
+    executionMode?: 'frontend' | 'backend' | 'both';
     /**
-     * Incidents.
+     * Type of task for inbox handling.
+     * - 'human-task': Requires inbox - needs human interaction
+     * - 'ui-activity': UI-only activity (no inbox) - immediate execution
+     * - 'system-activity': System/backend activity (no inbox) - automated execution
+     *
+     * Default: 'ui-activity' (for backward compatibility)
      */
-    incidents: AXPActivityIncident[];
+    taskType?: AXPTaskType;
     /**
-     * Fault (nullable).
+     * Input properties (form/schema for activity parameters).
      */
-    fault?: AXPWorkflowFaultState | null;
+    inputs?: AXPProperty[];
     /**
-     * Completion callbacks.
+     * Output properties (result shape + optional path/metadata).
      */
-    completionCallbacks: AXPCompletionCallbackState[];
+    outputs?: AXPWorkflowOutputProperty[];
     /**
-     * Activity execution contexts.
+     * Static outcomes (exit points).
+     * Example: ['Done', 'Success', 'Failed']
      */
-    activityExecutionContexts: AXPActivityExecutionContextState[];
+    outcomes?: string[];
     /**
-     * Input data.
+     * Whether this activity is browsable in the toolbox.
+     * Default: true
      */
-    input: Record<string, any>;
+    isBrowsable?: boolean;
     /**
-     * Output data.
+     * Whether this activity is a container (can have children).
+     * Default: false
      */
-    output: Record<string, any>;
+    isContainer?: boolean;
     /**
-     * Properties bag.
+     * Continuation prompt behavior when this activity runs inline in the workflow manager.
      */
-    properties: Record<string, any>;
+    workflowContinuation?: AXPWorkflowContinuationMetadata;
+}
+/**
+ * Query result shape for activity-definition catalog endpoints.
+ */
+interface AXPActivityDefinitionQueryResult {
+    total: number;
+    items: AXPActivityDefinition[];
+}
+
+/** Standard system status types used across the platform. */
+declare enum AXPSystemStatusType {
+    Todo = "todo",
+    InProgress = "in-progress",
+    InReview = "in-review",
+    Open = "open",
+    Closed = "closed",
+    Blocked = "blocked",
+    Done = "done",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    PendingReview = "pending-review",
+    WaitingSignOff = "waiting-sign-off",
+    WaitingApproval = "waiting-approval",
+    Approved = "approved",
+    Published = "published",
+    Archived = "archived",
+    Rejected = "rejected",
+    Active = "active",
+    Inactive = "inactive",
+    Pending = "pending",
+    Completed = "completed",
+    Suspended = "suspended",
+    Failed = "failed",
+    Review = "review",
+    Expired = "expired"
+}
+
+/**
+ * Status Definition Types
+ * Defines the structure for status definitions and their transitions
+ */
+/**
+ * Status definition with metadata
+ */
+interface AXPStatusDefinition {
     /**
-     * Created at timestamp (ISO date-time).
+     * Unique identifier for the status
      */
-    createdAt: string;
+    name: string;
     /**
-     * Updated at timestamp (ISO date-time).
+     * Display title for the status
      */
-    updatedAt: string;
+    title: string;
     /**
-     * Finished at timestamp (ISO date-time, nullable).
+     * Color code or semantic color name for the status
      */
-    finishedAt?: string | null;
+    color: string;
     /**
-     * Total number of activities/steps in the workflow (for progress display).
+     * Optional icon class (e.g., 'fa-light fa-check')
      */
-    totalSteps?: number;
-}
-/**
- * Workflow instance (stored in database).
- * This matches the Elsa Workflow Instance schema for backend compatibility.
- */
-interface AXPWorkflowInstance {
+    icon?: string;
     /**
-     * Schema reference.
+     * Optional description
      */
-    $schema?: string;
+    description?: string;
     /**
-     * Unique instance ID.
+     * Optional order for sorting
      */
-    id: string;
+    order?: number;
     /**
-     * Workflow definition ID.
+     * Whether this is a final status (end state)
      */
-    definitionId: string;
+    isFinal?: boolean;
     /**
-     * Workflow definition version ID.
+     * Whether this is an initial status (starting state)
      */
-    definitionVersionId: string;
+    isInitial?: boolean;
     /**
-     * Workflow definition version number.
+     * Whether list views should be automatically generated for this status
      */
-    version: number;
+    generateView?: boolean;
+}
+/**
+ * Status transition definition
+ */
+interface AXPStatusTransition {
     /**
-     * Parent workflow instance ID (nullable, for child workflows).
+     * Source status name
      */
-    parentWorkflowInstanceId?: string | null;
+    from: string;
     /**
-     * Workflow state (internal execution state).
+     * Target status name
      */
-    workflowState: AXPWorkflowState;
+    to: string;
     /**
-     * Workflow status.
+     * Optional condition expression to evaluate before allowing transition
+     * Uses expression evaluator syntax (e.g., "{{user.isAdmin}}", "{{item.priority > 5}}")
      */
-    status: AXPWorkflowStatus;
+    condition?: string;
     /**
-     * Workflow sub-status.
+     * Optional display title for the transition
      */
-    subStatus: AXPWorkflowSubStatus;
+    title?: string;
     /**
-     * Correlation ID (nullable).
+     * Optional description
      */
-    correlationId?: string | null;
+    description?: string;
     /**
-     * Instance name (nullable).
+     * Optional command descriptor to execute for this transition
+     * If not provided, defaults to Entity:UpdateStatus with entity, id, and status
      */
-    name?: string | null;
+    command?: {
+        name: string;
+        options?: Record<string, unknown>;
+    };
     /**
-     * Incident count.
+     * Whether this transition is automatic (no user action required)
      */
-    incidentCount: number;
+    isAutomatic?: boolean;
     /**
-     * Created at timestamp (ISO date-time).
+     * Whether this transition requires approval
      */
-    createdAt: string;
+    requiresApproval?: boolean;
+}
+/**
+ * Abstract class for status providers
+ * Similar to AXPTaskBadgeProvider pattern
+ */
+declare abstract class AXPStatusProvider {
     /**
-     * Updated at timestamp (ISO date-time).
+     * Unique key for the status (e.g., 'task-management.status')
      */
-    updatedAt: string;
+    abstract readonly key: string;
     /**
-     * Finished at timestamp (ISO date-time, nullable).
+     * List of available status definitions
      */
-    finishedAt?: string | null;
+    abstract readonly statuses: AXPStatusDefinition[];
     /**
-     * Entity reference ID (for linking workflow instances to business entities).
+     * List of allowed transitions between statuses
      */
-    entityRefId?: string | null;
+    abstract readonly transitions: AXPStatusTransition[];
     /**
-     * Entity reference type (e.g., 'HumanCapitalManagement.LeaveRequest').
+     * Optional default status name
      */
-    entityRefType?: string | null;
+    abstract readonly defaultStatus?: string;
+}
+
+/**
+ * Standard system status definitions
+ * Provides consistent status definitions across the platform
+ * Uses AXPStatusDefinition interface from status-definition.types.ts
+ */
+declare const AXPSystemStatuses: Readonly<{
+    readonly Open: {
+        readonly name: AXPSystemStatusType.Open;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly Closed: {
+        readonly name: AXPSystemStatusType.Closed;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Todo: {
+        readonly name: AXPSystemStatusType.Todo;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly InProgress: {
+        readonly name: AXPSystemStatusType.InProgress;
+        readonly title: string;
+        readonly icon: "fa-light fa-play";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly InReview: {
+        readonly name: AXPSystemStatusType.InReview;
+        readonly title: string;
+        readonly icon: "fa-light fa-eye";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Blocked: {
+        readonly name: AXPSystemStatusType.Blocked;
+        readonly title: string;
+        readonly icon: "fa-light fa-ban";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 4;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Done: {
+        readonly name: AXPSystemStatusType.Done;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Cancelled: {
+        readonly name: AXPSystemStatusType.Cancelled;
+        readonly title: string;
+        readonly icon: "fa-light fa-times-circle";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 6;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Draft: {
+        readonly name: AXPSystemStatusType.Draft;
+        readonly title: string;
+        readonly icon: "fa-light fa-file-pen";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly PendingReview: {
+        readonly name: AXPSystemStatusType.PendingReview;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly WaitingSignOff: {
+        readonly name: AXPSystemStatusType.WaitingSignOff;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly WaitingApproval: {
+        readonly name: AXPSystemStatusType.WaitingApproval;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly Approved: {
+        readonly name: AXPSystemStatusType.Approved;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Published: {
+        readonly name: AXPSystemStatusType.Published;
+        readonly title: string;
+        readonly icon: "fa-light fa-globe";
+        readonly color: "primary";
+        readonly description: string;
+        readonly order: 4;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Archived: {
+        readonly name: AXPSystemStatusType.Archived;
+        readonly title: string;
+        readonly icon: "fa-light fa-archive";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Rejected: {
+        readonly name: AXPSystemStatusType.Rejected;
+        readonly title: string;
+        readonly icon: "fa-light fa-times-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 6;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Active: {
+        readonly name: AXPSystemStatusType.Active;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Inactive: {
+        readonly name: AXPSystemStatusType.Inactive;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Pending: {
+        readonly name: AXPSystemStatusType.Pending;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly Completed: {
+        readonly name: AXPSystemStatusType.Completed;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Suspended: {
+        readonly name: AXPSystemStatusType.Suspended;
+        readonly title: string;
+        readonly icon: "fa-light fa-pause-circle";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Failed: {
+        readonly name: AXPSystemStatusType.Failed;
+        readonly title: string;
+        readonly icon: "fa-light fa-xmark-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Review: {
+        readonly name: AXPSystemStatusType.Review;
+        readonly title: string;
+        readonly icon: "fa-light fa-eye";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 3;
+    };
+    readonly Expired: {
+        readonly name: AXPSystemStatusType.Expired;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+}>;
+/**
+ * Get system status definition by type
+ * @param type - Status type
+ * @returns System status definition or undefined
+ */
+declare function getSystemStatus(type: AXPSystemStatusType): AXPStatusDefinition;
+/**
+ * Resolves the visual appearance (color and icon) for status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Color and icon for the status
+ */
+declare function resolveStatusLook(statusType: string): {
+    color: AXStyleColorType;
+    icon: string;
+};
+/**
+ * Resolves the complete status information (title, description, icon, color) for a status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Complete status information as AXPStatusDefinition
+ */
+declare function getStatusInfo(statusType: string): AXPStatusDefinition;
+/**
+ * Get system status definition directly (no conversion needed since it's already AXPStatusDefinition)
+ * @param statusType - Status type
+ * @param overrides - Optional overrides for the status definition
+ * @returns AXPStatusDefinition
+ */
+declare function systemStatusToDefinition(statusType: AXPSystemStatusType, overrides?: Partial<AXPStatusDefinition>): AXPStatusDefinition;
+
+/**
+ * Address mode type - determines the display mode of the address widget
+ * - simple: single text input for full address (one line)
+ * - popup: readonly summary + button to edit in popup dialog
+ * - expandable: expandable panel — collapsed shows full address, expanded shows inline form
+ */
+type AXPAddressMode = 'simple' | 'popup' | 'expandable';
+/**
+ * Address label option
+ */
+interface AXPAddressLabel {
+    id: string;
+    name: string;
+}
+/**
+ * Address data structure
+ */
+interface AXPAddressData {
+    street1: string;
+    street2?: string;
+    postalCode?: string;
+    coordinates?: string;
+    full: string;
+    label?: string;
+    country?: {
+        id?: string;
+        title?: string;
+    };
+    state?: {
+        id?: string;
+        title?: string;
+    };
+    city?: {
+        id?: string;
+        title?: string;
+    };
 }
 
 declare enum AXPFileStorageStatus {
@@ -936,5 +2155,317 @@ interface AXPMetaDataDefinition {
     features?: AXPMetaDataFeatures;
 }
 
-export { AXPFileStorageStatus, AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY };
-export type { AXPActivityCategory, AXPActivityDefinition, AXPActivityDefinitionCategoryRef, AXPActivityDefinitionQueryResult, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityStatus, AXPActivityVariable, AXPAddressData, AXPAddressLabel, AXPAddressMode, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPElsaWorkflowExtensions, AXPExceptionState, AXPFileManyStorageInfo, AXPFileStorageCreateRequest, AXPFileStorageFindRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPMetaDataDefinition, AXPMetaDataFeatures, AXPTaskType, AXPWorkflowActivityInstance, AXPWorkflowBinding, AXPWorkflowContinuationBeforeInteractive, AXPWorkflowContinuationMetadata, AXPWorkflowDefinition, AXPWorkflowExtensions, AXPWorkflowFaultState, AXPWorkflowGraph, AXPWorkflowInstance, AXPWorkflowOutputProperty, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowSubStatus };
+/** JSON data primitive for the specialist final deliverable. */
+type AXPAgentOutputKind = 'string' | 'object' | 'array';
+/** When `kind` is `object`, controls how the parsed value maps into chat transcript segments. */
+type AXPOutputTranscriptSegmentId = 'text' | 'node' | 'followUp' | 'file';
+
+type AXPSpreadsheetCellValue = string | null;
+/** Matrix data: row id → column id → cell value id */
+type AXPSpreadsheetData = Record<string, Record<string, AXPSpreadsheetCellValue>>;
+
+/** Platform core datasource registry names. */
+declare const AXPPlatformCoreDataSourceKeys: {
+    readonly ModuleManifests: "platform-module-manifests";
+    readonly CatalogScopes: "platform-catalog-scopes";
+};
+
+/**
+ * Regional and locale-related setting keys used by platform widgets and components.
+ * Most values use the `LocaleManagement:Setting:Regional.*` prefix; definitions live in the locale-management module where applicable.
+ */
+declare enum AXPRegionalSetting {
+    LocaleProfile = "LocaleManagement:Setting:Regional.LocaleProfile",
+    TimeZone = "LocaleManagement:Setting:Regional.TimeZone",
+    Language = "LocaleManagement:Setting:Regional.Language",
+    Country = "LocaleManagement:Setting:Regional.Country",
+    Calendar = "LocaleManagement:Setting:Regional.Calendar",
+    /** User-selected holiday calendars shown on the task board and other calendar views. */
+    CalendarEvents = "LocaleManagement:Setting:Regional.CalendarEvents",
+    FirstDayOfWeek = "LocaleManagement:Setting:Regional.FirstDayOfWeek",
+    WeekendDays = "LocaleManagement:Setting:Regional.WeekendDays",
+    ShortDate = "LocaleManagement:Setting:Regional.ShortDate",
+    MediumDate = "LocaleManagement:Setting:Regional.MediumDate",
+    LongDate = "LocaleManagement:Setting:Regional.LongDate",
+    ShortTime = "LocaleManagement:Setting:Regional.ShortTime",
+    MediumTime = "LocaleManagement:Setting:Regional.MediumTime",
+    LongTime = "LocaleManagement:Setting:Regional.LongTime",
+    MeasurementUnits = "LocaleManagement:Setting:Regional.MeasurementUnits",
+    TemperatureUnits = "LocaleManagement:Setting:Regional.TemperatureUnits",
+    DistanceUnits = "LocaleManagement:Setting:Regional.DistanceUnits",
+    WeightUnits = "LocaleManagement:Setting:Regional.WeightUnits",
+    VolumeUnits = "LocaleManagement:Setting:Regional.VolumeUnits",
+    SpeedUnits = "LocaleManagement:Setting:Regional.SpeedUnits",
+    AreaUnits = "LocaleManagement:Setting:Regional.AreaUnits",
+    /** Default multi-language behavior for standard text field names; defined in locale-management `AXMRegionalSettingProvider`. */
+    MultiLanguageSupport = "LocaleManagement:Setting:Regional.MultiLanguageSupport"
+}
+
+/** Registration key for {@link AXPPreviewWidgetFieldCommand}; lives in contracts so consumers can reference it without importing the command implementation. */
+declare const AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY = "Widget:Preview";
+
+/**
+ * Builds a locale map for mock seed data (`en-US` + `fa-IR`).
+ * Standalone copy for connectivity mocks — no dependency on @acorex/core/translation.
+ */
+declare function createMultiLanguageString(enUS: string, faIR?: string): Record<string, string>;
+/**
+ * Resolves {@link AXPMultiLanguageString} to a plain string for the given locale.
+ * Standalone copy for connectivity mocks — no dependency on @acorex/core/translation.
+ */
+declare function resolveMultiLanguageString(value: AXPMultiLanguageString | null | undefined, locale: string): string;
+/**
+ * Lightweight data helpers for mock seed files.
+ * Standalone copy for connectivity mocks — no dependency on @acorex/platform/core.
+ */
+declare class AXPDataGenerator {
+    static uuid(): string;
+    static number(max: number): number;
+    static number(min: number, max: number): number;
+    static date(): Date;
+    static date(start: Date): Date;
+    static date(start: Date, end: Date): Date;
+    static array<T>(length: number | undefined, generator: () => T): T[];
+    static pick<T>(items: T[]): T;
+    static pick<T>(items: T[], count: number): T[];
+    static string(length?: number): string;
+    static boolean(): boolean;
+    static item<T>(array?: T[]): T | undefined;
+    static color(format?: 'hsl' | 'rgb' | 'hex'): string;
+    private static hslToRgb;
+    static alphanumeric(length?: number): string;
+    static alphabet(length?: number): string;
+    static phone(): string;
+    static firstName(): string;
+    static lastName(): string;
+    static email(): string;
+    static email(firstName: string, lastName: string): string;
+    static country(): string;
+    static city(): string;
+    static state(): string;
+    static address(): string;
+    static avatar(): string;
+}
+
+declare const AXP_INTEGRATION_CONNECTION_STATUS: {
+    readonly NotConnected: "NotConnected";
+    readonly PendingAuthorization: "PendingAuthorization";
+    readonly Connected: "Connected";
+    readonly Expired: "Expired";
+    readonly RefreshRequired: "RefreshRequired";
+    readonly Invalid: "Invalid";
+    readonly Revoked: "Revoked";
+    readonly Disabled: "Disabled";
+    readonly Error: "Error";
+};
+type AXPIntegrationConnectionStatus = (typeof AXP_INTEGRATION_CONNECTION_STATUS)[keyof typeof AXP_INTEGRATION_CONNECTION_STATUS];
+declare const AXP_INTEGRATION_CONNECTION_SCOPE: {
+    readonly User: "user";
+    readonly Tenant: "tenant";
+};
+type AXPIntegrationConnectionScope = (typeof AXP_INTEGRATION_CONNECTION_SCOPE)[keyof typeof AXP_INTEGRATION_CONNECTION_SCOPE];
+declare const AXP_INTEGRATION_AUTH_METHOD_TYPE: {
+    readonly OAuth2: "oauth2";
+    readonly Pat: "pat";
+    readonly Basic: "basic";
+    readonly ApiToken: "apiToken";
+};
+type AXPIntegrationAuthMethodType = (typeof AXP_INTEGRATION_AUTH_METHOD_TYPE)[keyof typeof AXP_INTEGRATION_AUTH_METHOD_TYPE];
+declare const AXP_INTEGRATION_CATEGORY: {
+    readonly DevTools: "dev-tools";
+    readonly Messaging: "messaging";
+    readonly Productivity: "productivity";
+    readonly Identity: "identity";
+    readonly Storage: "storage";
+    readonly Other: "other";
+};
+type AXPIntegrationCategory = (typeof AXP_INTEGRATION_CATEGORY)[keyof typeof AXP_INTEGRATION_CATEGORY];
+declare const AXP_INTEGRATION_CAPABILITY: {
+    readonly Sync: "sync";
+    readonly Search: "search";
+    readonly Import: "import";
+    readonly Export: "export";
+    readonly Webhooks: "webhooks";
+    readonly IssueTracking: "issue-tracking";
+    readonly Messaging: "messaging";
+    readonly FileStorage: "file-storage";
+    readonly Calendar: "calendar";
+    readonly Identity: "identity";
+    readonly TimeLogging: "time-logging";
+    readonly CustomActions: "custom-actions";
+};
+type AXPIntegrationCapability = (typeof AXP_INTEGRATION_CAPABILITY)[keyof typeof AXP_INTEGRATION_CAPABILITY];
+
+/**
+ * Connection details safe for queries and UI responses.
+ * Never includes access tokens, passwords, or refresh tokens.
+ */
+interface AXPSafeIntegrationConnectionDto {
+    id: string;
+    providerId: string;
+    connectionScope: AXPIntegrationConnectionScope;
+    connectionKey: string;
+    displayName: string;
+    authMethodType: AXPIntegrationAuthMethodType;
+    status: AXPIntegrationConnectionStatus;
+    instanceUrl?: string | null;
+    externalAccountId?: string | null;
+    externalAccountName?: string | null;
+    grantedScopes?: string[] | null;
+    expiresAt?: string | null;
+    lastConnectedAt?: string | null;
+    lastValidatedAt?: string | null;
+    lastSyncAt?: string | null;
+    lastErrorCode?: string | null;
+    lastErrorMessage?: string | null;
+    isRevoked: boolean;
+    isDisabled: boolean;
+    config?: Record<string, unknown> | null;
+    hasSecret: boolean;
+    secretPreview?: string | null;
+}
+interface AXPIntegrationProviderListItemDto {
+    id: string;
+    module: string;
+    displayName: string;
+    description?: string;
+    icon?: string;
+    category: string;
+    capabilities: string[];
+    connectionScopes: AXPIntegrationConnectionScope[];
+    allowMultipleConnections: boolean;
+    authMethodTypes: AXPIntegrationAuthMethodType[];
+    isConnected: boolean;
+    connectionCount: number;
+}
+interface AXPIntegrationValidationResult {
+    valid: boolean;
+    status?: AXPIntegrationConnectionStatus;
+    externalAccountId?: string;
+    externalAccountName?: string;
+    grantedScopes?: string[];
+    expiresAt?: string;
+    errorCode?: string;
+    errorMessage?: string;
+}
+
+interface AXPIntegrationAuthFieldDefinition {
+    type: string;
+    path?: string;
+    name?: string;
+    visible?: boolean;
+    options?: Record<string, unknown>;
+    layout?: Record<string, unknown>;
+    children?: AXPIntegrationAuthFieldDefinition[];
+}
+interface AXPIntegrationOAuth2AuthMethodDefinition {
+    type: 'oauth2';
+    label: string;
+    usesRedirect: boolean;
+    supportsRefresh: boolean;
+    supportsRevoke: boolean;
+    supportsValidation: boolean;
+    defaultScopes?: string[];
+    fields?: AXPIntegrationAuthFieldDefinition[];
+}
+interface AXPIntegrationPatAuthMethodDefinition {
+    type: 'pat';
+    label: string;
+    supportsValidation: boolean;
+    fields: AXPIntegrationAuthFieldDefinition[];
+}
+interface AXPIntegrationBasicAuthMethodDefinition {
+    type: 'basic';
+    label: string;
+    supportsValidation: boolean;
+    fields: AXPIntegrationAuthFieldDefinition[];
+}
+interface AXPIntegrationApiTokenAuthMethodDefinition {
+    type: 'apiToken';
+    label: string;
+    supportsValidation: boolean;
+    fields: AXPIntegrationAuthFieldDefinition[];
+}
+type AXPIntegrationAuthMethodDefinition = AXPIntegrationOAuth2AuthMethodDefinition | AXPIntegrationPatAuthMethodDefinition | AXPIntegrationBasicAuthMethodDefinition | AXPIntegrationApiTokenAuthMethodDefinition;
+interface AXPIntegrationProviderDefinition {
+    id: string;
+    module: string;
+    displayName: string;
+    description?: string;
+    icon?: string;
+    category: AXPIntegrationCategory;
+    capabilities: AXPIntegrationCapability[];
+    connectionScopes: AXPIntegrationConnectionScope[];
+    allowMultipleConnections: boolean;
+    authMethods: AXPIntegrationAuthMethodDefinition[];
+    defaultConnectionKey?: string;
+    features?: string[];
+    customUiComponentKey?: string;
+}
+interface AXPIntegrationAuthContext {
+    tenantId: string;
+    userId: string;
+    connectionId: string;
+    providerId: string;
+    connectionScope: AXPIntegrationConnectionScope;
+    connectionKey: string;
+    authMethodType: AXPIntegrationAuthMethodType;
+    instanceUrl?: string | null;
+    config?: Record<string, unknown> | null;
+}
+interface AXPIntegrationRuntimeContext extends AXPIntegrationAuthContext {
+    secretRef: string;
+}
+interface AXPIntegrationProviderRuntimeHooks {
+    validateConnection?(ctx: AXPIntegrationRuntimeContext): Promise<AXPIntegrationValidationResult>;
+    revokeConnection?(ctx: AXPIntegrationRuntimeContext): Promise<void>;
+    refreshTokens?(ctx: AXPIntegrationRuntimeContext): Promise<AXPIntegrationValidationResult>;
+    createClient?(ctx: AXPIntegrationRuntimeContext): Promise<unknown>;
+}
+interface AXPIntegrationOAuthSecretPayload {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: string;
+    tokenType?: string;
+    scope?: string;
+}
+interface AXPIntegrationPatSecretPayload {
+    token: string;
+}
+interface AXPIntegrationBasicSecretPayload {
+    username: string;
+    password: string;
+}
+interface AXPIntegrationApiTokenSecretPayload {
+    email: string;
+    apiToken: string;
+}
+type AXPIntegrationSecretPayload = AXPIntegrationOAuthSecretPayload | AXPIntegrationPatSecretPayload | AXPIntegrationBasicSecretPayload | AXPIntegrationApiTokenSecretPayload;
+interface AXPIntegrationResolvedCredentials {
+    authMethodType: AXPIntegrationAuthMethodType;
+    accessToken?: string;
+    refreshToken?: string;
+    expiresAt?: string;
+    token?: string;
+    username?: string;
+    password?: string;
+    email?: string;
+    apiToken?: string;
+}
+declare class AXPIntegrationNotConnectedError extends Error {
+    readonly providerId: string;
+    constructor(providerId: string, message?: string);
+}
+declare class AXPIntegrationExpiredError extends Error {
+    readonly providerId: string;
+    readonly connectionId: string;
+    constructor(providerId: string, connectionId: string, message?: string);
+}
+declare class AXPIntegrationMissingScopeError extends Error {
+    readonly providerId: string;
+    readonly missingScopes: string[];
+    constructor(providerId: string, missingScopes: string[], message?: string);
+}
+
+export { AXPDataGenerator, AXPExportTemplateToken, AXPFileStorageStatus, AXPIntegrationExpiredError, AXPIntegrationMissingScopeError, AXPIntegrationNotConnectedError, AXPPlatformCoreDataSourceKeys, AXPPlatformScope, AXPRegionalSetting, AXPStatusProvider, AXPSystemActionType, AXPSystemStatusType, AXPSystemStatuses, AXPWidgetsCatalog, AXPWidgetsList, AXP_INTEGRATION_AUTH_METHOD_TYPE, AXP_INTEGRATION_CAPABILITY, AXP_INTEGRATION_CATEGORY, AXP_INTEGRATION_CONNECTION_SCOPE, AXP_INTEGRATION_CONNECTION_STATUS, AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY, createMultiLanguageString, getNestedKeys, getStatusInfo, getSystemStatus, normalizeDefinitionCategories, resolveMultiLanguageString, resolvePlatformScopeKey, resolvePlatformScopeName, resolveStatusLook, systemStatusToDefinition };
+export type { AXDataSourceFilterOption, AXDataSourceOperator, AXDataSourceOperatorType, AXDataSourceSortOption, AXFilterLogic, AXPActionMenuItem, AXPActivityCategory, AXPActivityDefinition, AXPActivityDefinitionCategoryRef, AXPActivityDefinitionQueryResult, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityStatus, AXPActivityVariable, AXPAddressData, AXPAddressLabel, AXPAddressMode, AXPAgentOutputKind, AXPApplicationUserReference, AXPBackButton, AXPBadge, AXPBookmark, AXPBreadcrumbItem, AXPCategorizedEntity, AXPCategorizedEntityDto, AXPCategoryEntity, AXPCategoryEntityWithItems, AXPCategoryListItem, AXPColumnQuery, AXPCommandMessage, AXPCompletionCallbackState, AXPConnection, AXPContent, AXPContentDirection, AXPContentType, AXPDataType, AXPDefinitionCategory, AXPElsaWorkflowExtensions, AXPEntityOp, AXPEntityReference, AXPEqualValidationRule, AXPExceptionState, AXPExecuteCommand, AXPExecuteCommandResult, AXPExportCsvOptions, AXPExportExcelOptions, AXPExportOptions, AXPExportPdfOptions, AXPExportPrintOptions, AXPExpression, AXPFileListItem, AXPFileManyStorageInfo, AXPFileSource, AXPFileStatus, AXPFileStorageCreateRequest, AXPFileStorageFindRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPFilterClause, AXPFilterDefinition, AXPFilterQuery, AXPFilterTriggerDefinition, AXPFlowDirection, AXPGridLayoutOptions, AXPGridPlacement, AXPIntegrationApiTokenAuthMethodDefinition, AXPIntegrationApiTokenSecretPayload, AXPIntegrationAuthContext, AXPIntegrationAuthFieldDefinition, AXPIntegrationAuthMethodDefinition, AXPIntegrationAuthMethodType, AXPIntegrationBasicAuthMethodDefinition, AXPIntegrationBasicSecretPayload, AXPIntegrationCapability, AXPIntegrationCategory, AXPIntegrationConnectionScope, AXPIntegrationConnectionStatus, AXPIntegrationOAuth2AuthMethodDefinition, AXPIntegrationOAuthSecretPayload, AXPIntegrationPatAuthMethodDefinition, AXPIntegrationPatSecretPayload, AXPIntegrationProviderDefinition, AXPIntegrationProviderListItemDto, AXPIntegrationProviderRuntimeHooks, AXPIntegrationResolvedCredentials, AXPIntegrationRuntimeContext, AXPIntegrationSecretPayload, AXPIntegrationValidationResult, AXPLogoConfig, AXPMaxLengthValidationRule, AXPMaybePromise, AXPMetaData, AXPMetaDataDefinition, AXPMetaDataFeatures, AXPMiddlewareErrorResponse, AXPMinLengthValidationRule, AXPMultiLanguageString, AXPMultiSourceRef, AXPOptionsData, AXPOutputTranscriptSegmentId, AXPPageStatus, AXPPagedListResult, AXPPartialNested, AXPPlatformScopeKey, AXPProperty, AXPPropertyGroup, AXPPropertyInterface, AXPQueryFetchResult, AXPQueryRequest, AXPReqexValidationRule, AXPRequiredValidationRule, AXPSafeIntegrationConnectionDto, AXPSortDefinition, AXPSortQuery, AXPSpreadsheetCellValue, AXPSpreadsheetData, AXPStatusDefinition, AXPStatusTransition, AXPStringValidationRules, AXPSystemAction, AXPTaskType, AXPUserReference, AXPValidationRule, AXPValidationRules, AXPValueTransformerFunction, AXPValueTransformerFunctions, AXPValueUnit, AXPValueUnits, AXPViewBlockDefinition, AXPViewDefinition, AXPViewFieldDefinition, AXPViewQuery, AXPWidgetNode, AXPWidgetRenderMode, AXPWidgetTrigger, AXPWidgetTriggers, AXPWorkflowActivityInstance, AXPWorkflowBinding, AXPWorkflowCategory, AXPWorkflowContinuationBeforeInteractive, AXPWorkflowContinuationMetadata, AXPWorkflowDefinition, AXPWorkflowExtensions, AXPWorkflowFaultState, AXPWorkflowGraph, AXPWorkflowInstance, AXPWorkflowOutputProperty, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowSubStatus, AXPopupSizeType, AXStyleColorType };