@oracle/oraclejet-core-pack 14.0.0

package/oj-c/types/editable-value/UNSAFE_useEditableValue/useEditableValue.d.ts

@@ -0,0 +1,47 @@
+import { ValueUpdateDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail';
+import { UseComponentMessagingProps } from '../UNSAFE_useComponentMessaging/useComponentMessaging';
+import { ConverterErrorSymbol, UseConverterProps } from '../UNSAFE_useConverter/useConverter';
+import { UseValidatorsProps, ValidationResult } from '../UNSAFE_useValidators/useValidators';
+import { UseValueProps, ValueState } from '../UNSAFE_useValue/useValue';
+import { ValidatorLike } from '../UNSAFE_useValidators/useValidators';
+declare type PickedComponentMessagingProps = Pick<UseComponentMessagingProps, 'messagesCustom' | 'onMessagesCustomChanged'>;
+declare type PickedConverterProps<V> = Pick<UseConverterProps<V>, 'converter'>;
+declare type PickedValidatorsProps<V> = Pick<UseValidatorsProps<V>, 'validators' | 'addBusyState' | 'onValidChanged'>;
+declare type PickedValueProps<V> = Pick<UseValueProps<V>, 'onRawValueChanged' | 'onTransientValueChanged' | 'onValueChanged' | 'value'>;
+declare type AriaProps = {
+    ariaDescribedBy?: string;
+};
+export declare type UseEditableValueProps<V> = PickedComponentMessagingProps & PickedConverterProps<V> & PickedValidatorsProps<V> & PickedValueProps<V> & AriaProps & {
+    displayOptions?: {
+        messages?: 'display' | 'none';
+    };
+    implicitComponentValidator?: ValidatorLike<V>;
+    labelHint?: string;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    shouldNormalizeValueOnCommit?: boolean;
+    wrapValueState?: (valueState: ValueState<V>) => ValueState<V>;
+};
+export declare function useEditableValue<V>({ ariaDescribedBy, converter, displayOptions, implicitComponentValidator, labelHint, messagesCustom, required, requiredMessageDetail, shouldNormalizeValueOnCommit, validators, value: valueProp, addBusyState, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, onTransientValueChanged, wrapValueState }: UseEditableValueProps<V>): {
+    value: V;
+    setValue: import("preact/hooks").StateUpdater<V>;
+    displayValue: string;
+    setDisplayValue: import("preact/hooks").StateUpdater<string>;
+    setTransientValue: import("preact/hooks").StateUpdater<V>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<'valid' | 'invalid'>;
+        showMessages: () => void;
+    };
+    textFieldProps: {
+        messages: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        value: string;
+        ariaDescribedBy: string | undefined;
+        onCommit: ({ value }: ValueUpdateDetail<string>) => Promise<void>;
+        onInput: ({ value }: ValueUpdateDetail<string>) => void;
+    };
+    onCommitValue: (value: V, doCommitOnValid?: boolean) => Promise<ValidationResult>;
+    format: (value: V, shouldSuppressError?: boolean) => string | null | undefined;
+    normalizeAndParseValue: (value: string) => typeof ConverterErrorSymbol | V | null;
+};
+export {};

package/oj-c/types/editable-value/UNSAFE_useStaleIdentity/useStaleIdentity.d.ts

@@ -0,0 +1,5 @@
+export declare function useStaleIdentity(): {
+    setStaleIdentity: (id: `use${string}`) => {
+        isStale: () => boolean;
+    };
+};

package/oj-c/types/editable-value/UNSAFE_useValidationLifecycle/useValidationLifecycle.d.ts

@@ -0,0 +1,15 @@
+import { ComponentMessagingState } from '../UNSAFE_useComponentMessaging/useComponentMessaging';
+import { ConverterErrorSymbol } from '../UNSAFE_useConverter/useConverter';
+import { UseValidatorsProps, ValidationState, ValidState } from '../UNSAFE_useValidators/useValidators';
+declare type PickedUseValidatorsProps<V> = Pick<UseValidatorsProps<V>, 'deferredValidators' | 'validators'>;
+declare type UseValidationLifecycleProps<V> = PickedUseValidatorsProps<V> & {
+    componentMessagingState: ComponentMessagingState;
+    validationState: ValidationState<V>;
+    addBusyState?: (desc?: string) => () => void;
+    getValueForValidation: (valid: ValidState) => V | typeof ConverterErrorSymbol;
+    setValueAfterValidation: (value: V) => void;
+};
+export declare function useValidationLifecycle<V>({ componentMessagingState, deferredValidators, validationState, validators, getValueForValidation, setValueAfterValidation }: UseValidationLifecycleProps<V>): {
+    runFullValidationAndUpdateValue: () => Promise<void>;
+};
+export {};

package/oj-c/types/editable-value/UNSAFE_useValidators/useValidators.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="ojvalidator" />
+/// <reference types="ojvalidator-async" />
+import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import Validator from 'ojs/ojvalidator';
+import AsyncValidator from 'ojs/ojvalidator-async';
+import { StateUpdater } from 'preact/hooks';
+import { ComponentMessagingState } from '../UNSAFE_useComponentMessaging/useComponentMessaging';
+export declare const ValidationResult: {
+    readonly VALID: "VALID";
+    readonly INVALID: "INVALID";
+    readonly STALE: "STALE";
+};
+export declare type ValidationResult = typeof ValidationResult[keyof typeof ValidationResult];
+export declare type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+export declare type ValidatorLike<V> = Validator<V> | AsyncValidator<V>;
+export declare type ValidationOptions = {
+    doNotClearMessagesCustom?: boolean;
+};
+export declare type ValidationState<V> = {
+    valid: ValidState;
+    setValid: StateUpdater<ValidState>;
+    deferredValidate: (value: V) => void | ComponentMessageItem[];
+    fullValidate: (value: V, options?: ValidationOptions) => Promise<boolean>;
+    validateValueOnInternalChange: (value: V, options?: ValidationOptions) => Promise<ValidationResult>;
+    validateValueOnExternalChange: (value: V) => ValidationResult;
+};
+export declare type UseValidatorsProps<V> = {
+    componentMessagingState: ComponentMessagingState;
+    defaultValidState?: ValidState;
+    deferredValidators?: ValidatorLike<V>[];
+    validators?: ValidatorLike<V>[];
+    addBusyState?: (desc?: string) => () => void;
+    onValidChanged?: (valid: ValidState) => void;
+};
+export declare function useValidators<V>({ componentMessagingState, defaultValidState, deferredValidators, validators, addBusyState, onValidChanged }: UseValidatorsProps<V>): ValidationState<V>;

package/oj-c/types/editable-value/UNSAFE_useValue/useValue.d.ts

@@ -0,0 +1,23 @@
+import { StateUpdater } from 'preact/hooks';
+import { ConverterErrorSymbol } from '../UNSAFE_useConverter/useConverter';
+import { ValidState } from '../UNSAFE_useValidators/useValidators';
+export declare type ValueState<V> = {
+    displayValue: string;
+    transientValue: V;
+    value: V;
+    getValueForValidation: (valid: ValidState) => V | typeof ConverterErrorSymbol;
+    setValueAfterValidation: (value: V) => void;
+    setDisplayValue: StateUpdater<string>;
+    setTransientValue: StateUpdater<V>;
+    setValue: StateUpdater<V>;
+    refreshDisplayValue: () => void;
+};
+export declare type UseValueProps<V> = {
+    value?: V;
+    format: (value: V, shouldSuppressError?: boolean) => string;
+    parse: (value: string) => V | typeof ConverterErrorSymbol;
+    onRawValueChanged?: (rawValue: string) => void;
+    onTransientValueChanged?: (transientValue: V | null | undefined) => void;
+    onValueChanged?: (value: V | null | undefined) => void;
+};
+export declare function useValue<V>({ value: valueProp, format, parse, onRawValueChanged, onTransientValueChanged, onValueChanged }: UseValueProps<V>): ValueState<V>;

package/oj-c/types/editable-value/UNSAFE_useValueLifecycle/useValueLifecycle.d.ts

@@ -0,0 +1,9 @@
+import { ValidationResult } from '../UNSAFE_useValidators/useValidators';
+import { ValueState } from '../UNSAFE_useValue/useValue';
+export declare type UseValueLifecycleProps<V> = {
+    value?: V;
+    valueState: ValueState<V>;
+    format: (value: V) => string;
+    validateValueOnExternalChange: (value: V) => ValidationResult;
+};
+export declare function useValueLifecycle<V>({ value, valueState, format, validateValueOnExternalChange }: UseValueLifecycleProps<V>): void;

package/oj-c/types/editable-value/utils/utils.d.ts

@@ -0,0 +1,6 @@
+import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import { ConverterError, ValidatorError } from 'ojs/ojvalidation-error';
+export declare function createMessageFromError(error: Error | ValidatorError | ConverterError): ComponentMessageItem;
+export declare function treatNull<T>(value?: T | null, defaultValue?: T): T | undefined;
+export declare function normalizeValue<T>(value?: T): T | null | undefined;
+export declare const isShallowEqual: <T>(a: T[], b: T[]) => boolean;

package/oj-c/types/file-picker/file-picker.d.ts

@@ -0,0 +1,103 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { FilePicker as PreactFilePicker } from '@oracle/oraclejet-preact/UNSAFE_FilePicker';
+import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import { ComponentProps } from 'preact';
+import { Action, CancelableAction, ObservedGlobalProps, Slot } from 'ojs/ojvcomponent';
+import 'css!oj-c/file-picker/file-picker-styles.css';
+declare type PreactFilePickerProps = ComponentProps<typeof PreactFilePicker>;
+declare type Props = ObservedGlobalProps<'aria-label'> & {
+    accept?: string[];
+    capture?: PreactFilePickerProps['capture'];
+    disabled?: boolean;
+    primaryText?: string | (() => string);
+    secondaryText?: string | ((fileOptions: {
+        selectionMode: 'multiple' | 'single';
+    }) => string);
+    selectionMode?: PreactFilePickerProps['selectionMode'];
+    trigger?: Slot;
+    onOjBeforeSelect?: CancelableAction<BeforeDetail>;
+    onOjInvalidSelect?: Action<InvalidDetail>;
+    onOjSelect?: Action<SelectDetail>;
+};
+declare type BeforeDetail = {
+    files: FileList;
+};
+declare type InvalidDetail = {
+    messages: ComponentMessageItem[];
+    until: Promise<void> | null;
+};
+declare type SelectDetail = {
+    files: FileList;
+};
+export declare const FilePicker: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<Props>>;
+export {};
+export interface CFilePickerElement extends JetElement<CFilePickerElementSettableProperties>, CFilePickerElementSettableProperties {
+    addEventListener<T extends keyof CFilePickerElementEventMap>(type: T, listener: (this: HTMLElement, ev: CFilePickerElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CFilePickerElementSettableProperties>(property: T): CFilePickerElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CFilePickerElementSettableProperties>(property: T, value: CFilePickerElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CFilePickerElementSettableProperties>): void;
+    setProperties(properties: CFilePickerElementSettablePropertiesLenient): void;
+    blur: () => void;
+    focus: () => void;
+}
+export namespace CFilePickerElement {
+    interface ojBeforeSelect extends CustomEvent<BeforeDetail & {
+        accept: (param: Promise<void>) => void;
+    }> {
+    }
+    interface ojInvalidSelect extends CustomEvent<InvalidDetail & {}> {
+    }
+    interface ojSelect extends CustomEvent<SelectDetail & {}> {
+    }
+    type acceptChanged = JetElementCustomEventStrict<CFilePickerElement['accept']>;
+    type captureChanged = JetElementCustomEventStrict<CFilePickerElement['capture']>;
+    type disabledChanged = JetElementCustomEventStrict<CFilePickerElement['disabled']>;
+    type primaryTextChanged = JetElementCustomEventStrict<CFilePickerElement['primaryText']>;
+    type secondaryTextChanged = JetElementCustomEventStrict<CFilePickerElement['secondaryText']>;
+    type selectionModeChanged = JetElementCustomEventStrict<CFilePickerElement['selectionMode']>;
+}
+export interface CFilePickerElementEventMap extends HTMLElementEventMap {
+    'ojBeforeSelect': CFilePickerElement.ojBeforeSelect;
+    'ojInvalidSelect': CFilePickerElement.ojInvalidSelect;
+    'ojSelect': CFilePickerElement.ojSelect;
+    'acceptChanged': JetElementCustomEventStrict<CFilePickerElement['accept']>;
+    'captureChanged': JetElementCustomEventStrict<CFilePickerElement['capture']>;
+    'disabledChanged': JetElementCustomEventStrict<CFilePickerElement['disabled']>;
+    'primaryTextChanged': JetElementCustomEventStrict<CFilePickerElement['primaryText']>;
+    'secondaryTextChanged': JetElementCustomEventStrict<CFilePickerElement['secondaryText']>;
+    'selectionModeChanged': JetElementCustomEventStrict<CFilePickerElement['selectionMode']>;
+}
+export interface CFilePickerElementSettableProperties extends JetSettableProperties {
+    accept?: ComponentProps<typeof FilePicker>['accept'];
+    capture?: ComponentProps<typeof FilePicker>['capture'];
+    disabled?: ComponentProps<typeof FilePicker>['disabled'];
+    primaryText?: ComponentProps<typeof FilePicker>['primaryText'];
+    secondaryText?: ComponentProps<typeof FilePicker>['secondaryText'];
+    selectionMode?: ComponentProps<typeof FilePicker>['selectionMode'];
+}
+export interface CFilePickerElementSettablePropertiesLenient extends Partial<CFilePickerElementSettableProperties> {
+    [key: string]: any;
+}
+export interface FilePickerIntrinsicProps extends Partial<Readonly<CFilePickerElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    onojBeforeSelect?: (value: CFilePickerElementEventMap['ojBeforeSelect']) => void;
+    onojInvalidSelect?: (value: CFilePickerElementEventMap['ojInvalidSelect']) => void;
+    onojSelect?: (value: CFilePickerElementEventMap['ojSelect']) => void;
+    onacceptChanged?: (value: CFilePickerElementEventMap['acceptChanged']) => void;
+    oncaptureChanged?: (value: CFilePickerElementEventMap['captureChanged']) => void;
+    ondisabledChanged?: (value: CFilePickerElementEventMap['disabledChanged']) => void;
+    onprimaryTextChanged?: (value: CFilePickerElementEventMap['primaryTextChanged']) => void;
+    onsecondaryTextChanged?: (value: CFilePickerElementEventMap['secondaryTextChanged']) => void;
+    onselectionModeChanged?: (value: CFilePickerElementEventMap['selectionModeChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-file-picker': FilePickerIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/file-picker/index.d.ts

@@ -0,0 +1,2 @@
+export { FilePicker } from './file-picker';
+export { CFilePickerElement } from './file-picker';

package/oj-c/types/hooks/UNSAFE_useDataProvider/DataProviderHandler.d.ts

@@ -0,0 +1,18 @@
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider } from 'ojs/ojdataprovider';
+declare type DataProviderHandlerCallback<Key, Data> = {
+    onDataUpdated: (data: Array<ItemContext<Key, Data>>) => void;
+};
+export declare class DataProviderHandler<Key, Data> {
+    private readonly addBusyState;
+    private readonly dataProvider;
+    private currentData;
+    private callback?;
+    private readonly handleMutateEvent;
+    private readonly handleRefreshEvent;
+    constructor(dataProvider: DataProvider<Key, Data>, addBusyState: (description: string) => () => void, callback?: DataProviderHandlerCallback<Key, Data>);
+    destroy(): void;
+    private _fetchData;
+    private _fetchDataAndNotify;
+}
+export {};

package/oj-c/types/hooks/UNSAFE_useDataProvider/useDataProvider.d.ts

@@ -0,0 +1,10 @@
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider } from 'ojs/ojdataprovider';
+declare type Props<Key, Data> = {
+    data?: DataProvider<Key, Data>;
+    addBusyState: (description: string) => () => void;
+};
+export declare function useDataProvider<K, D>({ addBusyState, data }: Props<K, D>): {
+    data: ItemContext<K, D>[];
+};
+export {};

package/oj-c/types/hooks/UNSAFE_useDataProvider/utils.d.ts

@@ -0,0 +1,3 @@
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider, DataProviderMutationEventDetail } from 'ojs/ojdataprovider';
+export declare function getUpdatedItemsFromMutationDetail<K, D>(detail: DataProviderMutationEventDetail<K, D>, currentData: ItemContext<K, D>[], dataProvider: DataProvider<K, D>): Promise<ItemContext<K, D>[]>;

package/oj-c/types/hooks/UNSAFE_useListData/__tests__/useListData.test.d.ts

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

package/oj-c/types/hooks/UNSAFE_useListData/useListData.d.ts

@@ -0,0 +1,21 @@
+import { DataState, Range } from '@oracle/oraclejet-preact/UNSAFE_Collection';
+import { DataProvider, FetchAttribute, DataFilter, SortCriterion } from 'ojs/ojdataprovider';
+export declare type ListDataState<K, D> = {
+    status: 'loading';
+    data: null;
+} | {
+    status: 'success';
+    data: DataState<K, D>;
+} | {
+    status: 'error';
+    error: any;
+};
+export declare type FetchOptions<D> = {
+    attributes?: string[] | FetchAttribute[];
+    filterCriterion?: DataFilter.Filter<D>;
+    sortCriteria?: SortCriterion<D>[];
+    isInitialFetchDeferred?: boolean;
+    initialRowsFetched?: number;
+    fetchSize?: number;
+};
+export declare const useListData: <K, D>(data: DataProvider<K, D>, options?: FetchOptions<D>) => [ListDataState<K, D>, (range: Range) => void];

package/oj-c/types/hooks/UNSAFE_useTreeData/__tests__/useTreeData.test.d.ts

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

package/oj-c/types/hooks/UNSAFE_useTreeData/useTreeData.d.ts

@@ -0,0 +1,27 @@
+import { FlattenedDataState, Range } from '@oracle/oraclejet-preact/UNSAFE_Collection';
+import { FetchAttribute, DataFilter, SortCriterion } from 'ojs/ojdataprovider';
+import TreeDataProvider from 'ojs/ojtreedataprovider';
+import { KeySet } from 'ojs/ojkeyset';
+export declare type TreeDataState<K, D> = {
+    status: 'loading';
+    data: null;
+} | {
+    status: 'success';
+    data: FlattenedDataState<K, D>;
+} | {
+    status: 'error';
+    error: any;
+};
+export declare type FetchOptions<K, D> = {
+    attributes?: string[] | FetchAttribute[];
+    filterCriterion?: DataFilter.Filter<D>;
+    sortCriteria?: SortCriterion<D>[];
+    isInitialFetchDeferred?: boolean;
+    initialRowsFetched?: number;
+    expanded?: KeySet<K>;
+    includeClosestParents?: boolean;
+};
+export declare type ToggleDetail<K> = {
+    key: K;
+};
+export declare const useTreeData: <K, D>(data: TreeDataProvider<K, D>, options?: FetchOptions<K, D>) => [TreeDataState<K, D>, (range: Range) => void, (detail: ToggleDetail<K>) => void];

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

@@ -0,0 +1,2 @@
+export { InputNumber } from './input-number';
+export { CInputNumberElement } from './input-number';

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

@@ -0,0 +1,231 @@
+/// <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 { NumberInputText as PreactNumberInputText } from '@oracle/oraclejet-preact/UNSAFE_NumberInputText';
+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 } from 'ojs/ojvcomponent';
+import { Component, ComponentProps } from 'preact';
+import 'css!oj-c/input-number/input-number-styles.css';
+declare type PreactNumberInputTextProps = ComponentProps<typeof PreactNumberInputText>;
+declare type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+declare type Props = ObservedGlobalProps<'aria-describedby' | 'autofocus' | 'id'> & {
+    autocomplete?: 'on' | 'off' | string;
+    containerReadonly?: boolean;
+    converter?: Converter<number> | null;
+    disabled?: boolean;
+    displayOptions?: DisplayOptions;
+    help?: Help;
+    helpHints?: HelpHints;
+    inputPrefix?: PreactNumberInputTextProps['prefix'];
+    inputSuffix?: PreactNumberInputTextProps['suffix'];
+    labelEdge?: PreactNumberInputTextProps['labelEdge'];
+    labelHint: string;
+    labelStartWidth?: string;
+    labelWrapping?: 'truncate' | 'wrap';
+    max?: number | null;
+    min?: number | null;
+    messagesCustom?: PreactNumberInputTextProps['messages'];
+    numberRangeExactMessageDetail?: string;
+    numberRangeOverflowMessageDetail?: string;
+    numberRangeUnderflowMessageDetail?: string;
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    step?: number;
+    textAlign?: PreactNumberInputTextProps['textAlign'];
+    userAssistanceDensity?: PreactNumberInputTextProps['userAssistanceDensity'];
+    validators?: (AsyncValidator<number> | Validator<number>)[] | null;
+    value?: number | null;
+    virtualKeyboard?: PreactNumberInputTextProps['virtualKeyboard'];
+    onMessagesCustomChanged?: PropertyChanged<PreactNumberInputTextProps['messages']>;
+    onRawValueChanged?: ReadOnlyPropertyChanged<string>;
+    onTransientValueChanged?: ReadOnlyPropertyChanged<number>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<number>;
+};
+export declare class InputNumber extends Component<ExtendGlobalProps<Props>> {
+    static defaultProps: Partial<Props>;
+    private busyContextRef;
+    private inputNumberRef;
+    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 InputNumberProps = Props;
+export {};
+export interface CInputNumberElement extends JetElement<CInputNumberElementSettableProperties>, CInputNumberElementSettableProperties {
+    readonly rawValue?: Parameters<Required<Props>['onRawValueChanged']>[0];
+    readonly transientValue?: Parameters<Required<Props>['onTransientValueChanged']>[0];
+    readonly valid?: Parameters<Required<Props>['onValidChanged']>[0];
+    addEventListener<T extends keyof CInputNumberElementEventMap>(type: T, listener: (this: HTMLElement, ev: CInputNumberElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CInputNumberElementSettableProperties>(property: T): CInputNumberElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CInputNumberElementSettableProperties>(property: T, value: CInputNumberElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CInputNumberElementSettableProperties>): void;
+    setProperties(properties: CInputNumberElementSettablePropertiesLenient): void;
+    blur: InputNumber['blur'];
+    focus: InputNumber['focus'];
+    reset: InputNumber['reset'];
+    showMessages: InputNumber['showMessages'];
+    validate: InputNumber['validate'];
+}
+export namespace CInputNumberElement {
+    type autocompleteChanged = JetElementCustomEventStrict<CInputNumberElement['autocomplete']>;
+    type containerReadonlyChanged = JetElementCustomEventStrict<CInputNumberElement['containerReadonly']>;
+    type converterChanged = JetElementCustomEventStrict<CInputNumberElement['converter']>;
+    type disabledChanged = JetElementCustomEventStrict<CInputNumberElement['disabled']>;
+    type displayOptionsChanged = JetElementCustomEventStrict<CInputNumberElement['displayOptions']>;
+    type helpChanged = JetElementCustomEventStrict<CInputNumberElement['help']>;
+    type helpHintsChanged = JetElementCustomEventStrict<CInputNumberElement['helpHints']>;
+    type inputPrefixChanged = JetElementCustomEventStrict<CInputNumberElement['inputPrefix']>;
+    type inputSuffixChanged = JetElementCustomEventStrict<CInputNumberElement['inputSuffix']>;
+    type labelEdgeChanged = JetElementCustomEventStrict<CInputNumberElement['labelEdge']>;
+    type labelHintChanged = JetElementCustomEventStrict<CInputNumberElement['labelHint']>;
+    type labelStartWidthChanged = JetElementCustomEventStrict<CInputNumberElement['labelStartWidth']>;
+    type labelWrappingChanged = JetElementCustomEventStrict<CInputNumberElement['labelWrapping']>;
+    type maxChanged = JetElementCustomEventStrict<CInputNumberElement['max']>;
+    type messagesCustomChanged = JetElementCustomEventStrict<CInputNumberElement['messagesCustom']>;
+    type minChanged = JetElementCustomEventStrict<CInputNumberElement['min']>;
+    type numberRangeExactMessageDetailChanged = JetElementCustomEventStrict<CInputNumberElement['numberRangeExactMessageDetail']>;
+    type numberRangeOverflowMessageDetailChanged = JetElementCustomEventStrict<CInputNumberElement['numberRangeOverflowMessageDetail']>;
+    type numberRangeUnderflowMessageDetailChanged = JetElementCustomEventStrict<CInputNumberElement['numberRangeUnderflowMessageDetail']>;
+    type placeholderChanged = JetElementCustomEventStrict<CInputNumberElement['placeholder']>;
+    type rawValueChanged = JetElementCustomEventStrict<CInputNumberElement['rawValue']>;
+    type readonlyChanged = JetElementCustomEventStrict<CInputNumberElement['readonly']>;
+    type requiredChanged = JetElementCustomEventStrict<CInputNumberElement['required']>;
+    type requiredMessageDetailChanged = JetElementCustomEventStrict<CInputNumberElement['requiredMessageDetail']>;
+    type stepChanged = JetElementCustomEventStrict<CInputNumberElement['step']>;
+    type textAlignChanged = JetElementCustomEventStrict<CInputNumberElement['textAlign']>;
+    type transientValueChanged = JetElementCustomEventStrict<CInputNumberElement['transientValue']>;
+    type userAssistanceDensityChanged = JetElementCustomEventStrict<CInputNumberElement['userAssistanceDensity']>;
+    type validChanged = JetElementCustomEventStrict<CInputNumberElement['valid']>;
+    type validatorsChanged = JetElementCustomEventStrict<CInputNumberElement['validators']>;
+    type valueChanged = JetElementCustomEventStrict<CInputNumberElement['value']>;
+    type virtualKeyboardChanged = JetElementCustomEventStrict<CInputNumberElement['virtualKeyboard']>;
+}
+export interface CInputNumberElementEventMap extends HTMLElementEventMap {
+    'autocompleteChanged': JetElementCustomEventStrict<CInputNumberElement['autocomplete']>;
+    'containerReadonlyChanged': JetElementCustomEventStrict<CInputNumberElement['containerReadonly']>;
+    'converterChanged': JetElementCustomEventStrict<CInputNumberElement['converter']>;
+    'disabledChanged': JetElementCustomEventStrict<CInputNumberElement['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CInputNumberElement['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CInputNumberElement['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CInputNumberElement['helpHints']>;
+    'inputPrefixChanged': JetElementCustomEventStrict<CInputNumberElement['inputPrefix']>;
+    'inputSuffixChanged': JetElementCustomEventStrict<CInputNumberElement['inputSuffix']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CInputNumberElement['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CInputNumberElement['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CInputNumberElement['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CInputNumberElement['labelWrapping']>;
+    'maxChanged': JetElementCustomEventStrict<CInputNumberElement['max']>;
+    'messagesCustomChanged': JetElementCustomEventStrict<CInputNumberElement['messagesCustom']>;
+    'minChanged': JetElementCustomEventStrict<CInputNumberElement['min']>;
+    'numberRangeExactMessageDetailChanged': JetElementCustomEventStrict<CInputNumberElement['numberRangeExactMessageDetail']>;
+    'numberRangeOverflowMessageDetailChanged': JetElementCustomEventStrict<CInputNumberElement['numberRangeOverflowMessageDetail']>;
+    'numberRangeUnderflowMessageDetailChanged': JetElementCustomEventStrict<CInputNumberElement['numberRangeUnderflowMessageDetail']>;
+    'placeholderChanged': JetElementCustomEventStrict<CInputNumberElement['placeholder']>;
+    'rawValueChanged': JetElementCustomEventStrict<CInputNumberElement['rawValue']>;
+    'readonlyChanged': JetElementCustomEventStrict<CInputNumberElement['readonly']>;
+    'requiredChanged': JetElementCustomEventStrict<CInputNumberElement['required']>;
+    'requiredMessageDetailChanged': JetElementCustomEventStrict<CInputNumberElement['requiredMessageDetail']>;
+    'stepChanged': JetElementCustomEventStrict<CInputNumberElement['step']>;
+    'textAlignChanged': JetElementCustomEventStrict<CInputNumberElement['textAlign']>;
+    'transientValueChanged': JetElementCustomEventStrict<CInputNumberElement['transientValue']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CInputNumberElement['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CInputNumberElement['valid']>;
+    'validatorsChanged': JetElementCustomEventStrict<CInputNumberElement['validators']>;
+    'valueChanged': JetElementCustomEventStrict<CInputNumberElement['value']>;
+    'virtualKeyboardChanged': JetElementCustomEventStrict<CInputNumberElement['virtualKeyboard']>;
+}
+export interface CInputNumberElementSettableProperties extends JetSettableProperties {
+    autocomplete?: Props['autocomplete'];
+    containerReadonly?: Props['containerReadonly'];
+    converter?: Props['converter'];
+    disabled?: Props['disabled'];
+    displayOptions?: Props['displayOptions'];
+    help?: Props['help'];
+    helpHints?: Props['helpHints'];
+    inputPrefix?: Props['inputPrefix'];
+    inputSuffix?: Props['inputSuffix'];
+    labelEdge?: Props['labelEdge'];
+    labelHint: Props['labelHint'];
+    labelStartWidth?: Props['labelStartWidth'];
+    labelWrapping?: Props['labelWrapping'];
+    max?: Props['max'];
+    messagesCustom?: Props['messagesCustom'];
+    min?: Props['min'];
+    numberRangeExactMessageDetail?: Props['numberRangeExactMessageDetail'];
+    numberRangeOverflowMessageDetail?: Props['numberRangeOverflowMessageDetail'];
+    numberRangeUnderflowMessageDetail?: Props['numberRangeUnderflowMessageDetail'];
+    placeholder?: Props['placeholder'];
+    readonly?: Props['readonly'];
+    required?: Props['required'];
+    requiredMessageDetail?: Props['requiredMessageDetail'];
+    step?: Props['step'];
+    textAlign?: Props['textAlign'];
+    userAssistanceDensity?: Props['userAssistanceDensity'];
+    validators?: Props['validators'];
+    value?: Props['value'];
+    virtualKeyboard?: Props['virtualKeyboard'];
+}
+export interface CInputNumberElementSettablePropertiesLenient extends Partial<CInputNumberElementSettableProperties> {
+    [key: string]: any;
+}
+export interface InputNumberIntrinsicProps extends Partial<Readonly<CInputNumberElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    rawValue?: never;
+    transientValue?: never;
+    valid?: never;
+    onautocompleteChanged?: (value: CInputNumberElementEventMap['autocompleteChanged']) => void;
+    oncontainerReadonlyChanged?: (value: CInputNumberElementEventMap['containerReadonlyChanged']) => void;
+    onconverterChanged?: (value: CInputNumberElementEventMap['converterChanged']) => void;
+    ondisabledChanged?: (value: CInputNumberElementEventMap['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CInputNumberElementEventMap['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CInputNumberElementEventMap['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CInputNumberElementEventMap['helpHintsChanged']) => void;
+    oninputPrefixChanged?: (value: CInputNumberElementEventMap['inputPrefixChanged']) => void;
+    oninputSuffixChanged?: (value: CInputNumberElementEventMap['inputSuffixChanged']) => void;
+    onlabelEdgeChanged?: (value: CInputNumberElementEventMap['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CInputNumberElementEventMap['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CInputNumberElementEventMap['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CInputNumberElementEventMap['labelWrappingChanged']) => void;
+    onmaxChanged?: (value: CInputNumberElementEventMap['maxChanged']) => void;
+    onmessagesCustomChanged?: (value: CInputNumberElementEventMap['messagesCustomChanged']) => void;
+    onminChanged?: (value: CInputNumberElementEventMap['minChanged']) => void;
+    onnumberRangeExactMessageDetailChanged?: (value: CInputNumberElementEventMap['numberRangeExactMessageDetailChanged']) => void;
+    onnumberRangeOverflowMessageDetailChanged?: (value: CInputNumberElementEventMap['numberRangeOverflowMessageDetailChanged']) => void;
+    onnumberRangeUnderflowMessageDetailChanged?: (value: CInputNumberElementEventMap['numberRangeUnderflowMessageDetailChanged']) => void;
+    onplaceholderChanged?: (value: CInputNumberElementEventMap['placeholderChanged']) => void;
+    onrawValueChanged?: (value: CInputNumberElementEventMap['rawValueChanged']) => void;
+    onreadonlyChanged?: (value: CInputNumberElementEventMap['readonlyChanged']) => void;
+    onrequiredChanged?: (value: CInputNumberElementEventMap['requiredChanged']) => void;
+    onrequiredMessageDetailChanged?: (value: CInputNumberElementEventMap['requiredMessageDetailChanged']) => void;
+    onstepChanged?: (value: CInputNumberElementEventMap['stepChanged']) => void;
+    ontextAlignChanged?: (value: CInputNumberElementEventMap['textAlignChanged']) => void;
+    ontransientValueChanged?: (value: CInputNumberElementEventMap['transientValueChanged']) => void;
+    onuserAssistanceDensityChanged?: (value: CInputNumberElementEventMap['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CInputNumberElementEventMap['validChanged']) => void;
+    onvalidatorsChanged?: (value: CInputNumberElementEventMap['validatorsChanged']) => void;
+    onvalueChanged?: (value: CInputNumberElementEventMap['valueChanged']) => void;
+    onvirtualKeyboardChanged?: (value: CInputNumberElementEventMap['virtualKeyboardChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-input-number': InputNumberIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export declare function determineSteppedValue(step: number, stepOpt: number, currentParsedValue: number, initialValue?: number, maxOpt?: number, minOpt?: number): number;

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

@@ -0,0 +1,10 @@
+/// <reference types="ojconverter" />
+import { NumberConverter } from 'ojs/ojconverter-nativenumber';
+import { ComponentProps } from 'preact';
+import { InputNumber } from './input-number';
+declare type InputNumberProps = ComponentProps<typeof InputNumber>;
+declare type UseImplicitNumberConverterProps = {
+    converter?: InputNumberProps['converter'];
+};
+export declare function useImplicitNumberConverter({ converter }: UseImplicitNumberConverterProps): import("ojs/ojconverter")<number> | NumberConverter;
+export {};

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

@@ -0,0 +1,17 @@
+/// <reference types="ojconverter" />
+/// <reference types="ojvalidator-numberrange" />
+import { ComponentProps } from 'preact';
+import NumberRangeValidator from 'ojs/ojvalidator-numberrange';
+import { InputNumber } from './input-number';
+declare type InputNumberProps = ComponentProps<typeof InputNumber>;
+import Converter from 'ojs/ojconverter';
+declare type UseImplicitNumberRangeValidatorProps = {
+    converter?: Converter<number>;
+    min?: Exclude<InputNumberProps['min'], null>;
+    max?: Exclude<InputNumberProps['max'], null>;
+    numberRangeExactMessageDetail?: string;
+    numberRangeOverflowMessageDetail?: string;
+    numberRangeUnderflowMessageDetail?: string;
+};
+export declare function useImplicitNumberRangeValidator({ converter, max, min, numberRangeExactMessageDetail, numberRangeOverflowMessageDetail, numberRangeUnderflowMessageDetail }: UseImplicitNumberRangeValidatorProps): NumberRangeValidator | null;
+export {};