@oracle/oraclejet-core-pack 14.0.0

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

@@ -0,0 +1,54 @@
+import { ComponentProps } from 'preact';
+import { ValueUpdateDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail';
+import type { InputNumber } from 'oj-c/input-number';
+declare type InputNumberProps = ComponentProps<typeof InputNumber>;
+import { StepEvent } from '@oracle/oraclejet-preact/UNSAFE_NumberInputText/useSteppers';
+export declare function useNumberInputTextPreact({ autocomplete, autofocus, converter: propConverter, disabled, displayOptions, inputPrefix, inputSuffix, labelEdge, labelHint, labelStartWidth, max, messagesCustom, min, numberRangeExactMessageDetail, numberRangeOverflowMessageDetail, numberRangeUnderflowMessageDetail, placeholder, readonly, required, requiredMessageDetail, step, textAlign, userAssistanceDensity, validators, value: propValue, virtualKeyboard, onMessagesCustomChanged, onRawValueChanged, onTransientValueChanged, onValidChanged, onValueChanged, ...otherProps }: InputNumberProps, addBusyState?: (desc?: string) => () => void): {
+    value: number | null;
+    setValue: import("preact/hooks").StateUpdater<number | null>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"valid" | "invalid">;
+        showMessages: () => void;
+    };
+    inputNumberProps: Omit<{
+        hasSteppers?: boolean | undefined;
+        isStepDownDisabled?: boolean | undefined;
+        isStepUpDisabled?: boolean | undefined;
+        onSpin?: ((event: StepEvent) => void) | undefined;
+        onSpinComplete?: (() => void) | undefined;
+        onStep?: ((event: StepEvent) => void) | undefined;
+    } & {
+        ariaDescribedBy?: string | undefined;
+        ariaValueMax?: number | undefined;
+        ariaValueMin?: number | undefined;
+        ariaValueNow?: number | undefined;
+        ariaValueText?: string | undefined;
+        assistiveText?: string | undefined;
+        autoComplete?: string | undefined;
+        autoFocus?: boolean | undefined;
+        helpSourceLink?: string | undefined;
+        helpSourceText?: string | undefined;
+        isDisabled?: boolean | undefined;
+        isReadonly?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        isRequiredShown?: boolean | undefined;
+        label: string;
+        labelEdge?: "start" | "none" | "top" | "inside" | undefined;
+        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
+        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        placeholder?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        textAlign?: "start" | "right" | "end" | undefined;
+        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+        value?: string | undefined;
+        variant?: "default" | "embedded" | undefined;
+        virtualKeyboard?: "number" | "text" | "auto" | undefined;
+        onCommit?: ((detail: ValueUpdateDetail<string>) => void) | undefined;
+        onInput: ((detail: ValueUpdateDetail<string>) => void) | undefined;
+    }, "ref"> & {
+        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
+    };
+};
+export {};

package/oj-c/types/input-password/index.d.ts

@@ -0,0 +1,2 @@
+export { InputPassword } from './input-password';
+export { CInputPasswordElement } from './input-password';

package/oj-c/types/input-password/input-password.d.ts

@@ -0,0 +1,183 @@
+/// <reference types="ojvalidator-async" />
+/// <reference types="ojvalidator" />
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { InputPassword as PreactInputPassword } from '@oracle/oraclejet-preact/UNSAFE_InputPassword';
+import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
+import Validator from 'ojs/ojvalidator';
+import AsyncValidator from 'ojs/ojvalidator-async';
+import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
+import { Component, ComponentProps } from 'preact';
+import 'css!oj-c/input-password/input-password-styles.css';
+declare type PreactInputPasswordProps = ComponentProps<typeof PreactInputPassword>;
+declare type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+declare type Props = ObservedGlobalProps<'aria-describedby' | 'autofocus' | 'id'> & {
+    autocomplete?: 'on' | 'off' | string;
+    clearIcon?: 'always' | 'never' | 'conditional';
+    containerReadonly?: boolean;
+    disabled?: boolean;
+    displayOptions?: DisplayOptions;
+    help?: Help;
+    helpHints?: HelpHints;
+    labelEdge?: PreactInputPasswordProps['labelEdge'];
+    labelHint: string;
+    labelStartWidth?: string;
+    labelWrapping?: 'truncate' | 'wrap';
+    maskIcon?: 'visible' | 'hidden';
+    messagesCustom?: PreactInputPasswordProps['messages'];
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    textAlign?: PreactInputPasswordProps['textAlign'];
+    userAssistanceDensity?: PreactInputPasswordProps['userAssistanceDensity'];
+    validators?: (AsyncValidator<string> | Validator<string>)[] | null;
+    value?: string | null;
+    onMessagesCustomChanged?: PropertyChanged<PreactInputPasswordProps['messages']>;
+    onRawValueChanged?: ReadOnlyPropertyChanged<string>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<string>;
+};
+export declare class InputPassword extends Component<ExtendGlobalProps<Props>> {
+    static defaultProps: Partial<Props>;
+    private busyContextRef;
+    private inputPasswordRef;
+    private rootRef;
+    componentDidMount(): void;
+    render(props: ExtendGlobalProps<Props>): import("preact").JSX.Element;
+    componentWillUnmount(): void;
+    reset(): void;
+    showMessages(): void;
+    validate(): Promise<'valid' | 'invalid'>;
+    blur(): void;
+    focus(): void;
+}
+export declare type InputPasswordProps = Props;
+export {};
+export interface CInputPasswordElement extends JetElement<CInputPasswordElementSettableProperties>, CInputPasswordElementSettableProperties {
+    readonly rawValue?: Parameters<Required<Props>['onRawValueChanged']>[0];
+    readonly valid?: Parameters<Required<Props>['onValidChanged']>[0];
+    addEventListener<T extends keyof CInputPasswordElementEventMap>(type: T, listener: (this: HTMLElement, ev: CInputPasswordElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CInputPasswordElementSettableProperties>(property: T): CInputPasswordElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CInputPasswordElementSettableProperties>(property: T, value: CInputPasswordElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CInputPasswordElementSettableProperties>): void;
+    setProperties(properties: CInputPasswordElementSettablePropertiesLenient): void;
+    blur: InputPassword['blur'];
+    focus: InputPassword['focus'];
+    reset: InputPassword['reset'];
+    showMessages: InputPassword['showMessages'];
+    validate: InputPassword['validate'];
+}
+export namespace CInputPasswordElement {
+    type autocompleteChanged = JetElementCustomEventStrict<CInputPasswordElement['autocomplete']>;
+    type clearIconChanged = JetElementCustomEventStrict<CInputPasswordElement['clearIcon']>;
+    type containerReadonlyChanged = JetElementCustomEventStrict<CInputPasswordElement['containerReadonly']>;
+    type disabledChanged = JetElementCustomEventStrict<CInputPasswordElement['disabled']>;
+    type displayOptionsChanged = JetElementCustomEventStrict<CInputPasswordElement['displayOptions']>;
+    type helpChanged = JetElementCustomEventStrict<CInputPasswordElement['help']>;
+    type helpHintsChanged = JetElementCustomEventStrict<CInputPasswordElement['helpHints']>;
+    type labelEdgeChanged = JetElementCustomEventStrict<CInputPasswordElement['labelEdge']>;
+    type labelHintChanged = JetElementCustomEventStrict<CInputPasswordElement['labelHint']>;
+    type labelStartWidthChanged = JetElementCustomEventStrict<CInputPasswordElement['labelStartWidth']>;
+    type labelWrappingChanged = JetElementCustomEventStrict<CInputPasswordElement['labelWrapping']>;
+    type maskIconChanged = JetElementCustomEventStrict<CInputPasswordElement['maskIcon']>;
+    type messagesCustomChanged = JetElementCustomEventStrict<CInputPasswordElement['messagesCustom']>;
+    type placeholderChanged = JetElementCustomEventStrict<CInputPasswordElement['placeholder']>;
+    type rawValueChanged = JetElementCustomEventStrict<CInputPasswordElement['rawValue']>;
+    type readonlyChanged = JetElementCustomEventStrict<CInputPasswordElement['readonly']>;
+    type requiredChanged = JetElementCustomEventStrict<CInputPasswordElement['required']>;
+    type requiredMessageDetailChanged = JetElementCustomEventStrict<CInputPasswordElement['requiredMessageDetail']>;
+    type textAlignChanged = JetElementCustomEventStrict<CInputPasswordElement['textAlign']>;
+    type userAssistanceDensityChanged = JetElementCustomEventStrict<CInputPasswordElement['userAssistanceDensity']>;
+    type validChanged = JetElementCustomEventStrict<CInputPasswordElement['valid']>;
+    type validatorsChanged = JetElementCustomEventStrict<CInputPasswordElement['validators']>;
+    type valueChanged = JetElementCustomEventStrict<CInputPasswordElement['value']>;
+}
+export interface CInputPasswordElementEventMap extends HTMLElementEventMap {
+    'autocompleteChanged': JetElementCustomEventStrict<CInputPasswordElement['autocomplete']>;
+    'clearIconChanged': JetElementCustomEventStrict<CInputPasswordElement['clearIcon']>;
+    'containerReadonlyChanged': JetElementCustomEventStrict<CInputPasswordElement['containerReadonly']>;
+    'disabledChanged': JetElementCustomEventStrict<CInputPasswordElement['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CInputPasswordElement['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CInputPasswordElement['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CInputPasswordElement['helpHints']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CInputPasswordElement['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CInputPasswordElement['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CInputPasswordElement['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CInputPasswordElement['labelWrapping']>;
+    'maskIconChanged': JetElementCustomEventStrict<CInputPasswordElement['maskIcon']>;
+    'messagesCustomChanged': JetElementCustomEventStrict<CInputPasswordElement['messagesCustom']>;
+    'placeholderChanged': JetElementCustomEventStrict<CInputPasswordElement['placeholder']>;
+    'rawValueChanged': JetElementCustomEventStrict<CInputPasswordElement['rawValue']>;
+    'readonlyChanged': JetElementCustomEventStrict<CInputPasswordElement['readonly']>;
+    'requiredChanged': JetElementCustomEventStrict<CInputPasswordElement['required']>;
+    'requiredMessageDetailChanged': JetElementCustomEventStrict<CInputPasswordElement['requiredMessageDetail']>;
+    'textAlignChanged': JetElementCustomEventStrict<CInputPasswordElement['textAlign']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CInputPasswordElement['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CInputPasswordElement['valid']>;
+    'validatorsChanged': JetElementCustomEventStrict<CInputPasswordElement['validators']>;
+    'valueChanged': JetElementCustomEventStrict<CInputPasswordElement['value']>;
+}
+export interface CInputPasswordElementSettableProperties extends JetSettableProperties {
+    autocomplete?: Props['autocomplete'];
+    clearIcon?: Props['clearIcon'];
+    containerReadonly?: Props['containerReadonly'];
+    disabled?: Props['disabled'];
+    displayOptions?: Props['displayOptions'];
+    help?: Props['help'];
+    helpHints?: Props['helpHints'];
+    labelEdge?: Props['labelEdge'];
+    labelHint: Props['labelHint'];
+    labelStartWidth?: Props['labelStartWidth'];
+    labelWrapping?: Props['labelWrapping'];
+    maskIcon?: Props['maskIcon'];
+    messagesCustom?: Props['messagesCustom'];
+    placeholder?: Props['placeholder'];
+    readonly?: Props['readonly'];
+    required?: Props['required'];
+    requiredMessageDetail?: Props['requiredMessageDetail'];
+    textAlign?: Props['textAlign'];
+    userAssistanceDensity?: Props['userAssistanceDensity'];
+    validators?: Props['validators'];
+    value?: Props['value'];
+}
+export interface CInputPasswordElementSettablePropertiesLenient extends Partial<CInputPasswordElementSettableProperties> {
+    [key: string]: any;
+}
+export interface InputPasswordIntrinsicProps extends Partial<Readonly<CInputPasswordElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    rawValue?: never;
+    valid?: never;
+    onautocompleteChanged?: (value: CInputPasswordElementEventMap['autocompleteChanged']) => void;
+    onclearIconChanged?: (value: CInputPasswordElementEventMap['clearIconChanged']) => void;
+    oncontainerReadonlyChanged?: (value: CInputPasswordElementEventMap['containerReadonlyChanged']) => void;
+    ondisabledChanged?: (value: CInputPasswordElementEventMap['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CInputPasswordElementEventMap['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CInputPasswordElementEventMap['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CInputPasswordElementEventMap['helpHintsChanged']) => void;
+    onlabelEdgeChanged?: (value: CInputPasswordElementEventMap['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CInputPasswordElementEventMap['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CInputPasswordElementEventMap['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CInputPasswordElementEventMap['labelWrappingChanged']) => void;
+    onmaskIconChanged?: (value: CInputPasswordElementEventMap['maskIconChanged']) => void;
+    onmessagesCustomChanged?: (value: CInputPasswordElementEventMap['messagesCustomChanged']) => void;
+    onplaceholderChanged?: (value: CInputPasswordElementEventMap['placeholderChanged']) => void;
+    onrawValueChanged?: (value: CInputPasswordElementEventMap['rawValueChanged']) => void;
+    onreadonlyChanged?: (value: CInputPasswordElementEventMap['readonlyChanged']) => void;
+    onrequiredChanged?: (value: CInputPasswordElementEventMap['requiredChanged']) => void;
+    onrequiredMessageDetailChanged?: (value: CInputPasswordElementEventMap['requiredMessageDetailChanged']) => void;
+    ontextAlignChanged?: (value: CInputPasswordElementEventMap['textAlignChanged']) => void;
+    onuserAssistanceDensityChanged?: (value: CInputPasswordElementEventMap['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CInputPasswordElementEventMap['validChanged']) => void;
+    onvalidatorsChanged?: (value: CInputPasswordElementEventMap['validatorsChanged']) => void;
+    onvalueChanged?: (value: CInputPasswordElementEventMap['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-input-password': InputPasswordIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/input-password/useInputPasswordPreact.d.ts

@@ -0,0 +1,40 @@
+import { ComponentProps } from 'preact';
+import type { InputPassword } from 'oj-c/input-password';
+declare type InputPasswordProps = ComponentProps<typeof InputPassword>;
+export declare function useInputPasswordPreact({ autocomplete, autofocus, clearIcon, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, maskIcon, messagesCustom, placeholder, readonly, required, requiredMessageDetail, textAlign, userAssistanceDensity, validators, value: propValue, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, ...otherProps }: InputPasswordProps, addBusyState?: (desc?: string) => () => void): {
+    value: string | null;
+    setValue: import("preact/hooks").StateUpdater<string | null>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"valid" | "invalid">;
+        showMessages: () => void;
+    };
+    inputPasswordProps: Omit<{
+        ariaDescribedBy?: string | undefined;
+        assistiveText?: string | undefined;
+        autoComplete?: string | undefined;
+        autoFocus?: boolean | 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?: "start" | "none" | "top" | "inside" | undefined;
+        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
+        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        placeholder?: string | undefined;
+        textAlign?: "start" | "right" | "end" | undefined;
+        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+        value?: string | undefined;
+        variant?: "default" | "embedded" | 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;
+    }, "ref"> & {
+        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
+    };
+};
+export {};

package/oj-c/types/input-text/__tests__/input-text.test.d.ts

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

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

@@ -0,0 +1,2 @@
+export { InputText } from './input-text';
+export { CInputTextElement } from './input-text';

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

@@ -0,0 +1,212 @@
+/// <reference types="ojconverter" />
+/// <reference types="ojvalidator-async" />
+/// <reference types="ojvalidator" />
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { InputText as PreactInputText } from '@oracle/oraclejet-preact/UNSAFE_InputText';
+import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
+import Converter from 'ojs/ojconverter';
+import Validator from 'ojs/ojvalidator';
+import AsyncValidator from 'ojs/ojvalidator-async';
+import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged, Slot } from 'ojs/ojvcomponent';
+import { Component, ComponentProps } from 'preact';
+import 'css!oj-c/input-text/input-text-styles.css';
+declare type PreactInputTextProps = ComponentProps<typeof PreactInputText>;
+declare type Length = {
+    countBy?: 'codePoint' | 'codeUnit';
+    max?: number | null;
+};
+declare type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+declare type Props<V> = ObservedGlobalProps<'aria-describedby' | 'autofocus' | 'id'> & {
+    autocomplete?: 'on' | 'off' | string;
+    clearIcon?: 'always' | 'never' | 'conditional';
+    containerReadonly?: boolean;
+    converter?: Converter<V> | null;
+    disabled?: boolean;
+    displayOptions?: DisplayOptions;
+    end?: Slot;
+    help?: Help;
+    helpHints?: HelpHints;
+    inputPrefix?: PreactInputTextProps['prefix'];
+    inputSuffix?: PreactInputTextProps['suffix'];
+    labelEdge?: PreactInputTextProps['labelEdge'];
+    labelHint: string;
+    labelStartWidth?: string;
+    labelWrapping?: 'truncate' | 'wrap';
+    length?: Length;
+    messagesCustom?: PreactInputTextProps['messages'];
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    start?: Slot;
+    textAlign?: PreactInputTextProps['textAlign'];
+    userAssistanceDensity?: PreactInputTextProps['userAssistanceDensity'];
+    validators?: (AsyncValidator<V> | Validator<V>)[] | null;
+    value?: V | null;
+    virtualKeyboard?: PreactInputTextProps['virtualKeyboard'];
+    onMessagesCustomChanged?: PropertyChanged<PreactInputTextProps['messages']>;
+    onRawValueChanged?: ReadOnlyPropertyChanged<string>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<V>;
+};
+export declare class InputText<V> extends Component<ExtendGlobalProps<Props<V>>> {
+    static defaultProps: Partial<Props<any>>;
+    private busyContextRef;
+    private inputTextRef;
+    private rootRef;
+    componentDidMount(): void;
+    render(props: ExtendGlobalProps<Props<V>>): import("preact").JSX.Element;
+    componentWillUnmount(): void;
+    reset(): void;
+    showMessages(): void;
+    validate(): Promise<'valid' | 'invalid'>;
+    blur(): void;
+    focus(): void;
+}
+export declare type InputTextProps<V> = Props<V>;
+export {};
+export interface CInputTextElement<V> extends JetElement<CInputTextElementSettableProperties<V>>, CInputTextElementSettableProperties<V> {
+    readonly rawValue?: Parameters<Required<Props<V>>['onRawValueChanged']>[0];
+    readonly valid?: Parameters<Required<Props<V>>['onValidChanged']>[0];
+    addEventListener<T extends keyof CInputTextElementEventMap<V>>(type: T, listener: (this: HTMLElement, ev: CInputTextElementEventMap<V>[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CInputTextElementSettableProperties<V>>(property: T): CInputTextElement<V>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CInputTextElementSettableProperties<V>>(property: T, value: CInputTextElementSettableProperties<V>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CInputTextElementSettableProperties<V>>): void;
+    setProperties(properties: CInputTextElementSettablePropertiesLenient<V>): void;
+    blur: InputText<V>['blur'];
+    focus: InputText<V>['focus'];
+    reset: InputText<V>['reset'];
+    showMessages: InputText<V>['showMessages'];
+    validate: InputText<V>['validate'];
+}
+export namespace CInputTextElement {
+    type autocompleteChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['autocomplete']>;
+    type clearIconChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['clearIcon']>;
+    type containerReadonlyChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['containerReadonly']>;
+    type converterChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['converter']>;
+    type disabledChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['disabled']>;
+    type displayOptionsChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['displayOptions']>;
+    type helpChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['help']>;
+    type helpHintsChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['helpHints']>;
+    type inputPrefixChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['inputPrefix']>;
+    type inputSuffixChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['inputSuffix']>;
+    type labelEdgeChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['labelEdge']>;
+    type labelHintChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['labelHint']>;
+    type labelStartWidthChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['labelStartWidth']>;
+    type labelWrappingChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['labelWrapping']>;
+    type lengthChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['length']>;
+    type messagesCustomChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['messagesCustom']>;
+    type placeholderChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['placeholder']>;
+    type rawValueChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['rawValue']>;
+    type readonlyChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['readonly']>;
+    type requiredChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['required']>;
+    type requiredMessageDetailChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['requiredMessageDetail']>;
+    type textAlignChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['textAlign']>;
+    type userAssistanceDensityChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['userAssistanceDensity']>;
+    type validChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['valid']>;
+    type validatorsChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['validators']>;
+    type valueChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['value']>;
+    type virtualKeyboardChanged<V> = JetElementCustomEventStrict<CInputTextElement<V>['virtualKeyboard']>;
+}
+export interface CInputTextElementEventMap<V> extends HTMLElementEventMap {
+    'autocompleteChanged': JetElementCustomEventStrict<CInputTextElement<V>['autocomplete']>;
+    'clearIconChanged': JetElementCustomEventStrict<CInputTextElement<V>['clearIcon']>;
+    'containerReadonlyChanged': JetElementCustomEventStrict<CInputTextElement<V>['containerReadonly']>;
+    'converterChanged': JetElementCustomEventStrict<CInputTextElement<V>['converter']>;
+    'disabledChanged': JetElementCustomEventStrict<CInputTextElement<V>['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CInputTextElement<V>['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CInputTextElement<V>['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CInputTextElement<V>['helpHints']>;
+    'inputPrefixChanged': JetElementCustomEventStrict<CInputTextElement<V>['inputPrefix']>;
+    'inputSuffixChanged': JetElementCustomEventStrict<CInputTextElement<V>['inputSuffix']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CInputTextElement<V>['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CInputTextElement<V>['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CInputTextElement<V>['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CInputTextElement<V>['labelWrapping']>;
+    'lengthChanged': JetElementCustomEventStrict<CInputTextElement<V>['length']>;
+    'messagesCustomChanged': JetElementCustomEventStrict<CInputTextElement<V>['messagesCustom']>;
+    'placeholderChanged': JetElementCustomEventStrict<CInputTextElement<V>['placeholder']>;
+    'rawValueChanged': JetElementCustomEventStrict<CInputTextElement<V>['rawValue']>;
+    'readonlyChanged': JetElementCustomEventStrict<CInputTextElement<V>['readonly']>;
+    'requiredChanged': JetElementCustomEventStrict<CInputTextElement<V>['required']>;
+    'requiredMessageDetailChanged': JetElementCustomEventStrict<CInputTextElement<V>['requiredMessageDetail']>;
+    'textAlignChanged': JetElementCustomEventStrict<CInputTextElement<V>['textAlign']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CInputTextElement<V>['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CInputTextElement<V>['valid']>;
+    'validatorsChanged': JetElementCustomEventStrict<CInputTextElement<V>['validators']>;
+    'valueChanged': JetElementCustomEventStrict<CInputTextElement<V>['value']>;
+    'virtualKeyboardChanged': JetElementCustomEventStrict<CInputTextElement<V>['virtualKeyboard']>;
+}
+export interface CInputTextElementSettableProperties<V> extends JetSettableProperties {
+    autocomplete?: Props<V>['autocomplete'];
+    clearIcon?: Props<V>['clearIcon'];
+    containerReadonly?: Props<V>['containerReadonly'];
+    converter?: Props<V>['converter'];
+    disabled?: Props<V>['disabled'];
+    displayOptions?: Props<V>['displayOptions'];
+    help?: Props<V>['help'];
+    helpHints?: Props<V>['helpHints'];
+    inputPrefix?: Props<V>['inputPrefix'];
+    inputSuffix?: Props<V>['inputSuffix'];
+    labelEdge?: Props<V>['labelEdge'];
+    labelHint: Props<V>['labelHint'];
+    labelStartWidth?: Props<V>['labelStartWidth'];
+    labelWrapping?: Props<V>['labelWrapping'];
+    length?: Props<V>['length'];
+    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 CInputTextElementSettablePropertiesLenient<V> extends Partial<CInputTextElementSettableProperties<V>> {
+    [key: string]: any;
+}
+export interface InputTextIntrinsicProps extends Partial<Readonly<CInputTextElementSettableProperties<any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    rawValue?: never;
+    valid?: never;
+    children?: import('preact').ComponentChildren;
+    onautocompleteChanged?: (value: CInputTextElementEventMap<any>['autocompleteChanged']) => void;
+    onclearIconChanged?: (value: CInputTextElementEventMap<any>['clearIconChanged']) => void;
+    oncontainerReadonlyChanged?: (value: CInputTextElementEventMap<any>['containerReadonlyChanged']) => void;
+    onconverterChanged?: (value: CInputTextElementEventMap<any>['converterChanged']) => void;
+    ondisabledChanged?: (value: CInputTextElementEventMap<any>['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CInputTextElementEventMap<any>['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CInputTextElementEventMap<any>['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CInputTextElementEventMap<any>['helpHintsChanged']) => void;
+    oninputPrefixChanged?: (value: CInputTextElementEventMap<any>['inputPrefixChanged']) => void;
+    oninputSuffixChanged?: (value: CInputTextElementEventMap<any>['inputSuffixChanged']) => void;
+    onlabelEdgeChanged?: (value: CInputTextElementEventMap<any>['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CInputTextElementEventMap<any>['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CInputTextElementEventMap<any>['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CInputTextElementEventMap<any>['labelWrappingChanged']) => void;
+    onlengthChanged?: (value: CInputTextElementEventMap<any>['lengthChanged']) => void;
+    onmessagesCustomChanged?: (value: CInputTextElementEventMap<any>['messagesCustomChanged']) => void;
+    onplaceholderChanged?: (value: CInputTextElementEventMap<any>['placeholderChanged']) => void;
+    onrawValueChanged?: (value: CInputTextElementEventMap<any>['rawValueChanged']) => void;
+    onreadonlyChanged?: (value: CInputTextElementEventMap<any>['readonlyChanged']) => void;
+    onrequiredChanged?: (value: CInputTextElementEventMap<any>['requiredChanged']) => void;
+    onrequiredMessageDetailChanged?: (value: CInputTextElementEventMap<any>['requiredMessageDetailChanged']) => void;
+    ontextAlignChanged?: (value: CInputTextElementEventMap<any>['textAlignChanged']) => void;
+    onuserAssistanceDensityChanged?: (value: CInputTextElementEventMap<any>['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CInputTextElementEventMap<any>['validChanged']) => void;
+    onvalidatorsChanged?: (value: CInputTextElementEventMap<any>['validatorsChanged']) => void;
+    onvalueChanged?: (value: CInputTextElementEventMap<any>['valueChanged']) => void;
+    onvirtualKeyboardChanged?: (value: CInputTextElementEventMap<any>['virtualKeyboardChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-input-text': InputTextIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+import { ComponentProps } from 'preact';
+import type { InputText } from 'oj-c/input-text';
+declare type InputTextProps = ComponentProps<typeof InputText>;
+export declare function useInputTextPreact<V>({ autocomplete, autofocus, clearIcon, converter, disabled, displayOptions, end, inputPrefix, inputSuffix, labelEdge, labelHint, labelStartWidth, length, messagesCustom, placeholder, readonly, required, requiredMessageDetail, start, textAlign, userAssistanceDensity, validators, value: propValue, virtualKeyboard, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, ...otherProps }: InputTextProps, addBusyState?: (desc?: string) => () => void): {
+    value: V;
+    setValue: import("preact/hooks").StateUpdater<V>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"valid" | "invalid">;
+        showMessages: () => void;
+    };
+    inputTextProps: Omit<{
+        ariaDescribedBy?: string | undefined;
+        assistiveText?: string | undefined;
+        autoComplete?: string | undefined;
+        autoFocus?: boolean | undefined;
+        endContent?: import("preact").ComponentChildren;
+        hasClearIcon?: "always" | "never" | "conditionally" | undefined;
+        helpSourceLink?: string | undefined;
+        helpSourceText?: string | undefined;
+        isDisabled?: boolean | undefined;
+        isReadonly?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        isRequiredShown?: boolean | undefined;
+        label: string;
+        labelEdge?: "start" | "none" | "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;
+        prefix?: string | undefined;
+        role?: string | undefined;
+        startContent?: import("preact").ComponentChildren;
+        suffix?: string | undefined;
+        textAlign?: "start" | "right" | "end" | undefined;
+        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+        value?: string | undefined;
+        variant?: "default" | "embedded" | undefined;
+        virtualKeyboard?: "number" | "text" | "auto" | "search" | "email" | "tel" | "url" | 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;
+    }, "ref"> & {
+        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
+    };
+};
+export {};

package/oj-c/types/list-item-layout/index.d.ts

@@ -0,0 +1,2 @@
+export { ListItemLayout } from './list-item-layout';
+export { CListItemLayoutElement } from './list-item-layout';

package/oj-c/types/list-item-layout/list-item-layout.d.ts

@@ -0,0 +1,53 @@
+import { ComponentProps } from 'preact';
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ComponentChildren } from 'preact';
+import { ObservedGlobalProps, Slot } from 'ojs/ojvcomponent';
+import 'css!oj-c/list-item-layout/list-item-layout-styles.css';
+export declare const ListItemLayout: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label"> & {
+    children?: ComponentChildren;
+    overline?: Slot;
+    selector?: Slot;
+    leading?: Slot;
+    secondary?: Slot;
+    tertiary?: Slot;
+    metadata?: Slot;
+    trailing?: Slot;
+    action?: Slot;
+    quaternary?: Slot;
+    navigation?: Slot;
+    inset?: "none" | "listInset" | undefined;
+}>>;
+export interface CListItemLayoutElement extends JetElement<CListItemLayoutElementSettableProperties>, CListItemLayoutElementSettableProperties {
+    addEventListener<T extends keyof CListItemLayoutElementEventMap>(type: T, listener: (this: HTMLElement, ev: CListItemLayoutElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CListItemLayoutElementSettableProperties>(property: T): CListItemLayoutElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CListItemLayoutElementSettableProperties>(property: T, value: CListItemLayoutElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CListItemLayoutElementSettableProperties>): void;
+    setProperties(properties: CListItemLayoutElementSettablePropertiesLenient): void;
+}
+export namespace CListItemLayoutElement {
+    type insetChanged = JetElementCustomEventStrict<CListItemLayoutElement['inset']>;
+}
+export interface CListItemLayoutElementEventMap extends HTMLElementEventMap {
+    'insetChanged': JetElementCustomEventStrict<CListItemLayoutElement['inset']>;
+}
+export interface CListItemLayoutElementSettableProperties extends JetSettableProperties {
+    inset?: ComponentProps<typeof ListItemLayout>['inset'];
+}
+export interface CListItemLayoutElementSettablePropertiesLenient extends Partial<CListItemLayoutElementSettableProperties> {
+    [key: string]: any;
+}
+export interface ListItemLayoutIntrinsicProps extends Partial<Readonly<CListItemLayoutElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    oninsetChanged?: (value: CListItemLayoutElementEventMap['insetChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-list-item-layout': ListItemLayoutIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/message-toast/index.d.ts

@@ -0,0 +1,2 @@
+export { MessageToast, MessageToastItem, MessageToastTemplateContext } from './message-toast';
+export { CMessageToastElement } from './message-toast';