@oracle/oraclejet-core-pack 14.0.0

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

@@ -0,0 +1,83 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { MessageToast as PreactMessageToast, MessageToastItem as PreactMessageToastItem } from '@oracle/oraclejet-preact/UNSAFE_MessageToast';
+import { DataProvider, ItemMetadata } from 'ojs/ojdataprovider';
+import { Action, DynamicTemplateSlots } from 'ojs/ojvcomponent';
+import { ComponentProps } from 'preact';
+import 'css!./message-toast-styles.css';
+declare type CloseActionDetail<K, D> = {
+    data: D;
+    key: K;
+    metadata?: ItemMetadata<K>;
+};
+declare type PreactMessageToastProps = ComponentProps<typeof PreactMessageToast>;
+export declare type MessageToastItem = PreactMessageToastItem;
+export declare type MessageToastTemplateContext<K, D> = {
+    data: D;
+    key: K;
+    metadata?: ItemMetadata<K>;
+};
+export declare type MessageToastProps<Key = string | number, Data = MessageToastItem> = {
+    data: DataProvider<Key, Data>;
+    detailTemplateValue?: PreactMessageToastProps['detailRendererKey'];
+    iconTemplateValue?: PreactMessageToastProps['iconRendererKey'];
+    messageTemplates?: DynamicTemplateSlots<MessageToastTemplateContext<Key, Data>>;
+    offset?: PreactMessageToastProps['offset'];
+    position?: PreactMessageToastProps['position'];
+    onOjClose?: Action<CloseActionDetail<Key, Data>>;
+};
+export declare const MessageToast: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<MessageToastProps<string | number, PreactMessageToastItem>>>;
+export {};
+export interface CMessageToastElement extends JetElement<CMessageToastElementSettableProperties>, CMessageToastElementSettableProperties {
+    addEventListener<T extends keyof CMessageToastElementEventMap>(type: T, listener: (this: HTMLElement, ev: CMessageToastElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CMessageToastElementSettableProperties>(property: T): CMessageToastElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CMessageToastElementSettableProperties>(property: T, value: CMessageToastElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CMessageToastElementSettableProperties>): void;
+    setProperties(properties: CMessageToastElementSettablePropertiesLenient): void;
+}
+export namespace CMessageToastElement {
+    interface ojClose<Key = string | number, Data = MessageToastItem> extends CustomEvent<CloseActionDetail<Key, Data> & {}> {
+    }
+    type dataChanged = JetElementCustomEventStrict<CMessageToastElement['data']>;
+    type detailTemplateValueChanged = JetElementCustomEventStrict<CMessageToastElement['detailTemplateValue']>;
+    type iconTemplateValueChanged = JetElementCustomEventStrict<CMessageToastElement['iconTemplateValue']>;
+    type offsetChanged = JetElementCustomEventStrict<CMessageToastElement['offset']>;
+    type positionChanged = JetElementCustomEventStrict<CMessageToastElement['position']>;
+}
+export interface CMessageToastElementEventMap extends HTMLElementEventMap {
+    'ojClose': CMessageToastElement.ojClose;
+    'dataChanged': JetElementCustomEventStrict<CMessageToastElement['data']>;
+    'detailTemplateValueChanged': JetElementCustomEventStrict<CMessageToastElement['detailTemplateValue']>;
+    'iconTemplateValueChanged': JetElementCustomEventStrict<CMessageToastElement['iconTemplateValue']>;
+    'offsetChanged': JetElementCustomEventStrict<CMessageToastElement['offset']>;
+    'positionChanged': JetElementCustomEventStrict<CMessageToastElement['position']>;
+}
+export interface CMessageToastElementSettableProperties<Key = string | number, Data = MessageToastItem> extends JetSettableProperties {
+    data: MessageToastProps<Key, Data>['data'];
+    detailTemplateValue?: MessageToastProps<Key, Data>['detailTemplateValue'];
+    iconTemplateValue?: MessageToastProps<Key, Data>['iconTemplateValue'];
+    offset?: MessageToastProps<Key, Data>['offset'];
+    position?: MessageToastProps<Key, Data>['position'];
+}
+export interface CMessageToastElementSettablePropertiesLenient<Key = string | number, Data = MessageToastItem> extends Partial<CMessageToastElementSettableProperties<Key, Data>> {
+    [key: string]: any;
+}
+export interface MessageToastIntrinsicProps extends Partial<Readonly<CMessageToastElementSettableProperties<any, any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    onojClose?: (value: CMessageToastElementEventMap['ojClose']) => void;
+    ondataChanged?: (value: CMessageToastElementEventMap['dataChanged']) => void;
+    ondetailTemplateValueChanged?: (value: CMessageToastElementEventMap['detailTemplateValueChanged']) => void;
+    oniconTemplateValueChanged?: (value: CMessageToastElementEventMap['iconTemplateValueChanged']) => void;
+    onoffsetChanged?: (value: CMessageToastElementEventMap['offsetChanged']) => void;
+    onpositionChanged?: (value: CMessageToastElementEventMap['positionChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-message-toast': MessageToastIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export { MeterBar } from './meter-bar';
+export { CMeterBarElement } from './meter-bar';

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

@@ -0,0 +1,133 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { MeterBar as PreactMeterBar } from '@oracle/oraclejet-preact/UNSAFE_MeterBar';
+import { ComponentProps } from 'preact';
+import { ObservedGlobalProps, ReadOnlyPropertyChanged, PropertyChanged } from 'ojs/ojvcomponent';
+import 'css!oj-c/meter-bar/meter-bar-styles.css';
+declare type PreactMeterBarProps = ComponentProps<typeof PreactMeterBar>;
+declare type PlotArea = {
+    color?: PreactMeterBarProps['trackColor'];
+    rendered?: 'on' | 'off';
+};
+export declare type ThresholdDisplay = 'all' | 'plotArea' | 'indicator';
+declare type DatatipContext = {
+    value: number;
+};
+export declare const MeterBar: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label"> & {
+    max?: number | undefined;
+    min?: number | undefined;
+    readonly?: boolean | undefined;
+    value?: number | null | undefined;
+    onValueChanged?: PropertyChanged<number | null> | undefined;
+    step?: number | undefined;
+    color?: PreactMeterBarProps['indicatorColor'];
+    indicatorSize?: number | undefined;
+    plotArea?: PlotArea | undefined;
+    orientation?: PreactMeterBarProps['orientation'];
+    referenceLines?: PreactMeterBarProps['referenceLines'];
+    thresholdDisplay?: ThresholdDisplay | undefined;
+    thresholds?: PreactMeterBarProps['thresholds'];
+    describedBy?: string | null | undefined;
+    labelledBy?: string | null | undefined;
+    size?: PreactMeterBarProps['size'];
+    datatip?: ((context: DatatipContext) => string | null) | undefined;
+    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined> | undefined;
+}>>;
+export {};
+export interface CMeterBarElement extends JetElement<CMeterBarElementSettableProperties>, CMeterBarElementSettableProperties {
+    readonly transientValue?: Parameters<Required<ComponentProps<typeof MeterBar>>['onTransientValueChanged']>[0];
+    addEventListener<T extends keyof CMeterBarElementEventMap>(type: T, listener: (this: HTMLElement, ev: CMeterBarElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CMeterBarElementSettableProperties>(property: T): CMeterBarElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CMeterBarElementSettableProperties>(property: T, value: CMeterBarElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CMeterBarElementSettableProperties>): void;
+    setProperties(properties: CMeterBarElementSettablePropertiesLenient): void;
+}
+export namespace CMeterBarElement {
+    type colorChanged = JetElementCustomEventStrict<CMeterBarElement['color']>;
+    type datatipChanged = JetElementCustomEventStrict<CMeterBarElement['datatip']>;
+    type describedByChanged = JetElementCustomEventStrict<CMeterBarElement['describedBy']>;
+    type indicatorSizeChanged = JetElementCustomEventStrict<CMeterBarElement['indicatorSize']>;
+    type labelledByChanged = JetElementCustomEventStrict<CMeterBarElement['labelledBy']>;
+    type maxChanged = JetElementCustomEventStrict<CMeterBarElement['max']>;
+    type minChanged = JetElementCustomEventStrict<CMeterBarElement['min']>;
+    type orientationChanged = JetElementCustomEventStrict<CMeterBarElement['orientation']>;
+    type plotAreaChanged = JetElementCustomEventStrict<CMeterBarElement['plotArea']>;
+    type readonlyChanged = JetElementCustomEventStrict<CMeterBarElement['readonly']>;
+    type referenceLinesChanged = JetElementCustomEventStrict<CMeterBarElement['referenceLines']>;
+    type sizeChanged = JetElementCustomEventStrict<CMeterBarElement['size']>;
+    type stepChanged = JetElementCustomEventStrict<CMeterBarElement['step']>;
+    type thresholdDisplayChanged = JetElementCustomEventStrict<CMeterBarElement['thresholdDisplay']>;
+    type thresholdsChanged = JetElementCustomEventStrict<CMeterBarElement['thresholds']>;
+    type transientValueChanged = JetElementCustomEventStrict<CMeterBarElement['transientValue']>;
+    type valueChanged = JetElementCustomEventStrict<CMeterBarElement['value']>;
+}
+export interface CMeterBarElementEventMap extends HTMLElementEventMap {
+    'colorChanged': JetElementCustomEventStrict<CMeterBarElement['color']>;
+    'datatipChanged': JetElementCustomEventStrict<CMeterBarElement['datatip']>;
+    'describedByChanged': JetElementCustomEventStrict<CMeterBarElement['describedBy']>;
+    'indicatorSizeChanged': JetElementCustomEventStrict<CMeterBarElement['indicatorSize']>;
+    'labelledByChanged': JetElementCustomEventStrict<CMeterBarElement['labelledBy']>;
+    'maxChanged': JetElementCustomEventStrict<CMeterBarElement['max']>;
+    'minChanged': JetElementCustomEventStrict<CMeterBarElement['min']>;
+    'orientationChanged': JetElementCustomEventStrict<CMeterBarElement['orientation']>;
+    'plotAreaChanged': JetElementCustomEventStrict<CMeterBarElement['plotArea']>;
+    'readonlyChanged': JetElementCustomEventStrict<CMeterBarElement['readonly']>;
+    'referenceLinesChanged': JetElementCustomEventStrict<CMeterBarElement['referenceLines']>;
+    'sizeChanged': JetElementCustomEventStrict<CMeterBarElement['size']>;
+    'stepChanged': JetElementCustomEventStrict<CMeterBarElement['step']>;
+    'thresholdDisplayChanged': JetElementCustomEventStrict<CMeterBarElement['thresholdDisplay']>;
+    'thresholdsChanged': JetElementCustomEventStrict<CMeterBarElement['thresholds']>;
+    'transientValueChanged': JetElementCustomEventStrict<CMeterBarElement['transientValue']>;
+    'valueChanged': JetElementCustomEventStrict<CMeterBarElement['value']>;
+}
+export interface CMeterBarElementSettableProperties extends JetSettableProperties {
+    color?: ComponentProps<typeof MeterBar>['color'];
+    datatip?: ComponentProps<typeof MeterBar>['datatip'];
+    describedBy?: ComponentProps<typeof MeterBar>['describedBy'];
+    indicatorSize?: ComponentProps<typeof MeterBar>['indicatorSize'];
+    labelledBy?: ComponentProps<typeof MeterBar>['labelledBy'];
+    max?: ComponentProps<typeof MeterBar>['max'];
+    min?: ComponentProps<typeof MeterBar>['min'];
+    orientation?: ComponentProps<typeof MeterBar>['orientation'];
+    plotArea?: ComponentProps<typeof MeterBar>['plotArea'];
+    readonly?: ComponentProps<typeof MeterBar>['readonly'];
+    referenceLines?: ComponentProps<typeof MeterBar>['referenceLines'];
+    size?: ComponentProps<typeof MeterBar>['size'];
+    step?: ComponentProps<typeof MeterBar>['step'];
+    thresholdDisplay?: ComponentProps<typeof MeterBar>['thresholdDisplay'];
+    thresholds?: ComponentProps<typeof MeterBar>['thresholds'];
+    value?: ComponentProps<typeof MeterBar>['value'];
+}
+export interface CMeterBarElementSettablePropertiesLenient extends Partial<CMeterBarElementSettableProperties> {
+    [key: string]: any;
+}
+export interface MeterBarIntrinsicProps extends Partial<Readonly<CMeterBarElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    transientValue?: never;
+    oncolorChanged?: (value: CMeterBarElementEventMap['colorChanged']) => void;
+    ondatatipChanged?: (value: CMeterBarElementEventMap['datatipChanged']) => void;
+    ondescribedByChanged?: (value: CMeterBarElementEventMap['describedByChanged']) => void;
+    onindicatorSizeChanged?: (value: CMeterBarElementEventMap['indicatorSizeChanged']) => void;
+    onlabelledByChanged?: (value: CMeterBarElementEventMap['labelledByChanged']) => void;
+    onmaxChanged?: (value: CMeterBarElementEventMap['maxChanged']) => void;
+    onminChanged?: (value: CMeterBarElementEventMap['minChanged']) => void;
+    onorientationChanged?: (value: CMeterBarElementEventMap['orientationChanged']) => void;
+    onplotAreaChanged?: (value: CMeterBarElementEventMap['plotAreaChanged']) => void;
+    onreadonlyChanged?: (value: CMeterBarElementEventMap['readonlyChanged']) => void;
+    onreferenceLinesChanged?: (value: CMeterBarElementEventMap['referenceLinesChanged']) => void;
+    onsizeChanged?: (value: CMeterBarElementEventMap['sizeChanged']) => void;
+    onstepChanged?: (value: CMeterBarElementEventMap['stepChanged']) => void;
+    onthresholdDisplayChanged?: (value: CMeterBarElementEventMap['thresholdDisplayChanged']) => void;
+    onthresholdsChanged?: (value: CMeterBarElementEventMap['thresholdsChanged']) => void;
+    ontransientValueChanged?: (value: CMeterBarElementEventMap['transientValueChanged']) => void;
+    onvalueChanged?: (value: CMeterBarElementEventMap['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-meter-bar': MeterBarIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/meter-circle/index.d.ts

@@ -0,0 +1,2 @@
+export { MeterCircle } from './meter-circle';
+export { CMeterCircleElement } from './meter-circle';

package/oj-c/types/meter-circle/meter-circle.d.ts

@@ -0,0 +1,148 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { MeterCircle as PreactMeterCircle, CenterContext } from '@oracle/oraclejet-preact/UNSAFE_MeterCircle';
+import { ComponentProps } from 'preact';
+import { ObservedGlobalProps, ReadOnlyPropertyChanged, PropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
+import 'css!oj-c/meter-circle/meter-circle-styles.css';
+declare type PreactMeterCircleProps = ComponentProps<typeof PreactMeterCircle>;
+export declare type Context = CenterContext & {
+    value: number | null;
+};
+declare type PlotArea = {
+    color?: PreactMeterCircleProps['trackColor'];
+    rendered?: 'on' | 'off';
+};
+export declare type DatatipContext = {
+    value: number;
+};
+export declare type ThresholdDisplay = 'all' | 'plotArea' | 'indicator';
+export declare const MeterCircle: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label"> & {
+    max?: number | undefined;
+    min?: number | undefined;
+    readonly?: boolean | undefined;
+    value?: number | null | undefined;
+    onValueChanged?: PropertyChanged<number | null> | undefined;
+    step?: number | undefined;
+    color?: PreactMeterCircleProps['indicatorColor'];
+    indicatorSize?: number | undefined;
+    innerRadius?: number | undefined;
+    plotArea: PlotArea;
+    angleExtent?: PreactMeterCircleProps['angleExtent'];
+    startAngle?: PreactMeterCircleProps['startAngle'];
+    referenceLines?: PreactMeterCircleProps['referenceLines'];
+    thresholdDisplay?: ThresholdDisplay | undefined;
+    thresholds?: PreactMeterCircleProps['thresholds'];
+    describedBy?: string | null | undefined;
+    labelledBy?: string | null | undefined;
+    size?: PreactMeterCircleProps['size'];
+    datatip?: ((context: DatatipContext) => string | null) | undefined;
+    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined> | undefined;
+    centerTemplate?: TemplateSlot<Context> | undefined;
+}>>;
+export {};
+export interface CMeterCircleElement extends JetElement<CMeterCircleElementSettableProperties>, CMeterCircleElementSettableProperties {
+    readonly transientValue?: Parameters<Required<ComponentProps<typeof MeterCircle>>['onTransientValueChanged']>[0];
+    addEventListener<T extends keyof CMeterCircleElementEventMap>(type: T, listener: (this: HTMLElement, ev: CMeterCircleElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CMeterCircleElementSettableProperties>(property: T): CMeterCircleElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CMeterCircleElementSettableProperties>(property: T, value: CMeterCircleElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CMeterCircleElementSettableProperties>): void;
+    setProperties(properties: CMeterCircleElementSettablePropertiesLenient): void;
+}
+export namespace CMeterCircleElement {
+    type angleExtentChanged = JetElementCustomEventStrict<CMeterCircleElement['angleExtent']>;
+    type colorChanged = JetElementCustomEventStrict<CMeterCircleElement['color']>;
+    type datatipChanged = JetElementCustomEventStrict<CMeterCircleElement['datatip']>;
+    type describedByChanged = JetElementCustomEventStrict<CMeterCircleElement['describedBy']>;
+    type indicatorSizeChanged = JetElementCustomEventStrict<CMeterCircleElement['indicatorSize']>;
+    type innerRadiusChanged = JetElementCustomEventStrict<CMeterCircleElement['innerRadius']>;
+    type labelledByChanged = JetElementCustomEventStrict<CMeterCircleElement['labelledBy']>;
+    type maxChanged = JetElementCustomEventStrict<CMeterCircleElement['max']>;
+    type minChanged = JetElementCustomEventStrict<CMeterCircleElement['min']>;
+    type plotAreaChanged = JetElementCustomEventStrict<CMeterCircleElement['plotArea']>;
+    type readonlyChanged = JetElementCustomEventStrict<CMeterCircleElement['readonly']>;
+    type referenceLinesChanged = JetElementCustomEventStrict<CMeterCircleElement['referenceLines']>;
+    type sizeChanged = JetElementCustomEventStrict<CMeterCircleElement['size']>;
+    type startAngleChanged = JetElementCustomEventStrict<CMeterCircleElement['startAngle']>;
+    type stepChanged = JetElementCustomEventStrict<CMeterCircleElement['step']>;
+    type thresholdDisplayChanged = JetElementCustomEventStrict<CMeterCircleElement['thresholdDisplay']>;
+    type thresholdsChanged = JetElementCustomEventStrict<CMeterCircleElement['thresholds']>;
+    type transientValueChanged = JetElementCustomEventStrict<CMeterCircleElement['transientValue']>;
+    type valueChanged = JetElementCustomEventStrict<CMeterCircleElement['value']>;
+}
+export interface CMeterCircleElementEventMap extends HTMLElementEventMap {
+    'angleExtentChanged': JetElementCustomEventStrict<CMeterCircleElement['angleExtent']>;
+    'colorChanged': JetElementCustomEventStrict<CMeterCircleElement['color']>;
+    'datatipChanged': JetElementCustomEventStrict<CMeterCircleElement['datatip']>;
+    'describedByChanged': JetElementCustomEventStrict<CMeterCircleElement['describedBy']>;
+    'indicatorSizeChanged': JetElementCustomEventStrict<CMeterCircleElement['indicatorSize']>;
+    'innerRadiusChanged': JetElementCustomEventStrict<CMeterCircleElement['innerRadius']>;
+    'labelledByChanged': JetElementCustomEventStrict<CMeterCircleElement['labelledBy']>;
+    'maxChanged': JetElementCustomEventStrict<CMeterCircleElement['max']>;
+    'minChanged': JetElementCustomEventStrict<CMeterCircleElement['min']>;
+    'plotAreaChanged': JetElementCustomEventStrict<CMeterCircleElement['plotArea']>;
+    'readonlyChanged': JetElementCustomEventStrict<CMeterCircleElement['readonly']>;
+    'referenceLinesChanged': JetElementCustomEventStrict<CMeterCircleElement['referenceLines']>;
+    'sizeChanged': JetElementCustomEventStrict<CMeterCircleElement['size']>;
+    'startAngleChanged': JetElementCustomEventStrict<CMeterCircleElement['startAngle']>;
+    'stepChanged': JetElementCustomEventStrict<CMeterCircleElement['step']>;
+    'thresholdDisplayChanged': JetElementCustomEventStrict<CMeterCircleElement['thresholdDisplay']>;
+    'thresholdsChanged': JetElementCustomEventStrict<CMeterCircleElement['thresholds']>;
+    'transientValueChanged': JetElementCustomEventStrict<CMeterCircleElement['transientValue']>;
+    'valueChanged': JetElementCustomEventStrict<CMeterCircleElement['value']>;
+}
+export interface CMeterCircleElementSettableProperties extends JetSettableProperties {
+    angleExtent?: ComponentProps<typeof MeterCircle>['angleExtent'];
+    color?: ComponentProps<typeof MeterCircle>['color'];
+    datatip?: ComponentProps<typeof MeterCircle>['datatip'];
+    describedBy?: ComponentProps<typeof MeterCircle>['describedBy'];
+    indicatorSize?: ComponentProps<typeof MeterCircle>['indicatorSize'];
+    innerRadius?: ComponentProps<typeof MeterCircle>['innerRadius'];
+    labelledBy?: ComponentProps<typeof MeterCircle>['labelledBy'];
+    max?: ComponentProps<typeof MeterCircle>['max'];
+    min?: ComponentProps<typeof MeterCircle>['min'];
+    plotArea: ComponentProps<typeof MeterCircle>['plotArea'];
+    readonly?: ComponentProps<typeof MeterCircle>['readonly'];
+    referenceLines?: ComponentProps<typeof MeterCircle>['referenceLines'];
+    size?: ComponentProps<typeof MeterCircle>['size'];
+    startAngle?: ComponentProps<typeof MeterCircle>['startAngle'];
+    step?: ComponentProps<typeof MeterCircle>['step'];
+    thresholdDisplay?: ComponentProps<typeof MeterCircle>['thresholdDisplay'];
+    thresholds?: ComponentProps<typeof MeterCircle>['thresholds'];
+    value?: ComponentProps<typeof MeterCircle>['value'];
+}
+export interface CMeterCircleElementSettablePropertiesLenient extends Partial<CMeterCircleElementSettableProperties> {
+    [key: string]: any;
+}
+export interface MeterCircleIntrinsicProps extends Partial<Readonly<CMeterCircleElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    transientValue?: never;
+    children?: import('preact').ComponentChildren;
+    onangleExtentChanged?: (value: CMeterCircleElementEventMap['angleExtentChanged']) => void;
+    oncolorChanged?: (value: CMeterCircleElementEventMap['colorChanged']) => void;
+    ondatatipChanged?: (value: CMeterCircleElementEventMap['datatipChanged']) => void;
+    ondescribedByChanged?: (value: CMeterCircleElementEventMap['describedByChanged']) => void;
+    onindicatorSizeChanged?: (value: CMeterCircleElementEventMap['indicatorSizeChanged']) => void;
+    oninnerRadiusChanged?: (value: CMeterCircleElementEventMap['innerRadiusChanged']) => void;
+    onlabelledByChanged?: (value: CMeterCircleElementEventMap['labelledByChanged']) => void;
+    onmaxChanged?: (value: CMeterCircleElementEventMap['maxChanged']) => void;
+    onminChanged?: (value: CMeterCircleElementEventMap['minChanged']) => void;
+    onplotAreaChanged?: (value: CMeterCircleElementEventMap['plotAreaChanged']) => void;
+    onreadonlyChanged?: (value: CMeterCircleElementEventMap['readonlyChanged']) => void;
+    onreferenceLinesChanged?: (value: CMeterCircleElementEventMap['referenceLinesChanged']) => void;
+    onsizeChanged?: (value: CMeterCircleElementEventMap['sizeChanged']) => void;
+    onstartAngleChanged?: (value: CMeterCircleElementEventMap['startAngleChanged']) => void;
+    onstepChanged?: (value: CMeterCircleElementEventMap['stepChanged']) => void;
+    onthresholdDisplayChanged?: (value: CMeterCircleElementEventMap['thresholdDisplayChanged']) => void;
+    onthresholdsChanged?: (value: CMeterCircleElementEventMap['thresholdsChanged']) => void;
+    ontransientValueChanged?: (value: CMeterCircleElementEventMap['transientValueChanged']) => void;
+    onvalueChanged?: (value: CMeterCircleElementEventMap['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-meter-circle': MeterCircleIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export { ProgressBar } from './progress-bar';
+export { CProgressBarElement } from './progress-bar';

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

@@ -0,0 +1,53 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ProgressBar as PreactProgressBar } from '@oracle/oraclejet-preact/UNSAFE_ProgressBar';
+import { ComponentProps } from 'preact';
+import { ObservedGlobalProps } from 'ojs/ojvcomponent';
+import 'css!oj-c/progress-bar/progress-bar-styles.css';
+declare type PreactProgressBarProps = ComponentProps<typeof PreactProgressBar>;
+export declare const ProgressBar: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-valuetext"> & {
+    max?: number | undefined;
+    value?: number | undefined;
+    edge?: PreactProgressBarProps['edge'];
+}>>;
+export {};
+export interface CProgressBarElement extends JetElement<CProgressBarElementSettableProperties>, CProgressBarElementSettableProperties {
+    addEventListener<T extends keyof CProgressBarElementEventMap>(type: T, listener: (this: HTMLElement, ev: CProgressBarElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CProgressBarElementSettableProperties>(property: T): CProgressBarElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CProgressBarElementSettableProperties>(property: T, value: CProgressBarElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CProgressBarElementSettableProperties>): void;
+    setProperties(properties: CProgressBarElementSettablePropertiesLenient): void;
+}
+export namespace CProgressBarElement {
+    type edgeChanged = JetElementCustomEventStrict<CProgressBarElement['edge']>;
+    type maxChanged = JetElementCustomEventStrict<CProgressBarElement['max']>;
+    type valueChanged = JetElementCustomEventStrict<CProgressBarElement['value']>;
+}
+export interface CProgressBarElementEventMap extends HTMLElementEventMap {
+    'edgeChanged': JetElementCustomEventStrict<CProgressBarElement['edge']>;
+    'maxChanged': JetElementCustomEventStrict<CProgressBarElement['max']>;
+    'valueChanged': JetElementCustomEventStrict<CProgressBarElement['value']>;
+}
+export interface CProgressBarElementSettableProperties extends JetSettableProperties {
+    edge?: ComponentProps<typeof ProgressBar>['edge'];
+    max?: ComponentProps<typeof ProgressBar>['max'];
+    value?: ComponentProps<typeof ProgressBar>['value'];
+}
+export interface CProgressBarElementSettablePropertiesLenient extends Partial<CProgressBarElementSettableProperties> {
+    [key: string]: any;
+}
+export interface ProgressBarIntrinsicProps extends Partial<Readonly<CProgressBarElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    onedgeChanged?: (value: CProgressBarElementEventMap['edgeChanged']) => void;
+    onmaxChanged?: (value: CProgressBarElementEventMap['maxChanged']) => void;
+    onvalueChanged?: (value: CProgressBarElementEventMap['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-progress-bar': ProgressBarIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/progress-circle/index.d.ts

@@ -0,0 +1,2 @@
+export { ProgressCircle } from './progress-circle';
+export { CProgressCircleElement } from './progress-circle';

package/oj-c/types/progress-circle/progress-circle.d.ts

@@ -0,0 +1,53 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ProgressCircle as PreactProgressCircle } from '@oracle/oraclejet-preact/UNSAFE_ProgressCircle';
+import { ComponentProps } from 'preact';
+import { ObservedGlobalProps } from 'ojs/ojvcomponent';
+import 'css!oj-c/progress-circle/progress-circle-styles.css';
+declare type PreactProgressCircleProps = ComponentProps<typeof PreactProgressCircle>;
+export declare const ProgressCircle: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-valuetext"> & {
+    max?: number | undefined;
+    value?: number | undefined;
+    size?: PreactProgressCircleProps['size'];
+}>>;
+export {};
+export interface CProgressCircleElement extends JetElement<CProgressCircleElementSettableProperties>, CProgressCircleElementSettableProperties {
+    addEventListener<T extends keyof CProgressCircleElementEventMap>(type: T, listener: (this: HTMLElement, ev: CProgressCircleElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CProgressCircleElementSettableProperties>(property: T): CProgressCircleElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CProgressCircleElementSettableProperties>(property: T, value: CProgressCircleElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CProgressCircleElementSettableProperties>): void;
+    setProperties(properties: CProgressCircleElementSettablePropertiesLenient): void;
+}
+export namespace CProgressCircleElement {
+    type maxChanged = JetElementCustomEventStrict<CProgressCircleElement['max']>;
+    type sizeChanged = JetElementCustomEventStrict<CProgressCircleElement['size']>;
+    type valueChanged = JetElementCustomEventStrict<CProgressCircleElement['value']>;
+}
+export interface CProgressCircleElementEventMap extends HTMLElementEventMap {
+    'maxChanged': JetElementCustomEventStrict<CProgressCircleElement['max']>;
+    'sizeChanged': JetElementCustomEventStrict<CProgressCircleElement['size']>;
+    'valueChanged': JetElementCustomEventStrict<CProgressCircleElement['value']>;
+}
+export interface CProgressCircleElementSettableProperties extends JetSettableProperties {
+    max?: ComponentProps<typeof ProgressCircle>['max'];
+    size?: ComponentProps<typeof ProgressCircle>['size'];
+    value?: ComponentProps<typeof ProgressCircle>['value'];
+}
+export interface CProgressCircleElementSettablePropertiesLenient extends Partial<CProgressCircleElementSettableProperties> {
+    [key: string]: any;
+}
+export interface ProgressCircleIntrinsicProps extends Partial<Readonly<CProgressCircleElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    onmaxChanged?: (value: CProgressCircleElementEventMap['maxChanged']) => void;
+    onsizeChanged?: (value: CProgressCircleElementEventMap['sizeChanged']) => void;
+    onvalueChanged?: (value: CProgressCircleElementEventMap['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-progress-circle': ProgressCircleIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/rating-gauge/index.d.ts

@@ -0,0 +1,2 @@
+export { RatingGauge } from './rating-gauge';
+export { CRatingGaugeElement } from './rating-gauge';

package/oj-c/types/rating-gauge/rating-gauge.d.ts

@@ -0,0 +1,109 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { RatingGauge as PreactRatingGauge } from '@oracle/oraclejet-preact/UNSAFE_RatingGauge';
+import { ComponentProps } from 'preact';
+import { ObservedGlobalProps, ReadOnlyPropertyChanged, PropertyChanged } from 'ojs/ojvcomponent';
+import 'css!oj-c/rating-gauge/rating-gauge-styles.css';
+declare type PreactRatingGaugeProps = ComponentProps<typeof PreactRatingGauge>;
+declare type DatatipContext = {
+    value: number;
+};
+export declare const RatingGauge: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label"> & {
+    max?: number | undefined;
+    readonly?: boolean | undefined;
+    disabled?: boolean | undefined;
+    changed?: boolean | undefined;
+    onChangedChanged?: PropertyChanged<boolean> | undefined;
+    value?: number | null | undefined;
+    onValueChanged?: PropertyChanged<number | null> | undefined;
+    step?: number | undefined;
+    describedBy?: string | null | undefined;
+    labelledBy?: string | null | undefined;
+    size?: PreactRatingGaugeProps['size'];
+    color?: PreactRatingGaugeProps['color'];
+    datatip?: ((context: DatatipContext) => string) | undefined;
+    tooltip?: string | undefined;
+    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined> | undefined;
+}>>;
+export {};
+export interface CRatingGaugeElement extends JetElement<CRatingGaugeElementSettableProperties>, CRatingGaugeElementSettableProperties {
+    readonly transientValue?: Parameters<Required<ComponentProps<typeof RatingGauge>>['onTransientValueChanged']>[0];
+    addEventListener<T extends keyof CRatingGaugeElementEventMap>(type: T, listener: (this: HTMLElement, ev: CRatingGaugeElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CRatingGaugeElementSettableProperties>(property: T): CRatingGaugeElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CRatingGaugeElementSettableProperties>(property: T, value: CRatingGaugeElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CRatingGaugeElementSettableProperties>): void;
+    setProperties(properties: CRatingGaugeElementSettablePropertiesLenient): void;
+}
+export namespace CRatingGaugeElement {
+    type changedChanged = JetElementCustomEventStrict<CRatingGaugeElement['changed']>;
+    type colorChanged = JetElementCustomEventStrict<CRatingGaugeElement['color']>;
+    type datatipChanged = JetElementCustomEventStrict<CRatingGaugeElement['datatip']>;
+    type describedByChanged = JetElementCustomEventStrict<CRatingGaugeElement['describedBy']>;
+    type disabledChanged = JetElementCustomEventStrict<CRatingGaugeElement['disabled']>;
+    type labelledByChanged = JetElementCustomEventStrict<CRatingGaugeElement['labelledBy']>;
+    type maxChanged = JetElementCustomEventStrict<CRatingGaugeElement['max']>;
+    type readonlyChanged = JetElementCustomEventStrict<CRatingGaugeElement['readonly']>;
+    type sizeChanged = JetElementCustomEventStrict<CRatingGaugeElement['size']>;
+    type stepChanged = JetElementCustomEventStrict<CRatingGaugeElement['step']>;
+    type tooltipChanged = JetElementCustomEventStrict<CRatingGaugeElement['tooltip']>;
+    type transientValueChanged = JetElementCustomEventStrict<CRatingGaugeElement['transientValue']>;
+    type valueChanged = JetElementCustomEventStrict<CRatingGaugeElement['value']>;
+}
+export interface CRatingGaugeElementEventMap extends HTMLElementEventMap {
+    'changedChanged': JetElementCustomEventStrict<CRatingGaugeElement['changed']>;
+    'colorChanged': JetElementCustomEventStrict<CRatingGaugeElement['color']>;
+    'datatipChanged': JetElementCustomEventStrict<CRatingGaugeElement['datatip']>;
+    'describedByChanged': JetElementCustomEventStrict<CRatingGaugeElement['describedBy']>;
+    'disabledChanged': JetElementCustomEventStrict<CRatingGaugeElement['disabled']>;
+    'labelledByChanged': JetElementCustomEventStrict<CRatingGaugeElement['labelledBy']>;
+    'maxChanged': JetElementCustomEventStrict<CRatingGaugeElement['max']>;
+    'readonlyChanged': JetElementCustomEventStrict<CRatingGaugeElement['readonly']>;
+    'sizeChanged': JetElementCustomEventStrict<CRatingGaugeElement['size']>;
+    'stepChanged': JetElementCustomEventStrict<CRatingGaugeElement['step']>;
+    'tooltipChanged': JetElementCustomEventStrict<CRatingGaugeElement['tooltip']>;
+    'transientValueChanged': JetElementCustomEventStrict<CRatingGaugeElement['transientValue']>;
+    'valueChanged': JetElementCustomEventStrict<CRatingGaugeElement['value']>;
+}
+export interface CRatingGaugeElementSettableProperties extends JetSettableProperties {
+    changed?: ComponentProps<typeof RatingGauge>['changed'];
+    color?: ComponentProps<typeof RatingGauge>['color'];
+    datatip?: ComponentProps<typeof RatingGauge>['datatip'];
+    describedBy?: ComponentProps<typeof RatingGauge>['describedBy'];
+    disabled?: ComponentProps<typeof RatingGauge>['disabled'];
+    labelledBy?: ComponentProps<typeof RatingGauge>['labelledBy'];
+    max?: ComponentProps<typeof RatingGauge>['max'];
+    readonly?: ComponentProps<typeof RatingGauge>['readonly'];
+    size?: ComponentProps<typeof RatingGauge>['size'];
+    step?: ComponentProps<typeof RatingGauge>['step'];
+    tooltip?: ComponentProps<typeof RatingGauge>['tooltip'];
+    value?: ComponentProps<typeof RatingGauge>['value'];
+}
+export interface CRatingGaugeElementSettablePropertiesLenient extends Partial<CRatingGaugeElementSettableProperties> {
+    [key: string]: any;
+}
+export interface RatingGaugeIntrinsicProps extends Partial<Readonly<CRatingGaugeElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    transientValue?: never;
+    onchangedChanged?: (value: CRatingGaugeElementEventMap['changedChanged']) => void;
+    oncolorChanged?: (value: CRatingGaugeElementEventMap['colorChanged']) => void;
+    ondatatipChanged?: (value: CRatingGaugeElementEventMap['datatipChanged']) => void;
+    ondescribedByChanged?: (value: CRatingGaugeElementEventMap['describedByChanged']) => void;
+    ondisabledChanged?: (value: CRatingGaugeElementEventMap['disabledChanged']) => void;
+    onlabelledByChanged?: (value: CRatingGaugeElementEventMap['labelledByChanged']) => void;
+    onmaxChanged?: (value: CRatingGaugeElementEventMap['maxChanged']) => void;
+    onreadonlyChanged?: (value: CRatingGaugeElementEventMap['readonlyChanged']) => void;
+    onsizeChanged?: (value: CRatingGaugeElementEventMap['sizeChanged']) => void;
+    onstepChanged?: (value: CRatingGaugeElementEventMap['stepChanged']) => void;
+    ontooltipChanged?: (value: CRatingGaugeElementEventMap['tooltipChanged']) => void;
+    ontransientValueChanged?: (value: CRatingGaugeElementEventMap['transientValueChanged']) => void;
+    onvalueChanged?: (value: CRatingGaugeElementEventMap['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-rating-gauge': RatingGaugeIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/select-common/UNSAFE_useDataProviderListeners/index.d.ts

@@ -0,0 +1,2 @@
+export { useDataProviderListeners } from './useDataProviderListeners';
+export type { UseDataProviderListenerProps } from './useDataProviderListeners';

package/oj-c/types/select-common/UNSAFE_useDataProviderListeners/useDataProviderListeners.d.ts

@@ -0,0 +1,13 @@
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider } from 'ojs/ojdataprovider';
+import { StateUpdater } from 'preact/hooks';
+import { Optional } from '../utils/utils';
+export declare type UseDataProviderListenerProps<K extends string | number, D extends Record<string, any>, V extends K | Set<K>, VI extends ItemContext<K, D> | Map<K, ItemContext<K, D>>> = {
+    dataProvider?: Optional<DataProvider<K, D>>;
+    setValue: StateUpdater<Optional<V>>;
+    setValueToSync: StateUpdater<Optional<V>>;
+    setValueItemsToSync: StateUpdater<Optional<VI>>;
+    value?: Optional<V>;
+    valueItems?: Optional<VI>;
+};
+export declare function useDataProviderListeners<K extends string | number, D extends Record<string, any>, V extends K | Set<K>, VI extends ItemContext<K, D> | Map<K, ItemContext<K, D>>>({ dataProvider, setValue, setValueToSync, setValueItemsToSync, value, valueItems }: UseDataProviderListenerProps<K, D, V, VI>): void;

package/oj-c/types/select-common/UNSAFE_useWrapDataProvider/index.d.ts

@@ -0,0 +1 @@
+export { useWrapDataProvider } from './useWrapDataProvider';