@oracle/oraclejet-core-pack 16.0.5 → 16.1.0

package/oj-c/types/input-month-mask/input-month-mask.d.ts

@@ -0,0 +1,184 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { CalendarMonth, CalendarMonthRequired, InputDateMask as PreactInputDateMask } from '@oracle/oraclejet-preact/UNSAFE_InputDateMask';
+import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
+import Validator = require('ojs/ojvalidator');
+import AsyncValidator = require('ojs/ojvalidator-async');
+import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
+import { ComponentProps, ComponentType, Ref } from 'preact';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+import { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
+import 'css!oj-c/input-month-mask/input-month-mask-styles.css';
+import type { OverflowMessageDetailParameters, UnderflowMessageDetailParameters } from './CalendarMonthRangeValidator';
+type PreactInputDateMaskProps = ComponentProps<typeof PreactInputDateMask>;
+type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+type Props = ObservedGlobalProps<'aria-describedby' | 'id'> & {
+    columnSpan?: LayoutColumnSpan;
+    containerReadonly?: boolean;
+    dateRangeOverflowMessageDetail?: (p: OverflowMessageDetailParameters) => string;
+    dateRangeUnderflowMessageDetail?: (p: UnderflowMessageDetailParameters) => string;
+    disabled?: boolean;
+    displayOptions?: Omit<DisplayOptions, 'converterHint'>;
+    help?: Help;
+    helpHints?: HelpHints;
+    labelEdge?: PreactInputDateMaskProps['labelEdge'];
+    labelHint: string;
+    labelStartWidth?: Size;
+    labelWrapping?: 'truncate' | 'wrap';
+    max?: CalendarMonthRequired | null;
+    messagesCustom?: PreactInputDateMaskProps['messages'];
+    min?: CalendarMonthRequired | null;
+    readonly?: boolean;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    textAlign?: PreactInputDateMaskProps['textAlign'];
+    userAssistanceDensity?: PreactInputDateMaskProps['userAssistanceDensity'];
+    validators?: (AsyncValidator<CalendarMonthRequired> | Validator<CalendarMonthRequired>)[] | null;
+    value?: CalendarMonthRequired | null;
+    onMessagesCustomChanged?: PropertyChanged<PreactInputDateMaskProps['messages']>;
+    onRawValueChanged?: ReadOnlyPropertyChanged<CalendarMonth>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<CalendarMonthRequired>;
+};
+type InputMonthMaskHandle = {
+    blur: () => void;
+    focus: () => void;
+    showMessages: () => void;
+    reset: () => void;
+    validate: () => Promise<'valid' | 'invalid'>;
+};
+declare const InputMonthMaskImpl: ({ columnSpan, disabled, displayOptions, help, helpHints, messagesCustom, readonly, required, userAssistanceDensity, validators, value, ...otherProps }: Props, ref: Ref<InputMonthMaskHandle>) => import("preact").JSX.Element;
+export declare const InputMonthMask: ComponentType<ExtendGlobalProps<ComponentProps<typeof InputMonthMaskImpl>>>;
+export type InputMonthMaskProps = Props;
+export {};
+export interface CInputMonthMaskElement extends JetElement<CInputMonthMaskElementSettableProperties>, CInputMonthMaskElementSettableProperties {
+    readonly rawValue?: Parameters<Required<Props>['onRawValueChanged']>[0];
+    readonly valid?: Parameters<Required<Props>['onValidChanged']>[0];
+    addEventListener<T extends keyof CInputMonthMaskElementEventMap>(type: T, listener: (this: HTMLElement, ev: CInputMonthMaskElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CInputMonthMaskElementSettableProperties>(property: T): CInputMonthMaskElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CInputMonthMaskElementSettableProperties>(property: T, value: CInputMonthMaskElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CInputMonthMaskElementSettableProperties>): void;
+    setProperties(properties: CInputMonthMaskElementSettablePropertiesLenient): void;
+    blur: () => void;
+    focus: () => void;
+    reset: () => void;
+    showMessages: () => void;
+    validate: () => Promise<'invalid' | 'valid'>;
+}
+export namespace CInputMonthMaskElement {
+    type columnSpanChanged = JetElementCustomEventStrict<CInputMonthMaskElement['columnSpan']>;
+    type containerReadonlyChanged = JetElementCustomEventStrict<CInputMonthMaskElement['containerReadonly']>;
+    type dateRangeOverflowMessageDetailChanged = JetElementCustomEventStrict<CInputMonthMaskElement['dateRangeOverflowMessageDetail']>;
+    type dateRangeUnderflowMessageDetailChanged = JetElementCustomEventStrict<CInputMonthMaskElement['dateRangeUnderflowMessageDetail']>;
+    type disabledChanged = JetElementCustomEventStrict<CInputMonthMaskElement['disabled']>;
+    type displayOptionsChanged = JetElementCustomEventStrict<CInputMonthMaskElement['displayOptions']>;
+    type helpChanged = JetElementCustomEventStrict<CInputMonthMaskElement['help']>;
+    type helpHintsChanged = JetElementCustomEventStrict<CInputMonthMaskElement['helpHints']>;
+    type labelEdgeChanged = JetElementCustomEventStrict<CInputMonthMaskElement['labelEdge']>;
+    type labelHintChanged = JetElementCustomEventStrict<CInputMonthMaskElement['labelHint']>;
+    type labelStartWidthChanged = JetElementCustomEventStrict<CInputMonthMaskElement['labelStartWidth']>;
+    type labelWrappingChanged = JetElementCustomEventStrict<CInputMonthMaskElement['labelWrapping']>;
+    type maxChanged = JetElementCustomEventStrict<CInputMonthMaskElement['max']>;
+    type messagesCustomChanged = JetElementCustomEventStrict<CInputMonthMaskElement['messagesCustom']>;
+    type minChanged = JetElementCustomEventStrict<CInputMonthMaskElement['min']>;
+    type rawValueChanged = JetElementCustomEventStrict<CInputMonthMaskElement['rawValue']>;
+    type readonlyChanged = JetElementCustomEventStrict<CInputMonthMaskElement['readonly']>;
+    type requiredChanged = JetElementCustomEventStrict<CInputMonthMaskElement['required']>;
+    type requiredMessageDetailChanged = JetElementCustomEventStrict<CInputMonthMaskElement['requiredMessageDetail']>;
+    type textAlignChanged = JetElementCustomEventStrict<CInputMonthMaskElement['textAlign']>;
+    type userAssistanceDensityChanged = JetElementCustomEventStrict<CInputMonthMaskElement['userAssistanceDensity']>;
+    type validChanged = JetElementCustomEventStrict<CInputMonthMaskElement['valid']>;
+    type validatorsChanged = JetElementCustomEventStrict<CInputMonthMaskElement['validators']>;
+    type valueChanged = JetElementCustomEventStrict<CInputMonthMaskElement['value']>;
+}
+export interface CInputMonthMaskElementEventMap extends HTMLElementEventMap {
+    'columnSpanChanged': JetElementCustomEventStrict<CInputMonthMaskElement['columnSpan']>;
+    'containerReadonlyChanged': JetElementCustomEventStrict<CInputMonthMaskElement['containerReadonly']>;
+    'dateRangeOverflowMessageDetailChanged': JetElementCustomEventStrict<CInputMonthMaskElement['dateRangeOverflowMessageDetail']>;
+    'dateRangeUnderflowMessageDetailChanged': JetElementCustomEventStrict<CInputMonthMaskElement['dateRangeUnderflowMessageDetail']>;
+    'disabledChanged': JetElementCustomEventStrict<CInputMonthMaskElement['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CInputMonthMaskElement['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CInputMonthMaskElement['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CInputMonthMaskElement['helpHints']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CInputMonthMaskElement['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CInputMonthMaskElement['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CInputMonthMaskElement['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CInputMonthMaskElement['labelWrapping']>;
+    'maxChanged': JetElementCustomEventStrict<CInputMonthMaskElement['max']>;
+    'messagesCustomChanged': JetElementCustomEventStrict<CInputMonthMaskElement['messagesCustom']>;
+    'minChanged': JetElementCustomEventStrict<CInputMonthMaskElement['min']>;
+    'rawValueChanged': JetElementCustomEventStrict<CInputMonthMaskElement['rawValue']>;
+    'readonlyChanged': JetElementCustomEventStrict<CInputMonthMaskElement['readonly']>;
+    'requiredChanged': JetElementCustomEventStrict<CInputMonthMaskElement['required']>;
+    'requiredMessageDetailChanged': JetElementCustomEventStrict<CInputMonthMaskElement['requiredMessageDetail']>;
+    'textAlignChanged': JetElementCustomEventStrict<CInputMonthMaskElement['textAlign']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CInputMonthMaskElement['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CInputMonthMaskElement['valid']>;
+    'validatorsChanged': JetElementCustomEventStrict<CInputMonthMaskElement['validators']>;
+    'valueChanged': JetElementCustomEventStrict<CInputMonthMaskElement['value']>;
+}
+export interface CInputMonthMaskElementSettableProperties extends JetSettableProperties {
+    columnSpan?: Props['columnSpan'];
+    containerReadonly?: Props['containerReadonly'];
+    dateRangeOverflowMessageDetail?: Props['dateRangeOverflowMessageDetail'];
+    dateRangeUnderflowMessageDetail?: Props['dateRangeUnderflowMessageDetail'];
+    disabled?: Props['disabled'];
+    displayOptions?: Props['displayOptions'];
+    help?: Props['help'];
+    helpHints?: Props['helpHints'];
+    labelEdge?: Props['labelEdge'];
+    labelHint: Props['labelHint'];
+    labelStartWidth?: Props['labelStartWidth'];
+    labelWrapping?: Props['labelWrapping'];
+    max?: Props['max'];
+    messagesCustom?: Props['messagesCustom'];
+    min?: Props['min'];
+    readonly?: Props['readonly'];
+    required?: Props['required'];
+    requiredMessageDetail?: Props['requiredMessageDetail'];
+    textAlign?: Props['textAlign'];
+    userAssistanceDensity?: Props['userAssistanceDensity'];
+    validators?: Props['validators'];
+    value?: Props['value'];
+}
+export interface CInputMonthMaskElementSettablePropertiesLenient extends Partial<CInputMonthMaskElementSettableProperties> {
+    [key: string]: any;
+}
+export interface InputMonthMaskIntrinsicProps extends Partial<Readonly<CInputMonthMaskElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    rawValue?: never;
+    valid?: never;
+    oncolumnSpanChanged?: (value: CInputMonthMaskElementEventMap['columnSpanChanged']) => void;
+    oncontainerReadonlyChanged?: (value: CInputMonthMaskElementEventMap['containerReadonlyChanged']) => void;
+    ondateRangeOverflowMessageDetailChanged?: (value: CInputMonthMaskElementEventMap['dateRangeOverflowMessageDetailChanged']) => void;
+    ondateRangeUnderflowMessageDetailChanged?: (value: CInputMonthMaskElementEventMap['dateRangeUnderflowMessageDetailChanged']) => void;
+    ondisabledChanged?: (value: CInputMonthMaskElementEventMap['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CInputMonthMaskElementEventMap['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CInputMonthMaskElementEventMap['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CInputMonthMaskElementEventMap['helpHintsChanged']) => void;
+    onlabelEdgeChanged?: (value: CInputMonthMaskElementEventMap['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CInputMonthMaskElementEventMap['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CInputMonthMaskElementEventMap['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CInputMonthMaskElementEventMap['labelWrappingChanged']) => void;
+    onmaxChanged?: (value: CInputMonthMaskElementEventMap['maxChanged']) => void;
+    onmessagesCustomChanged?: (value: CInputMonthMaskElementEventMap['messagesCustomChanged']) => void;
+    onminChanged?: (value: CInputMonthMaskElementEventMap['minChanged']) => void;
+    onrawValueChanged?: (value: CInputMonthMaskElementEventMap['rawValueChanged']) => void;
+    onreadonlyChanged?: (value: CInputMonthMaskElementEventMap['readonlyChanged']) => void;
+    onrequiredChanged?: (value: CInputMonthMaskElementEventMap['requiredChanged']) => void;
+    onrequiredMessageDetailChanged?: (value: CInputMonthMaskElementEventMap['requiredMessageDetailChanged']) => void;
+    ontextAlignChanged?: (value: CInputMonthMaskElementEventMap['textAlignChanged']) => void;
+    onuserAssistanceDensityChanged?: (value: CInputMonthMaskElementEventMap['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CInputMonthMaskElementEventMap['validChanged']) => void;
+    onvalidatorsChanged?: (value: CInputMonthMaskElementEventMap['validatorsChanged']) => void;
+    onvalueChanged?: (value: CInputMonthMaskElementEventMap['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-input-month-mask': InputMonthMaskIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/input-month-mask/useImplicitCalendarMonthRangeValidator.d.ts

@@ -0,0 +1,13 @@
+import { FormatObj } from '@oracle/oraclejet-preact/UNSAFE_IntlFormatParse';
+import type { CalendarMonthRequired } from '@oracle/oraclejet-preact/UNSAFE_InputDateMask';
+import { CalendarMonthRangeValidator } from './CalendarMonthRangeValidator';
+import type { CalendarMonthRangeValidatorOptions } from './CalendarMonthRangeValidator';
+type UseImplicitCalendarMonthRangeValidatorProps = {
+    formatObj: FormatObj<CalendarMonthRequired>;
+    dateRangeOverflowMessageDetail?: CalendarMonthRangeValidatorOptions['dateRangeOverflowMessageDetail'];
+    dateRangeUnderflowMessageDetail?: CalendarMonthRangeValidatorOptions['dateRangeUnderflowMessageDetail'];
+    max?: CalendarMonthRangeValidatorOptions['max'];
+    min?: CalendarMonthRangeValidatorOptions['min'];
+};
+export declare function useImplicitCalendarMonthRangeValidator({ formatObj, dateRangeOverflowMessageDetail, dateRangeUnderflowMessageDetail, max, min }: UseImplicitCalendarMonthRangeValidatorProps): CalendarMonthRangeValidator | null;
+export {};

package/oj-c/types/input-month-mask/useInputMonthMaskPreact.d.ts

@@ -0,0 +1,39 @@
+import { ComponentProps } from 'preact';
+import type { CalendarMonth } from '@oracle/oraclejet-preact/UNSAFE_InputDateMask';
+import type { InputMonthMask } from 'oj-c/input-month-mask';
+type InputMonthMaskProps = ComponentProps<typeof InputMonthMask>;
+export declare function useInputMonthMaskPreact({ dateRangeOverflowMessageDetail, dateRangeUnderflowMessageDetail, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, max, messagesCustom, min, readonly, required, requiredMessageDetail, textAlign, userAssistanceDensity, validators, value: propValue, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, ...otherProps }: InputMonthMaskProps, addBusyState?: (desc?: string) => () => void): {
+    value: Required<CalendarMonth> | undefined;
+    setValue: import("preact/hooks").StateUpdater<Required<CalendarMonth> | undefined>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"invalid" | "valid">;
+        showMessages: () => void;
+    };
+    inputMonthMaskProps: Omit<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
+        'aria-describedby'?: string | undefined;
+        assistiveText?: string | undefined;
+        columnSpan?: import("@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout").LayoutColumns | undefined;
+        granularity?: "day" | "month" | undefined;
+        helpSourceLink?: string | undefined;
+        helpSourceText?: string | undefined;
+        isDisabled?: boolean | undefined;
+        isReadonly?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        isRequiredShown?: boolean | undefined;
+        label: string;
+        labelEdge?: "none" | "start" | "top" | "inside" | undefined;
+        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
+        masks?: import("@oracle/oraclejet-preact/UNSAFE_InputDateMask").DatePlaceholders | undefined;
+        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        textAlign?: "end" | "start" | "right" | undefined;
+        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+        value?: import("@oracle/oraclejet-preact/UNSAFE_InputDateMask").CalendarDate | undefined;
+        variant?: "default" | "embedded" | undefined;
+        onCommit?: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<import("@oracle/oraclejet-preact/UNSAFE_InputDateMask").CalendarDate>) => void) | undefined;
+        onInput: (detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<import("@oracle/oraclejet-preact/UNSAFE_InputDateMask").CalendarDate>) => void;
+    }, "ref"> & {
+        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
+    };
+};
+export {};

package/oj-c/types/input-number/useImplicitNumberConverter.d.ts

@@ -5,5 +5,5 @@ type InputNumberProps = ComponentProps<typeof InputNumber>;
 type UseImplicitNumberConverterProps = {
     converter?: InputNumberProps['converter'];
 };
-export declare function useImplicitNumberConverter({ converter }: UseImplicitNumberConverterProps): NumberConverter | import("@oracle/oraclejet/ojconverter")<number>;
+export declare function useImplicitNumberConverter({ converter }: UseImplicitNumberConverterProps): import("@oracle/oraclejet/ojconverter")<number> | NumberConverter;
 export {};

package/oj-c/types/input-sensitive-text/index.d.ts

@@ -0,0 +1,2 @@
+export { InputSensitiveText } from './input-sensitive-text';
+export { CInputSensitiveTextElement } from './input-sensitive-text';

package/oj-c/types/input-sensitive-text/input-sensitive-text.d.ts

@@ -0,0 +1,199 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import 'ojs/oj-jsx-interfaces';
+import { ComponentProps, ComponentType, Ref } from 'preact';
+import { InputSensitiveText as PreactInputSensitiveText } from '@oracle/oraclejet-preact/UNSAFE_InputSensitiveText';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+import { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
+import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
+import Validator = require('ojs/ojvalidator');
+import AsyncValidator = require('ojs/ojvalidator-async');
+import { ExtendGlobalProps, GlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
+import 'css!oj-c/input-sensitive-text/input-sensitive-text-styles.css';
+type PreactInputSensitiveTextProps = ComponentProps<typeof PreactInputSensitiveText>;
+type Length = {
+    countBy?: 'codePoint' | 'codeUnit';
+    max?: number | null;
+};
+type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+type Props<V> = ObservedGlobalProps<'aria-describedby' | 'id'> & {
+    autofocus?: GlobalProps['autofocus'];
+    clearIcon?: 'always' | 'never' | 'conditional';
+    columnSpan?: LayoutColumnSpan;
+    containerReadonly?: boolean;
+    disabled?: boolean;
+    displayOptions?: Omit<DisplayOptions, 'converterHint'>;
+    help?: Help;
+    helpHints?: HelpHints;
+    labelEdge?: PreactInputSensitiveTextProps['labelEdge'];
+    labelHint: string;
+    labelStartWidth?: Size;
+    labelWrapping?: 'truncate' | 'wrap';
+    length?: Length;
+    maskIcon?: 'visible' | 'hidden';
+    maskIconLabel?: string;
+    messagesCustom?: PreactInputSensitiveTextProps['messages'];
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    textAlign?: PreactInputSensitiveTextProps['textAlign'];
+    userAssistanceDensity?: PreactInputSensitiveTextProps['userAssistanceDensity'];
+    validators?: (AsyncValidator<V> | Validator<V>)[] | null;
+    value?: V | null;
+    virtualKeyboard?: PreactInputSensitiveTextProps['virtualKeyboard'];
+    onMessagesCustomChanged?: PropertyChanged<PreactInputSensitiveTextProps['messages']>;
+    onRawValueChanged?: ReadOnlyPropertyChanged<string>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<V | null>;
+};
+type InputSensitiveTextHandle = {
+    blur: () => void;
+    focus: () => void;
+    showMessages: () => void;
+    reset: () => void;
+    validate: () => Promise<'valid' | 'invalid'>;
+};
+declare const FunctionalInputSensitiveText: import("preact").FunctionalComponent<Omit<Props<string>, "ref"> & {
+    ref?: Ref<InputSensitiveTextHandle> | undefined;
+}>;
+export declare const InputSensitiveText: ComponentType<ExtendGlobalProps<ComponentProps<typeof FunctionalInputSensitiveText>>>;
+export type InputSensitiveTextProps<V extends string = string> = Props<V>;
+export {};
+export interface CInputSensitiveTextElement<V extends string = string> extends JetElement<CInputSensitiveTextElementSettableProperties<V>>, CInputSensitiveTextElementSettableProperties<V> {
+    readonly rawValue?: Parameters<Required<Props<V>>['onRawValueChanged']>[0];
+    readonly valid?: Parameters<Required<Props<V>>['onValidChanged']>[0];
+    addEventListener<T extends keyof CInputSensitiveTextElementEventMap<V>>(type: T, listener: (this: HTMLElement, ev: CInputSensitiveTextElementEventMap<V>[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CInputSensitiveTextElementSettableProperties<V>>(property: T): CInputSensitiveTextElement<V>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CInputSensitiveTextElementSettableProperties<V>>(property: T, value: CInputSensitiveTextElementSettableProperties<V>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CInputSensitiveTextElementSettableProperties<V>>): void;
+    setProperties(properties: CInputSensitiveTextElementSettablePropertiesLenient<V>): void;
+    blur: () => void;
+    focus: () => void;
+    reset: () => void;
+    showMessages: () => void;
+    validate: () => Promise<'invalid' | 'valid'>;
+}
+export namespace CInputSensitiveTextElement {
+    type clearIconChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['clearIcon']>;
+    type columnSpanChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['columnSpan']>;
+    type containerReadonlyChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['containerReadonly']>;
+    type disabledChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['disabled']>;
+    type displayOptionsChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['displayOptions']>;
+    type helpChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['help']>;
+    type helpHintsChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['helpHints']>;
+    type labelEdgeChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['labelEdge']>;
+    type labelHintChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['labelHint']>;
+    type labelStartWidthChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['labelStartWidth']>;
+    type labelWrappingChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['labelWrapping']>;
+    type lengthChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['length']>;
+    type maskIconChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['maskIcon']>;
+    type maskIconLabelChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['maskIconLabel']>;
+    type messagesCustomChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['messagesCustom']>;
+    type placeholderChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['placeholder']>;
+    type rawValueChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['rawValue']>;
+    type readonlyChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['readonly']>;
+    type requiredChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['required']>;
+    type requiredMessageDetailChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['requiredMessageDetail']>;
+    type textAlignChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['textAlign']>;
+    type userAssistanceDensityChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['userAssistanceDensity']>;
+    type validChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['valid']>;
+    type validatorsChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['validators']>;
+    type valueChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['value']>;
+    type virtualKeyboardChanged<V extends string = string> = JetElementCustomEventStrict<CInputSensitiveTextElement<V>['virtualKeyboard']>;
+}
+export interface CInputSensitiveTextElementEventMap<V extends string = string> extends HTMLElementEventMap {
+    'clearIconChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['clearIcon']>;
+    'columnSpanChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['columnSpan']>;
+    'containerReadonlyChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['containerReadonly']>;
+    'disabledChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['helpHints']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['labelWrapping']>;
+    'lengthChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['length']>;
+    'maskIconChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['maskIcon']>;
+    'maskIconLabelChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['maskIconLabel']>;
+    'messagesCustomChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['messagesCustom']>;
+    'placeholderChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['placeholder']>;
+    'rawValueChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['rawValue']>;
+    'readonlyChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['readonly']>;
+    'requiredChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['required']>;
+    'requiredMessageDetailChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['requiredMessageDetail']>;
+    'textAlignChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['textAlign']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['valid']>;
+    'validatorsChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['validators']>;
+    'valueChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['value']>;
+    'virtualKeyboardChanged': JetElementCustomEventStrict<CInputSensitiveTextElement<V>['virtualKeyboard']>;
+}
+export interface CInputSensitiveTextElementSettableProperties<V> extends JetSettableProperties {
+    clearIcon?: Props<V>['clearIcon'];
+    columnSpan?: Props<V>['columnSpan'];
+    containerReadonly?: Props<V>['containerReadonly'];
+    disabled?: Props<V>['disabled'];
+    displayOptions?: Props<V>['displayOptions'];
+    help?: Props<V>['help'];
+    helpHints?: Props<V>['helpHints'];
+    labelEdge?: Props<V>['labelEdge'];
+    labelHint: Props<V>['labelHint'];
+    labelStartWidth?: Props<V>['labelStartWidth'];
+    labelWrapping?: Props<V>['labelWrapping'];
+    length?: Props<V>['length'];
+    maskIcon?: Props<V>['maskIcon'];
+    maskIconLabel?: Props<V>['maskIconLabel'];
+    messagesCustom?: Props<V>['messagesCustom'];
+    placeholder?: Props<V>['placeholder'];
+    readonly?: Props<V>['readonly'];
+    required?: Props<V>['required'];
+    requiredMessageDetail?: Props<V>['requiredMessageDetail'];
+    textAlign?: Props<V>['textAlign'];
+    userAssistanceDensity?: Props<V>['userAssistanceDensity'];
+    validators?: Props<V>['validators'];
+    value?: Props<V>['value'];
+    virtualKeyboard?: Props<V>['virtualKeyboard'];
+}
+export interface CInputSensitiveTextElementSettablePropertiesLenient<V> extends Partial<CInputSensitiveTextElementSettableProperties<V>> {
+    [key: string]: any;
+}
+export interface InputSensitiveTextIntrinsicProps extends Partial<Readonly<CInputSensitiveTextElementSettableProperties<any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    rawValue?: never;
+    valid?: never;
+    onclearIconChanged?: (value: CInputSensitiveTextElementEventMap<any>['clearIconChanged']) => void;
+    oncolumnSpanChanged?: (value: CInputSensitiveTextElementEventMap<any>['columnSpanChanged']) => void;
+    oncontainerReadonlyChanged?: (value: CInputSensitiveTextElementEventMap<any>['containerReadonlyChanged']) => void;
+    ondisabledChanged?: (value: CInputSensitiveTextElementEventMap<any>['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CInputSensitiveTextElementEventMap<any>['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CInputSensitiveTextElementEventMap<any>['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CInputSensitiveTextElementEventMap<any>['helpHintsChanged']) => void;
+    onlabelEdgeChanged?: (value: CInputSensitiveTextElementEventMap<any>['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CInputSensitiveTextElementEventMap<any>['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CInputSensitiveTextElementEventMap<any>['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CInputSensitiveTextElementEventMap<any>['labelWrappingChanged']) => void;
+    onlengthChanged?: (value: CInputSensitiveTextElementEventMap<any>['lengthChanged']) => void;
+    onmaskIconChanged?: (value: CInputSensitiveTextElementEventMap<any>['maskIconChanged']) => void;
+    onmaskIconLabelChanged?: (value: CInputSensitiveTextElementEventMap<any>['maskIconLabelChanged']) => void;
+    onmessagesCustomChanged?: (value: CInputSensitiveTextElementEventMap<any>['messagesCustomChanged']) => void;
+    onplaceholderChanged?: (value: CInputSensitiveTextElementEventMap<any>['placeholderChanged']) => void;
+    onrawValueChanged?: (value: CInputSensitiveTextElementEventMap<any>['rawValueChanged']) => void;
+    onreadonlyChanged?: (value: CInputSensitiveTextElementEventMap<any>['readonlyChanged']) => void;
+    onrequiredChanged?: (value: CInputSensitiveTextElementEventMap<any>['requiredChanged']) => void;
+    onrequiredMessageDetailChanged?: (value: CInputSensitiveTextElementEventMap<any>['requiredMessageDetailChanged']) => void;
+    ontextAlignChanged?: (value: CInputSensitiveTextElementEventMap<any>['textAlignChanged']) => void;
+    onuserAssistanceDensityChanged?: (value: CInputSensitiveTextElementEventMap<any>['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CInputSensitiveTextElementEventMap<any>['validChanged']) => void;
+    onvalidatorsChanged?: (value: CInputSensitiveTextElementEventMap<any>['validatorsChanged']) => void;
+    onvalueChanged?: (value: CInputSensitiveTextElementEventMap<any>['valueChanged']) => void;
+    onvirtualKeyboardChanged?: (value: CInputSensitiveTextElementEventMap<any>['virtualKeyboardChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-input-sensitive-text': InputSensitiveTextIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/input-sensitive-text/useInputSensitiveTextPreact.d.ts

@@ -0,0 +1,41 @@
+import type { InputSensitiveTextProps } from './input-sensitive-text';
+export declare function useInputSensitiveTextPreact<V extends string = string>({ autofocus, clearIcon, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, length, maskIcon, maskIconLabel, messagesCustom, placeholder, readonly, required, requiredMessageDetail, textAlign, userAssistanceDensity, validators, value: propValue, virtualKeyboard, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, ...otherProps }: InputSensitiveTextProps<V>, addBusyState?: (desc?: string) => () => void): {
+    value: V;
+    setValue: import("preact/hooks").StateUpdater<V>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"invalid" | "valid">;
+        showMessages: () => void;
+    };
+    inputSensitiveTextProps: Omit<{
+        'aria-describedby'?: string | undefined;
+        assistiveText?: string | undefined;
+        autoFocus?: boolean | undefined;
+        columnSpan?: import("@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout").LayoutColumns | undefined;
+        hasClearIcon?: "always" | "never" | "conditionally" | undefined;
+        hasRevealToggle?: "always" | "never" | undefined;
+        helpSourceLink?: string | undefined;
+        helpSourceText?: string | undefined;
+        isDisabled?: boolean | undefined;
+        isReadonly?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        isRequiredShown?: boolean | undefined;
+        label: string;
+        labelEdge?: "none" | "start" | "top" | "inside" | undefined;
+        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
+        maxLength?: number | undefined;
+        maxLengthUnit?: import("@oracle/oraclejet-preact/utils/UNSAFE_lengthFilter").CountUnit | undefined;
+        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        placeholder?: string | undefined;
+        revealToggleLabel?: string | undefined;
+        textAlign?: "end" | "start" | "right" | undefined;
+        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+        value?: string | undefined;
+        variant?: "default" | "embedded" | undefined;
+        virtualKeyboard?: "number" | "search" | "auto" | "url" | "text" | "email" | "tel" | undefined;
+        onCommit?: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
+        onInput: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
+    } & import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps, "ref"> & {
+        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
+    };
+};

package/oj-c/types/line-chart/line-chart.d.ts

@@ -8,7 +8,7 @@ import 'css!oj-c/line-chart/line-chart-styles.css';
 import { Action, ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
 import { ChartItemTemplateContext, ChartSeriesTemplateContext, ChartGroupTemplateContext } from '../hooks/UNSAFE_useChartData/useChartData';
 import { Group } from '@oracle/oraclejet-preact/UNSAFE_Axis/axis.types';
-import { ViewPortDetail, PlotArea, YAxis, XAxis, ValueFormats } from '../utils/UNSAFE_vizTypes/chartTypes';
+import type { ViewPortDetail, PlotArea, YAxis, XAxis, ValueFormats } from '../utils/UNSAFE_vizTypes/chartTypes';
 import type { ChartLegend } from '../utils/UNSAFE_vizTypes';
 import { DataProvider } from 'ojs/ojdataprovider';
 import { LineChartSeriesProps } from 'oj-c/line-chart-series/line-chart-series';
@@ -48,6 +48,7 @@ export type LineChartProps<K, D extends LineItem<K> | any> = ObservedGlobalProps
     seriesTemplate?: TemplateSlot<ChartSeriesTemplateContext<K, D>>;
     groupTemplate?: TemplateSlot<ChartGroupTemplateContext<K, D>>;
     orientation?: PreactLineChartProps['orientation'];
+    timeAxisType?: 'enabled' | 'mixedFrequency' | 'skipGaps';
     yAxis?: YAxis;
     xAxis?: XAxis;
     plotArea?: PlotArea;
@@ -71,7 +72,7 @@ export type LineChartProps<K, D extends LineItem<K> | any> = ObservedGlobalProps
     highlightMatch?: 'any' | 'all';
     legend?: ChartLegend;
 };
-declare function LineChartComp<K extends string | number, D extends LineItem<K> | any>({ data, hideAndShowBehavior, orientation, xAxis, yAxis, hoverBehavior, valueFormats, plotArea, zoomAndScroll, itemTemplate, seriesTemplate, groupTemplate, seriesComparator, groupComparator, drilling, hiddenCategories, highlightedCategories, highlightMatch, selection, selectionMode, stack, legend, ...props }: LineChartProps<K, D>): import("preact").JSX.Element;
+declare function LineChartComp<K extends string | number, D extends LineItem<K> | any>({ data, hideAndShowBehavior, orientation, xAxis, yAxis, hoverBehavior, valueFormats, plotArea, zoomAndScroll, itemTemplate, seriesTemplate, groupTemplate, seriesComparator, groupComparator, drilling, hiddenCategories, timeAxisType, highlightedCategories, highlightMatch, selection, selectionMode, stack, legend, ...props }: LineChartProps<K, D>): import("preact").JSX.Element;
 export declare const LineChart: ComponentType<ExtendGlobalProps<ComponentProps<typeof LineChartComp>>>;
 export {};
 export interface CLineChartElement<K extends string | number, D extends LineItem<K> | any> extends JetElement<CLineChartElementSettableProperties<K, D>>, CLineChartElementSettableProperties<K, D> {
@@ -107,6 +108,7 @@ export namespace CLineChartElement {
     type selectionModeChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['selectionMode']>;
     type seriesComparatorChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['seriesComparator']>;
     type stackChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['stack']>;
+    type timeAxisTypeChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['timeAxisType']>;
     type valueFormatsChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['valueFormats']>;
     type xAxisChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['xAxis']>;
     type yAxisChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['yAxis']>;
@@ -132,6 +134,7 @@ export interface CLineChartElementEventMap<K extends string | number, D extends
     'selectionModeChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['selectionMode']>;
     'seriesComparatorChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['seriesComparator']>;
     'stackChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['stack']>;
+    'timeAxisTypeChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['timeAxisType']>;
     'valueFormatsChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['valueFormats']>;
     'xAxisChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['xAxis']>;
     'yAxisChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['yAxis']>;
@@ -153,6 +156,7 @@ export interface CLineChartElementSettableProperties<K, D extends LineItem<K> |
     selectionMode?: LineChartProps<K, D>['selectionMode'];
     seriesComparator?: LineChartProps<K, D>['seriesComparator'];
     stack?: LineChartProps<K, D>['stack'];
+    timeAxisType?: LineChartProps<K, D>['timeAxisType'];
     valueFormats?: LineChartProps<K, D>['valueFormats'];
     xAxis?: LineChartProps<K, D>['xAxis'];
     yAxis?: LineChartProps<K, D>['yAxis'];
@@ -182,6 +186,7 @@ export interface LineChartIntrinsicProps extends Partial<Readonly<CLineChartElem
     onselectionModeChanged?: (value: CLineChartElementEventMap<any, any>['selectionModeChanged']) => void;
     onseriesComparatorChanged?: (value: CLineChartElementEventMap<any, any>['seriesComparatorChanged']) => void;
     onstackChanged?: (value: CLineChartElementEventMap<any, any>['stackChanged']) => void;
+    ontimeAxisTypeChanged?: (value: CLineChartElementEventMap<any, any>['timeAxisTypeChanged']) => void;
     onvalueFormatsChanged?: (value: CLineChartElementEventMap<any, any>['valueFormatsChanged']) => void;
     onxAxisChanged?: (value: CLineChartElementEventMap<any, any>['xAxisChanged']) => void;
     onyAxisChanged?: (value: CLineChartElementEventMap<any, any>['yAxisChanged']) => void;

package/oj-c/types/line-chart-item/line-chart-item.d.ts

@@ -5,6 +5,7 @@ export type LineChartItemProps = {
     seriesId: string;
     groupId: Array<string>;
     value: number;
+    x?: string;
     color?: string;
     markerDisplayed?: 'on' | 'off' | 'auto';
     markerShape?: 'circle' | 'diamond' | 'human' | 'plus' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | 'auto';
@@ -34,6 +35,7 @@ export namespace CLineChartItemElement {
     type seriesIdChanged = JetElementCustomEventStrict<CLineChartItemElement['seriesId']>;
     type shortDescChanged = JetElementCustomEventStrict<CLineChartItemElement['shortDesc']>;
     type valueChanged = JetElementCustomEventStrict<CLineChartItemElement['value']>;
+    type xChanged = JetElementCustomEventStrict<CLineChartItemElement['x']>;
 }
 export interface CLineChartItemElementEventMap extends HTMLElementEventMap {
     'categoriesChanged': JetElementCustomEventStrict<CLineChartItemElement['categories']>;
@@ -46,6 +48,7 @@ export interface CLineChartItemElementEventMap extends HTMLElementEventMap {
     'seriesIdChanged': JetElementCustomEventStrict<CLineChartItemElement['seriesId']>;
     'shortDescChanged': JetElementCustomEventStrict<CLineChartItemElement['shortDesc']>;
     'valueChanged': JetElementCustomEventStrict<CLineChartItemElement['value']>;
+    'xChanged': JetElementCustomEventStrict<CLineChartItemElement['x']>;
 }
 export interface CLineChartItemElementSettableProperties extends JetSettableProperties {
     categories?: LineChartItemProps['categories'];
@@ -58,6 +61,7 @@ export interface CLineChartItemElementSettableProperties extends JetSettableProp
     seriesId: LineChartItemProps['seriesId'];
     shortDesc?: LineChartItemProps['shortDesc'];
     value: LineChartItemProps['value'];
+    x?: LineChartItemProps['x'];
 }
 export interface CLineChartItemElementSettablePropertiesLenient extends Partial<CLineChartItemElementSettableProperties> {
     [key: string]: any;
@@ -73,6 +77,7 @@ export interface LineChartItemIntrinsicProps extends Partial<Readonly<CLineChart
     onseriesIdChanged?: (value: CLineChartItemElementEventMap['seriesIdChanged']) => void;
     onshortDescChanged?: (value: CLineChartItemElementEventMap['shortDescChanged']) => void;
     onvalueChanged?: (value: CLineChartItemElementEventMap['valueChanged']) => void;
+    onxChanged?: (value: CLineChartItemElementEventMap['xChanged']) => void;
 }
 declare global {
     namespace preact.JSX {