@oracle/oraclejet-core-pack 16.1.3 → 17.0.0

package/oj-c/types/buttonset-multiple/buttonset-multiple.d.ts

@@ -0,0 +1,95 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged } from 'ojs/ojvcomponent';
+import { ButtonSetMultiple as PreactButtonSetMultiple } from '@oracle/oraclejet-preact/UNSAFE_ButtonSetMultiple';
+import { type ToggleItem } from 'oj-c/utils/PRIVATE_toggleUtils/index';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+export type { ToggleItem } from 'oj-c/utils/PRIVATE_toggleUtils/toggleTypes';
+import { ComponentProps, Component } from 'preact';
+import 'css!oj-c/buttonset-multiple/buttonset-multiple-styles.css';
+export type PreactButtonSetMultipleProps = ComponentProps<typeof PreactButtonSetMultiple>;
+type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label'> & {
+    value?: string[];
+    onValueChanged?: PropertyChanged<string[] | undefined>;
+    items?: ToggleItem[];
+    display?: 'all' | 'icons' | 'label';
+    disabled?: boolean;
+    size?: PreactButtonSetMultipleProps['size'];
+    width?: Size;
+    maxWidth?: Size;
+    chroming?: PreactButtonSetMultipleProps['variant'];
+    layoutWidth?: PreactButtonSetMultipleProps['layoutWidth'];
+};
+export declare class ButtonsetMultiple extends Component<ExtendGlobalProps<Props>> {
+    static defaultProps: Partial<Props>;
+    private buttonRef;
+    render({ chroming, disabled, value, onValueChanged, size, width, maxWidth, layoutWidth, items, display, 'aria-label': accessibleLabel, 'aria-describedby': ariaDescribedBy }: ExtendGlobalProps<Props>): import("preact").JSX.Element;
+    blur(): void;
+    focus(): void;
+}
+export interface CButtonsetMultipleElement extends JetElement<CButtonsetMultipleElementSettableProperties>, CButtonsetMultipleElementSettableProperties {
+    addEventListener<T extends keyof CButtonsetMultipleElementEventMap>(type: T, listener: (this: HTMLElement, ev: CButtonsetMultipleElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CButtonsetMultipleElementSettableProperties>(property: T): CButtonsetMultipleElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CButtonsetMultipleElementSettableProperties>(property: T, value: CButtonsetMultipleElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CButtonsetMultipleElementSettableProperties>): void;
+    setProperties(properties: CButtonsetMultipleElementSettablePropertiesLenient): void;
+    blur: ButtonsetMultiple['blur'];
+    focus: ButtonsetMultiple['focus'];
+}
+export namespace CButtonsetMultipleElement {
+    type chromingChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['chroming']>;
+    type disabledChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['disabled']>;
+    type displayChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['display']>;
+    type itemsChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['items']>;
+    type layoutWidthChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['layoutWidth']>;
+    type maxWidthChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['maxWidth']>;
+    type sizeChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['size']>;
+    type valueChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['value']>;
+    type widthChanged = JetElementCustomEventStrict<CButtonsetMultipleElement['width']>;
+}
+export interface CButtonsetMultipleElementEventMap extends HTMLElementEventMap {
+    'chromingChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['chroming']>;
+    'disabledChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['disabled']>;
+    'displayChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['display']>;
+    'itemsChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['items']>;
+    'layoutWidthChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['layoutWidth']>;
+    'maxWidthChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['maxWidth']>;
+    'sizeChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['size']>;
+    'valueChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['value']>;
+    'widthChanged': JetElementCustomEventStrict<CButtonsetMultipleElement['width']>;
+}
+export interface CButtonsetMultipleElementSettableProperties extends JetSettableProperties {
+    chroming?: Props['chroming'];
+    disabled?: Props['disabled'];
+    display?: Props['display'];
+    items?: Props['items'];
+    layoutWidth?: Props['layoutWidth'];
+    maxWidth?: Props['maxWidth'];
+    size?: Props['size'];
+    value?: Props['value'];
+    width?: Props['width'];
+}
+export interface CButtonsetMultipleElementSettablePropertiesLenient extends Partial<CButtonsetMultipleElementSettableProperties> {
+    [key: string]: any;
+}
+export interface ButtonsetMultipleIntrinsicProps extends Partial<Readonly<CButtonsetMultipleElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    onchromingChanged?: (value: CButtonsetMultipleElementEventMap['chromingChanged']) => void;
+    ondisabledChanged?: (value: CButtonsetMultipleElementEventMap['disabledChanged']) => void;
+    ondisplayChanged?: (value: CButtonsetMultipleElementEventMap['displayChanged']) => void;
+    onitemsChanged?: (value: CButtonsetMultipleElementEventMap['itemsChanged']) => void;
+    onlayoutWidthChanged?: (value: CButtonsetMultipleElementEventMap['layoutWidthChanged']) => void;
+    onmaxWidthChanged?: (value: CButtonsetMultipleElementEventMap['maxWidthChanged']) => void;
+    onsizeChanged?: (value: CButtonsetMultipleElementEventMap['sizeChanged']) => void;
+    onvalueChanged?: (value: CButtonsetMultipleElementEventMap['valueChanged']) => void;
+    onwidthChanged?: (value: CButtonsetMultipleElementEventMap['widthChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-buttonset-multiple': ButtonsetMultipleIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/buttonset-multiple/index.d.ts

@@ -0,0 +1,2 @@
+export { ButtonsetMultiple, ToggleItem } from './buttonset-multiple';
+export { CButtonsetMultipleElement } from './buttonset-multiple';

package/oj-c/types/buttonset-single/buttonset-single.d.ts

@@ -0,0 +1,95 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged } from 'ojs/ojvcomponent';
+import { ButtonSetSingle as PreactButtonSetSingle } from '@oracle/oraclejet-preact/UNSAFE_ButtonSetSingle';
+import { type ToggleItem } from 'oj-c/utils/PRIVATE_toggleUtils/index';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+export type { ToggleItem } from 'oj-c/utils/PRIVATE_toggleUtils';
+import { ComponentProps, Component } from 'preact';
+import 'css!oj-c/buttonset-single/buttonset-single-styles.css';
+export type PreactButtonSetSingleProps = ComponentProps<typeof PreactButtonSetSingle>;
+type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label'> & {
+    value?: string;
+    onValueChanged?: PropertyChanged<string | undefined>;
+    items?: ToggleItem[];
+    display?: 'all' | 'icons' | 'label';
+    disabled?: boolean;
+    size?: PreactButtonSetSingleProps['size'];
+    width?: Size;
+    maxWidth?: Size;
+    chroming?: PreactButtonSetSingleProps['variant'];
+    layoutWidth?: PreactButtonSetSingleProps['layoutWidth'];
+};
+export declare class ButtonsetSingle extends Component<ExtendGlobalProps<Props>> {
+    static defaultProps: Partial<Props>;
+    private buttonRef;
+    render({ chroming, disabled, value, onValueChanged, size, items, width, maxWidth, layoutWidth, display, 'aria-label': accessibleLabel, 'aria-describedby': ariaDescribedBy }: ExtendGlobalProps<Props>): import("preact").JSX.Element;
+    blur(): void;
+    focus(): void;
+}
+export interface CButtonsetSingleElement extends JetElement<CButtonsetSingleElementSettableProperties>, CButtonsetSingleElementSettableProperties {
+    addEventListener<T extends keyof CButtonsetSingleElementEventMap>(type: T, listener: (this: HTMLElement, ev: CButtonsetSingleElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CButtonsetSingleElementSettableProperties>(property: T): CButtonsetSingleElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CButtonsetSingleElementSettableProperties>(property: T, value: CButtonsetSingleElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CButtonsetSingleElementSettableProperties>): void;
+    setProperties(properties: CButtonsetSingleElementSettablePropertiesLenient): void;
+    blur: ButtonsetSingle['blur'];
+    focus: ButtonsetSingle['focus'];
+}
+export namespace CButtonsetSingleElement {
+    type chromingChanged = JetElementCustomEventStrict<CButtonsetSingleElement['chroming']>;
+    type disabledChanged = JetElementCustomEventStrict<CButtonsetSingleElement['disabled']>;
+    type displayChanged = JetElementCustomEventStrict<CButtonsetSingleElement['display']>;
+    type itemsChanged = JetElementCustomEventStrict<CButtonsetSingleElement['items']>;
+    type layoutWidthChanged = JetElementCustomEventStrict<CButtonsetSingleElement['layoutWidth']>;
+    type maxWidthChanged = JetElementCustomEventStrict<CButtonsetSingleElement['maxWidth']>;
+    type sizeChanged = JetElementCustomEventStrict<CButtonsetSingleElement['size']>;
+    type valueChanged = JetElementCustomEventStrict<CButtonsetSingleElement['value']>;
+    type widthChanged = JetElementCustomEventStrict<CButtonsetSingleElement['width']>;
+}
+export interface CButtonsetSingleElementEventMap extends HTMLElementEventMap {
+    'chromingChanged': JetElementCustomEventStrict<CButtonsetSingleElement['chroming']>;
+    'disabledChanged': JetElementCustomEventStrict<CButtonsetSingleElement['disabled']>;
+    'displayChanged': JetElementCustomEventStrict<CButtonsetSingleElement['display']>;
+    'itemsChanged': JetElementCustomEventStrict<CButtonsetSingleElement['items']>;
+    'layoutWidthChanged': JetElementCustomEventStrict<CButtonsetSingleElement['layoutWidth']>;
+    'maxWidthChanged': JetElementCustomEventStrict<CButtonsetSingleElement['maxWidth']>;
+    'sizeChanged': JetElementCustomEventStrict<CButtonsetSingleElement['size']>;
+    'valueChanged': JetElementCustomEventStrict<CButtonsetSingleElement['value']>;
+    'widthChanged': JetElementCustomEventStrict<CButtonsetSingleElement['width']>;
+}
+export interface CButtonsetSingleElementSettableProperties extends JetSettableProperties {
+    chroming?: Props['chroming'];
+    disabled?: Props['disabled'];
+    display?: Props['display'];
+    items?: Props['items'];
+    layoutWidth?: Props['layoutWidth'];
+    maxWidth?: Props['maxWidth'];
+    size?: Props['size'];
+    value?: Props['value'];
+    width?: Props['width'];
+}
+export interface CButtonsetSingleElementSettablePropertiesLenient extends Partial<CButtonsetSingleElementSettableProperties> {
+    [key: string]: any;
+}
+export interface ButtonsetSingleIntrinsicProps extends Partial<Readonly<CButtonsetSingleElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    onchromingChanged?: (value: CButtonsetSingleElementEventMap['chromingChanged']) => void;
+    ondisabledChanged?: (value: CButtonsetSingleElementEventMap['disabledChanged']) => void;
+    ondisplayChanged?: (value: CButtonsetSingleElementEventMap['displayChanged']) => void;
+    onitemsChanged?: (value: CButtonsetSingleElementEventMap['itemsChanged']) => void;
+    onlayoutWidthChanged?: (value: CButtonsetSingleElementEventMap['layoutWidthChanged']) => void;
+    onmaxWidthChanged?: (value: CButtonsetSingleElementEventMap['maxWidthChanged']) => void;
+    onsizeChanged?: (value: CButtonsetSingleElementEventMap['sizeChanged']) => void;
+    onvalueChanged?: (value: CButtonsetSingleElementEventMap['valueChanged']) => void;
+    onwidthChanged?: (value: CButtonsetSingleElementEventMap['widthChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-buttonset-single': ButtonsetSingleIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/buttonset-single/index.d.ts

@@ -0,0 +1,2 @@
+export { ButtonsetSingle, ToggleItem } from './buttonset-single';
+export { CButtonsetSingleElement } from './buttonset-single';

package/oj-c/types/card-view/card-view.d.ts

@@ -0,0 +1,120 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ComponentProps, ComponentType } from 'preact';
+import { DataProvider, Item } from 'ojs/ojdataprovider';
+import { ImmutableKeySet } from 'ojs/ojkeyset';
+import { Action, ExtendGlobalProps, ObservedGlobalProps, ReadOnlyPropertyChanged, TemplateSlot, PropertyChanged } from 'ojs/ojvcomponent';
+import { CardGridView as PreactCardGridView } from '@oracle/oraclejet-preact/UNSAFE_CardGridView';
+import 'css!oj-c/card-view/card-view-styles.css';
+type PreactCardViewProps = ComponentProps<typeof PreactCardGridView>;
+export type ListItemContext<K, D> = {
+    data: D;
+    item: Item<K, D>;
+    isTabbable?: boolean;
+};
+export type ReorderDetail<K> = {
+    reorderedKeys: Array<K>;
+    itemKeys: Array<K>;
+    referenceKey: K | null;
+};
+type Props<K extends string | number, D> = ObservedGlobalProps<'aria-label' | 'aria-labelledby' | 'id'> & {
+    onCurrentItemChanged?: ReadOnlyPropertyChanged<K>;
+    data?: DataProvider<K, D> | null;
+    gutterSize?: PreactCardViewProps['gutterSize'];
+    noData?: TemplateSlot<any>;
+    scrollPolicyOptions?: {
+        fetchSize?: number;
+        scroller?: string;
+    };
+    selected?: ImmutableKeySet<K>;
+    itemTemplate?: TemplateSlot<ListItemContext<K, D>>;
+    onSelectedChanged?: PropertyChanged<ImmutableKeySet<K>>;
+    selectionMode?: PreactCardViewProps['selectionMode'];
+    initialAnimation?: PreactCardViewProps['initialAnimation'];
+    focusBehavior?: PreactCardViewProps['focusBehavior'];
+    columns?: PreactCardViewProps['columns'] | 'auto';
+    reorderable?: {
+        items?: 'enabled' | 'disabled';
+    };
+    onOjReorder?: Action<ReorderDetail<K>>;
+};
+declare const CardViewImpl: <K extends string | number, D>({ columns, data, focusBehavior, gutterSize, initialAnimation, scrollPolicyOptions, selectionMode, reorderable, ...rest }: Props<K, D>) => import("preact").JSX.Element;
+export declare const CardView: ComponentType<ExtendGlobalProps<ComponentProps<typeof CardViewImpl<string | number, any>>>>;
+export type CardViewProps<K extends string | number, D> = Props<K, D>;
+export {};
+export interface CCardViewElement<K extends string | number, D> extends JetElement<CCardViewElementSettableProperties<K, D>>, CCardViewElementSettableProperties<K, D> {
+    readonly currentItem?: Parameters<Required<Props<K, D>>['onCurrentItemChanged']>[0];
+    addEventListener<T extends keyof CCardViewElementEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: CCardViewElementEventMap<K, D>[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CCardViewElementSettableProperties<K, D>>(property: T): CCardViewElement<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CCardViewElementSettableProperties<K, D>>(property: T, value: CCardViewElementSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CCardViewElementSettableProperties<K, D>>): void;
+    setProperties(properties: CCardViewElementSettablePropertiesLenient<K, D>): void;
+}
+export namespace CCardViewElement {
+    interface ojReorder<K extends string | number> extends CustomEvent<ReorderDetail<K> & {}> {
+    }
+    type columnsChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['columns']>;
+    type currentItemChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['currentItem']>;
+    type dataChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['data']>;
+    type focusBehaviorChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['focusBehavior']>;
+    type gutterSizeChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['gutterSize']>;
+    type initialAnimationChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['initialAnimation']>;
+    type reorderableChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['reorderable']>;
+    type scrollPolicyOptionsChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['scrollPolicyOptions']>;
+    type selectedChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['selected']>;
+    type selectionModeChanged<K extends string | number, D> = JetElementCustomEventStrict<CCardViewElement<K, D>['selectionMode']>;
+    type RenderNoDataTemplate = import('ojs/ojvcomponent').TemplateSlot<{}>;
+    type RenderItemTemplate<K extends string | number, D> = import('ojs/ojvcomponent').TemplateSlot<ListItemContext<K, D>>;
+}
+export interface CCardViewElementEventMap<K extends string | number, D> extends HTMLElementEventMap {
+    'ojReorder': CCardViewElement.ojReorder<K>;
+    'columnsChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['columns']>;
+    'currentItemChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['currentItem']>;
+    'dataChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['data']>;
+    'focusBehaviorChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['focusBehavior']>;
+    'gutterSizeChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['gutterSize']>;
+    'initialAnimationChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['initialAnimation']>;
+    'reorderableChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['reorderable']>;
+    'scrollPolicyOptionsChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['scrollPolicyOptions']>;
+    'selectedChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['selected']>;
+    'selectionModeChanged': JetElementCustomEventStrict<CCardViewElement<K, D>['selectionMode']>;
+}
+export interface CCardViewElementSettableProperties<K extends string | number, D> extends JetSettableProperties {
+    columns?: Props<K, D>['columns'];
+    data?: Props<K, D>['data'];
+    focusBehavior?: Props<K, D>['focusBehavior'];
+    gutterSize?: Props<K, D>['gutterSize'];
+    initialAnimation?: Props<K, D>['initialAnimation'];
+    reorderable?: Props<K, D>['reorderable'];
+    scrollPolicyOptions?: Props<K, D>['scrollPolicyOptions'];
+    selected?: Props<K, D>['selected'];
+    selectionMode?: Props<K, D>['selectionMode'];
+}
+export interface CCardViewElementSettablePropertiesLenient<K extends string | number, D> extends Partial<CCardViewElementSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface CardViewIntrinsicProps extends Partial<Readonly<CCardViewElementSettableProperties<any, any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    currentItem?: never;
+    children?: import('preact').ComponentChildren;
+    onojReorder?: (value: CCardViewElementEventMap<any, any>['ojReorder']) => void;
+    oncolumnsChanged?: (value: CCardViewElementEventMap<any, any>['columnsChanged']) => void;
+    oncurrentItemChanged?: (value: CCardViewElementEventMap<any, any>['currentItemChanged']) => void;
+    ondataChanged?: (value: CCardViewElementEventMap<any, any>['dataChanged']) => void;
+    onfocusBehaviorChanged?: (value: CCardViewElementEventMap<any, any>['focusBehaviorChanged']) => void;
+    ongutterSizeChanged?: (value: CCardViewElementEventMap<any, any>['gutterSizeChanged']) => void;
+    oninitialAnimationChanged?: (value: CCardViewElementEventMap<any, any>['initialAnimationChanged']) => void;
+    onreorderableChanged?: (value: CCardViewElementEventMap<any, any>['reorderableChanged']) => void;
+    onscrollPolicyOptionsChanged?: (value: CCardViewElementEventMap<any, any>['scrollPolicyOptionsChanged']) => void;
+    onselectedChanged?: (value: CCardViewElementEventMap<any, any>['selectedChanged']) => void;
+    onselectionModeChanged?: (value: CCardViewElementEventMap<any, any>['selectionModeChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-card-view': CardViewIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/card-view/cardViewItem.d.ts

@@ -0,0 +1,9 @@
+import { ListItemContext as PreactListItemContext } from '@oracle/oraclejet-preact/UNSAFE_Collection';
+import { CardViewProps } from './card-view';
+import { Item } from 'ojs/ojdataprovider';
+type CardViewItemProps<K extends string | number, D> = {
+    context: PreactListItemContext<K, Item<K, D>>;
+    itemTemplate: CardViewProps<K, D>['itemTemplate'];
+};
+export declare const CardViewItem: <K extends string | number, D>({ context, itemTemplate }: CardViewItemProps<K, D>) => import("preact").JSX.Element;
+export {};

package/oj-c/types/card-view/index.d.ts

@@ -0,0 +1,2 @@
+export { CardView } from './card-view';
+export { CCardViewElement } from './card-view';

package/oj-c/types/card-view/useCardViewPreact.d.ts

@@ -0,0 +1,25 @@
+import { CurrentKeyDetail, SelectionDetail } from '@oracle/oraclejet-preact/UNSAFE_Collection';
+import { CardViewProps } from './card-view';
+export declare const useCardViewPreact: <K extends string | number, D>({ "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, data: propData, gutterSize, focusBehavior, onCurrentItemChanged, selected, onSelectedChanged, scrollPolicyOptions, selectionMode, initialAnimation, columns: corePackColumns, reorderable, onOjReorder }: Partial<CardViewProps<K, D>>, addBusyState: (desc?: string) => () => void, isClickthroughDisabled: (target: EventTarget | null) => boolean) => {
+    status: "error" | "loading" | "success";
+    cardViewProps: {
+        data: unknown[] | null;
+        onLoadMore?: (() => void) | undefined;
+        hasMore?: boolean | undefined;
+        getRowKey: (data: unknown) => string | number;
+        children: (context: import("@oracle/oraclejet-preact/UNSAFE_Collection").ListItemRendererContext<string | number, unknown>) => import("preact").ComponentChildren;
+        currentKey?: string | number | undefined;
+        onCurrentKeyChange?: ((detail: CurrentKeyDetail<string | number>) => void) | undefined;
+        selectionMode?: "none" | "multiple" | "single" | undefined;
+        selectedKeys?: import("@oracle/oraclejet-preact/utils/UNSAFE_keys").Keys<string | number> | undefined;
+        onSelectionChange?: ((detail: SelectionDetail<string | number>) => void) | undefined;
+        viewportConfig?: import("@oracle/oraclejet-preact/hooks/UNSAFE_useViewportIntersect").ViewportConfig | undefined;
+        focusBehavior?: "content" | "card" | undefined;
+        'aria-label'?: string | undefined;
+        'aria-labelledby'?: string | undefined;
+        initialAnimation?: "slideUp" | "slideDown" | undefined;
+        gutterSize?: ("xs" | "sm" | "md" | "lg" | "xl") | undefined;
+    } & import("@oracle/oraclejet-preact/UNSAFE_Collection/Reorderable.types").ReorderProps<string | number> & {
+        columns: number;
+    };
+};

package/oj-c/types/checkbox/checkbox.d.ts

@@ -1,22 +1,20 @@
 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 { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
+import { ComponentType, ComponentProps, ComponentChildren } from 'preact';
 import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
 import { Checkbox as PreactCheckbox } from '@oracle/oraclejet-preact/UNSAFE_Checkbox';
+import { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
 import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
 import 'css!oj-c/checkbox/checkbox-styles.css';
 type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
 type PreactCheckboxProps = ComponentProps<typeof PreactCheckbox>;
-type Props = ObservedGlobalProps<'aria-describedby' | 'id'> & {
+type CheckboxProps = ObservedGlobalProps<'aria-describedby' | 'id'> & {
     children: ComponentChildren;
     containerReadonly?: boolean;
     columnSpan?: LayoutColumnSpan;
     disabled?: boolean;
-    displayOptions?: {
-        messages: DisplayOptions['messages'];
-    };
+    displayOptions?: Pick<DisplayOptions, 'messages'>;
     help?: Help;
     helpHints?: HelpHints;
     messagesCustom?: PreactCheckboxProps['messages'];
@@ -29,24 +27,10 @@ type Props = ObservedGlobalProps<'aria-describedby' | 'id'> & {
     onValueChanged?: PropertyChanged<boolean | undefined>;
     value?: boolean;
 };
-declare class Checkbox extends Component<ExtendGlobalProps<Props>> {
-    static defaultProps: Partial<Props>;
-    private busyContextRef;
-    private checkboxRef;
-    private rootRef;
-    componentDidMount(): void;
-    render(props: ExtendGlobalProps<Props>): import("preact").JSX.Element;
-    componentWillUnmount(): void;
-    reset(): void;
-    showMessages(): void;
-    validate(): Promise<ValidState>;
-    blur(): void;
-    focus(): void;
-}
+declare const Checkbox: ComponentType<ExtendGlobalProps<CheckboxProps>>;
 export { Checkbox };
-export type { Props as CheckboxProps };
 export interface CCheckboxElement extends JetElement<CCheckboxElementSettableProperties>, CCheckboxElementSettableProperties {
-    readonly valid?: Parameters<Required<Props>['onValidChanged']>[0];
+    readonly valid?: Parameters<Required<CheckboxProps>['onValidChanged']>[0];
     addEventListener<T extends keyof CCheckboxElementEventMap>(type: T, listener: (this: HTMLElement, ev: CCheckboxElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
     getProperty<T extends keyof CCheckboxElementSettableProperties>(property: T): CCheckboxElement[T];
@@ -54,11 +38,11 @@ export interface CCheckboxElement extends JetElement<CCheckboxElementSettablePro
     setProperty<T extends keyof CCheckboxElementSettableProperties>(property: T, value: CCheckboxElementSettableProperties[T]): void;
     setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CCheckboxElementSettableProperties>): void;
     setProperties(properties: CCheckboxElementSettablePropertiesLenient): void;
-    blur: Checkbox['blur'];
-    focus: Checkbox['focus'];
-    reset: Checkbox['reset'];
-    showMessages: Checkbox['showMessages'];
-    validate: Checkbox['validate'];
+    blur: () => void;
+    focus: () => void;
+    reset: () => void;
+    showMessages: () => void;
+    validate: () => Promise<'invalid' | 'valid'>;
 }
 export namespace CCheckboxElement {
     type columnSpanChanged = JetElementCustomEventStrict<CCheckboxElement['columnSpan']>;
@@ -91,18 +75,18 @@ export interface CCheckboxElementEventMap extends HTMLElementEventMap {
     'valueChanged': JetElementCustomEventStrict<CCheckboxElement['value']>;
 }
 export interface CCheckboxElementSettableProperties extends JetSettableProperties {
-    columnSpan?: Props['columnSpan'];
-    containerReadonly?: Props['containerReadonly'];
-    disabled?: Props['disabled'];
-    displayOptions?: Props['displayOptions'];
-    help?: Props['help'];
-    helpHints?: Props['helpHints'];
-    messagesCustom?: Props['messagesCustom'];
-    readonly?: Props['readonly'];
-    required?: Props['required'];
-    requiredMessageDetail?: Props['requiredMessageDetail'];
-    userAssistanceDensity?: Props['userAssistanceDensity'];
-    value?: Props['value'];
+    columnSpan?: CheckboxProps['columnSpan'];
+    containerReadonly?: CheckboxProps['containerReadonly'];
+    disabled?: CheckboxProps['disabled'];
+    displayOptions?: CheckboxProps['displayOptions'];
+    help?: CheckboxProps['help'];
+    helpHints?: CheckboxProps['helpHints'];
+    messagesCustom?: CheckboxProps['messagesCustom'];
+    readonly?: CheckboxProps['readonly'];
+    required?: CheckboxProps['required'];
+    requiredMessageDetail?: CheckboxProps['requiredMessageDetail'];
+    userAssistanceDensity?: CheckboxProps['userAssistanceDensity'];
+    value?: CheckboxProps['value'];
 }
 export interface CCheckboxElementSettablePropertiesLenient extends Partial<CCheckboxElementSettableProperties> {
     [key: string]: any;

package/oj-c/types/checkbox/useCheckboxPreact.d.ts

@@ -5,13 +5,13 @@ import Validator = require('ojs/ojvalidator');
 type CheckboxProps = ComponentProps<typeof Checkbox> & {
     validators?: Validator<boolean>[];
 };
-export declare function useCheckboxPreact({ ['aria-describedby']: ariaDescribedBy, disabled, displayOptions, messagesCustom, readonly, requiredMessageDetail: propRequiredMessageDetail, required, userAssistanceDensity, value: propValue, onMessagesCustomChanged, onValidChanged, onValueChanged, validators }: Omit<CheckboxProps, 'children'>, addBusyState: (desc?: string) => () => void): {
+export declare function useCheckboxPreact({ ['aria-describedby']: ariaDescribedBy, disabled, displayOptions, messagesCustom, readonly, requiredMessageDetail, required, userAssistanceDensity, value: propValue, onMessagesCustomChanged, onValidChanged, onValueChanged, validators }: Omit<CheckboxProps, 'children'>, addBusyState: (desc?: string) => () => void): {
     methods: {
         reset: () => void;
         validate: () => Promise<"invalid" | "valid">;
         showMessages: () => void;
     };
-    checkboxProps: Omit<{
+    checkboxProps: import("preact/compat").PropsWithoutRef<{
         'aria-describedby'?: string | undefined;
         assistiveText?: string | undefined;
         children: import("preact").ComponentChildren;
@@ -25,7 +25,7 @@ export declare function useCheckboxPreact({ ['aria-describedby']: ariaDescribedB
         onCommit: (detail: ValueUpdateDetail<boolean>) => void;
         userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
         value?: boolean | undefined;
-    }, "ref"> & {
+    } & import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps> & {
         ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
     };
 };

package/oj-c/types/checkboxset/checkboxset.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 } from 'preact';
+import { ComponentProps } from 'preact';
 import { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
 import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
 import { DataProvider } from 'ojs/ojdataprovider';
@@ -9,6 +9,7 @@ import { CheckboxSet as PreactCheckboxSet } from '@oracle/oraclejet-preact/UNSAF
 import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
 import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
 import 'css!oj-c/checkboxset/checkboxset-styles.css';
+import { ComponentType } from 'preact';
 type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
 type PreactCheckboxSetProps = ComponentProps<typeof PreactCheckboxSet>;
 type CheckboxsetArrayDataItem<V extends string | number> = CheckboxsetDataItem & {
@@ -20,7 +21,7 @@ type CheckboxsetDataItem = {
     helpSourceLink?: string;
     helpSourceText?: string;
 };
-type Props<V extends string | number, D extends CheckboxsetDataItem> = ObservedGlobalProps<'aria-describedby' | 'id'> & {
+type CheckboxsetProps<V extends string | number, D extends CheckboxsetDataItem> = ObservedGlobalProps<'aria-describedby' | 'id'> & {
     containerReadonly?: boolean;
     columnSpan?: LayoutColumnSpan;
     disabled?: boolean;
@@ -43,24 +44,11 @@ type Props<V extends string | number, D extends CheckboxsetDataItem> = ObservedG
     onValueChanged?: PropertyChanged<Array<V> | null | undefined>;
     value?: Array<V> | null;
 };
-declare class Checkboxset<V extends string | number, D extends CheckboxsetDataItem> extends Component<ExtendGlobalProps<Props<V, D>>> {
-    static defaultProps: Partial<Props<string | number, CheckboxsetDataItem>>;
-    private busyContextRef;
-    private checkboxSetRef;
-    private rootRef;
-    componentDidMount(): void;
-    render(props: ExtendGlobalProps<Props<V, D>>): import("preact").JSX.Element;
-    componentWillUnmount(): void;
-    reset(): void;
-    showMessages(): void;
-    validate(): Promise<ValidState>;
-    blur(): void;
-    focus(): void;
-}
+declare const Checkboxset: ComponentType<ExtendGlobalProps<CheckboxsetProps<string | number, CheckboxsetDataItem>>>;
 export { Checkboxset };
-export type { Props as CheckboxsetProps, CheckboxsetArrayDataItem, CheckboxsetDataItem };
+export type { CheckboxsetDataItem, CheckboxsetArrayDataItem };
 export interface CCheckboxsetElement<V extends string | number, D extends CheckboxsetDataItem> extends JetElement<CCheckboxsetElementSettableProperties<V, D>>, CCheckboxsetElementSettableProperties<V, D> {
-    readonly valid?: Parameters<Required<Props<V, D>>['onValidChanged']>[0];
+    readonly valid?: Parameters<Required<CheckboxsetProps<V, D>>['onValidChanged']>[0];
     addEventListener<T extends keyof CCheckboxsetElementEventMap<V, D>>(type: T, listener: (this: HTMLElement, ev: CCheckboxsetElementEventMap<V, D>[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
     getProperty<T extends keyof CCheckboxsetElementSettableProperties<V, D>>(property: T): CCheckboxsetElement<V, D>[T];
@@ -68,11 +56,11 @@ export interface CCheckboxsetElement<V extends string | number, D extends Checkb
     setProperty<T extends keyof CCheckboxsetElementSettableProperties<V, D>>(property: T, value: CCheckboxsetElementSettableProperties<V, D>[T]): void;
     setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CCheckboxsetElementSettableProperties<V, D>>): void;
     setProperties(properties: CCheckboxsetElementSettablePropertiesLenient<V, D>): void;
-    blur: Checkboxset<V, D>['blur'];
-    focus: Checkboxset<V, D>['focus'];
-    reset: Checkboxset<V, D>['reset'];
-    showMessages: Checkboxset<V, D>['showMessages'];
-    validate: Checkboxset<V, D>['validate'];
+    blur: () => void;
+    focus: () => void;
+    reset: () => void;
+    showMessages: () => void;
+    validate: () => Promise<'invalid' | 'valid'>;
 }
 export namespace CCheckboxsetElement {
     type columnSpanChanged<V extends string | number, D extends CheckboxsetDataItem> = JetElementCustomEventStrict<CCheckboxsetElement<V, D>['columnSpan']>;
@@ -117,24 +105,24 @@ export interface CCheckboxsetElementEventMap<V extends string | number, D extend
     'valueChanged': JetElementCustomEventStrict<CCheckboxsetElement<V, D>['value']>;
 }
 export interface CCheckboxsetElementSettableProperties<V extends string | number, D extends CheckboxsetDataItem> extends JetSettableProperties {
-    columnSpan?: Props<V, D>['columnSpan'];
-    containerReadonly?: Props<V, D>['containerReadonly'];
-    direction?: Props<V, D>['direction'];
-    disabled?: Props<V, D>['disabled'];
-    displayOptions?: Props<V, D>['displayOptions'];
-    help?: Props<V, D>['help'];
-    helpHints?: Props<V, D>['helpHints'];
-    labelEdge?: Props<V, D>['labelEdge'];
-    labelHint: Props<V, D>['labelHint'];
-    labelStartWidth?: Props<V, D>['labelStartWidth'];
-    labelWrapping?: Props<V, D>['labelWrapping'];
-    messagesCustom?: Props<V, D>['messagesCustom'];
-    options: Props<V, D>['options'];
-    readonly?: Props<V, D>['readonly'];
-    required?: Props<V, D>['required'];
-    requiredMessageDetail?: Props<V, D>['requiredMessageDetail'];
-    userAssistanceDensity?: Props<V, D>['userAssistanceDensity'];
-    value?: Props<V, D>['value'];
+    columnSpan?: CheckboxsetProps<V, D>['columnSpan'];
+    containerReadonly?: CheckboxsetProps<V, D>['containerReadonly'];
+    direction?: CheckboxsetProps<V, D>['direction'];
+    disabled?: CheckboxsetProps<V, D>['disabled'];
+    displayOptions?: CheckboxsetProps<V, D>['displayOptions'];
+    help?: CheckboxsetProps<V, D>['help'];
+    helpHints?: CheckboxsetProps<V, D>['helpHints'];
+    labelEdge?: CheckboxsetProps<V, D>['labelEdge'];
+    labelHint: CheckboxsetProps<V, D>['labelHint'];
+    labelStartWidth?: CheckboxsetProps<V, D>['labelStartWidth'];
+    labelWrapping?: CheckboxsetProps<V, D>['labelWrapping'];
+    messagesCustom?: CheckboxsetProps<V, D>['messagesCustom'];
+    options: CheckboxsetProps<V, D>['options'];
+    readonly?: CheckboxsetProps<V, D>['readonly'];
+    required?: CheckboxsetProps<V, D>['required'];
+    requiredMessageDetail?: CheckboxsetProps<V, D>['requiredMessageDetail'];
+    userAssistanceDensity?: CheckboxsetProps<V, D>['userAssistanceDensity'];
+    value?: CheckboxsetProps<V, D>['value'];
 }
 export interface CCheckboxsetElementSettablePropertiesLenient<V extends string | number, D extends CheckboxsetDataItem> extends Partial<CCheckboxsetElementSettableProperties<V, D>> {
     [key: string]: any;

package/oj-c/types/checkboxset/useCheckboxsetPreact.d.ts

@@ -8,7 +8,7 @@ export declare function useCheckboxsetPreact({ 'aria-describedby': ariaDescribed
         validate: () => Promise<"invalid" | "valid">;
         showMessages: () => void;
     };
-    checkboxsetProps: Omit<{
+    checkboxsetProps: import("preact/compat").PropsWithoutRef<{
         'aria-describedby'?: string | undefined;
         assistiveText?: string | undefined;
         children: import("preact").ComponentChildren;
@@ -26,7 +26,7 @@ export declare function useCheckboxsetPreact({ 'aria-describedby': ariaDescribed
         onCommit: (detail: ValueUpdateDetail<Set<string | number>>) => void;
         userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
         value?: Set<string | number> | undefined;
-    }, "ref"> & {
+    } & import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps> & {
         ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
     };
 };