@omnia/fx 7.11.33 → 7.12.2

package/internal-do-not-import-from-here/ux/colorpicker/ColorPicker.d.ts

@@ -1,11 +1,7 @@
-import { IWebComponentInstance } from "../..";
-import { IColorPicker } from "./IColorPicker";
-import { IValidator, VueComponentBase, ColorPickerModel, ColorPickerDisplayOptions } from "..";
+import { IValidator, ColorPickerModel, ColorPickerDisplayOptions } from "..";
 import { ColorPickerStyles } from "../models/ColorPickerStyles";
 import "./ColorPicker.css";
-import { ColorPickerLocalization } from "./loc/localize";
-export declare class ColorPicker extends VueComponentBase implements IWebComponentInstance, IColorPicker {
-    private omniaContext;
+export interface ColorPickerProps {
     label?: string;
     placeholder?: string;
     valueBind: ColorPickerModel;
@@ -22,36 +18,16 @@ export declare class ColorPicker extends VueComponentBase implements IWebCompone
     attachedToParent?: boolean;
     disableContextColor?: boolean;
     disabled?: boolean;
-    private uxLoc;
-    loc: ColorPickerLocalization.locInterface;
-    private colors;
-    private availableColors;
-    private selectedColor;
-    private customColor;
-    private internalModel;
-    private loaded;
-    private displayCustomPicker;
-    private displayCustomPickerContainer;
-    private customColorContainerHeight;
-    private customColorStyle;
-    private classes;
-    private componentId;
-    onValueBindChanged(model: any): void;
-    created(): void;
-    mounted(): void;
-    private initInternalModel;
-    private loadColors;
-    handleCustomColorSelection(): void;
-    private changed;
-    private onSelectedChanged;
-    showCustomColor(): void;
-    setCustomColorPosition(): void;
-    onClickOutCustomColorPanel(): void;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const ColorPicker: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<ColorPickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ColorPickerProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<ColorPickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ColorPickerProps, never>;
+});
 export declare enum ColorType {
     PrimaryColor = 1,
     SecondaryColor = 2,
     CorporateColor = 3,
     CustomColor = 4
 }
+export default ColorPicker;

package/internal-do-not-import-from-here/ux/colorpicker/IColorPicker.d.ts

@@ -1,4 +1,3 @@
-import { TsxAllowUnknowProperties } from "../TsxAllowUnknowProperties";
 import { IValidator, ColorPickerModel, ColorPickerDisplayOptions } from "..";
 /**Color Picker*/
 export interface IColorPicker {
@@ -18,14 +17,3 @@ export interface IColorPicker {
     disableContextColor?: boolean;
     disabled?: boolean;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-color-picker": TsxAllowUnknowProperties<IColorPicker>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/confirmdialog/ConfirmDialog.d.ts

@@ -1,10 +1,9 @@
-import { VueComponentBase } from "../VueComponentBase";
-import { IConfirmDialog, ConfirmDialogDisplay } from "./IConfirmDialog";
+import { ConfirmDialogDisplay } from "./IConfirmDialog";
 import { ConfirmDialogOptions, ConfirmDialogResponse } from "./IVueConfirmDialog";
 import { ConfirmDialogStyles } from "../models/ConfirmDialogStyles";
 import "./ConfirmDialog.css";
 import { ButtonModes, ButtonSizes, ButtonTooltipOptions } from "../../models";
-export declare class ConfirmDialogComponent extends VueComponentBase implements IConfirmDialog {
+export interface ConfirmDialogComponentProps {
     icon?: string;
     type?: ConfirmDialogDisplay;
     flat?: boolean;
@@ -18,12 +17,10 @@ export declare class ConfirmDialogComponent extends VueComponentBase implements
     buttonNonFlatMode?: ButtonModes;
     loading?: boolean;
     getConfirmDialogOptions?: () => Promise<ConfirmDialogOptions>;
-    private omniaUxLoc;
-    private disable;
-    private confirmDialogClasses;
-    created(): void;
-    mounted(): void;
-    openConfirmDialog(dialogOptions?: ConfirmDialogOptions): void;
-    onClick(): void;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const ConfirmDialogComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<ConfirmDialogComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ConfirmDialogComponentProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<ConfirmDialogComponentProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ConfirmDialogComponentProps, never>;
+});
+export default ConfirmDialogComponent;

package/internal-do-not-import-from-here/ux/confirmdialog/IConfirmDialog.d.ts

@@ -1,4 +1,3 @@
-import { TsxAllowUnknowProperties } from "../TsxAllowUnknowProperties";
 import { ConfirmDialogOptions, ConfirmDialogResponse } from "./IVueConfirmDialog";
 import { ConfirmDialogStyles } from "../models/ConfirmDialogStyles";
 import { ButtonTooltipOptions } from "@omnia/fx-models";
@@ -19,14 +18,3 @@ export interface IConfirmDialog extends IConfirmDialogAttributes {
     tooltip?: ButtonTooltipOptions;
     getConfirmDialogOptions?: () => Promise<ConfirmDialogOptions>;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-confirm-dialog": TsxAllowUnknowProperties<IConfirmDialog>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/confirmdialog/VueConfirmDialog.d.ts

@@ -1,19 +1 @@
-import { ConfirmDialogOptions, ConfirmDialogResponse } from "./IVueConfirmDialog";
-import { VueComponentBase } from "../VueComponentBase";
-interface VueConfirmDialogProps {
-}
-export declare class ConfirmDialogVueComponent extends VueComponentBase<VueConfirmDialogProps> {
-    private omniaContext;
-    private themeStore;
-    private omniaUxLoc;
-    options: ConfirmDialogOptions;
-    private resolve;
-    private dialogOptions;
-    open(options?: ConfirmDialogOptions): Promise<ConfirmDialogResponse>;
-    static install(Vue: any, options: any): void;
-    private get defaultOptions();
-    private handleClickOk;
-    private handleClickCancel;
-    render(): VueTsxSupport.JSX.Element;
-}
-export {};
+export declare const ConfirmDialogVueComponent: any;

package/internal-do-not-import-from-here/ux/connectedtenantpicker/ConnectedTenantPicker.d.ts

@@ -1,11 +1,7 @@
-import Vue from "vue";
-import { IWebComponentInstance } from "../../";
-import { IConnectedTenantPicker } from "./IConnectedTenantPicker";
 import { ConnectedTenant, GuidValue } from "../../models";
 import { ScopedSlots } from "..";
 import { IVSelectScopedSlots } from "../vuetify";
-import { ConnectedTenantStore } from "../../stores";
-export declare class ConnectedTenantPicker extends Vue implements IWebComponentInstance, IConnectedTenantPicker {
+export interface ConnectedTenantPickerProps {
     valueBind: GuidValue;
     disabled?: boolean;
     label?: string;
@@ -14,14 +10,10 @@ export declare class ConnectedTenantPicker extends Vue implements IWebComponentI
     dark?: boolean;
     flat?: boolean;
     scopedSlots?: ScopedSlots<IVSelectScopedSlots>;
-    private omniaUxLoc;
-    connectedTenantStore: ConnectedTenantStore;
-    connectedTenants: ConnectedTenant[];
-    loading: boolean;
-    created(): void;
-    private getConnectedTenants;
-    mounted(): void;
-    beforeDestroy(): void;
-    private updateSelectedTenant;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const ConnectedTenantPicker: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<ConnectedTenantPickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ConnectedTenantPickerProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<ConnectedTenantPickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ConnectedTenantPickerProps, never>;
+});
+export default ConnectedTenantPicker;

package/internal-do-not-import-from-here/ux/connectedtenantpicker/IConnectedTenantPicker.d.ts

@@ -1,4 +1,4 @@
-import { TsxAllowUnknowProperties, ScopedSlots } from "../";
+import { ScopedSlots } from "../";
 import { ConnectedTenant, GuidValue } from "../../models";
 import { IVSelectScopedSlots } from "../vuetify";
 /**Context Conntect Tenant Picker*/
@@ -18,16 +18,3 @@ export interface IConnectedTenantPicker {
     /**Scoped slots */
     scopedSlots?: ScopedSlots<IVSelectScopedSlots>;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-connected-tenant": TsxAllowUnknowProperties<IConnectedTenantPicker>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/contextlanguagepicker/ContextLanguagePicker.d.ts

@@ -1,10 +1,6 @@
-import Vue from "vue";
-import { IWebComponentInstance } from "../../";
-import { IContextLanguagePicker } from "./IContextLanguagePicker";
-import { Language } from "../../models";
 import { ScopedSlots } from "..";
 import { IVSelectScopedSlots } from "../vuetify";
-export declare class ContextLanguagePicker extends Vue implements IWebComponentInstance, IContextLanguagePicker {
+export interface ContextLanguagePickerProps {
     valueBind: string;
     disabled?: boolean;
     label?: string;
@@ -15,14 +11,10 @@ export declare class ContextLanguagePicker extends Vue implements IWebComponentI
     hideDisplayFlag?: boolean;
     hideDisplayName?: boolean;
     scopedSlots?: ScopedSlots<IVSelectScopedSlots>;
-    private omniaContext;
-    private omniaUxLoc;
-    languages: Language[];
-    private get slots();
-    created(): void;
-    private getLanguages;
-    mounted(): void;
-    beforeDestroy(): void;
-    private updateSelectedContextLanguage;
-    render(): VueTsxSupport.JSX.Element;
 }
+export declare const ContextLanguagePicker: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<ContextLanguagePickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ContextLanguagePickerProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<ContextLanguagePickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<ContextLanguagePickerProps, never>;
+});
+export default ContextLanguagePicker;

package/internal-do-not-import-from-here/ux/contextlanguagepicker/IContextLanguagePicker.d.ts

@@ -1,4 +1,4 @@
-import { TsxAllowUnknowProperties, ScopedSlots } from "../";
+import { ScopedSlots } from "../";
 import { IVSelectScopedSlots } from "../vuetify";
 /**Context Language Picker*/
 export interface IContextLanguagePicker {
@@ -21,16 +21,3 @@ export interface IContextLanguagePicker {
     /**Scoped slots */
     scopedSlots?: ScopedSlots<IVSelectScopedSlots>;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface ElementAttributesProperty {
-        }
-        interface IntrinsicElements {
-            "omfx-context-language-picker": TsxAllowUnknowProperties<IContextLanguagePicker>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/customfont/AdminRegistration.d.ts

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/ux/customfont/Constants.d.ts

@@ -0,0 +1,7 @@
+export declare const CustomFontBladeIds: {
+    font: string;
+    additionalFont: string;
+};
+export declare const CustomFontElementNames: {
+    adminJourney: string;
+};

package/internal-do-not-import-from-here/ux/customfont/CustomFontStyle.d.ts

@@ -0,0 +1,33 @@
+export declare class CustomFontStyle {
+    private omniaContext;
+    private settingsService;
+    private fileStorageService;
+    private tenantSettings;
+    private businessProfilePropertyBagSubscription;
+    private toolingPortalTrackingInitialized;
+    private toolingPortalTrackingPending;
+    private toolingPortalTrackingRequested;
+    constructor();
+    private init;
+    private onContextChanged;
+    private subscribeToBusinessProfilePropertyBag;
+    private initToolingPortalTracking;
+    private applyEffectiveSettings;
+    private updateToolingPortalTracking;
+    private getEffectiveSettings;
+    private applySettings;
+    private mergeSettings;
+    private getFontUrl;
+    private createCss;
+    private getFontFaceRules;
+    private getScopedFontRules;
+    private createFontFaceRule;
+    private getScopeSelectors;
+    private qualifyToolingRoot;
+    private removeStyle;
+    private canUseDocument;
+    private isValidFontUrl;
+    private getFontFormat;
+    private escapeCssString;
+    private escapeCssUrl;
+}

package/internal-do-not-import-from-here/ux/customfont/FontSettingsBlade.d.ts

@@ -0,0 +1,7 @@
+import { JourneyInstance } from "@omnia/fx-models";
+interface FontSettingsBladeProps {
+    journey: JourneyInstance;
+    businessProfileScope?: boolean;
+}
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<FontSettingsBladeProps, never>, any, any, any>;
+export default _default;

package/internal-do-not-import-from-here/ux/customfont/FontSettingsJourney.d.ts

@@ -0,0 +1,19 @@
+import { JourneyInstance } from "@omnia/fx-models";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    category: string;
+    journey: () => JourneyInstance;
+}, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        category: string;
+        journey: () => JourneyInstance;
+    }, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    category: string;
+    journey: () => JourneyInstance;
+}, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        category: string;
+        journey: () => JourneyInstance;
+    }, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/customfont/loc/localize.d.ts

@@ -0,0 +1,43 @@
+export declare module CustomFontLocalization {
+    const namespace = "Omnia.Ux.CustomFont";
+    interface locInterface {
+        BladeTitle: string;
+        Previewing: string;
+        InheritFromTenant: string;
+        EnableCustomFont: string;
+        FontFamilyName: string;
+        FontSource: string;
+        FileUpload: string;
+        CdnFileLink: string;
+        SystemFont: string;
+        SystemFontHelp: string;
+        ChooseFontFile: string;
+        NoFileSelected: string;
+        SupportedFontFilesHelp: string;
+        CdnFontFileUrl: string;
+        CdnFontFileUrlPlaceholder: string;
+        AdditionalFonts: string;
+        AddAdditionalFont: string;
+        EditAdditionalFont: string;
+        NoAdditionalFonts: string;
+        AdditionalFontsHelp: string;
+        ApplyTo: string;
+        ScopeReadMode: string;
+        ScopeEverywhere: string;
+        PreviewTitle: string;
+        DisplayText: string;
+        HeadlineText: string;
+        TitleText: string;
+        BodyText: string;
+        SmallAction: string;
+        DefaultAction: string;
+        LargeAction: string;
+        FontFileTooLarge: string;
+        UnsupportedFontFileType: string;
+        FontFamilyRequired: string;
+        ValidFontFileRequired: string;
+        ValidCdnUrlRequired: string;
+        ValidFontSourceRequired: string;
+        UnexpectedError: string;
+    }
+}

package/internal-do-not-import-from-here/ux/datatable/Datatable.d.ts

@@ -1,10 +1,6 @@
-import { IWebComponentInstance } from "@omnia/fx";
-import { IDatatable } from "./IDatatable";
 import "./Datatable.css";
-import { VueComponentBase } from "..";
 import { VDataGridHeader, VDataGridItemScopedSlot } from "../../models";
-export declare class Datatable extends VueComponentBase<IDatatable> implements IWebComponentInstance, IDatatable {
-    private omniaUxLoc;
+export interface DatatableProps {
     items: any;
     itemsPerPage: number;
     skip: number;
@@ -16,22 +12,11 @@ export declare class Datatable extends VueComponentBase<IDatatable> implements I
     backgroundColor: string;
     onSort: (propName: string, sortDsc: boolean) => Promise<[]>;
     onPaging: (propName: string, sortDsc: boolean, skip: number) => Promise<[]>;
-    renderItem: (prop?: VDataGridItemScopedSlot<any>) => JSX.Element;
-    private propertyName;
-    private descending;
-    private isLoadingNextPage;
-    private noNextPage;
-    isChangingData(newValue: Array<any>, oldValue: Array<any>): void;
-    mounted(): void;
-    private registerScrollPaging;
-    beforeDestroy(): void;
-    private removeScrollPaging;
-    created(): void;
-    private init;
-    private nextPage;
-    private changeSort;
-    private getSortByAscendingText;
-    private getSortByDescendingText;
-    render(): VueTsxSupport.JSX.Element;
-    private renderHeaders;
+    renderItem: (prop?: VDataGridItemScopedSlot<any>) => VueTsxSupport.JSX.Element;
 }
+export declare const Datatable: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<DatatableProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<DatatableProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<DatatableProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<DatatableProps, never>;
+});
+export default Datatable;

package/internal-do-not-import-from-here/ux/datatable/IDatatable.d.ts

@@ -1,5 +1,4 @@
 import { VDataGridHeader, VDataGridItemScopedSlot } from "../../models";
-import { TsxAllowUnknowProperties } from "../TsxAllowUnknowProperties";
 export interface IDatatableProperties {
     itemsPerPage?: number;
     defaultProperty?: string;
@@ -17,14 +16,3 @@ export interface IDatatable extends IDatatableProperties {
     scrollElementSelector?: string;
     backgroundColor?: string;
 }
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-datatable": TsxAllowUnknowProperties<IDatatable>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/datetimepicker/DateTimePicker.d.ts

@@ -1,66 +1,14 @@
-import { VueComponentBase } from "..";
-import { IWebComponentInstance } from "../../index";
-import { TimeFormats } from "../../models";
-import "./DateTimePicker.css";
-import { IDateTimePicker, IDatetimePickerFormatter } from "./IDateTimePicker";
-import { DateTimePickerLocalization } from "./loc/localize";
-export declare class DateTimePicker extends VueComponentBase implements IWebComponentInstance, IDateTimePicker {
-    valueBind: string;
-    formatter?: IDatetimePickerFormatter;
-    color: string;
-    localeString: string;
-    scrollable: boolean;
-    pickerMode: "date-time" | "date" | "time";
-    onValueChanged: (model: string) => void;
-    label: string;
-    isRequired: boolean;
-    filled: boolean;
-    dense: boolean;
-    disabled: boolean;
-    dark?: boolean;
-    singleLine: boolean;
-    hideDetails: boolean;
-    hasIcon: boolean;
-    description: string;
-    isKeepMenuOpen?: (value: boolean) => void;
-    icon?: string;
+import { IDateTimePicker } from "..";
+type DateTimePickerProps = IDateTimePicker & {
+    localeString?: string;
+    dense?: boolean;
+    hasIcon?: boolean;
     tooltip?: string;
-    private omniaContext;
-    locDateTimePicker: DateTimePickerLocalization.locInterface;
-    private subscriptionHandler;
-    private timeFormatValues;
-    private styles;
-    private date;
-    private time;
-    private mask;
-    private displayText;
-    private inputFormat;
-    private outputFormat;
-    private dateFormat;
-    private status;
-    private showMenu;
-    private isError;
-    private defaultFormatter;
-    private isMobileMode;
-    private isClicking;
-    private attachElementId;
-    private activatorElementId;
-    private isUseAccessibilityFeature;
-    onValueBindChanged(newValue: string): void;
-    created(): void;
-    mounted(): void;
-    getTimeFormatAsString(timeFormat: TimeFormats): string;
-    init(): void;
-    getDisplayText(model: string): string;
-    prepareData(): void;
-    toggleStatus(): void;
-    rebuildDateTime(): void;
-    inputChange(): void;
-    updateInput(): void;
-    private getDateTimeValueInOutputFormat;
-    private keepMenuOpen;
-    updateModel(): void;
-    error(): string;
-    focusToMenuActivator(): void;
-    render(): JSX.Element;
-}
+    attachToParent?: boolean;
+};
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<DateTimePickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<DateTimePickerProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<DateTimePickerProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<DateTimePickerProps, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/datetimepicker/DateTimePickerCore.d.ts

@@ -0,0 +1,113 @@
+import dayjs from "dayjs";
+export type PickerTab = "date" | "time" | "month" | "year";
+/**
+ * Localization strings required by the shared picker panel.
+ * Both DateTimePickerLocalization and DateTimeZonePickerLocalization satisfy this shape.
+ */
+export interface PickerPanelLoc {
+    CalendarPicker: string;
+    TimePicker: string;
+    MonthPicker: string;
+    YearPicker: string;
+    PreviousMonth: string;
+    NextMonth: string;
+    PreviousYear: string;
+    NextYear: string;
+    PreviousYears: string;
+    NextYears: string;
+    YearLabel: string;
+    ClickToSelectMonth: string;
+    ClickToSelectYear: string;
+    CurrentYearIs: string;
+    SelectedDatePrefix: string;
+    TodayPrefix: string;
+    SelectedMonthPrefix: string;
+    SelectedYearPrefix: string;
+    IncreaseHour: string;
+    DecreaseHour: string;
+    IncreaseMinute: string;
+    DecreaseMinute: string;
+    HourLabel: string;
+    MinuteLabel: string;
+    SetAM?: string;
+    SetPM?: string;
+}
+/**
+ * Configuration object that drives the shared picker panel rendering.
+ * Each consumer (DateTimePicker, DateTimeZonePicker) builds this from its own state.
+ */
+export interface PickerPanelConfig {
+    pickerTab: PickerTab;
+    mainTab: number;
+    currentViewDate: dayjs.Dayjs;
+    selectedDate: string;
+    yearPageStart: number;
+    hourDisplay: string;
+    minuteDisplay: string;
+    mode: "date-time" | "date" | "time";
+    locale: string;
+    firstDayOfWeek: number;
+    activeColor: string;
+    activeTextColor: string;
+    is12HourFormat: boolean;
+    amPm?: "AM" | "PM";
+    loc: PickerPanelLoc;
+    okText: string;
+    cancelText: string;
+    styles: any;
+    onSelectDate: (date: string) => void;
+    onSelectMonth: (month: number) => void;
+    onSelectYear: (year: number) => void;
+    onPrevMonth: () => void;
+    onNextMonth: () => void;
+    onPrevYear: () => void;
+    onNextYear: () => void;
+    onPrevYearPage: () => void;
+    onNextYearPage: () => void;
+    onIncrementHour: () => void;
+    onDecrementHour: () => void;
+    onIncrementMinute: () => void;
+    onDecrementMinute: () => void;
+    onUpdateHourFromInput: (e: Event) => void;
+    onUpdateMinuteFromInput: (e: Event) => void;
+    onSetAmPm?: (value: "AM" | "PM") => void;
+    onConfirm: () => void;
+    onCancel: () => void;
+    setPickerTab: (tab: PickerTab) => void;
+    setPreviousPickerTab: (tab: "date" | "month") => void;
+    setMainTab: (tab: number) => void;
+    setYearPageStart: (start: number) => void;
+    isSelectedDateInDisplayedMonth: () => boolean;
+    isSelectedMonthInDisplayedYear: () => boolean;
+    isSelectedYearInDisplayedPage: () => boolean;
+    focusDateButton: (date: string) => void;
+    focusMonthButton: (month: number) => void;
+    focusYearButton: (year: number) => void;
+    focusDateGridEntry: () => void;
+    moveFocusedDate: (amount: number, unit: dayjs.ManipulateType) => void;
+    moveFocusedDateToWeekBoundary: (boundary: "start" | "end") => void;
+    moveFocusedMonth: (amount: number) => void;
+    moveFocusedMonthToRowBoundary: (boundary: "start" | "end") => void;
+    moveFocusedYear: (amount: number) => void;
+    moveFocusedYearToRowBoundary: (boundary: "start" | "end") => void;
+    moveFocusedToFirstDisplayedDate: () => void;
+    setTouchStartX: (x: number) => void;
+    getTouchStartX: () => number;
+    handlePickerKeydown: (e: KeyboardEvent) => void;
+}
+export declare function getPickerActiveTextColor(activeColor: string): string;
+export declare function handleKeyboardActivate(e: KeyboardEvent, action: () => void): void;
+export declare function createDateKeyboardHandler(cfg: PickerPanelConfig): (e: KeyboardEvent, date: string) => void;
+export declare function createMonthKeyboardHandler(cfg: PickerPanelConfig): (e: KeyboardEvent, month: number) => void;
+export declare function createYearKeyboardHandler(cfg: PickerPanelConfig): (e: KeyboardEvent, year: number) => void;
+export declare function createTouchStartHandler(cfg: PickerPanelConfig): (e: TouchEvent) => void;
+export declare function createCalendarTouchEndHandler(cfg: PickerPanelConfig): (e: TouchEvent) => void;
+export declare function createMonthTouchEndHandler(cfg: PickerPanelConfig): (e: TouchEvent) => void;
+export declare function createYearTouchEndHandler(cfg: PickerPanelConfig): (e: TouchEvent) => void;
+export declare function renderPickerHeader(cfg: PickerPanelConfig): any;
+export declare function renderCalendarGrid(cfg: PickerPanelConfig): any;
+export declare function renderMonthPicker(cfg: PickerPanelConfig): any;
+export declare function renderYearPicker(cfg: PickerPanelConfig): any;
+export declare function renderTimePicker(cfg: PickerPanelConfig): any;
+export declare function renderPickerContent(cfg: PickerPanelConfig): any;
+export declare function renderPickerFooter(cfg: PickerPanelConfig): any;

package/internal-do-not-import-from-here/ux/datetimepicker/IDateTimePicker.d.ts

@@ -47,9 +47,15 @@ export interface IDateTimePicker extends IDateTimePickerProperties {
     formatter?: IDatetimePickerFormatter;
     dark?: boolean;
     description?: string;
+    icon?: string;
+    isKeepMenuOpen?: (value: boolean) => void;
+}
+export interface IDateTimePickerElement extends HTMLElement {
+    valueBind: string | null;
+    refreshValueBind?: (value: string | null) => void;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {