@oracle/oraclejet-core-pack 16.1.3 → 17.0.0

package/oj-c/types/select-single/useSyncValueAndValueItem.d.ts

@@ -1,17 +1,20 @@
+import { ValidationResult } from 'oj-c/editable-value/UNSAFE_useValidators/useValidators';
 import { Optional } from 'oj-c/select-common/utils/utils';
 import { ItemContext } from 'ojs/ojcommontypes';
 import { DataProvider } from 'ojs/ojdataprovider';
-import { StateUpdater } from 'preact/hooks';
+import { Dispatch, StateUpdater } from 'preact/hooks';
 type Value<K> = Optional<K>;
 type ValueItem<K, D> = Optional<ItemContext<K, D>>;
 export type UseSyncValueAndValueItemProps<K, D> = {
     addBusyState: (desc?: string) => () => void;
     dataProvider?: Optional<DataProvider<K, D>>;
-    setIsLoading: StateUpdater<boolean>;
-    setValue: StateUpdater<Value<K>>;
+    setDisplayValue: Dispatch<StateUpdater<Value<K>>>;
+    setIsLoading: Dispatch<StateUpdater<boolean>>;
+    setValue: Dispatch<StateUpdater<Value<K>>>;
     setValueItem: (value: ValueItem<K, D>) => void;
     value?: Value<K>;
     valueItem?: ValueItem<K, D>;
+    validateValueOnExternalChange: (value: Value<K>) => ValidationResult;
 };
-export declare function useSyncValueAndValueItem<K extends string | number, D extends Record<string, any>>({ addBusyState, dataProvider, setIsLoading, setValue, setValueItem, value, valueItem }: UseSyncValueAndValueItemProps<K, D>): void;
+export declare function useSyncValueAndValueItem<K extends string | number, D extends Record<string, any>>({ addBusyState, dataProvider, setDisplayValue, setIsLoading, setValue, setValueItem, value, valueItem, validateValueOnExternalChange }: UseSyncValueAndValueItemProps<K, D>): void;
 export {};

package/oj-c/types/split-menu-button/split-menu-button.d.ts

@@ -1,15 +1,15 @@
 import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
 import { GlobalProps } from 'ojs/ojvcomponent';
 import 'ojs/oj-jsx-interfaces';
-import { SplitMenuButton as PreactSplitMenuButton } from '@oracle/oraclejet-preact/UNSAFE_SplitMenuButton';
-import { ComponentProps, Component } from 'preact';
 import { ExtendGlobalProps, Action, Bubbles, ObservedGlobalProps } from 'ojs/ojvcomponent';
-import 'css!oj-c/split-menu-button/split-menu-button-styles.css';
+import { SplitMenuButton as PreactSplitMenuButton } from '@oracle/oraclejet-preact/UNSAFE_SplitMenuButton';
 import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
-export type { MenuValueUpdateDetail } from '@oracle/oraclejet-preact/UNSAFE_Menu/menuUtils';
 import { MenuItemSelectionDetail, MenuItem, MenuSeparator } from '../utils/PRIVATE_ItemsMenu/items-menu';
+export type { MenuValueUpdateDetail } from '@oracle/oraclejet-preact/UNSAFE_Menu/menuUtils';
 export type { MenuSelection, MenuItemSelectionDetail } from '../utils/PRIVATE_ItemsMenu/items-menu';
 export type MenuItems = MenuItem | MenuSeparator;
+import { ComponentProps, Component } from 'preact';
+import 'css!oj-c/split-menu-button/split-menu-button-styles.css';
 type PreactSplitMenuButtonProps = ComponentProps<typeof PreactSplitMenuButton>;
 type Props = ObservedGlobalProps<'aria-describedby'> & {
     label: string;
@@ -25,7 +25,7 @@ type Props = ObservedGlobalProps<'aria-describedby'> & {
 export declare class SplitMenuButton extends Component<ExtendGlobalProps<Props>> {
     static defaultProps: Partial<Props>;
     private buttonRef;
-    render(props: ExtendGlobalProps<Props>): import("preact").JSX.Element;
+    render({ chroming, label, disabled, size, width, items, tooltip, onOjMenuAction, 'aria-describedby': ariaDescribedBy, onOjAction: onAction }: ExtendGlobalProps<Props>): import("preact").JSX.Element;
     blur(): void;
     focus(): void;
     doAction(): void;
@@ -43,9 +43,7 @@ export interface CSplitMenuButtonElement extends JetElement<CSplitMenuButtonElem
     focus: SplitMenuButton['focus'];
 }
 export namespace CSplitMenuButtonElement {
-    interface ojMenuAction extends CustomEvent<{
-        key: string;
-    }> {
+    interface ojMenuAction extends CustomEvent<MenuItemSelectionDetail & {}> {
     }
     interface ojAction extends CustomEvent<{}> {
     }

package/oj-c/types/tab-bar/ContentRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { DataTabBarProps } from './DataTabBar.types';
+import { FocusableHandle } from '@oracle/oraclejet-preact/UNSAFE_TabBarMixed';
+import { RefObject } from 'preact';
+export declare function TabBarRenderer<K extends string | number>(props: Omit<DataTabBarProps<K>, 'overflow' | 'onSelect'>, handleSelect: DataTabBarProps<K>['onSelect'], ref?: RefObject<FocusableHandle>): import("preact").JSX.Element;
+export declare function OverflowTabBarRenderer<K extends string | number>(props: Omit<DataTabBarProps<K>, 'reorderable' | 'onReorder' | 'onSelect' | 'overflow'>, handleSelect: DataTabBarProps<K>['onSelect']): import("preact").JSX.Element;

package/oj-c/types/tab-bar/DataTabBar.d.ts

@@ -0,0 +1,2 @@
+import type { DataTabBarProps } from './DataTabBar.types';
+export declare function DataTabBar<K extends string | number>(props: DataTabBarProps<K>): import("preact").JSX.Element;

package/oj-c/types/tab-bar/DataTabBar.types.d.ts

@@ -0,0 +1,32 @@
+import type { ComponentProps } from 'preact';
+import { TabBar } from '@oracle/oraclejet-preact/UNSAFE_TabBar';
+import { ReorderableTabBar } from '@oracle/oraclejet-preact/UNSAFE_ReorderableTabBar';
+import type { TabIconData } from './DataTabBarIcon';
+type TabBarProps = ComponentProps<typeof TabBar>;
+type ReorderableTabBarProps = ComponentProps<typeof ReorderableTabBar>;
+type Severity = 'warning' | 'info' | 'none' | 'error' | 'confirmation';
+export type TabData<K extends string | number> = {
+    itemKey: K;
+    label: string;
+    icon?: TabIconData;
+    badge?: number;
+    metadata?: string;
+    severity?: Severity;
+    tabPanelId?: string;
+    isRemovable?: boolean;
+};
+export type DataTabBarProps<K extends string | number> = {
+    data: TabData<K>[];
+    onRemove: TabBarProps['onRemove'];
+    onSelect: TabBarProps['onSelect'];
+    selection: TabBarProps['selection'];
+    display: TabBarProps['display'];
+    layout: TabBarProps['layout'];
+    edge: TabBarProps['edge'];
+    overflow?: 'conveyor' | 'popup' | 'hidden';
+    onReorder?: ReorderableTabBarProps['onReorder'];
+    reorderable?: 'enabled' | 'disabled';
+    'aria-label'?: TabBarProps['aria-label'];
+    'aria-labelledby'?: TabBarProps['aria-labelledby'];
+};
+export {};

package/oj-c/types/tab-bar/DataTabBarIcon.d.ts

@@ -0,0 +1,10 @@
+export type TabIconData = {
+    type?: 'class';
+    class: string;
+} | {
+    type: 'img';
+    src: string;
+};
+export declare function DataTabBarIcon(props: {
+    icon: TabIconData;
+}): import("preact").JSX.Element | null;

package/oj-c/types/tab-bar/index.d.ts

@@ -0,0 +1,2 @@
+export { TabBar, KeyDetail, SelectionActionDetail, TabData, TabIconData, ReorderDetail } from './tab-bar';
+export { CTabBarElement } from './tab-bar';

package/oj-c/types/tab-bar/tab-bar.d.ts

@@ -0,0 +1,125 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import type { Action, CancelableAction, ExtendGlobalProps, ObservedGlobalProps, PropertyChanged } from 'ojs/ojvcomponent';
+import type { ComponentProps, ComponentType } from 'preact';
+import { DataProvider } from 'ojs/ojdataprovider';
+import { DataTabBar } from './DataTabBar';
+type DataTabBarProps = ComponentProps<typeof DataTabBar>;
+type Severity = 'warning' | 'info' | 'none' | 'error' | 'confirmation';
+export type TabIconData = {
+    type?: 'class';
+    class: string;
+} | {
+    type: 'img';
+    src: string;
+};
+export type TabData<K extends string | number> = {
+    itemKey: K;
+    label: string;
+    icon?: TabIconData;
+    badge?: number;
+    metadata?: string;
+    severity?: Severity;
+    tabPanelId?: string;
+    isRemovable?: boolean;
+};
+export type KeyDetail<K extends string | number> = {
+    key: K;
+};
+export type SelectionActionDetail<K extends string | number> = {
+    previousValue: K;
+    value: K;
+};
+export type ReorderDetail<K extends string | number> = {
+    reorderedKeys: K[];
+};
+export type Props<K extends string | number> = ObservedGlobalProps<'aria-label' | 'id' | 'aria-labelledby'> & {
+    data?: DataTabBarProps['data'] | DataProvider<K, TabData<K>>;
+    selection?: K;
+    onOjBeforeSelect?: CancelableAction<KeyDetail<K>>;
+    onOjRemove?: Action<KeyDetail<K>>;
+    onOjReorder?: Action<ReorderDetail<K>>;
+    onOjSelectionAction?: Action<SelectionActionDetail<K>>;
+    onSelectionChanged?: PropertyChanged<K>;
+    reorderable?: DataTabBarProps['reorderable'];
+    overflow?: DataTabBarProps['overflow'];
+    display?: DataTabBarProps['display'];
+    layout?: DataTabBarProps['layout'];
+    edge?: DataTabBarProps['edge'];
+};
+export declare const TabBar: ComponentType<ExtendGlobalProps<Props<string | number>>>;
+export {};
+export interface CTabBarElement extends JetElement<CTabBarElementSettableProperties<string | number>>, CTabBarElementSettableProperties<string | number> {
+    addEventListener<T extends keyof CTabBarElementEventMap>(type: T, listener: (this: HTMLElement, ev: CTabBarElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CTabBarElementSettableProperties<string | number>>(property: T): CTabBarElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CTabBarElementSettableProperties<string | number>>(property: T, value: CTabBarElementSettableProperties<string | number>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CTabBarElementSettableProperties<string | number>>): void;
+    setProperties(properties: CTabBarElementSettablePropertiesLenient<string | number>): void;
+}
+export namespace CTabBarElement {
+    interface ojBeforeSelect<K extends string | number> extends CustomEvent<KeyDetail<K> & {
+        accept: (param: Promise<void>) => void;
+    }> {
+    }
+    interface ojRemove<K extends string | number> extends CustomEvent<KeyDetail<K> & {}> {
+    }
+    interface ojReorder<K extends string | number> extends CustomEvent<ReorderDetail<K> & {}> {
+    }
+    interface ojSelectionAction<K extends string | number> extends CustomEvent<SelectionActionDetail<K> & {}> {
+    }
+    type dataChanged = JetElementCustomEventStrict<CTabBarElement['data']>;
+    type displayChanged = JetElementCustomEventStrict<CTabBarElement['display']>;
+    type edgeChanged = JetElementCustomEventStrict<CTabBarElement['edge']>;
+    type layoutChanged = JetElementCustomEventStrict<CTabBarElement['layout']>;
+    type overflowChanged = JetElementCustomEventStrict<CTabBarElement['overflow']>;
+    type reorderableChanged = JetElementCustomEventStrict<CTabBarElement['reorderable']>;
+    type selectionChanged = JetElementCustomEventStrict<CTabBarElement['selection']>;
+}
+export interface CTabBarElementEventMap extends HTMLElementEventMap {
+    'ojBeforeSelect': CTabBarElement.ojBeforeSelect<string | number>;
+    'ojRemove': CTabBarElement.ojRemove<string | number>;
+    'ojReorder': CTabBarElement.ojReorder<string | number>;
+    'ojSelectionAction': CTabBarElement.ojSelectionAction<string | number>;
+    'dataChanged': JetElementCustomEventStrict<CTabBarElement['data']>;
+    'displayChanged': JetElementCustomEventStrict<CTabBarElement['display']>;
+    'edgeChanged': JetElementCustomEventStrict<CTabBarElement['edge']>;
+    'layoutChanged': JetElementCustomEventStrict<CTabBarElement['layout']>;
+    'overflowChanged': JetElementCustomEventStrict<CTabBarElement['overflow']>;
+    'reorderableChanged': JetElementCustomEventStrict<CTabBarElement['reorderable']>;
+    'selectionChanged': JetElementCustomEventStrict<CTabBarElement['selection']>;
+}
+export interface CTabBarElementSettableProperties<K extends string | number> extends JetSettableProperties {
+    data?: Props<K>['data'];
+    display?: Props<K>['display'];
+    edge?: Props<K>['edge'];
+    layout?: Props<K>['layout'];
+    overflow?: Props<K>['overflow'];
+    reorderable?: Props<K>['reorderable'];
+    selection?: Props<K>['selection'];
+}
+export interface CTabBarElementSettablePropertiesLenient<K extends string | number> extends Partial<CTabBarElementSettableProperties<K>> {
+    [key: string]: any;
+}
+export interface TabBarIntrinsicProps extends Partial<Readonly<CTabBarElementSettableProperties<any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    onojBeforeSelect?: (value: CTabBarElementEventMap['ojBeforeSelect']) => void;
+    onojRemove?: (value: CTabBarElementEventMap['ojRemove']) => void;
+    onojReorder?: (value: CTabBarElementEventMap['ojReorder']) => void;
+    onojSelectionAction?: (value: CTabBarElementEventMap['ojSelectionAction']) => void;
+    ondataChanged?: (value: CTabBarElementEventMap['dataChanged']) => void;
+    ondisplayChanged?: (value: CTabBarElementEventMap['displayChanged']) => void;
+    onedgeChanged?: (value: CTabBarElementEventMap['edgeChanged']) => void;
+    onlayoutChanged?: (value: CTabBarElementEventMap['layoutChanged']) => void;
+    onoverflowChanged?: (value: CTabBarElementEventMap['overflowChanged']) => void;
+    onreorderableChanged?: (value: CTabBarElementEventMap['reorderableChanged']) => void;
+    onselectionChanged?: (value: CTabBarElementEventMap['selectionChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-tab-bar': TabBarIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/tag-cloud/tag-cloud.d.ts

@@ -58,6 +58,7 @@ export namespace CTagCloudElement {
     type selectionChanged<K extends string | number, D extends any> = JetElementCustomEventStrict<CTagCloudElement<K, D>['selection']>;
     type selectionModeChanged<K extends string | number, D extends any> = JetElementCustomEventStrict<CTagCloudElement<K, D>['selectionMode']>;
     type touchResponseChanged<K extends string | number, D extends any> = JetElementCustomEventStrict<CTagCloudElement<K, D>['touchResponse']>;
+    type RenderItemTemplate<K extends string | number, D extends any> = import('ojs/ojvcomponent').TemplateSlot<TagCloudItemTemplateContext<K, D>>;
 }
 export interface CTagCloudElementEventMap<K extends string | number, D extends any> extends HTMLElementEventMap {
     'dataChanged': JetElementCustomEventStrict<CTagCloudElement<K, D>['data']>;

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

@@ -6,7 +6,7 @@ import Converter = require('ojs/ojconverter');
 import Validator = require('ojs/ojvalidator');
 import AsyncValidator = require('ojs/ojvalidator-async');
 import { ExtendGlobalProps, GlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
-import { Component, ComponentProps } from 'preact';
+import { ComponentProps, ComponentType, Ref } from 'preact';
 import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
 import { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
 import 'css!oj-c/text-area/text-area-styles.css';
@@ -46,29 +46,23 @@ type Props<V> = ObservedGlobalProps<'aria-describedby' | 'id'> & {
     resizeBehavior?: PreactTextAreaProps['resize'] | 'none';
     rows?: number;
     textAlign?: PreactTextAreaProps['textAlign'];
-    unsafe_labelledBy?: string;
     userAssistanceDensity?: PreactTextAreaProps['userAssistanceDensity'];
     validators?: (AsyncValidator<V> | Validator<V>)[] | null;
     value?: V | null;
     onMessagesCustomChanged?: PropertyChanged<PreactTextAreaProps['messages']>;
     onRawValueChanged?: ReadOnlyPropertyChanged<string>;
     onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
-    onValueChanged?: PropertyChanged<V>;
+    onValueChanged?: PropertyChanged<V | null>;
 };
-export declare class TextArea<V> extends Component<ExtendGlobalProps<Props<V>>> {
-    static defaultProps: Partial<Props<any>>;
-    private busyContextRef;
-    private textAreaRef;
-    private rootRef;
-    componentDidMount(): void;
-    render({ columnSpan, ...props }: ExtendGlobalProps<Props<V>>): import("preact").JSX.Element;
-    componentWillUnmount(): void;
-    reset(): void;
-    showMessages(): void;
-    validate(): Promise<'valid' | 'invalid'>;
-    blur(): void;
-    focus(): void;
-}
+type TextAreaHandle = {
+    blur: () => void;
+    focus: () => void;
+    showMessages: () => void;
+    reset: () => void;
+    validate: () => Promise<'valid' | 'invalid'>;
+};
+declare function TextAreaImpl<V>({ autocomplete, columnSpan, converter, containerReadonly: propContainerReadonly, disabled, displayOptions, help, helpHints, id, labelWrapping: propLabelWrapping, length, messagesCustom, readonly: propReadonly, required, resizeBehavior, userAssistanceDensity: propUserAssistanceDensity, validators, value, ...otherProps }: Props<V>, ref: Ref<TextAreaHandle>): import("preact").JSX.Element;
+export declare const TextArea: ComponentType<ExtendGlobalProps<ComponentProps<typeof TextAreaImpl<any>>>>;
 export {};
 export interface CTextAreaElement<V> extends JetElement<CTextAreaElementSettableProperties<V>>, CTextAreaElementSettableProperties<V> {
     readonly rawValue?: Parameters<Required<Props<V>>['onRawValueChanged']>[0];
@@ -80,11 +74,11 @@ export interface CTextAreaElement<V> extends JetElement<CTextAreaElementSettable
     setProperty<T extends keyof CTextAreaElementSettableProperties<V>>(property: T, value: CTextAreaElementSettableProperties<V>[T]): void;
     setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CTextAreaElementSettableProperties<V>>): void;
     setProperties(properties: CTextAreaElementSettablePropertiesLenient<V>): void;
-    blur: TextArea<V>['blur'];
-    focus: TextArea<V>['focus'];
-    reset: TextArea<V>['reset'];
-    showMessages: TextArea<V>['showMessages'];
-    validate: TextArea<V>['validate'];
+    blur: () => void;
+    focus: () => void;
+    reset: () => void;
+    showMessages: () => void;
+    validate: () => Promise<'invalid' | 'valid'>;
 }
 export namespace CTextAreaElement {
     type autocompleteChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['autocomplete']>;
@@ -110,7 +104,6 @@ export namespace CTextAreaElement {
     type resizeBehaviorChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['resizeBehavior']>;
     type rowsChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['rows']>;
     type textAlignChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['textAlign']>;
-    type unsafe_labelledByChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['unsafe_labelledBy']>;
     type userAssistanceDensityChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['userAssistanceDensity']>;
     type validChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['valid']>;
     type validatorsChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['validators']>;
@@ -140,7 +133,6 @@ export interface CTextAreaElementEventMap<V> extends HTMLElementEventMap {
     'resizeBehaviorChanged': JetElementCustomEventStrict<CTextAreaElement<V>['resizeBehavior']>;
     'rowsChanged': JetElementCustomEventStrict<CTextAreaElement<V>['rows']>;
     'textAlignChanged': JetElementCustomEventStrict<CTextAreaElement<V>['textAlign']>;
-    'unsafe_labelledByChanged': JetElementCustomEventStrict<CTextAreaElement<V>['unsafe_labelledBy']>;
     'userAssistanceDensityChanged': JetElementCustomEventStrict<CTextAreaElement<V>['userAssistanceDensity']>;
     'validChanged': JetElementCustomEventStrict<CTextAreaElement<V>['valid']>;
     'validatorsChanged': JetElementCustomEventStrict<CTextAreaElement<V>['validators']>;
@@ -169,7 +161,6 @@ export interface CTextAreaElementSettableProperties<V> extends JetSettableProper
     resizeBehavior?: Props<V>['resizeBehavior'];
     rows?: Props<V>['rows'];
     textAlign?: Props<V>['textAlign'];
-    unsafe_labelledBy?: Props<V>['unsafe_labelledBy'];
     userAssistanceDensity?: Props<V>['userAssistanceDensity'];
     validators?: Props<V>['validators'];
     value?: Props<V>['value'];
@@ -203,7 +194,6 @@ export interface TextAreaIntrinsicProps extends Partial<Readonly<CTextAreaElemen
     onresizeBehaviorChanged?: (value: CTextAreaElementEventMap<any>['resizeBehaviorChanged']) => void;
     onrowsChanged?: (value: CTextAreaElementEventMap<any>['rowsChanged']) => void;
     ontextAlignChanged?: (value: CTextAreaElementEventMap<any>['textAlignChanged']) => void;
-    onunsafe_labelledByChanged?: (value: CTextAreaElementEventMap<any>['unsafe_labelledByChanged']) => void;
     onuserAssistanceDensityChanged?: (value: CTextAreaElementEventMap<any>['userAssistanceDensityChanged']) => void;
     onvalidChanged?: (value: CTextAreaElementEventMap<any>['validChanged']) => void;
     onvalidatorsChanged?: (value: CTextAreaElementEventMap<any>['validatorsChanged']) => void;

package/oj-c/types/text-area/useTextAreaAutosizePreact.d.ts

@@ -2,14 +2,12 @@ import { ComponentProps } from 'preact';
 import type { TextArea } from 'oj-c/text-area';
 type TextAreaProps = ComponentProps<typeof TextArea>;
 export declare function useTextAreaAutosizePreact<V>({ autocomplete, autofocus, converter, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, length, maxRows, messagesCustom, placeholder, readonly, required, requiredMessageDetail, resizeBehavior, rows, textAlign, userAssistanceDensity, validators, value: propValue, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, ...otherProps }: TextAreaProps, addBusyState?: (desc?: string) => () => void): {
-    value: V;
-    setValue: import("preact/hooks").StateUpdater<V>;
     methods: {
         reset: () => void;
-        validate: () => Promise<"invalid" | "valid">;
         showMessages: () => void;
+        validate: () => Promise<"invalid" | "valid">;
     };
-    textAreaProps: Omit<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
+    textAreaProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
         'aria-describedby'?: string | undefined;
         assistiveText?: string | undefined;
         autoComplete?: string | undefined;
@@ -38,7 +36,7 @@ export declare function useTextAreaAutosizePreact<V>({ autocomplete, autofocus,
         variant?: "default" | "embedded" | undefined;
         onCommit?: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
         onInput: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
-    }, "ref"> & {
+    }> & {
         ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
     };
 };

package/oj-c/types/text-area/useTextAreaPreact.d.ts

@@ -2,14 +2,12 @@ import { ComponentProps } from 'preact';
 import type { TextArea } from 'oj-c/text-area';
 type TextAreaProps = ComponentProps<typeof TextArea>;
 export declare function useTextAreaPreact<V>({ autocomplete, autofocus, converter, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, length, messagesCustom, placeholder, readonly, required, requiredMessageDetail, resizeBehavior, rows, textAlign, userAssistanceDensity, validators, value: propValue, onMessagesCustomChanged, onRawValueChanged, onValueChanged, onValidChanged, ...otherProps }: TextAreaProps, addBusyState?: (desc?: string) => () => void): {
-    value: V;
-    setValue: import("preact/hooks").StateUpdater<V>;
     methods: {
         reset: () => void;
-        validate: () => Promise<"invalid" | "valid">;
         showMessages: () => void;
+        validate: () => Promise<"invalid" | "valid">;
     };
-    textAreaProps: Omit<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
+    textAreaProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
         'aria-describedby'?: string | undefined;
         assistiveText?: string | undefined;
         autoComplete?: string | undefined;
@@ -38,7 +36,7 @@ export declare function useTextAreaPreact<V>({ autocomplete, autofocus, converte
         variant?: "default" | "embedded" | undefined;
         onCommit?: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
         onInput: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
-    }, "ref"> & {
+    }> & {
         ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
     };
 };

package/oj-c/types/toggle-button/index.d.ts

@@ -0,0 +1,2 @@
+export { ToggleButton } from './toggle-button';
+export { CToggleButtonElement } from './toggle-button';

package/oj-c/types/toggle-button/toggle-button.d.ts

@@ -0,0 +1,94 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, Slot } from 'ojs/ojvcomponent';
+import { ToggleButton as PreactToggleButton } from '@oracle/oraclejet-preact/UNSAFE_ToggleButton';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+import { ComponentProps, Component } from 'preact';
+import 'css!oj-c/button/button-styles.css';
+type PreactToggleButtonProps = ComponentProps<typeof PreactToggleButton>;
+type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label'> & {
+    label: string;
+    value?: boolean;
+    onValueChanged?: PropertyChanged<boolean>;
+    tooltip?: string;
+    startIcon?: Slot;
+    endIcon?: Slot;
+    disabled?: boolean;
+    width?: Size;
+    display?: 'all' | 'icons' | 'label';
+    size?: 'sm' | 'md' | 'lg';
+    chroming?: PreactToggleButtonProps['variant'];
+};
+export declare class ToggleButton extends Component<ExtendGlobalProps<Props>> {
+    static defaultProps: Partial<Props>;
+    private buttonRef;
+    render({ chroming: variant, disabled: isDisabled, 'aria-label': accessibleLabel, 'aria-describedby': ariaDescribedBy, width, display, value, label, tooltip, endIcon, startIcon, size, onValueChanged }: ExtendGlobalProps<Props>): import("preact").JSX.Element;
+    click(): void;
+    blur(): void;
+    focus(): void;
+}
+export {};
+export interface CToggleButtonElement extends JetElement<CToggleButtonElementSettableProperties>, CToggleButtonElementSettableProperties {
+    addEventListener<T extends keyof CToggleButtonElementEventMap>(type: T, listener: (this: HTMLElement, ev: CToggleButtonElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CToggleButtonElementSettableProperties>(property: T): CToggleButtonElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CToggleButtonElementSettableProperties>(property: T, value: CToggleButtonElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CToggleButtonElementSettableProperties>): void;
+    setProperties(properties: CToggleButtonElementSettablePropertiesLenient): void;
+    blur: ToggleButton['blur'];
+    click: ToggleButton['click'];
+    focus: ToggleButton['focus'];
+}
+export namespace CToggleButtonElement {
+    type chromingChanged = JetElementCustomEventStrict<CToggleButtonElement['chroming']>;
+    type disabledChanged = JetElementCustomEventStrict<CToggleButtonElement['disabled']>;
+    type displayChanged = JetElementCustomEventStrict<CToggleButtonElement['display']>;
+    type labelChanged = JetElementCustomEventStrict<CToggleButtonElement['label']>;
+    type sizeChanged = JetElementCustomEventStrict<CToggleButtonElement['size']>;
+    type tooltipChanged = JetElementCustomEventStrict<CToggleButtonElement['tooltip']>;
+    type valueChanged = JetElementCustomEventStrict<CToggleButtonElement['value']>;
+    type widthChanged = JetElementCustomEventStrict<CToggleButtonElement['width']>;
+}
+export interface CToggleButtonElementEventMap extends HTMLElementEventMap {
+    'chromingChanged': JetElementCustomEventStrict<CToggleButtonElement['chroming']>;
+    'disabledChanged': JetElementCustomEventStrict<CToggleButtonElement['disabled']>;
+    'displayChanged': JetElementCustomEventStrict<CToggleButtonElement['display']>;
+    'labelChanged': JetElementCustomEventStrict<CToggleButtonElement['label']>;
+    'sizeChanged': JetElementCustomEventStrict<CToggleButtonElement['size']>;
+    'tooltipChanged': JetElementCustomEventStrict<CToggleButtonElement['tooltip']>;
+    'valueChanged': JetElementCustomEventStrict<CToggleButtonElement['value']>;
+    'widthChanged': JetElementCustomEventStrict<CToggleButtonElement['width']>;
+}
+export interface CToggleButtonElementSettableProperties extends JetSettableProperties {
+    chroming?: Props['chroming'];
+    disabled?: Props['disabled'];
+    display?: Props['display'];
+    label: Props['label'];
+    size?: Props['size'];
+    tooltip?: Props['tooltip'];
+    value?: Props['value'];
+    width?: Props['width'];
+}
+export interface CToggleButtonElementSettablePropertiesLenient extends Partial<CToggleButtonElementSettableProperties> {
+    [key: string]: any;
+}
+export interface ToggleButtonIntrinsicProps extends Partial<Readonly<CToggleButtonElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    onchromingChanged?: (value: CToggleButtonElementEventMap['chromingChanged']) => void;
+    ondisabledChanged?: (value: CToggleButtonElementEventMap['disabledChanged']) => void;
+    ondisplayChanged?: (value: CToggleButtonElementEventMap['displayChanged']) => void;
+    onlabelChanged?: (value: CToggleButtonElementEventMap['labelChanged']) => void;
+    onsizeChanged?: (value: CToggleButtonElementEventMap['sizeChanged']) => void;
+    ontooltipChanged?: (value: CToggleButtonElementEventMap['tooltipChanged']) => void;
+    onvalueChanged?: (value: CToggleButtonElementEventMap['valueChanged']) => void;
+    onwidthChanged?: (value: CToggleButtonElementEventMap['widthChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-toggle-button': ToggleButtonIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/utils/PRIVATE_ItemsMenu/index.d.ts

@@ -1 +1 @@
-export { MenuItem, MenuItems, MenuSeparator, MenuSelection, MenuItemSelectionDetail, ItemsMenu } from './items-menu';
+export { MenuItem, MenuItems, ContextMenuItems, MenuSeparator, MenuSelection, MenuItemSelectionDetail, ItemsMenu } from './items-menu';

package/oj-c/types/utils/PRIVATE_ItemsMenu/items-menu.d.ts

@@ -1,10 +1,14 @@
-import { MenuItems, MenuSelection, MenuItemSelectionDetail } from './menuTypes';
-export { MenuItem, MenuItems, MenuSeparator, MenuSelection, MenuItemSelectionDetail, MenuIcon, MenuSelectItem } from './menuTypes';
+import { ContextMenuItems, MenuSelection, MenuItemSelectionDetail, SelectMenuItemDetail } from './menuTypes';
+export { MenuItem, MenuItems, ContextMenuItems, MenuSeparator, MenuSelection, MenuItemSelectionDetail, MenuIcon, MenuSelectItem, SelectMenuItemDetail } from './menuTypes';
+type ItemsMenuMenuItems = (ContextMenuItems | {
+    type: 'divider';
+})[];
 type Props = {
-    items?: MenuItems[];
+    items?: ItemsMenuMenuItems;
     selection?: Readonly<Record<string, MenuSelection>>;
     onSelectionChanged?: (value: Readonly<Record<string, MenuSelection>>) => void;
     onOjMenuAction?: (details: MenuItemSelectionDetail) => void;
+    onOjMenuSelection?: (details: SelectMenuItemDetail<string | Array<string>>) => void;
     isSplitMenu?: boolean;
 };
-export declare const ItemsMenu: ({ items, selection, onSelectionChanged, onOjMenuAction, isSplitMenu }: Props) => import("preact").JSX.Element;
+export declare const ItemsMenu: ({ items, selection, onSelectionChanged, onOjMenuAction, isSplitMenu, onOjMenuSelection }: Props) => import("preact").JSX.Element;

package/oj-c/types/utils/PRIVATE_ItemsMenu/menuTypes.d.ts

@@ -1,3 +1,4 @@
+import { MenuValueUpdateDetail } from '@oracle/oraclejet-preact/UNSAFE_Menu/menuUtils';
 export type { MenuValueUpdateDetail } from '@oracle/oraclejet-preact/UNSAFE_Menu/menuUtils';
 export type MenuIcon = {
     type?: 'class';
@@ -13,7 +14,7 @@ export type MenuSelectItem = {
     value: string;
 };
 export interface MenuItemSelectionDetail {
-    key?: string;
+    key: string;
 }
 export type MenuSelection = string | Array<string>;
 export type MenuSeparator = {
@@ -47,3 +48,21 @@ export type MenuSelectMultiple = {
     items?: Array<MenuSelectItem>;
 };
 export type MenuItems = MenuSeparator | MenuItem | MenuSubMenu | MenuSelectSingle | MenuSelectMultiple;
+type ContextMenuSeparator = {
+    type: 'separator';
+};
+type ContextMenuSubMenu = Omit<MenuSubMenu, 'items'> & {
+    items?: Array<ContextMenuItems>;
+};
+export type ContextMenuSelectSingle = MenuSelectSingle & {
+    selection?: string;
+    onSelection?: (detail: SelectMenuItemDetail<string>) => void;
+};
+export type ContextMenuSelectMultiple = MenuSelectMultiple & {
+    selection?: Array<string>;
+    onSelection?: (detail: SelectMenuItemDetail<Array<string>>) => void;
+};
+export type SelectMenuItemDetail<T extends MenuSelection> = {
+    value: MenuValueUpdateDetail<T>['value'];
+};
+export type ContextMenuItems = ContextMenuSeparator | MenuItem | ContextMenuSubMenu | ContextMenuSelectSingle | ContextMenuSelectMultiple;

package/oj-c/types/utils/PRIVATE_chartUtils/events.d.ts

@@ -1,11 +1,10 @@
-import { Group } from '@oracle/oraclejet-preact/UNSAFE_Axis/axis.types';
-import { GroupContext, ItemContext } from '@oracle/oraclejet-preact/UNSAFE_Chart/chart.types';
+import { Group, GroupDetail, ItemDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_visTypes/chart';
 export declare function getIdFromDetail(detail: {
     seriesIndex?: number;
     groupIndex?: number;
 }, series: Record<any, string>[], getDataItem: (seriesIndex: number, groupIndex: number) => any): any;
-export declare const getChartEventsHandler: <K, D>(series: Record<string, any>[], groups: Group[], drilling: 'on' | 'groupsOnly' | 'seriesOnly' | 'off', onOjItemDrill?: ((detail: any) => void) | undefined, onOjGroupDrill?: ((detail: any) => void) | undefined, onOjSeriesDrill?: ((detail: any) => void) | undefined) => {
-    itemDrillHandler: (detail: ItemContext<K, D>) => void;
-    groupDrillHandler: (detail: GroupContext) => void;
+export declare const getChartEventsHandler: <K, D>(series: Record<string, any>[], groups: Group[], drilling: 'on' | 'groupsOnly' | 'seriesOnly' | 'off', onOjItemDrill?: (detail: any) => void, onOjGroupDrill?: (detail: any) => void, onOjSeriesDrill?: (detail: any) => void) => {
+    itemDrillHandler: (detail: ItemDetail<K, D>) => void;
+    groupDrillHandler: (detail: GroupDetail) => void;
     seriesDrillHandler: (detail: any) => void;
 };

package/oj-c/types/utils/PRIVATE_chartUtils/lineAreaUtils.d.ts

@@ -1,4 +1,4 @@
-import { ValueFormats } from '@oracle/oraclejet-preact/UNSAFE_Chart/chart.types';
+import { ValueFormats } from '@oracle/oraclejet-preact/utils/UNSAFE_visTypes/chart';
 export declare function transformItem(item: any, series: any): {
     markerColor: any;
     accessibleLabel: any;