@oracle/oraclejet-core-pack 16.1.4 → 17.0.0

package/oj-c/types/conveyor-belt/conveyor-belt.d.ts

@@ -0,0 +1,77 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ExtendGlobalProps, PropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
+import { ComponentChildren, ComponentType, Ref, ComponentProps } from 'preact';
+import 'css!oj-c/conveyor-belt/conveyor-belt-styles.css';
+import { ConveyorItemContext } from './conveyorBeltItem';
+import { DataProvider } from 'ojs/ojdataprovider';
+type ScrollableHandle = {
+    scrollElementIntoView: (element: HTMLElement) => void;
+};
+export type ConveyorBeltDataItem = {
+    label?: string;
+};
+export type ConveyorBeltArrayDataItem<K, D> = {
+    data: D;
+    key: K;
+};
+export type ConevyorBeltPreactWrapperProps<K extends string | number, D> = {
+    children: ComponentChildren;
+    scrollPosition?: number;
+    onScrollPositionChanged?: PropertyChanged<number>;
+    arrowVisibility?: 'auto' | 'visible' | 'hidden';
+    items?: Array<ConveyorBeltArrayDataItem<K, D>> | DataProvider<K, D>;
+    itemTemplate?: TemplateSlot<ConveyorItemContext<K, D>>;
+    orientation?: 'horizontal' | 'vertical';
+};
+export type ConveyorProps<K extends string | number, D extends ConveyorBeltDataItem> = ConevyorBeltPreactWrapperProps<K, D>;
+declare const ConveyorBeltComp: ({ children, orientation, ...rest }: ConevyorBeltPreactWrapperProps<string | number, ConveyorBeltDataItem>, ref?: Ref<ScrollableHandle>) => import("preact").JSX.Element;
+export declare const ConveyorBelt: ComponentType<ExtendGlobalProps<ComponentProps<typeof ConveyorBeltComp>>>;
+export {};
+export interface CConveyorBeltElement extends JetElement<CConveyorBeltElementSettableProperties<string | number, ConveyorBeltDataItem>>, CConveyorBeltElementSettableProperties<string | number, ConveyorBeltDataItem> {
+    addEventListener<T extends keyof CConveyorBeltElementEventMap>(type: T, listener: (this: HTMLElement, ev: CConveyorBeltElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CConveyorBeltElementSettableProperties<string | number, ConveyorBeltDataItem>>(property: T): CConveyorBeltElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CConveyorBeltElementSettableProperties<string | number, ConveyorBeltDataItem>>(property: T, value: CConveyorBeltElementSettableProperties<string | number, ConveyorBeltDataItem>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CConveyorBeltElementSettableProperties<string | number, ConveyorBeltDataItem>>): void;
+    setProperties(properties: CConveyorBeltElementSettablePropertiesLenient<string | number, ConveyorBeltDataItem>): void;
+    scrollElementIntoView: (element: HTMLElement) => void;
+}
+export namespace CConveyorBeltElement {
+    type arrowVisibilityChanged = JetElementCustomEventStrict<CConveyorBeltElement['arrowVisibility']>;
+    type itemsChanged = JetElementCustomEventStrict<CConveyorBeltElement['items']>;
+    type orientationChanged = JetElementCustomEventStrict<CConveyorBeltElement['orientation']>;
+    type scrollPositionChanged = JetElementCustomEventStrict<CConveyorBeltElement['scrollPosition']>;
+    type RenderItemTemplate<K extends string | number, D> = import('ojs/ojvcomponent').TemplateSlot<ConveyorItemContext<K, D>>;
+}
+export interface CConveyorBeltElementEventMap extends HTMLElementEventMap {
+    'arrowVisibilityChanged': JetElementCustomEventStrict<CConveyorBeltElement['arrowVisibility']>;
+    'itemsChanged': JetElementCustomEventStrict<CConveyorBeltElement['items']>;
+    'orientationChanged': JetElementCustomEventStrict<CConveyorBeltElement['orientation']>;
+    'scrollPositionChanged': JetElementCustomEventStrict<CConveyorBeltElement['scrollPosition']>;
+}
+export interface CConveyorBeltElementSettableProperties<K extends string | number, D> extends JetSettableProperties {
+    arrowVisibility?: ConevyorBeltPreactWrapperProps<K, D>['arrowVisibility'];
+    items?: ConevyorBeltPreactWrapperProps<K, D>['items'];
+    orientation?: ConevyorBeltPreactWrapperProps<K, D>['orientation'];
+    scrollPosition?: ConevyorBeltPreactWrapperProps<K, D>['scrollPosition'];
+}
+export interface CConveyorBeltElementSettablePropertiesLenient<K extends string | number, D> extends Partial<CConveyorBeltElementSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ConveyorBeltIntrinsicProps extends Partial<Readonly<CConveyorBeltElementSettableProperties<any, any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    onarrowVisibilityChanged?: (value: CConveyorBeltElementEventMap['arrowVisibilityChanged']) => void;
+    onitemsChanged?: (value: CConveyorBeltElementEventMap['itemsChanged']) => void;
+    onorientationChanged?: (value: CConveyorBeltElementEventMap['orientationChanged']) => void;
+    onscrollPositionChanged?: (value: CConveyorBeltElementEventMap['scrollPositionChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-conveyor-belt': ConveyorBeltIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/conveyor-belt/conveyorBeltItem.d.ts

@@ -0,0 +1,24 @@
+import { TemplateSlot } from 'ojs/ojvcomponent';
+import { Item } from 'ojs/ojdataprovider';
+export type ConveyorItemContext<K, D> = {
+    data: D;
+    item: Item<K, D>;
+};
+export type Metadata<K> = {
+    key: K;
+    suggestion?: Record<string, any>;
+    treeDepth?: number;
+    isLeaf?: boolean;
+    parentKey?: K;
+};
+export type ConveyorBeltItemRendererContext<K, D> = {
+    index: number;
+    data: D;
+    metadata: Metadata<K>;
+};
+type ConveyorBeltItemProps<K extends string | number, D> = {
+    context: ConveyorBeltItemRendererContext<K, Item<K, D>>;
+    itemTemplate: TemplateSlot<ConveyorItemContext<K, D>>;
+};
+export declare const ConveyorBeltItem: <K extends string | number, D>({ context, itemTemplate }: ConveyorBeltItemProps<K, D>) => import("preact").JSX.Element;
+export {};

package/oj-c/types/conveyor-belt/index.d.ts

@@ -0,0 +1,2 @@
+export { ConveyorBelt } from './conveyor-belt';
+export { CConveyorBeltElement } from './conveyor-belt';

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

@@ -0,0 +1,113 @@
+import { ComponentProps } from 'preact';
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ObservedGlobalProps, PropertyChanged } from 'ojs/ojvcomponent';
+import { DateISOStr } from '@oracle/oraclejet-preact/UNSAFE_IntlDateTime';
+import { CalendarDateRequired } from '@oracle/oraclejet-preact/utils/UNSAFE_calendarDateUtils';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+type Props = ObservedGlobalProps<'aria-describedby' | 'id'> & {
+    dayFormatter?: (date: CalendarDateRequired) => {
+        state: 'disabled' | 'enabled' | 'restricted';
+    };
+    daysOutsideMonth?: 'hidden' | 'selectable';
+    monthAndYearPicker?: 'on' | 'off';
+    max?: DateISOStr | null;
+    maxWidth?: Size;
+    min?: DateISOStr | null;
+    readonly?: boolean;
+    todayButton?: 'visible' | 'hidden';
+    todayTimeZone?: Intl.DateTimeFormatOptions['timeZone'];
+    value?: DateISOStr | null;
+    width?: Size;
+    onValueChanged?: PropertyChanged<DateISOStr | null>;
+};
+export declare const DatePicker: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"id" | "aria-describedby"> & {
+    dayFormatter?: ((date: CalendarDateRequired) => {
+        state: 'disabled' | 'enabled' | 'restricted';
+    }) | undefined;
+    daysOutsideMonth?: "hidden" | "selectable" | undefined;
+    monthAndYearPicker?: "off" | "on" | undefined;
+    max?: string | null | undefined;
+    maxWidth?: Size | undefined;
+    min?: string | null | undefined;
+    readonly?: boolean | undefined;
+    todayButton?: "hidden" | "visible" | undefined;
+    todayTimeZone?: Intl.DateTimeFormatOptions['timeZone'];
+    value?: string | null | undefined;
+    width?: Size | undefined;
+    onValueChanged?: PropertyChanged<string | null> | undefined;
+}>>;
+export type DatePickerProps = Props;
+export {};
+export interface CDatePickerElement extends JetElement<CDatePickerElementSettableProperties>, CDatePickerElementSettableProperties {
+    addEventListener<T extends keyof CDatePickerElementEventMap>(type: T, listener: (this: HTMLElement, ev: CDatePickerElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CDatePickerElementSettableProperties>(property: T): CDatePickerElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CDatePickerElementSettableProperties>(property: T, value: CDatePickerElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CDatePickerElementSettableProperties>): void;
+    setProperties(properties: CDatePickerElementSettablePropertiesLenient): void;
+}
+export namespace CDatePickerElement {
+    type dayFormatterChanged = JetElementCustomEventStrict<CDatePickerElement['dayFormatter']>;
+    type daysOutsideMonthChanged = JetElementCustomEventStrict<CDatePickerElement['daysOutsideMonth']>;
+    type maxChanged = JetElementCustomEventStrict<CDatePickerElement['max']>;
+    type maxWidthChanged = JetElementCustomEventStrict<CDatePickerElement['maxWidth']>;
+    type minChanged = JetElementCustomEventStrict<CDatePickerElement['min']>;
+    type monthAndYearPickerChanged = JetElementCustomEventStrict<CDatePickerElement['monthAndYearPicker']>;
+    type readonlyChanged = JetElementCustomEventStrict<CDatePickerElement['readonly']>;
+    type todayButtonChanged = JetElementCustomEventStrict<CDatePickerElement['todayButton']>;
+    type todayTimeZoneChanged = JetElementCustomEventStrict<CDatePickerElement['todayTimeZone']>;
+    type valueChanged = JetElementCustomEventStrict<CDatePickerElement['value']>;
+    type widthChanged = JetElementCustomEventStrict<CDatePickerElement['width']>;
+}
+export interface CDatePickerElementEventMap extends HTMLElementEventMap {
+    'dayFormatterChanged': JetElementCustomEventStrict<CDatePickerElement['dayFormatter']>;
+    'daysOutsideMonthChanged': JetElementCustomEventStrict<CDatePickerElement['daysOutsideMonth']>;
+    'maxChanged': JetElementCustomEventStrict<CDatePickerElement['max']>;
+    'maxWidthChanged': JetElementCustomEventStrict<CDatePickerElement['maxWidth']>;
+    'minChanged': JetElementCustomEventStrict<CDatePickerElement['min']>;
+    'monthAndYearPickerChanged': JetElementCustomEventStrict<CDatePickerElement['monthAndYearPicker']>;
+    'readonlyChanged': JetElementCustomEventStrict<CDatePickerElement['readonly']>;
+    'todayButtonChanged': JetElementCustomEventStrict<CDatePickerElement['todayButton']>;
+    'todayTimeZoneChanged': JetElementCustomEventStrict<CDatePickerElement['todayTimeZone']>;
+    'valueChanged': JetElementCustomEventStrict<CDatePickerElement['value']>;
+    'widthChanged': JetElementCustomEventStrict<CDatePickerElement['width']>;
+}
+export interface CDatePickerElementSettableProperties extends JetSettableProperties {
+    dayFormatter?: ComponentProps<typeof DatePicker>['dayFormatter'];
+    daysOutsideMonth?: ComponentProps<typeof DatePicker>['daysOutsideMonth'];
+    max?: ComponentProps<typeof DatePicker>['max'];
+    maxWidth?: ComponentProps<typeof DatePicker>['maxWidth'];
+    min?: ComponentProps<typeof DatePicker>['min'];
+    monthAndYearPicker?: ComponentProps<typeof DatePicker>['monthAndYearPicker'];
+    readonly?: ComponentProps<typeof DatePicker>['readonly'];
+    todayButton?: ComponentProps<typeof DatePicker>['todayButton'];
+    todayTimeZone?: ComponentProps<typeof DatePicker>['todayTimeZone'];
+    value?: ComponentProps<typeof DatePicker>['value'];
+    width?: ComponentProps<typeof DatePicker>['width'];
+}
+export interface CDatePickerElementSettablePropertiesLenient extends Partial<CDatePickerElementSettableProperties> {
+    [key: string]: any;
+}
+export interface DatePickerIntrinsicProps extends Partial<Readonly<CDatePickerElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    ondayFormatterChanged?: (value: CDatePickerElementEventMap['dayFormatterChanged']) => void;
+    ondaysOutsideMonthChanged?: (value: CDatePickerElementEventMap['daysOutsideMonthChanged']) => void;
+    onmaxChanged?: (value: CDatePickerElementEventMap['maxChanged']) => void;
+    onmaxWidthChanged?: (value: CDatePickerElementEventMap['maxWidthChanged']) => void;
+    onminChanged?: (value: CDatePickerElementEventMap['minChanged']) => void;
+    onmonthAndYearPickerChanged?: (value: CDatePickerElementEventMap['monthAndYearPickerChanged']) => void;
+    onreadonlyChanged?: (value: CDatePickerElementEventMap['readonlyChanged']) => void;
+    ontodayButtonChanged?: (value: CDatePickerElementEventMap['todayButtonChanged']) => void;
+    ontodayTimeZoneChanged?: (value: CDatePickerElementEventMap['todayTimeZoneChanged']) => void;
+    onvalueChanged?: (value: CDatePickerElementEventMap['valueChanged']) => void;
+    onwidthChanged?: (value: CDatePickerElementEventMap['widthChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-date-picker': DatePickerIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export { DatePicker } from './date-picker';
+export { CDatePickerElement } from './date-picker';

package/oj-c/types/drag-handle/drag-handle.d.ts

@@ -0,0 +1,24 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ExtendGlobalProps } from 'ojs/ojvcomponent';
+import { ComponentProps, ComponentType } from 'preact';
+declare const DragHandleImpl: () => import("preact").JSX.Element;
+export declare const DragHandle: ComponentType<ExtendGlobalProps<ComponentProps<typeof DragHandleImpl>>>;
+export {};
+export interface CDragHandleElement extends JetElement<CDragHandleElementSettableProperties>, CDragHandleElementSettableProperties {
+    addEventListener<T extends keyof CDragHandleElementEventMap>(type: T, listener: (this: HTMLElement, ev: CDragHandleElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CDragHandleElementSettableProperties>(property: T): CDragHandleElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CDragHandleElementSettableProperties>(property: T, value: CDragHandleElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CDragHandleElementSettableProperties>): void;
+    setProperties(properties: CDragHandleElementSettablePropertiesLenient): void;
+}
+export interface CDragHandleElementEventMap extends HTMLElementEventMap {
+}
+export interface CDragHandleElementSettableProperties extends JetSettableProperties {
+}
+export interface CDragHandleElementSettablePropertiesLenient extends Partial<CDragHandleElementSettableProperties> {
+    [key: string]: any;
+}

package/oj-c/types/drag-handle/index.d.ts

@@ -0,0 +1,2 @@
+export { DragHandle } from './drag-handle';
+export { CDragHandleElement } from './drag-handle';

package/oj-c/types/drawer-layout/drawer-layout.d.ts

@@ -0,0 +1,91 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { Action, CancelableAction, ExtendGlobalProps, PropertyChanged, Slot } from 'ojs/ojvcomponent';
+import { ComponentChildren, ComponentType } from 'preact';
+import 'css!oj-c/drawer-layout/drawer-layout-styles.css';
+type Placement = 'start' | 'end' | 'bottom';
+type OnCloseDetail = {
+    edge: Placement;
+};
+type Props = {
+    children: ComponentChildren;
+    start?: Slot;
+    end?: Slot;
+    bottom?: Slot;
+    startOpened?: boolean;
+    endOpened?: boolean;
+    bottomOpened?: boolean;
+    startDisplay?: 'auto' | 'reflow' | 'overlay';
+    endDisplay?: 'auto' | 'reflow' | 'overlay';
+    bottomDisplay?: 'auto' | 'reflow' | 'overlay';
+    onOjBeforeClose?: CancelableAction<OnCloseDetail>;
+    onOjClose?: Action<OnCloseDetail>;
+    onStartOpenedChanged?: PropertyChanged<boolean>;
+    onEndOpenedChanged?: PropertyChanged<boolean>;
+    onBottomOpenedChanged?: PropertyChanged<boolean>;
+};
+export declare const DrawerLayout: ComponentType<ExtendGlobalProps<Props>>;
+export {};
+export interface CDrawerLayoutElement extends JetElement<CDrawerLayoutElementSettableProperties>, CDrawerLayoutElementSettableProperties {
+    addEventListener<T extends keyof CDrawerLayoutElementEventMap>(type: T, listener: (this: HTMLElement, ev: CDrawerLayoutElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CDrawerLayoutElementSettableProperties>(property: T): CDrawerLayoutElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CDrawerLayoutElementSettableProperties>(property: T, value: CDrawerLayoutElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CDrawerLayoutElementSettableProperties>): void;
+    setProperties(properties: CDrawerLayoutElementSettablePropertiesLenient): void;
+}
+export namespace CDrawerLayoutElement {
+    interface ojBeforeClose extends CustomEvent<OnCloseDetail & {
+        accept: (param: Promise<void>) => void;
+    }> {
+    }
+    interface ojClose extends CustomEvent<OnCloseDetail & {}> {
+    }
+    type bottomDisplayChanged = JetElementCustomEventStrict<CDrawerLayoutElement['bottomDisplay']>;
+    type bottomOpenedChanged = JetElementCustomEventStrict<CDrawerLayoutElement['bottomOpened']>;
+    type endDisplayChanged = JetElementCustomEventStrict<CDrawerLayoutElement['endDisplay']>;
+    type endOpenedChanged = JetElementCustomEventStrict<CDrawerLayoutElement['endOpened']>;
+    type startDisplayChanged = JetElementCustomEventStrict<CDrawerLayoutElement['startDisplay']>;
+    type startOpenedChanged = JetElementCustomEventStrict<CDrawerLayoutElement['startOpened']>;
+}
+export interface CDrawerLayoutElementEventMap extends HTMLElementEventMap {
+    'ojBeforeClose': CDrawerLayoutElement.ojBeforeClose;
+    'ojClose': CDrawerLayoutElement.ojClose;
+    'bottomDisplayChanged': JetElementCustomEventStrict<CDrawerLayoutElement['bottomDisplay']>;
+    'bottomOpenedChanged': JetElementCustomEventStrict<CDrawerLayoutElement['bottomOpened']>;
+    'endDisplayChanged': JetElementCustomEventStrict<CDrawerLayoutElement['endDisplay']>;
+    'endOpenedChanged': JetElementCustomEventStrict<CDrawerLayoutElement['endOpened']>;
+    'startDisplayChanged': JetElementCustomEventStrict<CDrawerLayoutElement['startDisplay']>;
+    'startOpenedChanged': JetElementCustomEventStrict<CDrawerLayoutElement['startOpened']>;
+}
+export interface CDrawerLayoutElementSettableProperties extends JetSettableProperties {
+    bottomDisplay?: Props['bottomDisplay'];
+    bottomOpened?: Props['bottomOpened'];
+    endDisplay?: Props['endDisplay'];
+    endOpened?: Props['endOpened'];
+    startDisplay?: Props['startDisplay'];
+    startOpened?: Props['startOpened'];
+}
+export interface CDrawerLayoutElementSettablePropertiesLenient extends Partial<CDrawerLayoutElementSettableProperties> {
+    [key: string]: any;
+}
+export interface DrawerLayoutIntrinsicProps extends Partial<Readonly<CDrawerLayoutElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    onojBeforeClose?: (value: CDrawerLayoutElementEventMap['ojBeforeClose']) => void;
+    onojClose?: (value: CDrawerLayoutElementEventMap['ojClose']) => void;
+    onbottomDisplayChanged?: (value: CDrawerLayoutElementEventMap['bottomDisplayChanged']) => void;
+    onbottomOpenedChanged?: (value: CDrawerLayoutElementEventMap['bottomOpenedChanged']) => void;
+    onendDisplayChanged?: (value: CDrawerLayoutElementEventMap['endDisplayChanged']) => void;
+    onendOpenedChanged?: (value: CDrawerLayoutElementEventMap['endOpenedChanged']) => void;
+    onstartDisplayChanged?: (value: CDrawerLayoutElementEventMap['startDisplayChanged']) => void;
+    onstartOpenedChanged?: (value: CDrawerLayoutElementEventMap['startOpenedChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-drawer-layout': DrawerLayoutIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/drawer-layout/index.d.ts

@@ -0,0 +1,2 @@
+export { DrawerLayout } from './drawer-layout';
+export { CDrawerLayoutElement } from './drawer-layout';

package/oj-c/types/drawer-popup/drawer-popup.d.ts

@@ -1,10 +1,10 @@
 import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
 import { GlobalProps } from 'ojs/ojvcomponent';
 import 'ojs/oj-jsx-interfaces';
-import { CancelableAction, ExtendGlobalProps, PropertyChanged, ObservedGlobalProps } from 'ojs/ojvcomponent';
+import { Action, CancelableAction, ExtendGlobalProps, PropertyChanged, ObservedGlobalProps } from 'ojs/ojvcomponent';
 import { ComponentChildren, ComponentType } from 'preact';
 import 'css!oj-c/drawer-popup/drawer-popup-styles.css';
-type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label' | 'aria-labelledby'> & {
+type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label' | 'aria-labelledby' | 'id'> & {
     children: ComponentChildren;
     opened: boolean;
     modality?: 'modal' | 'modeless';
@@ -12,6 +12,7 @@ type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label' | 'aria-label
     autoDismiss?: 'focus-loss' | 'none';
     closeGesture?: 'swipe' | 'none';
     onOjBeforeClose?: CancelableAction<object>;
+    onOjClose?: Action;
     onOpenedChanged?: PropertyChanged<boolean>;
 };
 export declare const DrawerPopup: ComponentType<ExtendGlobalProps<Props>>;
@@ -30,6 +31,8 @@ export namespace CDrawerPopupElement {
         accept: (param: Promise<void>) => void;
     }> {
     }
+    interface ojClose extends CustomEvent<{}> {
+    }
     type autoDismissChanged = JetElementCustomEventStrict<CDrawerPopupElement['autoDismiss']>;
     type closeGestureChanged = JetElementCustomEventStrict<CDrawerPopupElement['closeGesture']>;
     type edgeChanged = JetElementCustomEventStrict<CDrawerPopupElement['edge']>;
@@ -38,6 +41,7 @@ export namespace CDrawerPopupElement {
 }
 export interface CDrawerPopupElementEventMap extends HTMLElementEventMap {
     'ojBeforeClose': CDrawerPopupElement.ojBeforeClose;
+    'ojClose': CDrawerPopupElement.ojClose;
     'autoDismissChanged': JetElementCustomEventStrict<CDrawerPopupElement['autoDismiss']>;
     'closeGestureChanged': JetElementCustomEventStrict<CDrawerPopupElement['closeGesture']>;
     'edgeChanged': JetElementCustomEventStrict<CDrawerPopupElement['edge']>;
@@ -57,6 +61,7 @@ export interface CDrawerPopupElementSettablePropertiesLenient extends Partial<CD
 export interface DrawerPopupIntrinsicProps extends Partial<Readonly<CDrawerPopupElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
     children?: import('preact').ComponentChildren;
     onojBeforeClose?: (value: CDrawerPopupElementEventMap['ojBeforeClose']) => void;
+    onojClose?: (value: CDrawerPopupElementEventMap['ojClose']) => void;
     onautoDismissChanged?: (value: CDrawerPopupElementEventMap['autoDismissChanged']) => void;
     oncloseGestureChanged?: (value: CDrawerPopupElementEventMap['closeGestureChanged']) => void;
     onedgeChanged?: (value: CDrawerPopupElementEventMap['edgeChanged']) => void;

package/oj-c/types/editable-value/UNSAFE_useComponentMessaging/useComponentMessaging.d.ts

@@ -1,5 +1,5 @@
 import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
-import { StateUpdater } from 'preact/hooks';
+import { Dispatch, StateUpdater } from 'preact/hooks';
 export type ComponentMessagingState = {
     componentMessages: ComponentMessageItem[];
     deferredComponentMessages: ComponentMessageItem[];
@@ -13,8 +13,8 @@ export type ComponentMessagingState = {
     hasCustomErrorMessages: () => boolean;
     hasHiddenMessages: () => boolean;
     hasNoErrorMessages: () => boolean;
-    setComponentMessages: StateUpdater<ComponentMessageItem[]>;
-    setDeferredComponentMessages: StateUpdater<ComponentMessageItem[]>;
+    setComponentMessages: Dispatch<StateUpdater<ComponentMessageItem[]>>;
+    setDeferredComponentMessages: Dispatch<StateUpdater<ComponentMessageItem[]>>;
     showHiddenMessages: () => void;
 };
 export type UseComponentMessagingProps = {

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

@@ -26,10 +26,10 @@ export type UseEditableValueProps<V> = PickedComponentMessagingProps & PickedCon
 };
 export declare function useEditableValue<V>({ ariaDescribedBy, converter, disabled, displayOptions, implicitComponentValidator, labelHint, messagesCustom, readonly, required, requiredMessageDetail, shouldNormalizeValueOnCommit, validators, value: valueProp, addBusyState, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, onTransientValueChanged, wrapValueState }: UseEditableValueProps<V>): {
     value: V;
-    setValue: import("preact/hooks").StateUpdater<V>;
+    setValue: import("preact/hooks").Dispatch<import("preact/hooks").StateUpdater<V>>;
     displayValue: string;
-    setDisplayValue: import("preact/hooks").StateUpdater<string>;
-    setTransientValue: import("preact/hooks").StateUpdater<V>;
+    setDisplayValue: import("preact/hooks").Dispatch<import("preact/hooks").StateUpdater<string>>;
+    setTransientValue: import("preact/hooks").Dispatch<import("preact/hooks").StateUpdater<V>>;
     methods: {
         reset: () => void;
         validate: () => Promise<'valid' | 'invalid'>;
@@ -45,5 +45,6 @@ export declare function useEditableValue<V>({ ariaDescribedBy, converter, disabl
     onCommitValue: (value: V, doCommitOnValid?: boolean) => Promise<ValidationResult>;
     format: (value: V, shouldSuppressError?: boolean) => string | null | undefined;
     normalizeAndParseValue: (value: string) => typeof ConverterErrorSymbol | V | null;
+    validateValueOnExternalChange: (value: V) => ValidationResult;
 };
 export {};

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

@@ -1,7 +1,7 @@
 import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
 import Validator = require('ojs/ojvalidator');
 import AsyncValidator = require('ojs/ojvalidator-async');
-import { StateUpdater } from 'preact/hooks';
+import { Dispatch, StateUpdater } from 'preact/hooks';
 import { ComponentMessagingState } from '../UNSAFE_useComponentMessaging/useComponentMessaging';
 export declare const ValidationResult: {
     readonly VALID: "VALID";
@@ -16,7 +16,7 @@ export type ValidationOptions = {
 };
 export type ValidationState<V> = {
     valid: ValidState;
-    setValid: StateUpdater<ValidState>;
+    setValid: Dispatch<StateUpdater<ValidState>>;
     deferredValidate: (value: V) => void | ComponentMessageItem[];
     fullValidate: (value: V, options?: ValidationOptions) => Promise<boolean>;
     validateValueOnInternalChange: (value: V, options?: ValidationOptions) => Promise<ValidationResult>;

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

@@ -1,4 +1,4 @@
-import { StateUpdater } from 'preact/hooks';
+import { Dispatch, StateUpdater } from 'preact/hooks';
 import { ConverterErrorSymbol } from '../UNSAFE_useConverter/useConverter';
 import { ValidState } from '../UNSAFE_useValidators/useValidators';
 export type ValueState<V> = {
@@ -7,9 +7,9 @@ export type ValueState<V> = {
     value: V;
     getValueForValidation: (valid: ValidState) => V | typeof ConverterErrorSymbol;
     setValueAfterValidation: (value: V) => void;
-    setDisplayValue: StateUpdater<string>;
-    setTransientValue: StateUpdater<V>;
-    setValue: StateUpdater<V>;
+    setDisplayValue: Dispatch<StateUpdater<string>>;
+    setTransientValue: Dispatch<StateUpdater<V>>;
+    setValue: Dispatch<StateUpdater<V>>;
     refreshDisplayValue: () => void;
 };
 export type UseValueProps<V> = {

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

@@ -41,7 +41,6 @@ export interface CFilePickerElement extends JetElement<CFilePickerElementSettabl
     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;
-    _doSelectHelper: (fileList: FileList) => void;
     blur: () => void;
     focus: () => void;
 }

package/oj-c/types/form-layout/form-layout.d.ts

@@ -1,7 +1,7 @@
 import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
 import { GlobalProps } from 'ojs/ojvcomponent';
 import 'ojs/oj-jsx-interfaces';
-import { Component, ComponentProps, ComponentChildren } from 'preact';
+import { ComponentType, ComponentProps, ComponentChildren } from 'preact';
 import { FormLayout as PreactFormLayout } from '@oracle/oraclejet-preact/UNSAFE_FormLayout';
 import { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
 import { ExtendGlobalProps, ObservedGlobalProps } from 'ojs/ojvcomponent';
@@ -20,13 +20,8 @@ type Props = ObservedGlobalProps<'id'> & {
     readonly?: boolean;
     userAssistanceDensity?: PreactFormLayoutProps['userAssistanceDensity'];
 };
-export declare class FormLayout extends Component<ExtendGlobalProps<Props>> {
-    static defaultProps: Partial<Props>;
-    private busyContextRef;
-    private rootRef;
-    componentDidMount(): void;
-    render({ columnSpan, ...props }: ExtendGlobalProps<Props>): import("preact").JSX.Element;
-}
+declare function FormLayoutImpl({ columns, columnSpan, direction, fullWidth, id, maxColumns, ...otherProps }: Props): import("preact").JSX.Element;
+export declare const FormLayout: ComponentType<ExtendGlobalProps<ComponentProps<typeof FormLayoutImpl>>>;
 export type FormLayoutProps = Props;
 export {};
 export interface CFormLayoutElement extends JetElement<CFormLayoutElementSettableProperties>, CFormLayoutElementSettableProperties {

package/oj-c/types/hooks/PRIVATE_useVisData/useVisData.d.ts

@@ -0,0 +1,10 @@
+import { DataProvider } from 'ojs/ojdataprovider';
+type Props<K, D> = {
+    dataProvider?: DataProvider<K, D>;
+    addBusyState: (description: string) => () => void;
+};
+export declare function useVisData<K, D>({ addBusyState, dataProvider }: Props<K, D>): {
+    data: import("@oracle/oraclejet/ojcommontypes").ItemContext<K, D>[];
+    isLoading: boolean;
+};
+export {};

package/oj-c/types/hooks/UNSAFE_useChartData/dataUtil.d.ts

@@ -17,7 +17,7 @@ export type GroupsProps = {
     groups?: GroupsProps[];
     symbol?: symbol;
 } & AreaChartGroupProps;
-declare const createGroupsAndSeries: <K, D>(data: ItemContext<K, D>[], itemTemplate?: TemplateSlot<ChartItemTemplateContext<K, D>> | undefined, seriesTemplate?: TemplateSlot<ChartSeriesTemplateContext<K, D>> | undefined, groupTemplate?: TemplateSlot<ChartGroupTemplateContext<K, D>> | undefined, itemElementName?: string, seriesElementName?: string, groupElementName?: string, seriesComparator?: ((context1: ChartSeriesTemplateContext<K, D>, context2: ChartSeriesTemplateContext<K, D>) => number) | undefined, groupComparator?: ((context1: ChartGroupTemplateContext<K, D>, context2: ChartGroupTemplateContext<K, D>) => number) | undefined) => {
+declare const createGroupsAndSeries: <K, D>(data: ItemContext<K, D>[], itemTemplate?: TemplateSlot<ChartItemTemplateContext<K, D>>, seriesTemplate?: TemplateSlot<ChartSeriesTemplateContext<K, D>>, groupTemplate?: TemplateSlot<ChartGroupTemplateContext<K, D>>, itemElementName?: string, seriesElementName?: string, groupElementName?: string, seriesComparator?: (context1: ChartSeriesTemplateContext<K, D>, context2: ChartSeriesTemplateContext<K, D>) => number, groupComparator?: (context1: ChartGroupTemplateContext<K, D>, context2: ChartGroupTemplateContext<K, D>) => number) => {
     groups: (Record<string, any> | {
         drilling: any;
         name: any;

package/oj-c/types/hooks/UNSAFE_useChartData/useChartData.d.ts

@@ -40,4 +40,5 @@ export declare function useChartData<K, D>(dataProvider: ArrayDataProvider<K, D>
         accessibleLabel: any;
     })[];
     getDataItem: (seriesIndex: number, groupIndex: number) => any;
+    isLoading: boolean;
 };

package/oj-c/types/hooks/UNSAFE_useEditableValue/converterUtils.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import type { Converter } from './types';
+type ConversionSuccess<T> = {
+    result: 'success';
+    value: T;
+};
+type ConversionFailure = {
+    result: 'failure';
+    error: ComponentMessageItem;
+};
+type ConversionResult<T> = ConversionFailure | ConversionSuccess<T>;
+declare function parse<V, DV>(displayValue: DV, converter: Converter<V, DV>): ConversionResult<V>;
+declare function format<V, DV>(value: V, defaultValue: DV, converter: Converter<V, DV>): ConversionResult<DV>;
+export { format, parse };

package/oj-c/types/hooks/UNSAFE_useEditableValue/index.d.ts

@@ -0,0 +1,2 @@
+export { Converter, ValidState } from './types';
+export { useEditableValue } from './useEditableValue';