Typedefinitions for Oracle Jet (#29350)

* Initial commit.

Does not compile yet due to strictNullChecks and all. Need to fix those in the next transaction.

* Update to latest version

* npm test fail fix

* fix npm test error

* fix npm test

* fix npm test

* test. move to scoped

* move to scoped

* move to scoped location

* update for scoped

* Update for scoped

* Remove trailing space

types/oracle__oraclejet/index.d.ts

@@ -0,0 +1,60 @@
+// Type definitions for oraclejet 6.0
+// Project: https://github.com/oracle/oraclejet
+// Definitions by: Naizam Olakara <https://github.com/nolakara>
+//                 Jing Wu <https://github.com/jingxwu>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.9
+import { Model, Collection } from './ojmodel';
+export namespace oj {
+    let revision: string;
+    let version: string;
+    function ajax(settings?: object): object;
+    function sync(method: string, model: Model | Collection, options?: object): object;
+}
+export interface baseComponent<SP extends baseComponentSettableProperties = baseComponentSettableProperties> extends JetElement<SP> {
+    translations: object | null;
+    onTranslationsChanged: ((event: JetElementCustomEvent<baseComponent<SP>["translations"]>) => any) | null;
+    addEventListener<T extends keyof baseComponentEventMap<SP>>(type: T, listener: (this: HTMLElement, ev: baseComponentEventMap<SP>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof baseComponentSettableProperties>(property: T): baseComponent<SP>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof baseComponentSettableProperties>(property: T, value: baseComponentSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, baseComponentSettableProperties>): void;
+    setProperties(properties: baseComponentSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface baseComponentEventMap<SP extends baseComponentSettableProperties = baseComponentSettableProperties> extends HTMLElementEventMap {
+    'translationsChanged': JetElementCustomEvent<baseComponent<SP>["translations"]>;
+}
+export interface baseComponentSettableProperties extends JetSettableProperties {
+    translations: object | null;
+}
+export interface baseComponentSettablePropertiesLenient extends Partial<baseComponentSettableProperties> {
+    [key: string]: any;
+}
+export interface GenericSetter<SP> {
+    set<K extends keyof SP>(propertyName: K, propertyValue: SP[K]): void;
+    unset(propertyName: keyof SP): void;
+}
+export interface JetElement<SP> extends HTMLElement, GenericSetter<SP> {
+    set<K extends keyof SP>(propertyName: K, propertyValue: SP[K]): void;
+    unset(propertyName: keyof SP): void;
+}
+export interface JetElementCustomEvent<V> extends CustomEvent<{
+    value: V;
+    previousValue: V;
+    updatedFrom: 'external' | 'internal';
+    subproperty: {
+        path: string;
+        value: any;
+        previousValue: any;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}> {
+}
+// This interfaces is empty but required to keep the component chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface JetSettableProperties {
+}
+export type JetSetPropertyType<K, U extends JetSettableProperties> = K extends keyof U ? U[K] : any;

types/oracle__oraclejet/ojaccordion/index.d.ts

@@ -0,0 +1,66 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojAccordion extends baseComponent<ojAccordionSettableProperties> {
+    expanded: Array<{
+        id?: string;
+        index?: number;
+    }> | null;
+    multiple: boolean;
+    onExpandedChanged: ((event: JetElementCustomEvent<ojAccordion["expanded"]>) => any) | null;
+    onMultipleChanged: ((event: JetElementCustomEvent<ojAccordion["multiple"]>) => any) | null;
+    onOjBeforeCollapse: ((event: ojAccordion.ojBeforeCollapse) => any) | null;
+    onOjBeforeExpand: ((event: ojAccordion.ojBeforeExpand) => any) | null;
+    onOjCollapse: ((event: ojAccordion.ojCollapse) => any) | null;
+    onOjExpand: ((event: ojAccordion.ojExpand) => any) | null;
+    addEventListener<T extends keyof ojAccordionEventMap>(type: T, listener: (this: HTMLElement, ev: ojAccordionEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojAccordionSettableProperties>(property: T): ojAccordion[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojAccordionSettableProperties>(property: T, value: ojAccordionSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojAccordionSettableProperties>): void;
+    setProperties(properties: ojAccordionSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export namespace ojAccordion {
+    interface ojBeforeCollapse extends CustomEvent<{
+        toCollapsible: Element;
+        fromCollapsible: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeExpand extends CustomEvent<{
+        toCollapsible: Element;
+        fromCollapsible: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojCollapse extends CustomEvent<{
+        toCollapsible: Element;
+        fromCollapsible: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojExpand extends CustomEvent<{
+        toCollapsible: Element;
+        fromCollapsible: Element;
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojAccordionEventMap extends baseComponentEventMap<ojAccordionSettableProperties> {
+    'ojBeforeCollapse': ojAccordion.ojBeforeCollapse;
+    'ojBeforeExpand': ojAccordion.ojBeforeExpand;
+    'ojCollapse': ojAccordion.ojCollapse;
+    'ojExpand': ojAccordion.ojExpand;
+    'expandedChanged': JetElementCustomEvent<ojAccordion["expanded"]>;
+    'multipleChanged': JetElementCustomEvent<ojAccordion["multiple"]>;
+}
+export interface ojAccordionSettableProperties extends baseComponentSettableProperties {
+    expanded: string[] | number[] | Array<{
+        id?: string;
+        index?: number;
+    }> | null;
+    multiple: boolean;
+}
+export interface ojAccordionSettablePropertiesLenient extends Partial<ojAccordionSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojanimation/index.d.ts

@@ -0,0 +1,111 @@
+export function collapse(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    direction?: string;
+    startMaxHeight?: string;
+    endMaxHeight?: string;
+    startMaxWidth?: string;
+    endMaxWidth?: string;
+}): Promise<boolean>;
+export function expand(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    direction?: string;
+    startMaxHeight?: string;
+    endMaxHeight?: string;
+    startMaxWidth?: string;
+    endMaxWidth?: string;
+}): Promise<boolean>;
+export function fadeIn(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    startOpacity?: number;
+    endOpacity?: number;
+}): Promise<boolean>;
+export function fadeOut(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    startOpacity?: number;
+    endOpacity?: number;
+}): Promise<boolean>;
+export function flipIn(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    axis?: string;
+    startAngle?: string;
+    endAngle?: string;
+    backfaceVisibility?: string;
+    perspective?: string;
+    transformOrigin?: string;
+    flipTarget?: string;
+}): Promise<boolean>;
+export function flipOut(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    axis?: string;
+    startAngle?: string;
+    endAngle?: string;
+    backfaceVisibility?: string;
+    perspective?: string;
+    transformOrigin?: string;
+    flipTarget?: string;
+}): Promise<boolean>;
+export function ripple(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    offsetX?: string;
+    offsetY?: string;
+    color?: string;
+    diameter?: string;
+    startOpacity?: number;
+    endOpacity?: number;
+}): Promise<boolean>;
+export function slideIn(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    direction?: string;
+    offsetX?: string;
+    offsetY?: string;
+}): Promise<boolean>;
+export function slideOut(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    direction?: string;
+    offsetX?: string;
+    offsetY?: string;
+}): Promise<boolean>;
+export function zoomIn(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    axis?: string;
+    transformOrigin?: string;
+}): Promise<boolean>;
+export function zoomOut(element: Element, options?: {
+    delay?: string;
+    duration?: string;
+    timingFunction?: string;
+    persist?: string;
+    axis?: string;
+    transformOrigin?: string;
+}): Promise<boolean>;
+// tslint:disable-next-line interface-over-type-literal
+export type AnimationMethods = 'collapse' | 'expand' | 'fadeIn' | 'fadeOut' | 'flipIn' | 'flipOut' | 'ripple' | 'slideIn' | 'slideOut' | 'zoomIn' | 'zoomOut';

types/oracle__oraclejet/ojarraydataprovider/index.d.ts

@@ -0,0 +1,27 @@
+import { DataProvider, SortCriterion, FetchByKeysParameters, ContainsKeysResults, FetchByKeysResults, FetchByOffsetParameters, FetchByOffsetResults, FetchListResult,
+   FetchListParameters } from '../ojdataprovider';
+declare class ArrayDataProvider<K, D> implements DataProvider<K, D> {
+    constructor(data: any[] | (() => any[]), options?: {
+        sortComparators?: ArrayDataProvider.SortComparators<D>;
+        implicitSort?: Array<SortCriterion<D>>;
+        keys?: any[] | (() => any[]);
+        idAttribute?: string | string[];
+        keyAttributes?: string | string[];
+    });
+    addEventListener(eventType: string, listener: EventListener): void;
+    containsKeys(params: FetchByKeysParameters<K>): Promise<ContainsKeysResults<K>>;
+    dispatchEvent(evt: Event): boolean;
+    fetchByKeys(params: FetchByKeysParameters<K>): Promise<FetchByKeysResults<K, D>>;
+    fetchByOffset(params: FetchByOffsetParameters<D>): Promise<FetchByOffsetResults<K, D>>;
+    fetchFirst(params?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>;
+    getCapability(capabilityName?: string): any;
+    getTotalSize(): Promise<number>;
+    isEmpty(): 'yes' | 'no' | 'unknown';
+    removeEventListener(eventType: string, listener: EventListener): void;
+}
+export = ArrayDataProvider;
+declare namespace ArrayDataProvider {
+    interface SortComparators<D> {
+        comparators: Map<keyof D, (a: any, b: any) => number>;
+    }
+}

types/oracle__oraclejet/ojarraytreedataprovider/index.d.ts

@@ -0,0 +1,25 @@
+import { DataProvider, SortCriterion, FetchByKeysParameters, ContainsKeysResults, FetchByKeysResults, FetchByOffsetParameters, FetchByOffsetResults, FetchListResult,
+   FetchListParameters } from '../ojdataprovider';
+import ArrayDataProvider = require('../ojarraydataprovider');
+import TreeDataProvider = require('../ojtreedataprovider');
+declare class ArrayTreeDataProvider<K, D> implements TreeDataProvider<K, D> {
+    constructor(data: any[] | (() => any[]), options?: {
+        sortComparators?: ArrayDataProvider.SortComparators<D>;
+        implicitSort?: Array<SortCriterion<D>>;
+        keyAttributes?: string | string[];
+        keyAttributesScope?: 'global' | 'siblings';
+        childrenAttribute?: string;
+    });
+    addEventListener(eventType: string, listener: EventListener): void;
+    containsKeys(params: FetchByKeysParameters<K>): Promise<ContainsKeysResults<K>>;
+    dispatchEvent(evt: Event): boolean;
+    fetchByKeys(params: FetchByKeysParameters<K>): Promise<FetchByKeysResults<K, D>>;
+    fetchByOffset(params: FetchByOffsetParameters<D>): Promise<FetchByOffsetResults<K, D>>;
+    fetchFirst(params?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>;
+    getCapability(capabilityName?: string): any;
+    getChildDataProvider(parentKey: any): ArrayTreeDataProvider<K, D>;
+    getTotalSize(): Promise<number>;
+    isEmpty(): 'yes' | 'no' | 'unknown';
+    removeEventListener(eventType: string, listener: EventListener): void;
+}
+export = ArrayTreeDataProvider;

types/oracle__oraclejet/ojattributegrouphandler/index.d.ts

@@ -0,0 +1,23 @@
+export class AttributeGroupHandler {
+    constructor(matchRules?: {
+        [propName: string]: any;
+    });
+    addMatchRule(category: string, attributeValue: any): void;
+    getCategoryAssignments(): Array<{
+        [propName: string]: any;
+    }>;
+    getValue(category: string): any;
+    getValueRamp(): any[];
+}
+export class ColorAttributeGroupHandler extends AttributeGroupHandler {
+    constructor(matchRules?: {
+        [propName: string]: any;
+    });
+    getValueRamp(): string[];
+}
+export class ShapeAttributeGroupHandler extends AttributeGroupHandler {
+    constructor(matchRules?: {
+        [propName: string]: any;
+    });
+    getValueRamp(): string[];
+}

types/oracle__oraclejet/ojavatar/index.d.ts

@@ -0,0 +1,29 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojAvatar extends JetElement<ojAvatarSettableProperties> {
+    initials: string;
+    size: 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+    src: string;
+    onInitialsChanged: ((event: JetElementCustomEvent<ojAvatar["initials"]>) => any) | null;
+    onSizeChanged: ((event: JetElementCustomEvent<ojAvatar["size"]>) => any) | null;
+    onSrcChanged: ((event: JetElementCustomEvent<ojAvatar["src"]>) => any) | null;
+    addEventListener<T extends keyof ojAvatarEventMap>(type: T, listener: (this: HTMLElement, ev: ojAvatarEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojAvatarSettableProperties>(property: T): ojAvatar[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojAvatarSettableProperties>(property: T, value: ojAvatarSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojAvatarSettableProperties>): void;
+    setProperties(properties: ojAvatarSettablePropertiesLenient): void;
+}
+export interface ojAvatarEventMap extends HTMLElementEventMap {
+    'initialsChanged': JetElementCustomEvent<ojAvatar["initials"]>;
+    'sizeChanged': JetElementCustomEvent<ojAvatar["size"]>;
+    'srcChanged': JetElementCustomEvent<ojAvatar["src"]>;
+}
+export interface ojAvatarSettableProperties extends JetSettableProperties {
+    initials: string;
+    size: 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+    src: string;
+}
+export interface ojAvatarSettablePropertiesLenient extends Partial<ojAvatarSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojbutton/index.d.ts

@@ -0,0 +1,165 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojButton<SP extends ojButtonSettableProperties = ojButtonSettableProperties> extends baseComponent<SP> {
+    chroming: 'full' | 'half' | 'outlined';
+    disabled: boolean;
+    display: 'all' | 'icons';
+    onChromingChanged: ((event: JetElementCustomEvent<ojButton<SP>["chroming"]>) => any) | null;
+    onDisabledChanged: ((event: JetElementCustomEvent<ojButton<SP>["disabled"]>) => any) | null;
+    onDisplayChanged: ((event: JetElementCustomEvent<ojButton<SP>["display"]>) => any) | null;
+    onOjAction: ((event: ojButton.ojAction) => any) | null;
+    addEventListener<T extends keyof ojButtonEventMap<SP>>(type: T, listener: (this: HTMLElement, ev: ojButtonEventMap<SP>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojButtonSettableProperties>(property: T): ojButton<SP>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojButtonSettableProperties>(property: T, value: ojButtonSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojButtonSettableProperties>): void;
+    setProperties(properties: ojButtonSettablePropertiesLenient): void;
+}
+export namespace ojButton {
+    interface ojAction extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojButtonEventMap<SP extends ojButtonSettableProperties = ojButtonSettableProperties> extends baseComponentEventMap<SP> {
+    'ojAction': ojButton.ojAction;
+    'chromingChanged': JetElementCustomEvent<ojButton<SP>["chroming"]>;
+    'disabledChanged': JetElementCustomEvent<ojButton<SP>["disabled"]>;
+    'displayChanged': JetElementCustomEvent<ojButton<SP>["display"]>;
+}
+export interface ojButtonSettableProperties extends baseComponentSettableProperties {
+    chroming: 'full' | 'half' | 'outlined';
+    disabled: boolean;
+    display: 'all' | 'icons';
+}
+export interface ojButtonSettablePropertiesLenient extends Partial<ojButtonSettableProperties> {
+    [key: string]: any;
+}
+export interface ojButtonset<SP extends ojButtonsetSettableProperties = ojButtonsetSettableProperties> extends baseComponent<SP> {
+    addEventListener<T extends keyof ojButtonsetEventMap<SP>>(type: T, listener: (this: HTMLElement, ev: ojButtonsetEventMap<SP>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojButtonsetSettableProperties>(property: T): ojButtonset<SP>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojButtonsetSettableProperties>(property: T, value: ojButtonsetSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojButtonsetSettableProperties>): void;
+    setProperties(properties: ojButtonsetSettablePropertiesLenient): void;
+}
+// These interfaces are empty but required to keep the event chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface ojButtonsetEventMap<SP extends ojButtonsetSettableProperties = ojButtonsetSettableProperties> extends baseComponentEventMap<SP> {
+}
+// These interfaces are empty but required to keep the component chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface ojButtonsetSettableProperties extends baseComponentSettableProperties {
+}
+export interface ojButtonsetSettablePropertiesLenient extends Partial<ojButtonsetSettableProperties> {
+    [key: string]: any;
+}
+export interface ojButtonsetMany extends ojButtonset<ojButtonsetManySettableProperties> {
+    chroming: 'full' | 'half' | 'outlined';
+    disabled: boolean;
+    display: 'all' | 'icons';
+    focusManagement: 'oneTabstop' | 'none';
+    value: any[] | null;
+    onChromingChanged: ((event: JetElementCustomEvent<ojButtonsetMany["chroming"]>) => any) | null;
+    onDisabledChanged: ((event: JetElementCustomEvent<ojButtonsetMany["disabled"]>) => any) | null;
+    onDisplayChanged: ((event: JetElementCustomEvent<ojButtonsetMany["display"]>) => any) | null;
+    onFocusManagementChanged: ((event: JetElementCustomEvent<ojButtonsetMany["focusManagement"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojButtonsetMany["value"]>) => any) | null;
+    addEventListener<T extends keyof ojButtonsetManyEventMap>(type: T, listener: (this: HTMLElement, ev: ojButtonsetManyEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojButtonsetManySettableProperties>(property: T): ojButtonsetMany[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojButtonsetManySettableProperties>(property: T, value: ojButtonsetManySettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojButtonsetManySettableProperties>): void;
+    setProperties(properties: ojButtonsetManySettablePropertiesLenient): void;
+}
+export interface ojButtonsetManyEventMap extends ojButtonsetEventMap<ojButtonsetManySettableProperties> {
+    'chromingChanged': JetElementCustomEvent<ojButtonsetMany["chroming"]>;
+    'disabledChanged': JetElementCustomEvent<ojButtonsetMany["disabled"]>;
+    'displayChanged': JetElementCustomEvent<ojButtonsetMany["display"]>;
+    'focusManagementChanged': JetElementCustomEvent<ojButtonsetMany["focusManagement"]>;
+    'valueChanged': JetElementCustomEvent<ojButtonsetMany["value"]>;
+}
+export interface ojButtonsetManySettableProperties extends ojButtonsetSettableProperties {
+    chroming: 'full' | 'half' | 'outlined';
+    disabled: boolean;
+    display: 'all' | 'icons';
+    focusManagement: 'oneTabstop' | 'none';
+    value: any[] | null;
+}
+export interface ojButtonsetManySettablePropertiesLenient extends Partial<ojButtonsetManySettableProperties> {
+    [key: string]: any;
+}
+export interface ojButtonsetOne extends ojButtonset<ojButtonsetOneSettableProperties> {
+    chroming: 'full' | 'half' | 'outlined';
+    disabled: boolean;
+    display: 'all' | 'icons';
+    focusManagement: 'oneTabstop' | 'none';
+    value: any;
+    onChromingChanged: ((event: JetElementCustomEvent<ojButtonsetOne["chroming"]>) => any) | null;
+    onDisabledChanged: ((event: JetElementCustomEvent<ojButtonsetOne["disabled"]>) => any) | null;
+    onDisplayChanged: ((event: JetElementCustomEvent<ojButtonsetOne["display"]>) => any) | null;
+    onFocusManagementChanged: ((event: JetElementCustomEvent<ojButtonsetOne["focusManagement"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojButtonsetOne["value"]>) => any) | null;
+    addEventListener<T extends keyof ojButtonsetOneEventMap>(type: T, listener: (this: HTMLElement, ev: ojButtonsetOneEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojButtonsetOneSettableProperties>(property: T): ojButtonsetOne[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojButtonsetOneSettableProperties>(property: T, value: ojButtonsetOneSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojButtonsetOneSettableProperties>): void;
+    setProperties(properties: ojButtonsetOneSettablePropertiesLenient): void;
+}
+export interface ojButtonsetOneEventMap extends ojButtonsetEventMap<ojButtonsetOneSettableProperties> {
+    'chromingChanged': JetElementCustomEvent<ojButtonsetOne["chroming"]>;
+    'disabledChanged': JetElementCustomEvent<ojButtonsetOne["disabled"]>;
+    'displayChanged': JetElementCustomEvent<ojButtonsetOne["display"]>;
+    'focusManagementChanged': JetElementCustomEvent<ojButtonsetOne["focusManagement"]>;
+    'valueChanged': JetElementCustomEvent<ojButtonsetOne["value"]>;
+}
+export interface ojButtonsetOneSettableProperties extends ojButtonsetSettableProperties {
+    chroming: 'full' | 'half' | 'outlined';
+    disabled: boolean;
+    display: 'all' | 'icons';
+    focusManagement: 'oneTabstop' | 'none';
+    value: any;
+}
+export interface ojButtonsetOneSettablePropertiesLenient extends Partial<ojButtonsetOneSettableProperties> {
+    [key: string]: any;
+}
+export interface ojMenuButton extends ojButton<ojMenuButtonSettableProperties> {
+    chroming: 'full' | 'half' | 'outlined';
+    disabled: boolean;
+    display: 'all' | 'icons';
+    onChromingChanged: ((event: JetElementCustomEvent<ojMenuButton["chroming"]>) => any) | null;
+    onDisabledChanged: ((event: JetElementCustomEvent<ojMenuButton["disabled"]>) => any) | null;
+    onDisplayChanged: ((event: JetElementCustomEvent<ojMenuButton["display"]>) => any) | null;
+    onOjAction: ((event: ojMenuButton.ojAction) => any) | null;
+    addEventListener<T extends keyof ojMenuButtonEventMap>(type: T, listener: (this: HTMLElement, ev: ojMenuButtonEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojMenuButtonSettableProperties>(property: T): ojMenuButton[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojMenuButtonSettableProperties>(property: T, value: ojMenuButtonSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojMenuButtonSettableProperties>): void;
+    setProperties(properties: ojMenuButtonSettablePropertiesLenient): void;
+}
+export namespace ojMenuButton {
+    interface ojAction extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojMenuButtonEventMap extends ojButtonEventMap<ojMenuButtonSettableProperties> {
+    'ojAction': ojMenuButton.ojAction;
+    'chromingChanged': JetElementCustomEvent<ojMenuButton["chroming"]>;
+    'disabledChanged': JetElementCustomEvent<ojMenuButton["disabled"]>;
+    'displayChanged': JetElementCustomEvent<ojMenuButton["display"]>;
+}
+export interface ojMenuButtonSettableProperties extends ojButtonSettableProperties {
+    chroming: 'full' | 'half' | 'outlined';
+    disabled: boolean;
+    display: 'all' | 'icons';
+}
+export interface ojMenuButtonSettablePropertiesLenient extends Partial<ojMenuButtonSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojcheckboxset/index.d.ts

@@ -0,0 +1,69 @@
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojCheckboxset extends editableValue<any[], ojCheckboxsetSettableProperties> {
+    disabled: boolean;
+    labelledBy: string | null;
+    required: boolean;
+    value: any[];
+    translations: {
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+    onDisabledChanged: ((event: JetElementCustomEvent<ojCheckboxset["disabled"]>) => any) | null;
+    onLabelledByChanged: ((event: JetElementCustomEvent<ojCheckboxset["labelledBy"]>) => any) | null;
+    onRequiredChanged: ((event: JetElementCustomEvent<ojCheckboxset["required"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojCheckboxset["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojCheckboxset.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojCheckboxset.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojCheckboxsetEventMap>(type: T, listener: (this: HTMLElement, ev: ojCheckboxsetEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojCheckboxsetSettableProperties>(property: T): ojCheckboxset[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojCheckboxsetSettableProperties>(property: T, value: ojCheckboxsetSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojCheckboxsetSettableProperties>): void;
+    setProperties(properties: ojCheckboxsetSettablePropertiesLenient): void;
+    refresh(): void;
+    validate(): Promise<string>;
+}
+export namespace ojCheckboxset {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojCheckboxsetEventMap extends editableValueEventMap<any[], ojCheckboxsetSettableProperties> {
+    'ojAnimateEnd': ojCheckboxset.ojAnimateEnd;
+    'ojAnimateStart': ojCheckboxset.ojAnimateStart;
+    'disabledChanged': JetElementCustomEvent<ojCheckboxset["disabled"]>;
+    'labelledByChanged': JetElementCustomEvent<ojCheckboxset["labelledBy"]>;
+    'requiredChanged': JetElementCustomEvent<ojCheckboxset["required"]>;
+    'valueChanged': JetElementCustomEvent<ojCheckboxset["value"]>;
+}
+export interface ojCheckboxsetSettableProperties extends editableValueSettableProperties<any[]> {
+    disabled: boolean;
+    labelledBy: string | null;
+    required: boolean;
+    value: any[];
+    translations: {
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+}
+export interface ojCheckboxsetSettablePropertiesLenient extends Partial<ojCheckboxsetSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojcollapsible/index.d.ts

@@ -0,0 +1,64 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojCollapsible extends baseComponent<ojCollapsibleSettableProperties> {
+    disabled: boolean;
+    expandArea: 'header' | 'disclosureIcon';
+    expanded: boolean;
+    onDisabledChanged: ((event: JetElementCustomEvent<ojCollapsible["disabled"]>) => any) | null;
+    onExpandAreaChanged: ((event: JetElementCustomEvent<ojCollapsible["expandArea"]>) => any) | null;
+    onExpandedChanged: ((event: JetElementCustomEvent<ojCollapsible["expanded"]>) => any) | null;
+    onOjBeforeCollapse: ((event: ojCollapsible.ojBeforeCollapse) => any) | null;
+    onOjBeforeExpand: ((event: ojCollapsible.ojBeforeExpand) => any) | null;
+    onOjCollapse: ((event: ojCollapsible.ojCollapse) => any) | null;
+    onOjExpand: ((event: ojCollapsible.ojExpand) => any) | null;
+    addEventListener<T extends keyof ojCollapsibleEventMap>(type: T, listener: (this: HTMLElement, ev: ojCollapsibleEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojCollapsibleSettableProperties>(property: T): ojCollapsible[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojCollapsibleSettableProperties>(property: T, value: ojCollapsibleSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojCollapsibleSettableProperties>): void;
+    setProperties(properties: ojCollapsibleSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export namespace ojCollapsible {
+    interface ojBeforeCollapse extends CustomEvent<{
+        header: Element;
+        content: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeExpand extends CustomEvent<{
+        header: Element;
+        content: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojCollapse extends CustomEvent<{
+        header: Element;
+        content: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojExpand extends CustomEvent<{
+        header: Element;
+        content: Element;
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojCollapsibleEventMap extends baseComponentEventMap<ojCollapsibleSettableProperties> {
+    'ojBeforeCollapse': ojCollapsible.ojBeforeCollapse;
+    'ojBeforeExpand': ojCollapsible.ojBeforeExpand;
+    'ojCollapse': ojCollapsible.ojCollapse;
+    'ojExpand': ojCollapsible.ojExpand;
+    'disabledChanged': JetElementCustomEvent<ojCollapsible["disabled"]>;
+    'expandAreaChanged': JetElementCustomEvent<ojCollapsible["expandArea"]>;
+    'expandedChanged': JetElementCustomEvent<ojCollapsible["expanded"]>;
+}
+export interface ojCollapsibleSettableProperties extends baseComponentSettableProperties {
+    disabled: boolean;
+    expandArea: 'header' | 'disclosureIcon';
+    expanded: boolean;
+}
+export interface ojCollapsibleSettablePropertiesLenient extends Partial<ojCollapsibleSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojcollectiondataprovider/index.d.ts

@@ -0,0 +1,16 @@
+import { Collection } from '../ojmodel';
+import { DataProvider, FetchByKeysParameters, ContainsKeysResults, FetchByKeysResults, FetchByOffsetParameters, FetchByOffsetResults, FetchListResult, FetchListParameters } from '../ojdataprovider';
+declare class CollectionDataProvider<K, D> implements DataProvider<K, D> {
+    constructor(collection: Collection);
+    addEventListener(eventType: string, listener: EventListener): void;
+    containsKeys(params: FetchByKeysParameters<K>): Promise<ContainsKeysResults<K>>;
+    dispatchEvent(evt: Event): boolean;
+    fetchByKeys(params: FetchByKeysParameters<K>): Promise<FetchByKeysResults<K, D>>;
+    fetchByOffset(params: FetchByOffsetParameters<D>): Promise<FetchByOffsetResults<K, D>>;
+    fetchFirst(params?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>;
+    getCapability(capabilityName?: string): any;
+    getTotalSize(): Promise<number>;
+    isEmpty(): 'yes' | 'no' | 'unknown';
+    removeEventListener(eventType: string, listener: EventListener): void;
+}
+export = CollectionDataProvider;

types/oracle__oraclejet/ojcolor/index.d.ts

@@ -0,0 +1,182 @@
+declare class Color {
+    static ALICEBLUE: Color;
+    static ANTIQUEWHITE: Color;
+    static AQUA: Color;
+    static AQUAMARINE: Color;
+    static AZURE: Color;
+    static BEIGE: Color;
+    static BISQUE: Color;
+    static BLACK: Color;
+    static BLANCHEDALMOND: Color;
+    static BLUE: Color;
+    static BLUEVIOLET: Color;
+    static BROWN: Color;
+    static BURLYWOOD: Color;
+    static CADETBLUE: Color;
+    static CHARTREUSE: Color;
+    static CHOCOLATE: Color;
+    static CORAL: Color;
+    static CORNFLOWERBLUE: Color;
+    static CORNSILK: Color;
+    static CRIMSON: Color;
+    static CYAN: Color;
+    static DARKBLUE: Color;
+    static DARKCYAN: Color;
+    static DARKGOLDENROD: Color;
+    static DARKGRAY: Color;
+    static DARKGREEN: Color;
+    static DARKGREY: Color;
+    static DARKKHAKI: Color;
+    static DARKMAGENTA: Color;
+    static DARKOLIVEGREEN: Color;
+    static DARKORANGE: Color;
+    static DARKORCHID: Color;
+    static DARKRED: Color;
+    static DARKSALMON: Color;
+    static DARKSEAGREEN: Color;
+    static DARKSLATEBLUE: Color;
+    static DARKSLATEGRAY: Color;
+    static DARKSLATEGREY: Color;
+    static DARKTURQUOISE: Color;
+    static DARKVIOLET: Color;
+    static DEEPPINK: Color;
+    static DEEPSKYBLUE: Color;
+    static DIMGRAY: Color;
+    static DIMGREY: Color;
+    static DODGERBLUE: Color;
+    static FIREBRICK: Color;
+    static FLORALWHITE: Color;
+    static FORESTGREEN: Color;
+    static FUCHSIA: Color;
+    static GAINSBORO: Color;
+    static GHOSTWHITE: Color;
+    static GOLD: Color;
+    static GOLDENROD: Color;
+    static GRAY: Color;
+    static GREEN: Color;
+    static GREENYELLOW: Color;
+    static GREY: Color;
+    static HONEYDEW: Color;
+    static HOTPINK: Color;
+    static INDIANRED: Color;
+    static INDIGO: Color;
+    static IVORY: Color;
+    static KHAKI: Color;
+    static LAVENDER: Color;
+    static LAVENDERBLUSH: Color;
+    static LAWNGREEN: Color;
+    static LEMONCHIFFON: Color;
+    static LIGHTBLUE: Color;
+    static LIGHTCORAL: Color;
+    static LIGHTCYAN: Color;
+    static LIGHTGOLDENRODYELLOW: Color;
+    static LIGHTGRAY: Color;
+    static LIGHTGREEN: Color;
+    static LIGHTGREY: Color;
+    static LIGHTPINK: Color;
+    static LIGHTSALMON: Color;
+    static LIGHTSEAGREEN: Color;
+    static LIGHTSKYBLUE: Color;
+    static LIGHTSLATEGRAY: Color;
+    static LIGHTSLATEGREY: Color;
+    static LIGHTSTEELBLUE: Color;
+    static LIGHTYELLOW: Color;
+    static LIME: Color;
+    static LIMEGREEN: Color;
+    static LINEN: Color;
+    static MAGENTA: Color;
+    static MAROON: Color;
+    static MEDIUMAQUAMARINE: Color;
+    static MEDIUMBLUE: Color;
+    static MEDIUMORCHID: Color;
+    static MEDIUMPURPLE: Color;
+    static MEDIUMSEAGREEN: Color;
+    static MEDIUMSLATEBLUE: Color;
+    static MEDIUMSPRINGGREEN: Color;
+    static MEDIUMTURQUOISE: Color;
+    static MEDIUMVIOLETRED: Color;
+    static MIDNIGHTBLUE: Color;
+    static MINTCREAM: Color;
+    static MISTYROSE: Color;
+    static MOCCASIN: Color;
+    static NAVAJOWHITE: Color;
+    static NAVY: Color;
+    static OLDLACE: Color;
+    static OLIVE: Color;
+    static OLIVEDRAB: Color;
+    static ORANGE: Color;
+    static ORANGERED: Color;
+    static ORCHID: Color;
+    static PALEGOLDENROD: Color;
+    static PALEGREEN: Color;
+    static PALETURQUOISE: Color;
+    static PALEVIOLETRED: Color;
+    static PAPAYAWHIP: Color;
+    static PEACHPUFF: Color;
+    static PERU: Color;
+    static PINK: Color;
+    static PLUM: Color;
+    static POWDERBLUE: Color;
+    static PURPLE: Color;
+    static REBECCAPURPLE: Color;
+    static RED: Color;
+    static ROSYBROWN: Color;
+    static ROYALBLUE: Color;
+    static SADDLEBROWN: Color;
+    static SALMON: Color;
+    static SANDYBROWN: Color;
+    static SEAGREEN: Color;
+    static SEASHELL: Color;
+    static SIENNA: Color;
+    static SILVER: Color;
+    static SKYBLUE: Color;
+    static SLATEBLUE: Color;
+    static SLATEGRAY: Color;
+    static SLATEGREY: Color;
+    static SNOW: Color;
+    static SPRINGGREEN: Color;
+    static STEELBLUE: Color;
+    static TAN: Color;
+    static TEAL: Color;
+    static THISTLE: Color;
+    static TOMATO: Color;
+    static TRANSPARENT: Color;
+    static TURQUOISE: Color;
+    static VIOLET: Color;
+    static WHEAT: Color;
+    static WHITE: Color;
+    static WHITESMOKE: Color;
+    static YELLOW: Color;
+    static YELLOWGREEN: Color;
+    constructor(color: string | Color.RGBA | Color.HSLA | Color.HSVA);
+    getAlpha(): number;
+    getBlue(doNotRound?: boolean): number;
+    getGreen(doNotRound?: boolean): number;
+    getRed(doNotRound?: boolean): number;
+    isEqual(color: Color): boolean;
+    toString(): string;
+}
+declare namespace Color {
+    // tslint:disable-next-line interface-over-type-literal
+    type HSLA = {
+        h: number;
+        s: number;
+        l: number;
+        a?: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type HSVA = {
+        h: number;
+        s: number;
+        v: number;
+        a?: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RGBA = {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    };
+}
+export = Color;

types/oracle__oraclejet/ojcolorpalette/index.d.ts

@@ -0,0 +1,74 @@
+import Color = require('../ojcolor');
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojColorPalette extends editableValue<Color, ojColorPaletteSettableProperties> {
+    labelDisplay: 'auto' | 'off';
+    labelledBy: string | null;
+    layout: 'grid' | 'list';
+    palette: Array<{
+        color: Color;
+        label?: string;
+    }>;
+    swatchSize: 'xs' | 'sm' | 'lg';
+    value: Color;
+    translations: {
+        labelNone?: string;
+    };
+    onLabelDisplayChanged: ((event: JetElementCustomEvent<ojColorPalette["labelDisplay"]>) => any) | null;
+    onLabelledByChanged: ((event: JetElementCustomEvent<ojColorPalette["labelledBy"]>) => any) | null;
+    onLayoutChanged: ((event: JetElementCustomEvent<ojColorPalette["layout"]>) => any) | null;
+    onPaletteChanged: ((event: JetElementCustomEvent<ojColorPalette["palette"]>) => any) | null;
+    onSwatchSizeChanged: ((event: JetElementCustomEvent<ojColorPalette["swatchSize"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojColorPalette["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojColorPalette.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojColorPalette.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojColorPaletteEventMap>(type: T, listener: (this: HTMLElement, ev: ojColorPaletteEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojColorPaletteSettableProperties>(property: T): ojColorPalette[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojColorPaletteSettableProperties>(property: T, value: ojColorPaletteSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojColorPaletteSettableProperties>): void;
+    setProperties(properties: ojColorPaletteSettablePropertiesLenient): void;
+}
+export namespace ojColorPalette {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojColorPaletteEventMap extends editableValueEventMap<Color, ojColorPaletteSettableProperties> {
+    'ojAnimateEnd': ojColorPalette.ojAnimateEnd;
+    'ojAnimateStart': ojColorPalette.ojAnimateStart;
+    'labelDisplayChanged': JetElementCustomEvent<ojColorPalette["labelDisplay"]>;
+    'labelledByChanged': JetElementCustomEvent<ojColorPalette["labelledBy"]>;
+    'layoutChanged': JetElementCustomEvent<ojColorPalette["layout"]>;
+    'paletteChanged': JetElementCustomEvent<ojColorPalette["palette"]>;
+    'swatchSizeChanged': JetElementCustomEvent<ojColorPalette["swatchSize"]>;
+    'valueChanged': JetElementCustomEvent<ojColorPalette["value"]>;
+}
+export interface ojColorPaletteSettableProperties extends editableValueSettableProperties<Color> {
+    labelDisplay: 'auto' | 'off';
+    labelledBy: string | null;
+    layout: 'grid' | 'list';
+    palette: Array<{
+        color: Color;
+        label?: string;
+    }>;
+    swatchSize: 'xs' | 'sm' | 'lg';
+    value: Color;
+    translations: {
+        labelNone?: string;
+    };
+}
+export interface ojColorPaletteSettablePropertiesLenient extends Partial<ojColorPaletteSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojcolorspectrum/index.d.ts

@@ -0,0 +1,62 @@
+import Color = require('../ojcolor');
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojColorSpectrum extends editableValue<Color, ojColorSpectrumSettableProperties> {
+    labelledBy: string | null;
+    readonly transientValue: Color;
+    value: Color;
+    translations: {
+        labelHue?: string;
+        labelOpacity?: string;
+        labelSatLum?: string;
+        labelThumbDesc?: string;
+    };
+    onLabelledByChanged: ((event: JetElementCustomEvent<ojColorSpectrum["labelledBy"]>) => any) | null;
+    onTransientValueChanged: ((event: JetElementCustomEvent<ojColorSpectrum["transientValue"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojColorSpectrum["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojColorSpectrum.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojColorSpectrum.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojColorSpectrumEventMap>(type: T, listener: (this: HTMLElement, ev: ojColorSpectrumEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojColorSpectrumSettableProperties>(property: T): ojColorSpectrum[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojColorSpectrumSettableProperties>(property: T, value: ojColorSpectrumSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojColorSpectrumSettableProperties>): void;
+    setProperties(properties: ojColorSpectrumSettablePropertiesLenient): void;
+}
+export namespace ojColorSpectrum {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojColorSpectrumEventMap extends editableValueEventMap<Color, ojColorSpectrumSettableProperties> {
+    'ojAnimateEnd': ojColorSpectrum.ojAnimateEnd;
+    'ojAnimateStart': ojColorSpectrum.ojAnimateStart;
+    'labelledByChanged': JetElementCustomEvent<ojColorSpectrum["labelledBy"]>;
+    'transientValueChanged': JetElementCustomEvent<ojColorSpectrum["transientValue"]>;
+    'valueChanged': JetElementCustomEvent<ojColorSpectrum["value"]>;
+}
+export interface ojColorSpectrumSettableProperties extends editableValueSettableProperties<Color> {
+    labelledBy: string | null;
+    readonly transientValue: Color;
+    value: Color;
+    translations: {
+        labelHue?: string;
+        labelOpacity?: string;
+        labelSatLum?: string;
+        labelThumbDesc?: string;
+    };
+}
+export interface ojColorSpectrumSettablePropertiesLenient extends Partial<ojColorSpectrumSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojcomponentcore/index.d.ts

@@ -0,0 +1,6 @@
+export function subtreeAttached(node: Element): void;
+export function subtreeDetached(node: Element): void;
+export function subtreeHidden(node: Element): void;
+export function subtreeShown(node: Element, options?: {
+    initialRender: boolean;
+}): void;

types/oracle__oraclejet/ojcomposite/index.d.ts

@@ -0,0 +1,45 @@
+export function getComponentMetadata(name: string): Metadata | null;
+export function register(name: string, descriptor: {
+    metadata: Metadata;
+    view: string;
+    viewModel: ((param0: ViewModelContext) => void | object);
+    parseFunction: ((value: string, name: string, meta: object, defaultParseFunction: (value: string) => any) => any);
+}): void;
+// tslint:disable-next-line interface-over-type-literal
+export type Metadata = {
+    name: string;
+    version: string;
+    jetVersion: string;
+    properties?: object;
+    methods?: object;
+    events?: object;
+    slots?: object;
+};
+// tslint:disable-next-line interface-over-type-literal
+export type PropertyChangedContext = {
+    property: string;
+    value: any;
+    previousValue: any;
+    updatedFrom: 'external' | 'internal';
+    subproperty?: {
+        path: string;
+        value: any;
+        previousValue: any;
+    };
+};
+// tslint:disable-next-line interface-over-type-literal
+export type ViewModel = {
+    activated: ((param0: ViewModelContext) => Promise<any> | void);
+    connected: ((param0: ViewModelContext) => void);
+    bindingsApplied: ((param0: ViewModelContext) => void);
+    propertyChanged: ((param0: PropertyChangedContext) => void);
+    disconnected: ((param0: Element) => void);
+};
+// tslint:disable-next-line interface-over-type-literal
+export type ViewModelContext = {
+    element: Element;
+    properties: object;
+    slotCounts: object;
+    unique: string;
+    uniqueId: string;
+};

types/oracle__oraclejet/ojconfig/index.d.ts

@@ -0,0 +1,9 @@
+export function getAutomationMode(): string;
+export function getDeviceType(): 'phone' | 'tablet' | 'others';
+export function getLocale(): string;
+export function getResourceUrl(relativePath: string): string;
+export function getVersionInfo(): string;
+export function logVersionInfo(): undefined;
+export function setAutomationMode(mode: string): undefined;
+export function setLocale(locale: string, callback?: (() => void)): undefined;
+export function setResourceBaseUrl(baseUrl: string): undefined;

types/oracle__oraclejet/ojcontext/index.d.ts

@@ -0,0 +1,39 @@
+declare class BusyContext {
+    addBusyState(options: {
+        description: object | (() => string);
+    }): (() => void);
+    applicationBootstrapComplete(): undefined;
+    clear(): undefined;
+    dump(message?: string): undefined;
+    getBusyStates(): Array<{
+        id: string;
+        description: string;
+    }>;
+    isReady(): boolean;
+    toString(): string;
+    whenReady(timeout?: number): Promise<(boolean | Error)>;
+}
+declare namespace Context {
+    interface BusyContext {
+        addBusyState(options: {
+            description: object | (() => string);
+        }): (() => void);
+        applicationBootstrapComplete(): undefined;
+        clear(): undefined;
+        dump(message?: string): undefined;
+        getBusyStates(): Array<{
+            id: string;
+            description: string;
+        }>;
+        isReady(): boolean;
+        toString(): string;
+        whenReady(timeout?: number): Promise<(boolean | Error)>;
+    }
+}
+declare class Context {
+    static getContext(node: Element): Context;
+    static getPageContext(): Context;
+    static setBusyContextDefaultTimeout(timeout: number): any;
+    getBusyContext(): BusyContext;
+}
+export = Context;

types/oracle__oraclejet/ojconveyorbelt/index.d.ts

@@ -0,0 +1,26 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojConveyorBelt extends baseComponent<ojConveyorBeltSettableProperties> {
+    contentParent: string | null;
+    orientation: 'horizontal' | 'vertical';
+    onContentParentChanged: ((event: JetElementCustomEvent<ojConveyorBelt["contentParent"]>) => any) | null;
+    onOrientationChanged: ((event: JetElementCustomEvent<ojConveyorBelt["orientation"]>) => any) | null;
+    addEventListener<T extends keyof ojConveyorBeltEventMap>(type: T, listener: (this: HTMLElement, ev: ojConveyorBeltEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojConveyorBeltSettableProperties>(property: T): ojConveyorBelt[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojConveyorBeltSettableProperties>(property: T, value: ojConveyorBeltSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojConveyorBeltSettableProperties>): void;
+    setProperties(properties: ojConveyorBeltSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface ojConveyorBeltEventMap extends baseComponentEventMap<ojConveyorBeltSettableProperties> {
+    'contentParentChanged': JetElementCustomEvent<ojConveyorBelt["contentParent"]>;
+    'orientationChanged': JetElementCustomEvent<ojConveyorBelt["orientation"]>;
+}
+export interface ojConveyorBeltSettableProperties extends baseComponentSettableProperties {
+    contentParent: string | null;
+    orientation: 'horizontal' | 'vertical';
+}
+export interface ojConveyorBeltSettablePropertiesLenient extends Partial<ojConveyorBeltSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojdatagrid/index.d.ts

@@ -0,0 +1,520 @@
+import { DataProvider } from '../ojdataprovider';
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojDataGrid<K, D> extends baseComponent<ojDataGridSettableProperties<K, D>> {
+    bandingInterval: {
+        column: number;
+        row: number;
+    };
+    cell: {
+        className?: ((context: ojDataGrid.CellContext<K, D>) => string | void | null) | string | null;
+        renderer?: ((context: ojDataGrid.CellContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void | null) | null;
+        style?: ((context: ojDataGrid.CellContext<K, D>) => string | void | null) | string | null;
+    };
+    currentCell: ojDataGrid.CurrentCell<K> | null;
+    data: DataProvider<K, D>;
+    dnd: {
+        reorder: {
+            row: 'enable' | 'disable';
+        };
+    };
+    editMode: 'none' | 'cellNavigation' | 'cellEdit';
+    gridlines: {
+        horizontal: 'visible' | 'hidden';
+        vertical: 'visible' | 'hidden';
+    };
+    header: {
+        column: {
+            className?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            label: {
+                className?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+                renderer?: ((context: ojDataGrid.LabelContext<K, D>) => {
+                    insert: HTMLElement | string;
+                } | void | null) | null;
+                style?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+            };
+            renderer?: ((context: ojDataGrid.HeaderContext<K, D>) => {
+                insert: HTMLElement | string;
+            } | void | null) | null;
+            resizable: {
+                height: 'enable' | 'disable';
+                width?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+            };
+            sortable?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+            style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+        };
+        columnEnd: {
+            className?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            label: {
+                className?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+                renderer?: ((context: ojDataGrid.LabelContext<K, D>) => {
+                    insert: HTMLElement | string;
+                } | void | null) | null;
+                style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            };
+            renderer?: ((context: ojDataGrid.HeaderContext<K, D>) => {
+                insert: HTMLElement | string;
+            } | void | null) | null;
+            resizable: {
+                height: 'enable' | 'disable';
+                width?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+            };
+            style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+        };
+        row: {
+            className?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            label: {
+                className?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+                renderer?: ((context: ojDataGrid.LabelContext<K, D>) => {
+                    insert: HTMLElement | string;
+                } | void | null) | null;
+                style?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+            };
+            renderer?: ((context: ojDataGrid.HeaderContext<K, D>) => {
+                insert: HTMLElement | string;
+            } | void | null) | null;
+            resizable: {
+                height?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+                width: 'enable' | 'disable';
+            };
+            sortable?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+            style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+        };
+        rowEnd: {
+            className?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            label: {
+                className?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+                renderer?: ((context: ojDataGrid.LabelContext<K, D>) => {
+                    insert: HTMLElement | string;
+                } | void | null) | null;
+                style?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+            };
+            renderer?: ((context: ojDataGrid.HeaderContext<K, D>) => {
+                insert: HTMLElement | string;
+            } | void | null) | null;
+            resizable: {
+                height?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+                width: 'enable' | 'disable';
+            };
+            style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+        };
+    };
+    scrollPolicy: 'auto' | 'loadMoreOnScroll' | 'scroll';
+    scrollPolicyOptions: {
+        maxColumnCount: number;
+        maxRowCount: number;
+    };
+    scrollPosition: {
+        x?: number;
+        y?: number;
+        rowIndex?: number;
+        columnIndex?: number;
+        rowKey?: K;
+        columnKey?: K;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    selection: Array<ojDataGrid.Selection<K>>;
+    selectionMode: {
+        cell: 'none' | 'single' | 'multiple';
+        row: 'none' | 'single' | 'multiple';
+    };
+    translations: {
+        accessibleActionableMode?: string;
+        accessibleColumnContext?: string;
+        accessibleColumnEndHeaderContext?: string;
+        accessibleColumnHeaderContext?: string;
+        accessibleColumnSelected?: string;
+        accessibleColumnSpanContext?: string;
+        accessibleFirstColumn?: string;
+        accessibleFirstRow?: string;
+        accessibleLastColumn?: string;
+        accessibleLastRow?: string;
+        accessibleLevelContext?: string;
+        accessibleMultiCellSelected?: string;
+        accessibleNavigationMode?: string;
+        accessibleRangeSelectModeOff?: string;
+        accessibleRangeSelectModeOn?: string;
+        accessibleRowCollapsed?: string;
+        accessibleRowContext?: string;
+        accessibleRowEndHeaderContext?: string;
+        accessibleRowExpanded?: string;
+        accessibleRowHeaderContext?: string;
+        accessibleRowSelected?: string;
+        accessibleRowSpanContext?: string;
+        accessibleSelectionAffordanceBottom?: string;
+        accessibleSelectionAffordanceTop?: string;
+        accessibleSortAscending?: string;
+        accessibleSortDescending?: string;
+        accessibleStateSelected?: string;
+        accessibleSummaryEstimate?: string;
+        accessibleSummaryExact?: string;
+        accessibleSummaryExpanded?: string;
+        labelCut?: string;
+        labelDisableNonContiguous?: string;
+        labelEnableNonContiguous?: string;
+        labelPaste?: string;
+        labelResize?: string;
+        labelResizeDialogSubmit?: string;
+        labelResizeHeight?: string;
+        labelResizeWidth?: string;
+        labelSortCol?: string;
+        labelSortColAsc?: string;
+        labelSortColDsc?: string;
+        labelSortRow?: string;
+        labelSortRowAsc?: string;
+        labelSortRowDsc?: string;
+        msgFetchingData?: string;
+        msgNoData?: string;
+    };
+    onBandingIntervalChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["bandingInterval"]>) => any) | null;
+    onCellChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["cell"]>) => any) | null;
+    onCurrentCellChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["currentCell"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["data"]>) => any) | null;
+    onDndChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["dnd"]>) => any) | null;
+    onEditModeChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["editMode"]>) => any) | null;
+    onGridlinesChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["gridlines"]>) => any) | null;
+    onHeaderChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["header"]>) => any) | null;
+    onScrollPolicyChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["scrollPolicy"]>) => any) | null;
+    onScrollPolicyOptionsChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["scrollPolicyOptions"]>) => any) | null;
+    onScrollPositionChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["scrollPosition"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojDataGrid<K, D>["selectionMode"]>) => any) | null;
+    onOjBeforeCurrentCell: ((event: ojDataGrid.ojBeforeCurrentCell<K>) => any) | null;
+    onOjBeforeEdit: ((event: ojDataGrid.ojBeforeEdit<K, D>) => any) | null;
+    onOjBeforeEditEnd: ((event: ojDataGrid.ojBeforeEditEnd<K, D>) => any) | null;
+    onOjResize: ((event: ojDataGrid.ojResize) => any) | null;
+    onOjScroll: ((event: ojDataGrid.ojScroll) => any) | null;
+    onOjSort: ((event: ojDataGrid.ojSort) => any) | null;
+    addEventListener<T extends keyof ojDataGridEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojDataGridEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojDataGridSettableProperties<K, D>>(property: T): ojDataGrid<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojDataGridSettableProperties<K, D>>(property: T, value: ojDataGridSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojDataGridSettableProperties<K, D>>): void;
+    setProperties(properties: ojDataGridSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojDataGrid.CellContext<K, D> & {
+        subId: 'oj-datagrid-cell';
+    } | ojDataGrid.HeaderContext<K, D> & {
+        subId: 'oj-datagrid-header';
+    } | ojDataGrid.LabelContext<K, D> & {
+        subId: 'oj-datagrid-header-label';
+    };
+    refresh(): void;
+}
+export namespace ojDataGrid {
+    interface ojBeforeCurrentCell<K> extends CustomEvent<{
+        currentCell: CurrentCell<K>;
+        previousCurrentCell: CurrentCell<K>;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeEdit<K, D> extends CustomEvent<{
+        cellContext: CellContext<K, D>;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeEditEnd<K, D> extends CustomEvent<{
+        cellContext: CellContext<K, D>;
+        cancelEdit: boolean;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojResize extends CustomEvent<{
+        header: string | number;
+        oldDimensions: {
+            width: number;
+            height: number;
+        };
+        newDimensions: {
+            width: number;
+            height: number;
+        };
+        [propName: string]: any;
+    }> {
+    }
+    interface ojScroll extends CustomEvent<{
+        scrollX: number;
+        scrollY: number;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojSort extends CustomEvent<{
+        header: any;
+        direction: 'ascending' | 'descending';
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type CellContext<K, D> = {
+        componentElement: Element;
+        parentElement: Element;
+        cell: D;
+        data: D;
+        datasource: DataProvider<K, D> | null;
+        indexes: {
+            row: number;
+            column: number;
+        };
+        keys: {
+            row: K;
+            column: K;
+        };
+        extents: {
+            row: number;
+            column: number;
+        };
+        mode: 'edit' | 'navigation';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type CurrentCell<K> = {
+        type: 'cell' | 'header' | 'label';
+        axis?: 'column' | 'columnEnd' | 'row' | 'rowEnd';
+        index?: number;
+        level?: number;
+        key?: any;
+        indexes?: {
+            row: number;
+            column: number;
+        };
+        keys?: {
+            row: K;
+            column: K;
+        };
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type HeaderContext<K, D> = {
+        componentElement: Element;
+        parentElement: Element;
+        data: D;
+        datasource: DataProvider<K, D> | null;
+        axis: 'column' | 'columnEnd' | 'row' | 'rowEnd';
+        index: number;
+        key: K;
+        level: number;
+        extent: number;
+        depth: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type LabelContext<K, D> = {
+        componentElement: Element;
+        parentElement: Element;
+        datasource: DataProvider<K, D> | null;
+        axis: 'column' | 'columnEnd' | 'row' | 'rowEnd';
+        key: K;
+        level: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type Selection<K> = {
+        startIndex?: {
+            row: number;
+            column?: number;
+        };
+        startKey?: {
+            row: K;
+            column?: K;
+        };
+        endIndex?: {
+            row: number;
+            column?: number;
+        };
+        endKey?: {
+            row: K;
+            column?: K;
+        };
+    };
+}
+export interface ojDataGridEventMap<K, D> extends baseComponentEventMap<ojDataGridSettableProperties<K, D>> {
+    'ojBeforeCurrentCell': ojDataGrid.ojBeforeCurrentCell<K>;
+    'ojBeforeEdit': ojDataGrid.ojBeforeEdit<K, D>;
+    'ojBeforeEditEnd': ojDataGrid.ojBeforeEditEnd<K, D>;
+    'ojResize': ojDataGrid.ojResize;
+    'ojScroll': ojDataGrid.ojScroll;
+    'ojSort': ojDataGrid.ojSort;
+    'bandingIntervalChanged': JetElementCustomEvent<ojDataGrid<K, D>["bandingInterval"]>;
+    'cellChanged': JetElementCustomEvent<ojDataGrid<K, D>["cell"]>;
+    'currentCellChanged': JetElementCustomEvent<ojDataGrid<K, D>["currentCell"]>;
+    'dataChanged': JetElementCustomEvent<ojDataGrid<K, D>["data"]>;
+    'dndChanged': JetElementCustomEvent<ojDataGrid<K, D>["dnd"]>;
+    'editModeChanged': JetElementCustomEvent<ojDataGrid<K, D>["editMode"]>;
+    'gridlinesChanged': JetElementCustomEvent<ojDataGrid<K, D>["gridlines"]>;
+    'headerChanged': JetElementCustomEvent<ojDataGrid<K, D>["header"]>;
+    'scrollPolicyChanged': JetElementCustomEvent<ojDataGrid<K, D>["scrollPolicy"]>;
+    'scrollPolicyOptionsChanged': JetElementCustomEvent<ojDataGrid<K, D>["scrollPolicyOptions"]>;
+    'scrollPositionChanged': JetElementCustomEvent<ojDataGrid<K, D>["scrollPosition"]>;
+    'selectionChanged': JetElementCustomEvent<ojDataGrid<K, D>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojDataGrid<K, D>["selectionMode"]>;
+}
+export interface ojDataGridSettableProperties<K, D> extends baseComponentSettableProperties {
+    bandingInterval: {
+        column: number;
+        row: number;
+    };
+    cell: {
+        className?: ((context: ojDataGrid.CellContext<K, D>) => string | void | null) | string | null;
+        renderer?: ((context: ojDataGrid.CellContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void | null) | null;
+        style?: ((context: ojDataGrid.CellContext<K, D>) => string | void | null) | string | null;
+    };
+    currentCell: ojDataGrid.CurrentCell<K> | null;
+    data: DataProvider<K, D> | null;
+    dnd: {
+        reorder: {
+            row: 'enable' | 'disable';
+        };
+    };
+    editMode: 'none' | 'cellNavigation' | 'cellEdit';
+    gridlines: {
+        horizontal: 'visible' | 'hidden';
+        vertical: 'visible' | 'hidden';
+    };
+    header: {
+        column: {
+            className?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            label: {
+                className?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+                renderer?: ((context: ojDataGrid.LabelContext<K, D>) => {
+                    insert: HTMLElement | string;
+                } | void | null) | null;
+                style?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+            };
+            renderer?: ((context: ojDataGrid.HeaderContext<K, D>) => {
+                insert: HTMLElement | string;
+            } | void | null) | null;
+            resizable: {
+                height: 'enable' | 'disable';
+                width?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+            };
+            sortable?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+            style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+        };
+        columnEnd: {
+            className?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            label: {
+                className?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+                renderer?: ((context: ojDataGrid.LabelContext<K, D>) => {
+                    insert: HTMLElement | string;
+                } | void | null) | null;
+                style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            };
+            renderer?: ((context: ojDataGrid.HeaderContext<K, D>) => {
+                insert: HTMLElement | string;
+            } | void | null) | null;
+            resizable: {
+                height: 'enable' | 'disable';
+                width?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+            };
+            style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+        };
+        row: {
+            className?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            label: {
+                className?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+                renderer?: ((context: ojDataGrid.LabelContext<K, D>) => {
+                    insert: HTMLElement | string;
+                } | void | null) | null;
+                style?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+            };
+            renderer?: ((context: ojDataGrid.HeaderContext<K, D>) => {
+                insert: HTMLElement | string;
+            } | void | null) | null;
+            resizable: {
+                height?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+                width: 'enable' | 'disable';
+            };
+            sortable?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+            style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+        };
+        rowEnd: {
+            className?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+            label: {
+                className?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+                renderer?: ((context: ojDataGrid.LabelContext<K, D>) => {
+                    insert: HTMLElement | string;
+                } | void | null) | null;
+                style?: ((context: ojDataGrid.LabelContext<K, D>) => string | void | null) | string | null;
+            };
+            renderer?: ((context: ojDataGrid.HeaderContext<K, D>) => {
+                insert: HTMLElement | string;
+            } | void | null) | null;
+            resizable: {
+                height?: ((context: ojDataGrid.HeaderContext<K, D>) => string) | string | null;
+                width: 'enable' | 'disable';
+            };
+            style?: ((context: ojDataGrid.HeaderContext<K, D>) => string | void | null) | string | null;
+        };
+    };
+    scrollPolicy: 'auto' | 'loadMoreOnScroll' | 'scroll';
+    scrollPolicyOptions: {
+        maxColumnCount: number;
+        maxRowCount: number;
+    };
+    scrollPosition: {
+        x?: number;
+        y?: number;
+        rowIndex?: number;
+        columnIndex?: number;
+        rowKey?: K;
+        columnKey?: K;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    selection: Array<ojDataGrid.Selection<K>>;
+    selectionMode: {
+        cell: 'none' | 'single' | 'multiple';
+        row: 'none' | 'single' | 'multiple';
+    };
+    translations: {
+        accessibleActionableMode?: string;
+        accessibleColumnContext?: string;
+        accessibleColumnEndHeaderContext?: string;
+        accessibleColumnHeaderContext?: string;
+        accessibleColumnSelected?: string;
+        accessibleColumnSpanContext?: string;
+        accessibleFirstColumn?: string;
+        accessibleFirstRow?: string;
+        accessibleLastColumn?: string;
+        accessibleLastRow?: string;
+        accessibleLevelContext?: string;
+        accessibleMultiCellSelected?: string;
+        accessibleNavigationMode?: string;
+        accessibleRangeSelectModeOff?: string;
+        accessibleRangeSelectModeOn?: string;
+        accessibleRowCollapsed?: string;
+        accessibleRowContext?: string;
+        accessibleRowEndHeaderContext?: string;
+        accessibleRowExpanded?: string;
+        accessibleRowHeaderContext?: string;
+        accessibleRowSelected?: string;
+        accessibleRowSpanContext?: string;
+        accessibleSelectionAffordanceBottom?: string;
+        accessibleSelectionAffordanceTop?: string;
+        accessibleSortAscending?: string;
+        accessibleSortDescending?: string;
+        accessibleStateSelected?: string;
+        accessibleSummaryEstimate?: string;
+        accessibleSummaryExact?: string;
+        accessibleSummaryExpanded?: string;
+        labelCut?: string;
+        labelDisableNonContiguous?: string;
+        labelEnableNonContiguous?: string;
+        labelPaste?: string;
+        labelResize?: string;
+        labelResizeDialogSubmit?: string;
+        labelResizeHeight?: string;
+        labelResizeWidth?: string;
+        labelSortCol?: string;
+        labelSortColAsc?: string;
+        labelSortColDsc?: string;
+        labelSortRow?: string;
+        labelSortRowAsc?: string;
+        labelSortRowDsc?: string;
+        msgFetchingData?: string;
+        msgNoData?: string;
+    };
+}
+export interface ojDataGridSettablePropertiesLenient<K, D> extends Partial<ojDataGridSettableProperties<K, D>> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojdataprovider/index.d.ts

@@ -0,0 +1,111 @@
+export interface AttributeFilterOperator<D> {
+    attribute: string;
+    op: AttributeFilterOperator.AttributeOperator;
+    value: any;
+}
+export namespace AttributeFilterOperator {
+    type AttributeOperator = "$co" | "$eq" | "$ew" | "$pr" | "$gt" | "$ge" | "$lt" | "$le" | "$ne" | "$regex" | "$sw";
+}
+export interface CompoundFilterOperator<D> {
+    criteria: Array<FilterOperator<D>>;
+    op: CompoundFilterOperator.CompoundOperator;
+}
+export namespace CompoundFilterOperator {
+    type CompoundOperator = "$and" | "$or";
+}
+export interface ContainsKeysResults<K> {
+    containsParameters: FetchByKeysParameters<K>;
+    results: Set<K>;
+}
+export interface DataMapping<K, D, Kin, Din> {
+    mapFields: (item: Item<Kin, Din>) => Item<K, D>;
+    mapFilterCriterion?: (filterCriterion: Array<FilterOperator<D>>) => Array<FilterOperator<Din>>;
+    mapSortCriteria?: (sortCriteria: Array<SortCriterion<D>>) => Array<SortCriterion<Din>>;
+    unmapSortCriteria?: (sortCriteria: Array<SortCriterion<Din>>) => Array<SortCriterion<D>>;
+}
+export interface DataProvider<K, D> extends EventTarget {
+    containsKeys(parameters: FetchByKeysParameters<K>): Promise<ContainsKeysResults<K>>;
+    fetchByKeys(parameters: FetchByKeysParameters<K>): Promise<FetchByKeysResults<K, D>>;
+    fetchByOffset(parameters: FetchByOffsetParameters<D>): Promise<FetchByOffsetResults<K, D>>;
+    fetchFirst(parameters?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>;
+    getCapability(capabilityName: string): any;
+    getTotalSize(): Promise<number>;
+    isEmpty(): 'yes' | 'no' | 'unknown';
+}
+export interface DataProviderAddOperationEventDetail<K, D> extends DataProviderOperationEventDetail<K, D> {
+    addBeforeKeys?: K[];
+    parentKeys?: K[];
+}
+export interface DataProviderMutationEventDetail<K, D> {
+    add?: DataProviderAddOperationEventDetail<K, D>;
+    remove?: DataProviderOperationEventDetail<K, D>;
+    update?: DataProviderOperationEventDetail<K, D>;
+}
+export interface DataProviderOperationEventDetail<K, D> {
+    data?: D[];
+    indexes?: number[];
+    keys: Set<K>;
+    metadata?: Array<ItemMetadata<K>>;
+}
+export interface FetchByKeysCapability<D> {
+    implementation: 'iteration' | 'lookup';
+}
+export namespace FetchByKeysMixin {
+    function applyMixin(derivedCtor: {
+        new (): DataProvider<any, any>;
+    }): any;
+}
+export interface FetchByKeysParameters<K> {
+    keys: Set<K>;
+}
+export interface FetchByKeysResults<K, D> {
+    fetchParameters: FetchByKeysParameters<K>;
+    results: Map<K, Item<K, D>>;
+}
+export interface FetchByOffsetCapability<D> {
+    implementation: 'iteration' | 'randomAccess';
+}
+export namespace FetchByOffsetMixin {
+    function applyMixin(derivedCtor: {
+        new (): DataProvider<any, any>;
+    }): any;
+}
+export interface FetchByOffsetParameters<D> extends FetchListParameters<D> {
+    offset: number;
+}
+export interface FetchByOffsetResults<K, D> {
+    done: boolean;
+    fetchParameters: FetchByOffsetParameters<D>;
+    results: Array<Item<K, D>>;
+}
+export interface FetchListParameters<D> {
+    filterCriterion?: FilterOperator<D>;
+    size: number;
+    sortCriteria?: Array<SortCriterion<D>>;
+}
+export interface FetchListResult<K, D> {
+    data: D[];
+    fetchParameters: FetchListParameters<D>;
+    metadata: Array<ItemMetadata<K>>;
+}
+export interface FilterCapability {
+    operators: string[];
+}
+export interface FilterOperator<D> {
+    op: AttributeFilterOperator.AttributeOperator | CompoundFilterOperator.CompoundOperator;
+    filter(data: any[]): any[];
+}
+export interface Item<K, D> {
+    data: D;
+    metadata: ItemMetadata<K>;
+}
+export interface ItemMetadata<K> {
+    key: K;
+}
+export interface SortCapability<D> {
+    attributes: 'none' | 'single' | 'multiple';
+}
+export interface SortCriterion<D> {
+    attribute: keyof D;
+    direction: string;
+}

types/oracle__oraclejet/ojdatetimepicker/index.d.ts

@@ -0,0 +1,639 @@
+import { Converter, Validator, Validation } from '../ojvalidation-base';
+import { inputBase, inputBaseEventMap, inputBaseSettableProperties } from '../ojinputtext';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojDatePicker extends ojInputDate<ojDatePickerSettableProperties> {
+    keyboardEdit: 'disabled';
+    max: string | null;
+    min: string | null;
+    renderMode: 'jet';
+    value: string;
+    onMaxChanged: ((event: JetElementCustomEvent<ojDatePicker["max"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojDatePicker["min"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojDatePicker["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojDatePicker.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojDatePicker.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojDatePickerEventMap>(type: T, listener: (this: HTMLElement, ev: ojDatePickerEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojDatePickerSettableProperties>(property: T): ojDatePicker[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojDatePickerSettableProperties>(property: T, value: ojDatePickerSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojDatePickerSettableProperties>): void;
+    setProperties(properties: ojDatePickerSettablePropertiesLenient): void;
+}
+export namespace ojDatePicker {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojDatePickerEventMap extends ojInputDateEventMap<ojDatePickerSettableProperties> {
+    'ojAnimateEnd': ojDatePicker.ojAnimateEnd;
+    'ojAnimateStart': ojDatePicker.ojAnimateStart;
+    'maxChanged': JetElementCustomEvent<ojDatePicker["max"]>;
+    'minChanged': JetElementCustomEvent<ojDatePicker["min"]>;
+    'valueChanged': JetElementCustomEvent<ojDatePicker["value"]>;
+}
+export interface ojDatePickerSettableProperties extends ojInputDateSettableProperties {
+    keyboardEdit: 'disabled';
+    max: string | null;
+    min: string | null;
+    renderMode: 'jet';
+    value: string;
+}
+export interface ojDatePickerSettablePropertiesLenient extends Partial<ojDatePickerSettableProperties> {
+    [key: string]: any;
+}
+export interface ojDateTimePicker extends ojInputDateTime<ojDateTimePickerSettableProperties> {
+    keyboardEdit: 'disabled';
+    max: string | null;
+    min: string | null;
+    renderMode: 'jet';
+    value: string;
+    onMaxChanged: ((event: JetElementCustomEvent<ojDateTimePicker["max"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojDateTimePicker["min"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojDateTimePicker["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojDateTimePicker.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojDateTimePicker.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojDateTimePickerEventMap>(type: T, listener: (this: HTMLElement, ev: ojDateTimePickerEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojDateTimePickerSettableProperties>(property: T): ojDateTimePicker[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojDateTimePickerSettableProperties>(property: T, value: ojDateTimePickerSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojDateTimePickerSettableProperties>): void;
+    setProperties(properties: ojDateTimePickerSettablePropertiesLenient): void;
+}
+export namespace ojDateTimePicker {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojDateTimePickerEventMap extends ojInputDateTimeEventMap<ojDateTimePickerSettableProperties> {
+    'ojAnimateEnd': ojDateTimePicker.ojAnimateEnd;
+    'ojAnimateStart': ojDateTimePicker.ojAnimateStart;
+    'maxChanged': JetElementCustomEvent<ojDateTimePicker["max"]>;
+    'minChanged': JetElementCustomEvent<ojDateTimePicker["min"]>;
+    'valueChanged': JetElementCustomEvent<ojDateTimePicker["value"]>;
+}
+export interface ojDateTimePickerSettableProperties extends ojInputDateTimeSettableProperties {
+    keyboardEdit: 'disabled';
+    max: string | null;
+    min: string | null;
+    renderMode: 'jet';
+    value: string;
+}
+export interface ojDateTimePickerSettablePropertiesLenient extends Partial<ojDateTimePickerSettableProperties> {
+    [key: string]: any;
+}
+export interface ojInputDate<SP extends ojInputDateSettableProperties = ojInputDateSettableProperties> extends inputBase<string, SP> {
+    converter: Converter<string> | Validation.RegisteredConverter;
+    datePicker: {
+        changeMonth: 'select' | 'none';
+        changeYear: 'select' | 'none';
+        currentMonthPos: number;
+        daysOutsideMonth: 'hidden' | 'visible' | 'selectable';
+        footerLayout: '' | 'today';
+        numberOfMonths: number;
+        showOn: 'focus' | 'image';
+        stepBigMonths: number;
+        stepMonths: 'numberOfMonths' | number;
+        weekDisplay: 'number' | 'none';
+        yearRange: string;
+    };
+    dayFormatter: (param: ojInputDate.DayFormatterInput) => (null | 'all' | ojInputDate.DayFormatterOutput);
+    dayMetaData: {
+        [key: string]: {
+            [key: string]: {
+                [key: string]: {
+                    disabled?: boolean;
+                    className?: string;
+                    tooltip?: string;
+                };
+            };
+        };
+    };
+    keyboardEdit: 'enabled' | 'disabled';
+    max: string | null;
+    min: string | null;
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    renderMode: 'jet' | 'native';
+    validators: Array<Validator<string> | Validation.RegisteredValidator> | null;
+    value: string;
+    translations: {
+        currentText?: string;
+        dateRestriction?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        dateTimeRange?: {
+            hint?: {
+                inRange?: string;
+                max?: string;
+                min?: string;
+            };
+            messageDetail?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+            messageSummary?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+        };
+        nextText?: string;
+        prevText?: string;
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        tooltipCalendar?: string;
+        tooltipCalendarDisabled?: string;
+        tooltipCalendarTime?: string;
+        tooltipCalendarTimeDisabled?: string;
+        weekHeader?: string;
+    };
+    onConverterChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["converter"]>) => any) | null;
+    onDatePickerChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["datePicker"]>) => any) | null;
+    onDayFormatterChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["dayFormatter"]>) => any) | null;
+    onDayMetaDataChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["dayMetaData"]>) => any) | null;
+    onKeyboardEditChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["keyboardEdit"]>) => any) | null;
+    onMaxChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["max"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["min"]>) => any) | null;
+    onPickerAttributesChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["pickerAttributes"]>) => any) | null;
+    onRenderModeChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["renderMode"]>) => any) | null;
+    onValidatorsChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["validators"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojInputDate<SP>["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojInputDate.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojInputDate.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojInputDateEventMap<SP>>(type: T, listener: (this: HTMLElement, ev: ojInputDateEventMap<SP>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojInputDateSettableProperties>(property: T): ojInputDate<SP>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojInputDateSettableProperties>(property: T, value: ojInputDateSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojInputDateSettableProperties>): void;
+    setProperties(properties: ojInputDateSettablePropertiesLenient): void;
+    hide(): void;
+    refresh(): void;
+    show(): void;
+}
+export namespace ojInputDate {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type DayFormatterInput = {
+        fullYear: number;
+        month: number;
+        date: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type DayFormatterOutput = {
+        disabled?: boolean;
+        className?: string;
+        tooltip?: string;
+    };
+}
+export interface ojInputDateEventMap<SP extends ojInputDateSettableProperties = ojInputDateSettableProperties> extends inputBaseEventMap<string, SP> {
+    'ojAnimateEnd': ojInputDate.ojAnimateEnd;
+    'ojAnimateStart': ojInputDate.ojAnimateStart;
+    'converterChanged': JetElementCustomEvent<ojInputDate<SP>["converter"]>;
+    'datePickerChanged': JetElementCustomEvent<ojInputDate<SP>["datePicker"]>;
+    'dayFormatterChanged': JetElementCustomEvent<ojInputDate<SP>["dayFormatter"]>;
+    'dayMetaDataChanged': JetElementCustomEvent<ojInputDate<SP>["dayMetaData"]>;
+    'keyboardEditChanged': JetElementCustomEvent<ojInputDate<SP>["keyboardEdit"]>;
+    'maxChanged': JetElementCustomEvent<ojInputDate<SP>["max"]>;
+    'minChanged': JetElementCustomEvent<ojInputDate<SP>["min"]>;
+    'pickerAttributesChanged': JetElementCustomEvent<ojInputDate<SP>["pickerAttributes"]>;
+    'renderModeChanged': JetElementCustomEvent<ojInputDate<SP>["renderMode"]>;
+    'validatorsChanged': JetElementCustomEvent<ojInputDate<SP>["validators"]>;
+    'valueChanged': JetElementCustomEvent<ojInputDate<SP>["value"]>;
+}
+export interface ojInputDateSettableProperties extends inputBaseSettableProperties<string> {
+    converter: Converter<string> | Validation.RegisteredConverter;
+    datePicker: {
+        changeMonth: 'select' | 'none';
+        changeYear: 'select' | 'none';
+        currentMonthPos: number;
+        daysOutsideMonth: 'hidden' | 'visible' | 'selectable';
+        footerLayout: '' | 'today';
+        numberOfMonths: number;
+        showOn: 'focus' | 'image';
+        stepBigMonths: number;
+        stepMonths: 'numberOfMonths' | number;
+        weekDisplay: 'number' | 'none';
+        yearRange: string;
+    };
+    dayFormatter: (param: ojInputDate.DayFormatterInput) => (null | 'all' | ojInputDate.DayFormatterOutput);
+    dayMetaData: {
+        [key: string]: {
+            [key: string]: {
+                [key: string]: {
+                    disabled?: boolean;
+                    className?: string;
+                    tooltip?: string;
+                };
+            };
+        };
+    };
+    keyboardEdit: 'enabled' | 'disabled';
+    max: string | null;
+    min: string | null;
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    renderMode: 'jet' | 'native';
+    validators: Array<Validator<string> | Validation.RegisteredValidator> | null;
+    value: string;
+    translations: {
+        currentText?: string;
+        dateRestriction?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        dateTimeRange?: {
+            hint?: {
+                inRange?: string;
+                max?: string;
+                min?: string;
+            };
+            messageDetail?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+            messageSummary?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+        };
+        nextText?: string;
+        prevText?: string;
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        tooltipCalendar?: string;
+        tooltipCalendarDisabled?: string;
+        tooltipCalendarTime?: string;
+        tooltipCalendarTimeDisabled?: string;
+        weekHeader?: string;
+    };
+}
+export interface ojInputDateSettablePropertiesLenient extends Partial<ojInputDateSettableProperties> {
+    [key: string]: any;
+}
+export interface ojInputDateTime<SP extends ojInputDateTimeSettableProperties = ojInputDateTimeSettableProperties> extends ojInputDate<SP> {
+    converter: Converter<string> | Validation.RegisteredConverter;
+    max: string | null;
+    min: string | null;
+    renderMode: 'jet' | 'native';
+    timePicker: {
+        footerLayout: '' | 'now';
+        showOn: 'focus' | 'image';
+        timeIncrement: string;
+    };
+    validators: Array<Validator<string> | Validation.RegisteredValidator> | null;
+    value: string;
+    translations: {
+        cancel?: string;
+        currentText?: string;
+        dateRestriction?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        dateTimeRange?: {
+            hint?: {
+                inRange?: string;
+                max?: string;
+                min?: string;
+            };
+            messageDetail?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+            messageSummary?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+        };
+        done?: string;
+        nextText?: string;
+        prevText?: string;
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        tooltipCalendar?: string;
+        tooltipCalendarDisabled?: string;
+        tooltipCalendarTime?: string;
+        tooltipCalendarTimeDisabled?: string;
+        weekHeader?: string;
+    };
+    onConverterChanged: ((event: JetElementCustomEvent<ojInputDateTime<SP>["converter"]>) => any) | null;
+    onMaxChanged: ((event: JetElementCustomEvent<ojInputDateTime<SP>["max"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojInputDateTime<SP>["min"]>) => any) | null;
+    onRenderModeChanged: ((event: JetElementCustomEvent<ojInputDateTime<SP>["renderMode"]>) => any) | null;
+    onTimePickerChanged: ((event: JetElementCustomEvent<ojInputDateTime<SP>["timePicker"]>) => any) | null;
+    onValidatorsChanged: ((event: JetElementCustomEvent<ojInputDateTime<SP>["validators"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojInputDateTime<SP>["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojInputDateTime.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojInputDateTime.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojInputDateTimeEventMap<SP>>(type: T, listener: (this: HTMLElement, ev: ojInputDateTimeEventMap<SP>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojInputDateTimeSettableProperties>(property: T): ojInputDateTime<SP>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojInputDateTimeSettableProperties>(property: T, value: ojInputDateTimeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojInputDateTimeSettableProperties>): void;
+    setProperties(properties: ojInputDateTimeSettablePropertiesLenient): void;
+    hideTimePicker(): void;
+    show(): void;
+    showTimePicker(): void;
+}
+export namespace ojInputDateTime {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojInputDateTimeEventMap<SP extends ojInputDateTimeSettableProperties = ojInputDateTimeSettableProperties> extends ojInputDateEventMap<SP> {
+    'ojAnimateEnd': ojInputDateTime.ojAnimateEnd;
+    'ojAnimateStart': ojInputDateTime.ojAnimateStart;
+    'converterChanged': JetElementCustomEvent<ojInputDateTime<SP>["converter"]>;
+    'maxChanged': JetElementCustomEvent<ojInputDateTime<SP>["max"]>;
+    'minChanged': JetElementCustomEvent<ojInputDateTime<SP>["min"]>;
+    'renderModeChanged': JetElementCustomEvent<ojInputDateTime<SP>["renderMode"]>;
+    'timePickerChanged': JetElementCustomEvent<ojInputDateTime<SP>["timePicker"]>;
+    'validatorsChanged': JetElementCustomEvent<ojInputDateTime<SP>["validators"]>;
+    'valueChanged': JetElementCustomEvent<ojInputDateTime<SP>["value"]>;
+}
+export interface ojInputDateTimeSettableProperties extends ojInputDateSettableProperties {
+    converter: Converter<string> | Validation.RegisteredConverter;
+    max: string | null;
+    min: string | null;
+    renderMode: 'jet' | 'native';
+    timePicker: {
+        footerLayout: '' | 'now';
+        showOn: 'focus' | 'image';
+        timeIncrement: string;
+    };
+    validators: Array<Validator<string> | Validation.RegisteredValidator> | null;
+    value: string;
+    translations: {
+        cancel?: string;
+        currentText?: string;
+        dateRestriction?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        dateTimeRange?: {
+            hint?: {
+                inRange?: string;
+                max?: string;
+                min?: string;
+            };
+            messageDetail?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+            messageSummary?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+        };
+        done?: string;
+        nextText?: string;
+        prevText?: string;
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        tooltipCalendar?: string;
+        tooltipCalendarDisabled?: string;
+        tooltipCalendarTime?: string;
+        tooltipCalendarTimeDisabled?: string;
+        weekHeader?: string;
+    };
+}
+export interface ojInputDateTimeSettablePropertiesLenient extends Partial<ojInputDateTimeSettableProperties> {
+    [key: string]: any;
+}
+export interface ojInputTime extends inputBase<string, ojInputTimeSettableProperties> {
+    converter: Converter<string> | Validation.RegisteredConverter;
+    keyboardEdit: 'enabled' | 'disabled';
+    max: string | null;
+    min: string | null;
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    renderMode: 'jet' | 'native';
+    timePicker: {
+        footerLayout: '' | 'now';
+        showOn: 'focus' | 'image';
+        timeIncrement: string;
+    };
+    validators: Array<Validator<string> | Validation.RegisteredValidator> | null;
+    value: string;
+    translations: {
+        ampmWheelLabel?: string;
+        cancelText?: string;
+        currentTimeText?: string;
+        dateTimeRange?: {
+            hint?: {
+                inRange?: string;
+                max?: string;
+                min?: string;
+            };
+            messageDetail?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+            messageSummary?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+        };
+        hourWheelLabel?: string;
+        minuteWheelLabel?: string;
+        okText?: string;
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        tooltipTime?: string;
+        tooltipTimeDisabled?: string;
+    };
+    onConverterChanged: ((event: JetElementCustomEvent<ojInputTime["converter"]>) => any) | null;
+    onKeyboardEditChanged: ((event: JetElementCustomEvent<ojInputTime["keyboardEdit"]>) => any) | null;
+    onMaxChanged: ((event: JetElementCustomEvent<ojInputTime["max"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojInputTime["min"]>) => any) | null;
+    onPickerAttributesChanged: ((event: JetElementCustomEvent<ojInputTime["pickerAttributes"]>) => any) | null;
+    onRenderModeChanged: ((event: JetElementCustomEvent<ojInputTime["renderMode"]>) => any) | null;
+    onTimePickerChanged: ((event: JetElementCustomEvent<ojInputTime["timePicker"]>) => any) | null;
+    onValidatorsChanged: ((event: JetElementCustomEvent<ojInputTime["validators"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojInputTime["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojInputTime.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojInputTime.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojInputTimeEventMap>(type: T, listener: (this: HTMLElement, ev: ojInputTimeEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojInputTimeSettableProperties>(property: T): ojInputTime[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojInputTimeSettableProperties>(property: T, value: ojInputTimeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojInputTimeSettableProperties>): void;
+    setProperties(properties: ojInputTimeSettablePropertiesLenient): void;
+    hide(): void;
+    refresh(): void;
+    show(): void;
+}
+export namespace ojInputTime {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojInputTimeEventMap extends inputBaseEventMap<string, ojInputTimeSettableProperties> {
+    'ojAnimateEnd': ojInputTime.ojAnimateEnd;
+    'ojAnimateStart': ojInputTime.ojAnimateStart;
+    'converterChanged': JetElementCustomEvent<ojInputTime["converter"]>;
+    'keyboardEditChanged': JetElementCustomEvent<ojInputTime["keyboardEdit"]>;
+    'maxChanged': JetElementCustomEvent<ojInputTime["max"]>;
+    'minChanged': JetElementCustomEvent<ojInputTime["min"]>;
+    'pickerAttributesChanged': JetElementCustomEvent<ojInputTime["pickerAttributes"]>;
+    'renderModeChanged': JetElementCustomEvent<ojInputTime["renderMode"]>;
+    'timePickerChanged': JetElementCustomEvent<ojInputTime["timePicker"]>;
+    'validatorsChanged': JetElementCustomEvent<ojInputTime["validators"]>;
+    'valueChanged': JetElementCustomEvent<ojInputTime["value"]>;
+}
+export interface ojInputTimeSettableProperties extends inputBaseSettableProperties<string> {
+    converter: Converter<string> | Validation.RegisteredConverter;
+    keyboardEdit: 'enabled' | 'disabled';
+    max: string | null;
+    min: string | null;
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    renderMode: 'jet' | 'native';
+    timePicker: {
+        footerLayout: '' | 'now';
+        showOn: 'focus' | 'image';
+        timeIncrement: string;
+    };
+    validators: Array<Validator<string> | Validation.RegisteredValidator> | null;
+    value: string;
+    translations: {
+        ampmWheelLabel?: string;
+        cancelText?: string;
+        currentTimeText?: string;
+        dateTimeRange?: {
+            hint?: {
+                inRange?: string;
+                max?: string;
+                min?: string;
+            };
+            messageDetail?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+            messageSummary?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+        };
+        hourWheelLabel?: string;
+        minuteWheelLabel?: string;
+        okText?: string;
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        tooltipTime?: string;
+        tooltipTimeDisabled?: string;
+    };
+}
+export interface ojInputTimeSettablePropertiesLenient extends Partial<ojInputTimeSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojdefer/index.d.ts

@@ -0,0 +1,21 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojDefer extends JetElement<ojDeferSettableProperties> {
+    addEventListener<T extends keyof ojDeferEventMap>(type: T, listener: (this: HTMLElement, ev: ojDeferEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojDeferSettableProperties>(property: T): ojDefer[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojDeferSettableProperties>(property: T, value: ojDeferSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojDeferSettableProperties>): void;
+    setProperties(properties: ojDeferSettablePropertiesLenient): void;
+}
+// These interfaces are empty but required to keep the event chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface ojDeferEventMap extends HTMLElementEventMap {
+}
+// These interfaces are empty but required to keep the component chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface ojDeferSettableProperties extends JetSettableProperties {
+}
+export interface ojDeferSettablePropertiesLenient extends Partial<ojDeferSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojdeferreddataprovider/index.d.ts

@@ -0,0 +1,16 @@
+import { DataProvider, SortCriterion, FetchByKeysParameters, ContainsKeysResults, FetchByKeysResults, FetchByOffsetParameters, FetchByOffsetResults, FetchListResult,
+   FetchListParameters } from '../ojdataprovider';
+declare class DeferredDataProvider<K, D> implements DataProvider<K, D> {
+    constructor(dataProvider: Promise<DataProvider<K, D>>, capabilityFunc: (capabilityName: string) => any);
+    addEventListener(eventType: string, listener: EventListener): any;
+    containsKeys(params: FetchByKeysParameters<K>): Promise<ContainsKeysResults<K>>;
+    dispatchEvent(evt: Event): boolean;
+    fetchByKeys(params: FetchByKeysParameters<K>): Promise<FetchByKeysResults<K, D>>;
+    fetchByOffset(params: FetchByOffsetParameters<D>): Promise<FetchByOffsetResults<K, D>>;
+    fetchFirst(params?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>;
+    getCapability(capabilityName: string): object;
+    getTotalSize(): Promise<number>;
+    isEmpty(): 'yes' | 'no' | 'unknown';
+    removeEventListener(eventType: string, listener: EventListener): any;
+}
+export = DeferredDataProvider;

types/oracle__oraclejet/ojdiagram/index.d.ts

@@ -0,0 +1,790 @@
+import { KeySet } from '../ojkeyset';
+import { DataProvider } from '../ojdataprovider';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface DvtDiagramLayoutContext {
+    getCommonContainer(nodeId1: any, nodeId2: any): any;
+    getComponentSize(): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    getCurrentViewport(): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    getEventData(): object;
+    getLinkById(id: any): DvtDiagramLayoutContextLink;
+    getLinkByIndex(index: number): DvtDiagramLayoutContextLink;
+    getLinkCount(): number;
+    getNodeById(id: any): DvtDiagramLayoutContextNode;
+    getNodeByIndex(index: number): DvtDiagramLayoutContextNode;
+    getNodeCount(): number;
+    getViewport(): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    isLocaleR2L(): boolean;
+    setViewport(viewport: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }): void;
+}
+export interface DvtDiagramLayoutContextLink {
+    getCoordinateSpace(): any;
+    getData(): object | any[];
+    getEndConnectorOffset(): number;
+    getEndId(): any;
+    getId(): any;
+    getLabelBounds(): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    getLabelHalign(): 'left' | 'center' | 'right';
+    getLabelPosition(): {
+        x: number;
+        y: number;
+    };
+    getLabelRotationAngle(): number;
+    getLabelRotationPoint(): {
+        x: number;
+        y: number;
+    };
+    getLabelValign(): 'top' | 'middle' | 'bottom' | 'baseline';
+    getLinkWidth(): number;
+    getPoints(): any[];
+    getSelected(): boolean;
+    getStartConnectorOffset(): number;
+    getStartId(): any;
+    isPromoted(): boolean;
+    setCoordinateSpace(containerId: any): void;
+    setLabelHalign(halign: 'left' | 'center' | 'right'): void;
+    setLabelPosition(pos: {
+        x: number;
+        y: number;
+    }): void;
+    setLabelRotationAngle(angle: number): void;
+    setLabelRotationPoint(point: {
+        x: number;
+        y: number;
+    }): void;
+    setLabelValign(valign: 'top' | 'middle' | 'bottom' | 'baseline'): void;
+    setPoints(points: any[]): void;
+}
+export interface DvtDiagramLayoutContextNode {
+    getBounds(): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    getChildNodes(): any[];
+    getContentBounds(): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    getData(): object;
+    getId(): any;
+    getLabelBounds(): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    getLabelHalign(): 'left' | 'center' | 'right';
+    getLabelPosition(): {
+        x: number;
+        y: number;
+    };
+    getLabelRotationAngle(): number;
+    getLabelRotationPoint(): {
+        x: number;
+        y: number;
+    };
+    getLabelValign(): 'top' | 'middle' | 'bottom' | 'baseline';
+    getPosition(): {
+        x: number;
+        y: number;
+    };
+    getRelativePosition(containerId: any): {
+        x: number;
+        y: number;
+    };
+    getSelected(): boolean;
+    isDisclosed(): boolean;
+    setLabelHalign(halign: 'left' | 'center' | 'right'): void;
+    setLabelPosition(pos: {
+        x: number;
+        y: number;
+    }): void;
+    setLabelRotationAngle(angle: number): void;
+    setLabelRotationPoint(point: {
+        x: number;
+        y: number;
+    }): void;
+    setLabelValign(valign: 'top' | 'middle' | 'bottom' | 'baseline'): void;
+    setPosition(pos: {
+        x: number;
+        y: number;
+    }): void;
+}
+export interface ojDiagram<K1, K2, D1, D2> extends dvtBaseComponent<ojDiagramSettableProperties<K1, K2, D1, D2>> {
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    as: string;
+    dnd: {
+        drag: {
+            nodes: {
+                dataTypes: string | string[];
+                drag: ((param0: Event) => void);
+                dragEnd: ((param0: Event) => void);
+                dragStart: ((param0: Event, param1: object) => void);
+            };
+            ports: {
+                dataTypes: string | string[];
+                drag: ((param0: Event) => void);
+                dragEnd: ((param0: Event) => void);
+                dragStart: ((param0: Event, param1: object) => void);
+                linkStyle: ((param0: object) => void);
+                selector: string;
+            };
+        };
+        drop: {
+            background: {
+                dataTypes: string | string[];
+                dragEnter: ((param0: Event, param1: object) => void);
+                dragLeave: ((param0: Event, param1: object) => void);
+                dragOver: ((param0: Event, param1: object) => void);
+                drop: ((param0: Event, param1: object) => void);
+            };
+            links: {
+                dataTypes: string | string[];
+                dragEnter: ((param0: Event, param1: object) => void);
+                dragLeave: ((param0: Event, param1: object) => void);
+                dragOver: ((param0: Event, param1: object) => void);
+                drop: ((param0: Event, param1: object) => void);
+            };
+            nodes: {
+                dataTypes: string | string[];
+                dragEnter: ((param0: Event, param1: object) => void);
+                dragLeave: ((param0: Event, param1: object) => void);
+                dragOver: ((param0: Event, param1: object) => void);
+                drop: ((param0: Event, param1: object) => void);
+            };
+            ports: {
+                dataTypes: string | string[];
+                dragEnter: ((param0: Event, param1: object) => void);
+                dragLeave: ((param0: Event, param1: object) => void);
+                dragOver: ((param0: Event, param1: object) => void);
+                drop: ((param0: Event, param1: object) => void);
+                selector: string;
+            };
+        };
+    };
+    expanded: KeySet<K1>;
+    focusRenderer: ((context: ojDiagram.RendererContext<K1, D1>) => {
+        insert: SVGElement;
+    } | void) | null;
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverRenderer: ((context: ojDiagram.RendererContext<K1, D1>) => {
+        insert: SVGElement;
+    } | void) | null;
+    layout: ((param0: DvtDiagramLayoutContext) => void);
+    linkData: DataProvider<K2, D2> | null;
+    linkHighlightMode: 'linkAndNodes' | 'link';
+    maxZoom: number;
+    minZoom: number;
+    nodeData: DataProvider<K1, D1> | null;
+    nodeHighlightMode: 'nodeAndIncomingLinks' | 'nodeAndOutgoingLinks' | 'nodeAndLinks' | 'node';
+    overview: {
+        halign: 'start' | 'end' | 'center';
+        height: number;
+        rendered: 'on' | 'off';
+        valign: 'top' | 'bottom' | 'middle';
+        width: number;
+    };
+    panDirection: 'x' | 'y' | 'auto';
+    panning: 'auto' | 'none';
+    promotedLinkBehavior: 'none' | 'full' | 'lazy';
+    renderer: ((context: ojDiagram.RendererContext<K1, D1>) => ({
+        insert: SVGElement;
+    }));
+    selection: Array<K1 | K2>;
+    selectionMode: 'single' | 'multiple' | 'none';
+    selectionRenderer: ((context: ojDiagram.RendererContext<K1, D1>) => {
+        insert: SVGElement;
+    } | void) | null;
+    styleDefaults: {
+        animationDuration: number;
+        hoverBehaviorDelay: number;
+        linkDefaults: {
+            color: string;
+            endConnectorType: 'arrowOpen' | 'arrow' | 'arrowConcave' | 'circle' | 'rectangle' | 'rectangleRounded' | 'none';
+            labelStyle: object;
+            startConnectorType: 'arrowOpen' | 'arrow' | 'arrowConcave' | 'circle' | 'rectangle' | 'rectangleRounded' | 'none';
+            svgClassName: string;
+            svgStyle: object;
+            width: number;
+        };
+        nodeDefaults: {
+            icon: {
+                borderColor: string;
+                borderRadius: string;
+                borderWidth: number;
+                color: string;
+                height: number;
+                pattern: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+                   'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+                shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+                source: string;
+                sourceHover: string;
+                sourceHoverSelected: string;
+                sourceSelected: string;
+                svgClassName: string;
+                svgStyle: object;
+                width: number;
+            };
+            labelStyle: object;
+            showDisclosure: 'off' | 'on';
+        };
+        promotedLink: {
+            color: string;
+            endConnectorType: 'arrowOpen' | 'arrow' | 'arrowConcave' | 'circle' | 'rectangle' | 'rectangleRounded' | 'none';
+            startConnectorType: 'arrowOpen' | 'arrow' | 'arrowConcave' | 'circle' | 'rectangle' | 'rectangleRounded' | 'none';
+            svgClassName: string;
+            svgStyle: object;
+            width: number;
+        };
+    };
+    tooltip: {
+        renderer: ((context: ojDiagram.TooltipContext<K1, K2, D1, D2>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    touchResponse: 'touchStart' | 'auto';
+    zoomRenderer: ((context: ojDiagram.RendererContext<K1, D1>) => {
+        insert: SVGElement;
+    } | void) | null;
+    zooming: 'auto' | 'none';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        promotedLink?: string;
+        promotedLinkAriaDesc?: string;
+        promotedLinks?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    onAnimationOnDataChangeChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["animationOnDataChange"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["animationOnDisplay"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["as"]>) => any) | null;
+    onDndChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["dnd"]>) => any) | null;
+    onExpandedChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["expanded"]>) => any) | null;
+    onFocusRendererChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["focusRenderer"]>) => any) | null;
+    onHiddenCategoriesChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["hiddenCategories"]>) => any) | null;
+    onHighlightMatchChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["highlightMatch"]>) => any) | null;
+    onHighlightedCategoriesChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["highlightedCategories"]>) => any) | null;
+    onHoverBehaviorChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["hoverBehavior"]>) => any) | null;
+    onHoverRendererChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["hoverRenderer"]>) => any) | null;
+    onLayoutChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["layout"]>) => any) | null;
+    onLinkDataChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["linkData"]>) => any) | null;
+    onLinkHighlightModeChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["linkHighlightMode"]>) => any) | null;
+    onMaxZoomChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["maxZoom"]>) => any) | null;
+    onMinZoomChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["minZoom"]>) => any) | null;
+    onNodeDataChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["nodeData"]>) => any) | null;
+    onNodeHighlightModeChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["nodeHighlightMode"]>) => any) | null;
+    onOverviewChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["overview"]>) => any) | null;
+    onPanDirectionChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["panDirection"]>) => any) | null;
+    onPanningChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["panning"]>) => any) | null;
+    onPromotedLinkBehaviorChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["promotedLinkBehavior"]>) => any) | null;
+    onRendererChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["renderer"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["selectionMode"]>) => any) | null;
+    onSelectionRendererChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["selectionRenderer"]>) => any) | null;
+    onStyleDefaultsChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["styleDefaults"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["tooltip"]>) => any) | null;
+    onTouchResponseChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["touchResponse"]>) => any) | null;
+    onZoomRendererChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["zoomRenderer"]>) => any) | null;
+    onZoomingChanged: ((event: JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["zooming"]>) => any) | null;
+    onOjBeforeCollapse: ((event: ojDiagram.ojBeforeCollapse) => any) | null;
+    onOjBeforeExpand: ((event: ojDiagram.ojBeforeExpand) => any) | null;
+    onOjCollapse: ((event: ojDiagram.ojCollapse) => any) | null;
+    onOjExpand: ((event: ojDiagram.ojExpand) => any) | null;
+    addEventListener<T extends keyof ojDiagramEventMap<K1, K2, D1, D2>>(type: T, listener: (this: HTMLElement, ev: ojDiagramEventMap<K1, K2, D1, D2>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojDiagramSettableProperties<K1, K2, D1, D2>>(property: T): ojDiagram<K1, K2, D1, D2>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojDiagramSettableProperties<K1, K2, D1, D2>>(property: T, value: ojDiagramSettableProperties<K1, K2, D1, D2>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojDiagramSettableProperties<K1, K2, D1, D2>>): void;
+    setProperties(properties: ojDiagramSettablePropertiesLenient<K1, K2, D1, D2>): void;
+    getContextByNode(node: Element): object | null;
+    getLink(linkIndex: number): object | null;
+    getLinkCount(): number;
+    getNode(nodeIndex: number): object | null;
+    getNodeCount(): number;
+    getPromotedLink(startNodeIndex: number, endNodeIndex: number): object | null;
+}
+export namespace ojDiagram {
+    interface ojBeforeCollapse extends CustomEvent<{
+        nodeId: any;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeExpand extends CustomEvent<{
+        nodeId: any;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojCollapse extends CustomEvent<{
+        nodeId: any;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojExpand extends CustomEvent<{
+        nodeId: any;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type RendererContext<K1, D1> = {
+        parentElement: Element;
+        componentElement: Element;
+        data: object;
+        itemData: D1;
+        content: {
+            element: Element;
+            width: number;
+            height: number;
+        };
+        state: {
+            hovered: boolean;
+            selected: boolean;
+            focused: boolean;
+            expanded: boolean;
+            zoom: number;
+        };
+        previousState: {
+            hovered: boolean;
+            selected: boolean;
+            focused: boolean;
+            expanded: boolean;
+            zoom: number;
+        };
+        id: K1;
+        type: string;
+        renderDefaultFocus: (() => void);
+        renderDefaultHover: (() => void);
+        renderDefaultSelection: (() => void);
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext<K1, K2, D1, D2> = {
+        parentElement: Element;
+        componentElement: Element;
+        id: K1 | K2;
+        type: string;
+        label: string;
+        data: object | object[];
+        itemData: D1 | D2 | D2[];
+    };
+}
+export interface ojDiagramEventMap<K1, K2, D1, D2> extends dvtBaseComponentEventMap<ojDiagramSettableProperties<K1, K2, D1, D2>> {
+    'ojBeforeCollapse': ojDiagram.ojBeforeCollapse;
+    'ojBeforeExpand': ojDiagram.ojBeforeExpand;
+    'ojCollapse': ojDiagram.ojCollapse;
+    'ojExpand': ojDiagram.ojExpand;
+    'animationOnDataChangeChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["animationOnDataChange"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["animationOnDisplay"]>;
+    'asChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["as"]>;
+    'dndChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["dnd"]>;
+    'expandedChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["expanded"]>;
+    'focusRendererChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["focusRenderer"]>;
+    'hiddenCategoriesChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["hiddenCategories"]>;
+    'highlightMatchChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["highlightMatch"]>;
+    'highlightedCategoriesChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["highlightedCategories"]>;
+    'hoverBehaviorChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["hoverBehavior"]>;
+    'hoverRendererChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["hoverRenderer"]>;
+    'layoutChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["layout"]>;
+    'linkDataChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["linkData"]>;
+    'linkHighlightModeChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["linkHighlightMode"]>;
+    'maxZoomChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["maxZoom"]>;
+    'minZoomChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["minZoom"]>;
+    'nodeDataChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["nodeData"]>;
+    'nodeHighlightModeChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["nodeHighlightMode"]>;
+    'overviewChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["overview"]>;
+    'panDirectionChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["panDirection"]>;
+    'panningChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["panning"]>;
+    'promotedLinkBehaviorChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["promotedLinkBehavior"]>;
+    'rendererChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["renderer"]>;
+    'selectionChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["selectionMode"]>;
+    'selectionRendererChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["selectionRenderer"]>;
+    'styleDefaultsChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["styleDefaults"]>;
+    'tooltipChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["tooltip"]>;
+    'touchResponseChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["touchResponse"]>;
+    'zoomRendererChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["zoomRenderer"]>;
+    'zoomingChanged': JetElementCustomEvent<ojDiagram<K1, K2, D1, D2>["zooming"]>;
+}
+export interface ojDiagramSettableProperties<K1, K2, D1, D2> extends dvtBaseComponentSettableProperties {
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    as: string;
+    dnd: {
+        drag: {
+            nodes: {
+                dataTypes: string | string[];
+                drag: ((param0: Event) => void);
+                dragEnd: ((param0: Event) => void);
+                dragStart: ((param0: Event, param1: object) => void);
+            };
+            ports: {
+                dataTypes: string | string[];
+                drag: ((param0: Event) => void);
+                dragEnd: ((param0: Event) => void);
+                dragStart: ((param0: Event, param1: object) => void);
+                linkStyle: ((param0: object) => void);
+                selector: string;
+            };
+        };
+        drop: {
+            background: {
+                dataTypes: string | string[];
+                dragEnter: ((param0: Event, param1: object) => void);
+                dragLeave: ((param0: Event, param1: object) => void);
+                dragOver: ((param0: Event, param1: object) => void);
+                drop: ((param0: Event, param1: object) => void);
+            };
+            links: {
+                dataTypes: string | string[];
+                dragEnter: ((param0: Event, param1: object) => void);
+                dragLeave: ((param0: Event, param1: object) => void);
+                dragOver: ((param0: Event, param1: object) => void);
+                drop: ((param0: Event, param1: object) => void);
+            };
+            nodes: {
+                dataTypes: string | string[];
+                dragEnter: ((param0: Event, param1: object) => void);
+                dragLeave: ((param0: Event, param1: object) => void);
+                dragOver: ((param0: Event, param1: object) => void);
+                drop: ((param0: Event, param1: object) => void);
+            };
+            ports: {
+                dataTypes: string | string[];
+                dragEnter: ((param0: Event, param1: object) => void);
+                dragLeave: ((param0: Event, param1: object) => void);
+                dragOver: ((param0: Event, param1: object) => void);
+                drop: ((param0: Event, param1: object) => void);
+                selector: string;
+            };
+        };
+    };
+    expanded: KeySet<K1>;
+    focusRenderer: ((context: ojDiagram.RendererContext<K1, D1>) => {
+        insert: SVGElement;
+    } | void) | null;
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverRenderer: ((context: ojDiagram.RendererContext<K1, D1>) => {
+        insert: SVGElement;
+    } | void) | null;
+    layout: ((param0: DvtDiagramLayoutContext) => void);
+    linkData: DataProvider<K2, D2> | null;
+    linkHighlightMode: 'linkAndNodes' | 'link';
+    maxZoom: number;
+    minZoom: number;
+    nodeData: DataProvider<K1, D1> | null;
+    nodeHighlightMode: 'nodeAndIncomingLinks' | 'nodeAndOutgoingLinks' | 'nodeAndLinks' | 'node';
+    overview: {
+        halign: 'start' | 'end' | 'center';
+        height: number;
+        rendered: 'on' | 'off';
+        valign: 'top' | 'bottom' | 'middle';
+        width: number;
+    };
+    panDirection: 'x' | 'y' | 'auto';
+    panning: 'auto' | 'none';
+    promotedLinkBehavior: 'none' | 'full' | 'lazy';
+    renderer: ((context: ojDiagram.RendererContext<K1, D1>) => ({
+        insert: SVGElement;
+    }));
+    selection: Array<K1 | K2>;
+    selectionMode: 'single' | 'multiple' | 'none';
+    selectionRenderer: ((context: ojDiagram.RendererContext<K1, D1>) => {
+        insert: SVGElement;
+    } | void) | null;
+    styleDefaults: {
+        animationDuration: number;
+        hoverBehaviorDelay: number;
+        linkDefaults: {
+            color: string;
+            endConnectorType: 'arrowOpen' | 'arrow' | 'arrowConcave' | 'circle' | 'rectangle' | 'rectangleRounded' | 'none';
+            labelStyle: object;
+            startConnectorType: 'arrowOpen' | 'arrow' | 'arrowConcave' | 'circle' | 'rectangle' | 'rectangleRounded' | 'none';
+            svgClassName: string;
+            svgStyle: object;
+            width: number;
+        };
+        nodeDefaults: {
+            icon: {
+                borderColor: string;
+                borderRadius: string;
+                borderWidth: number;
+                color: string;
+                height: number;
+                pattern: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+                   'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+                shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+                source: string;
+                sourceHover: string;
+                sourceHoverSelected: string;
+                sourceSelected: string;
+                svgClassName: string;
+                svgStyle: object;
+                width: number;
+            };
+            labelStyle: object;
+            showDisclosure: 'off' | 'on';
+        };
+        promotedLink: {
+            color: string;
+            endConnectorType: 'arrowOpen' | 'arrow' | 'arrowConcave' | 'circle' | 'rectangle' | 'rectangleRounded' | 'none';
+            startConnectorType: 'arrowOpen' | 'arrow' | 'arrowConcave' | 'circle' | 'rectangle' | 'rectangleRounded' | 'none';
+            svgClassName: string;
+            svgStyle: object;
+            width: number;
+        };
+    };
+    tooltip: {
+        renderer: ((context: ojDiagram.TooltipContext<K1, K2, D1, D2>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    touchResponse: 'touchStart' | 'auto';
+    zoomRenderer: ((context: ojDiagram.RendererContext<K1, D1>) => {
+        insert: SVGElement;
+    } | void) | null;
+    zooming: 'auto' | 'none';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        promotedLink?: string;
+        promotedLinkAriaDesc?: string;
+        promotedLinks?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface ojDiagramSettablePropertiesLenient<K1, K2, D1, D2> extends Partial<ojDiagramSettableProperties<K1, K2, D1, D2>> {
+    [key: string]: any;
+}
+export interface ojDiagramLink extends JetElement<ojDiagramLinkSettableProperties> {
+    categories: string[];
+    color?: string;
+    endConnectorType?: 'arrow' | 'arrowConcave' | 'arrowOpen' | 'circle' | 'none' | 'rectangle' | 'rectangleRounded';
+    endNode: any;
+    label?: string;
+    labelStyle?: object | null;
+    selectable?: 'auto' | 'off';
+    shortDesc?: string;
+    startConnectorType?: 'arrow' | 'arrowConcave' | 'arrowOpen' | 'circle' | 'none' | 'rectangle' | 'rectangleRounded';
+    startNode: any;
+    svgClassName?: string;
+    svgStyle?: object;
+    width?: number;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojDiagramLink["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojDiagramLink["color"]>) => any) | null;
+    onEndConnectorTypeChanged: ((event: JetElementCustomEvent<ojDiagramLink["endConnectorType"]>) => any) | null;
+    onEndNodeChanged: ((event: JetElementCustomEvent<ojDiagramLink["endNode"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojDiagramLink["label"]>) => any) | null;
+    onLabelStyleChanged: ((event: JetElementCustomEvent<ojDiagramLink["labelStyle"]>) => any) | null;
+    onSelectableChanged: ((event: JetElementCustomEvent<ojDiagramLink["selectable"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojDiagramLink["shortDesc"]>) => any) | null;
+    onStartConnectorTypeChanged: ((event: JetElementCustomEvent<ojDiagramLink["startConnectorType"]>) => any) | null;
+    onStartNodeChanged: ((event: JetElementCustomEvent<ojDiagramLink["startNode"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojDiagramLink["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojDiagramLink["svgStyle"]>) => any) | null;
+    onWidthChanged: ((event: JetElementCustomEvent<ojDiagramLink["width"]>) => any) | null;
+    addEventListener<T extends keyof ojDiagramLinkEventMap>(type: T, listener: (this: HTMLElement, ev: ojDiagramLinkEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojDiagramLinkSettableProperties>(property: T): ojDiagramLink[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojDiagramLinkSettableProperties>(property: T, value: ojDiagramLinkSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojDiagramLinkSettableProperties>): void;
+    setProperties(properties: ojDiagramLinkSettablePropertiesLenient): void;
+}
+export interface ojDiagramLinkEventMap extends HTMLElementEventMap {
+    'categoriesChanged': JetElementCustomEvent<ojDiagramLink["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojDiagramLink["color"]>;
+    'endConnectorTypeChanged': JetElementCustomEvent<ojDiagramLink["endConnectorType"]>;
+    'endNodeChanged': JetElementCustomEvent<ojDiagramLink["endNode"]>;
+    'labelChanged': JetElementCustomEvent<ojDiagramLink["label"]>;
+    'labelStyleChanged': JetElementCustomEvent<ojDiagramLink["labelStyle"]>;
+    'selectableChanged': JetElementCustomEvent<ojDiagramLink["selectable"]>;
+    'shortDescChanged': JetElementCustomEvent<ojDiagramLink["shortDesc"]>;
+    'startConnectorTypeChanged': JetElementCustomEvent<ojDiagramLink["startConnectorType"]>;
+    'startNodeChanged': JetElementCustomEvent<ojDiagramLink["startNode"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojDiagramLink["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojDiagramLink["svgStyle"]>;
+    'widthChanged': JetElementCustomEvent<ojDiagramLink["width"]>;
+}
+export interface ojDiagramLinkSettableProperties extends JetSettableProperties {
+    categories: string[];
+    color?: string;
+    endConnectorType?: 'arrow' | 'arrowConcave' | 'arrowOpen' | 'circle' | 'none' | 'rectangle' | 'rectangleRounded';
+    endNode: any;
+    label?: string;
+    labelStyle?: object | null;
+    selectable?: 'auto' | 'off';
+    shortDesc?: string;
+    startConnectorType?: 'arrow' | 'arrowConcave' | 'arrowOpen' | 'circle' | 'none' | 'rectangle' | 'rectangleRounded';
+    startNode: any;
+    svgClassName?: string;
+    svgStyle?: object;
+    width?: number;
+}
+export interface ojDiagramLinkSettablePropertiesLenient extends Partial<ojDiagramLinkSettableProperties> {
+    [key: string]: any;
+}
+export interface ojDiagramNode extends JetElement<ojDiagramNodeSettableProperties> {
+    categories?: string[];
+    descendantsConnectivity?: 'connected' | 'disjoint' | 'unknown';
+    icon?: {
+        borderColor?: string;
+        borderRadius?: string;
+        borderWidth?: number;
+        color?: string;
+        height?: number;
+        opacity?: number;
+        pattern?: 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' | 'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none' | 'mallChecker' | 'smallCrosshatch' |
+           'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle';
+        shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+        source?: string;
+        sourceHover?: string;
+        sourceHoverSelected?: string;
+        sourceSelected?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+        width?: number;
+    };
+    label?: string;
+    labelStyle?: object | null;
+    overview?: {
+        icon?: {
+            shape?: 'inherit' | 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+            svgClassName?: string;
+            svgStyle?: object;
+        };
+    };
+    selectable?: 'auto' | 'off';
+    shortDesc?: string;
+    showDisclosure?: 'on' | 'off';
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojDiagramNode["categories"]>) => any) | null;
+    onDescendantsConnectivityChanged: ((event: JetElementCustomEvent<ojDiagramNode["descendantsConnectivity"]>) => any) | null;
+    onIconChanged: ((event: JetElementCustomEvent<ojDiagramNode["icon"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojDiagramNode["label"]>) => any) | null;
+    onLabelStyleChanged: ((event: JetElementCustomEvent<ojDiagramNode["labelStyle"]>) => any) | null;
+    onOverviewChanged: ((event: JetElementCustomEvent<ojDiagramNode["overview"]>) => any) | null;
+    onSelectableChanged: ((event: JetElementCustomEvent<ojDiagramNode["selectable"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojDiagramNode["shortDesc"]>) => any) | null;
+    onShowDisclosureChanged: ((event: JetElementCustomEvent<ojDiagramNode["showDisclosure"]>) => any) | null;
+    addEventListener<T extends keyof ojDiagramNodeEventMap>(type: T, listener: (this: HTMLElement, ev: ojDiagramNodeEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojDiagramNodeSettableProperties>(property: T): ojDiagramNode[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojDiagramNodeSettableProperties>(property: T, value: ojDiagramNodeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojDiagramNodeSettableProperties>): void;
+    setProperties(properties: ojDiagramNodeSettablePropertiesLenient): void;
+}
+export interface ojDiagramNodeEventMap extends HTMLElementEventMap {
+    'categoriesChanged': JetElementCustomEvent<ojDiagramNode["categories"]>;
+    'descendantsConnectivityChanged': JetElementCustomEvent<ojDiagramNode["descendantsConnectivity"]>;
+    'iconChanged': JetElementCustomEvent<ojDiagramNode["icon"]>;
+    'labelChanged': JetElementCustomEvent<ojDiagramNode["label"]>;
+    'labelStyleChanged': JetElementCustomEvent<ojDiagramNode["labelStyle"]>;
+    'overviewChanged': JetElementCustomEvent<ojDiagramNode["overview"]>;
+    'selectableChanged': JetElementCustomEvent<ojDiagramNode["selectable"]>;
+    'shortDescChanged': JetElementCustomEvent<ojDiagramNode["shortDesc"]>;
+    'showDisclosureChanged': JetElementCustomEvent<ojDiagramNode["showDisclosure"]>;
+}
+export interface ojDiagramNodeSettableProperties extends JetSettableProperties {
+    categories?: string[];
+    descendantsConnectivity?: 'connected' | 'disjoint' | 'unknown';
+    icon?: {
+        borderColor?: string;
+        borderRadius?: string;
+        borderWidth?: number;
+        color?: string;
+        height?: number;
+        opacity?: number;
+        pattern?: 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' | 'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none' | 'mallChecker' | 'smallCrosshatch' |
+           'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle';
+        shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+        source?: string;
+        sourceHover?: string;
+        sourceHoverSelected?: string;
+        sourceSelected?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+        width?: number;
+    };
+    label?: string;
+    labelStyle?: object | null;
+    overview?: {
+        icon?: {
+            shape?: 'inherit' | 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+            svgClassName?: string;
+            svgStyle?: object;
+        };
+    };
+    selectable?: 'auto' | 'off';
+    shortDesc?: string;
+    showDisclosure?: 'on' | 'off';
+}
+export interface ojDiagramNodeSettablePropertiesLenient extends Partial<ojDiagramNodeSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojdialog/index.d.ts

@@ -0,0 +1,148 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojDialog extends baseComponent<ojDialogSettableProperties> {
+    cancelBehavior: 'icon' | 'escape' | 'none';
+    dragAffordance: 'title-bar' | 'none';
+    initialVisibility: 'hide' | 'show';
+    modality: 'modal' | 'modeless';
+    position: ojDialog.Position;
+    resizeBehavior: 'resizable' | 'none';
+    role: string;
+    translations: {
+        labelCloseIcon?: string;
+    };
+    onCancelBehaviorChanged: ((event: JetElementCustomEvent<ojDialog["cancelBehavior"]>) => any) | null;
+    onDragAffordanceChanged: ((event: JetElementCustomEvent<ojDialog["dragAffordance"]>) => any) | null;
+    onInitialVisibilityChanged: ((event: JetElementCustomEvent<ojDialog["initialVisibility"]>) => any) | null;
+    onModalityChanged: ((event: JetElementCustomEvent<ojDialog["modality"]>) => any) | null;
+    onPositionChanged: ((event: JetElementCustomEvent<ojDialog["position"]>) => any) | null;
+    onResizeBehaviorChanged: ((event: JetElementCustomEvent<ojDialog["resizeBehavior"]>) => any) | null;
+    onRoleChanged: ((event: JetElementCustomEvent<ojDialog["role"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojDialog.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojDialog.ojAnimateStart) => any) | null;
+    onOjBeforeClose: ((event: ojDialog.ojBeforeClose) => any) | null;
+    onOjBeforeOpen: ((event: ojDialog.ojBeforeOpen) => any) | null;
+    onOjClose: ((event: ojDialog.ojClose) => any) | null;
+    onOjFocus: ((event: ojDialog.ojFocus) => any) | null;
+    onOjOpen: ((event: ojDialog.ojOpen) => any) | null;
+    onOjResize: ((event: ojDialog.ojResize) => any) | null;
+    onOjResizeStart: ((event: ojDialog.ojResizeStart) => any) | null;
+    onOjResizeStop: ((event: ojDialog.ojResizeStop) => any) | null;
+    addEventListener<T extends keyof ojDialogEventMap>(type: T, listener: (this: HTMLElement, ev: ojDialogEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojDialogSettableProperties>(property: T): ojDialog[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojDialogSettableProperties>(property: T, value: ojDialogSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojDialogSettableProperties>): void;
+    setProperties(properties: ojDialogSettablePropertiesLenient): void;
+    close(): void;
+    isOpen(): boolean;
+    open(): void;
+    refresh(): void;
+}
+export namespace ojDialog {
+    interface ojAnimateEnd extends CustomEvent<{
+        element: Element;
+        action: 'open' | 'close';
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: 'open' | 'close';
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeClose extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeOpen extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojClose extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojFocus extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojOpen extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojResize extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojResizeStart extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojResizeStop extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type Position = {
+        my?: PositionAlign;
+        at?: PositionAlign;
+        offset?: PositionPoint;
+        of?: string | PositionPoint;
+        collision?: 'flip' | 'fit' | 'flipfit' | 'none';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PositionAlign = {
+        vertical?: 'top' | 'bottom' | 'center';
+        horizontal?: 'start' | 'end' | 'left' | 'center' | 'bottom';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PositionPoint = {
+        x?: number;
+        y?: number;
+    };
+}
+export interface ojDialogEventMap extends baseComponentEventMap<ojDialogSettableProperties> {
+    'ojAnimateEnd': ojDialog.ojAnimateEnd;
+    'ojAnimateStart': ojDialog.ojAnimateStart;
+    'ojBeforeClose': ojDialog.ojBeforeClose;
+    'ojBeforeOpen': ojDialog.ojBeforeOpen;
+    'ojClose': ojDialog.ojClose;
+    'ojFocus': ojDialog.ojFocus;
+    'ojOpen': ojDialog.ojOpen;
+    'ojResize': ojDialog.ojResize;
+    'ojResizeStart': ojDialog.ojResizeStart;
+    'ojResizeStop': ojDialog.ojResizeStop;
+    'cancelBehaviorChanged': JetElementCustomEvent<ojDialog["cancelBehavior"]>;
+    'dragAffordanceChanged': JetElementCustomEvent<ojDialog["dragAffordance"]>;
+    'initialVisibilityChanged': JetElementCustomEvent<ojDialog["initialVisibility"]>;
+    'modalityChanged': JetElementCustomEvent<ojDialog["modality"]>;
+    'positionChanged': JetElementCustomEvent<ojDialog["position"]>;
+    'resizeBehaviorChanged': JetElementCustomEvent<ojDialog["resizeBehavior"]>;
+    'roleChanged': JetElementCustomEvent<ojDialog["role"]>;
+}
+export interface ojDialogSettableProperties extends baseComponentSettableProperties {
+    cancelBehavior: 'icon' | 'escape' | 'none';
+    dragAffordance: 'title-bar' | 'none';
+    initialVisibility: 'hide' | 'show';
+    modality: 'modal' | 'modeless';
+    position: ojDialog.Position;
+    resizeBehavior: 'resizable' | 'none';
+    role: string;
+    translations: {
+        labelCloseIcon?: string;
+    };
+}
+export interface ojDialogSettablePropertiesLenient extends Partial<ojDialogSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojdvt-base/index.d.ts

@@ -0,0 +1,57 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface dvtBaseComponent<SP extends dvtBaseComponentSettableProperties = dvtBaseComponentSettableProperties> extends baseComponent<SP> {
+    trackResize: 'on' | 'off';
+    translations: {
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    onTrackResizeChanged: ((event: JetElementCustomEvent<dvtBaseComponent<SP>["trackResize"]>) => any) | null;
+    addEventListener<T extends keyof dvtBaseComponentEventMap<SP>>(type: T, listener: (this: HTMLElement, ev: dvtBaseComponentEventMap<SP>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof dvtBaseComponentSettableProperties>(property: T): dvtBaseComponent<SP>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof dvtBaseComponentSettableProperties>(property: T, value: dvtBaseComponentSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, dvtBaseComponentSettableProperties>): void;
+    setProperties(properties: dvtBaseComponentSettablePropertiesLenient): void;
+}
+export interface dvtBaseComponentEventMap<SP extends dvtBaseComponentSettableProperties = dvtBaseComponentSettableProperties> extends baseComponentEventMap<SP> {
+    'trackResizeChanged': JetElementCustomEvent<dvtBaseComponent<SP>["trackResize"]>;
+}
+export interface dvtBaseComponentSettableProperties extends baseComponentSettableProperties {
+    trackResize: 'on' | 'off';
+    translations: {
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface dvtBaseComponentSettablePropertiesLenient extends Partial<dvtBaseComponentSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojeditablevalue/index.d.ts

@@ -0,0 +1,96 @@
+import Message = require('../ojmessaging');
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface editableValue<V, SP extends editableValueSettableProperties<V, SV, RV>, SV = V, RV = V> extends baseComponent<SP> {
+    describedBy: string | null;
+    disabled: boolean;
+    displayOptions: {
+        converterHint: Array<'placeholder' | 'notewindow' | 'none'> | 'placeholder' | 'notewindow' | 'none';
+        helpInstruction: Array<'notewindow' | 'none'> | 'notewindow' | 'none';
+        messages: Array<'inline' | 'notewindow' | 'none'> | 'inline' | 'notewindow' | 'none';
+        validatorHint: Array<'notewindow' | 'none'> | 'notewindow' | 'none';
+    };
+    help: {
+        instruction?: string;
+    };
+    helpHints: {
+        definition?: string;
+        source?: string;
+    };
+    labelHint: string;
+    messagesCustom: Message[];
+    readonly valid: 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+    value: V;
+    onDescribedByChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["describedBy"]>) => any) | null;
+    onDisabledChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["disabled"]>) => any) | null;
+    onDisplayOptionsChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["displayOptions"]>) => any) | null;
+    onHelpChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["help"]>) => any) | null;
+    onHelpHintsChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["helpHints"]>) => any) | null;
+    onLabelHintChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["labelHint"]>) => any) | null;
+    onMessagesCustomChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["messagesCustom"]>) => any) | null;
+    onValidChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["valid"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<editableValue<V, SP, SV, RV>["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: editableValue.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: editableValue.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof editableValueEventMap<V, SP, SV, RV>>(type: T, listener: (this: HTMLElement, ev: editableValueEventMap<V, SP, SV, RV>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof editableValueSettableProperties<V, SV, RV>>(property: T): editableValue<V, SP, SV, RV>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof editableValueSettableProperties<V, SV, RV>>(property: T, value: editableValueSettableProperties<V, SV, RV>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, editableValueSettableProperties<V, SV, RV>>): void;
+    setProperties(properties: editableValueSettablePropertiesLenient<V, SV, RV>): void;
+    refresh(): void;
+    reset(): void;
+    showMessages(): void;
+}
+export namespace editableValue {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface editableValueEventMap<V, SP extends editableValueSettableProperties<V, SV, RV>, SV = V, RV = V> extends baseComponentEventMap<SP> {
+    'ojAnimateEnd': editableValue.ojAnimateEnd;
+    'ojAnimateStart': editableValue.ojAnimateStart;
+    'describedByChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["describedBy"]>;
+    'disabledChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["disabled"]>;
+    'displayOptionsChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["displayOptions"]>;
+    'helpChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["help"]>;
+    'helpHintsChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["helpHints"]>;
+    'labelHintChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["labelHint"]>;
+    'messagesCustomChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["messagesCustom"]>;
+    'validChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["valid"]>;
+    'valueChanged': JetElementCustomEvent<editableValue<V, SP, SV, RV>["value"]>;
+}
+export interface editableValueSettableProperties<V, SV = V, RV = V> extends baseComponentSettableProperties {
+    describedBy: string | null;
+    disabled: boolean;
+    displayOptions: {
+        converterHint: Array<'placeholder' | 'notewindow' | 'none'> | 'placeholder' | 'notewindow' | 'none';
+        helpInstruction: Array<'notewindow' | 'none'> | 'notewindow' | 'none';
+        messages: Array<'inline' | 'notewindow' | 'none'> | 'inline' | 'notewindow' | 'none';
+        validatorHint: Array<'notewindow' | 'none'> | 'notewindow' | 'none';
+    };
+    help: {
+        instruction?: string;
+    };
+    helpHints: {
+        definition?: string;
+        source?: string;
+    };
+    labelHint: string;
+    messagesCustom: Message[];
+    readonly valid: 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+    value: SV;
+}
+export interface editableValueSettablePropertiesLenient<V, SV, RV> extends Partial<editableValueSettableProperties<V, SV, RV>> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojexpressionutils/index.d.ts

@@ -0,0 +1,5 @@
+export function createGenericExpressionEvaluator(expressionText: string): (context: any) => any;
+export function getExpressionInfo(expression: string): {
+    expr: (null | string);
+    downstreamOnly: boolean;
+};

types/oracle__oraclejet/ojfilepicker/index.d.ts

@@ -0,0 +1,43 @@
+import { ProgressItem } from '../ojprogresslist';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface FileUploadTransport {
+    flush(): void;
+    queue(fileList: FileList): ProgressItem[];
+}
+export interface ojFilePicker extends JetElement<ojFilePickerSettableProperties> {
+    accept: string[] | null;
+    selectOn: 'auto' | 'click' | 'drop' | 'clickAndDrop';
+    selectionMode: 'multiple' | 'single';
+    onAcceptChanged: ((event: JetElementCustomEvent<ojFilePicker["accept"]>) => any) | null;
+    onSelectOnChanged: ((event: JetElementCustomEvent<ojFilePicker["selectOn"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojFilePicker["selectionMode"]>) => any) | null;
+    onOjSelect: ((event: ojFilePicker.ojSelect) => any) | null;
+    addEventListener<T extends keyof ojFilePickerEventMap>(type: T, listener: (this: HTMLElement, ev: ojFilePickerEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojFilePickerSettableProperties>(property: T): ojFilePicker[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojFilePickerSettableProperties>(property: T, value: ojFilePickerSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojFilePickerSettableProperties>): void;
+    setProperties(properties: ojFilePickerSettablePropertiesLenient): void;
+}
+export namespace ojFilePicker {
+    interface ojSelect extends CustomEvent<{
+        files: FileList;
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojFilePickerEventMap extends HTMLElementEventMap {
+    'ojSelect': ojFilePicker.ojSelect;
+    'acceptChanged': JetElementCustomEvent<ojFilePicker["accept"]>;
+    'selectOnChanged': JetElementCustomEvent<ojFilePicker["selectOn"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojFilePicker["selectionMode"]>;
+}
+export interface ojFilePickerSettableProperties extends JetSettableProperties {
+    accept: string[] | null;
+    selectOn: 'auto' | 'click' | 'drop' | 'clickAndDrop';
+    selectionMode: 'multiple' | 'single';
+}
+export interface ojFilePickerSettablePropertiesLenient extends Partial<ojFilePickerSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojfilmstrip/index.d.ts

@@ -0,0 +1,63 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojFilmStrip extends baseComponent<ojFilmStripSettableProperties> {
+    arrowPlacement: 'adjacent' | 'overlay';
+    arrowVisibility: 'visible' | 'hidden' | 'hover' | 'auto';
+    currentItem: {
+        id?: string;
+        index?: number;
+    };
+    looping: 'off' | 'page';
+    maxItemsPerPage: number;
+    orientation: 'horizontal' | 'vertical';
+    translations: {
+        labelAccArrowNextPage?: string;
+        labelAccArrowPreviousPage?: string;
+        labelAccFilmStrip?: string;
+        tipArrowNextPage?: string;
+        tipArrowPreviousPage?: string;
+    };
+    onArrowPlacementChanged: ((event: JetElementCustomEvent<ojFilmStrip["arrowPlacement"]>) => any) | null;
+    onArrowVisibilityChanged: ((event: JetElementCustomEvent<ojFilmStrip["arrowVisibility"]>) => any) | null;
+    onCurrentItemChanged: ((event: JetElementCustomEvent<ojFilmStrip["currentItem"]>) => any) | null;
+    onLoopingChanged: ((event: JetElementCustomEvent<ojFilmStrip["looping"]>) => any) | null;
+    onMaxItemsPerPageChanged: ((event: JetElementCustomEvent<ojFilmStrip["maxItemsPerPage"]>) => any) | null;
+    onOrientationChanged: ((event: JetElementCustomEvent<ojFilmStrip["orientation"]>) => any) | null;
+    addEventListener<T extends keyof ojFilmStripEventMap>(type: T, listener: (this: HTMLElement, ev: ojFilmStripEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojFilmStripSettableProperties>(property: T): ojFilmStrip[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojFilmStripSettableProperties>(property: T, value: ojFilmStripSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojFilmStripSettableProperties>): void;
+    setProperties(properties: ojFilmStripSettablePropertiesLenient): void;
+    getItemsPerPage(): number;
+    refresh(): void;
+}
+export interface ojFilmStripEventMap extends baseComponentEventMap<ojFilmStripSettableProperties> {
+    'arrowPlacementChanged': JetElementCustomEvent<ojFilmStrip["arrowPlacement"]>;
+    'arrowVisibilityChanged': JetElementCustomEvent<ojFilmStrip["arrowVisibility"]>;
+    'currentItemChanged': JetElementCustomEvent<ojFilmStrip["currentItem"]>;
+    'loopingChanged': JetElementCustomEvent<ojFilmStrip["looping"]>;
+    'maxItemsPerPageChanged': JetElementCustomEvent<ojFilmStrip["maxItemsPerPage"]>;
+    'orientationChanged': JetElementCustomEvent<ojFilmStrip["orientation"]>;
+}
+export interface ojFilmStripSettableProperties extends baseComponentSettableProperties {
+    arrowPlacement: 'adjacent' | 'overlay';
+    arrowVisibility: 'visible' | 'hidden' | 'hover' | 'auto';
+    currentItem: {
+        id?: string;
+        index?: number;
+    };
+    looping: 'off' | 'page';
+    maxItemsPerPage: number;
+    orientation: 'horizontal' | 'vertical';
+    translations: {
+        labelAccArrowNextPage?: string;
+        labelAccArrowPreviousPage?: string;
+        labelAccFilmStrip?: string;
+        tipArrowNextPage?: string;
+        tipArrowPreviousPage?: string;
+    };
+}
+export interface ojFilmStripSettablePropertiesLenient extends Partial<ojFilmStripSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojformlayout/index.d.ts

@@ -0,0 +1,38 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojFormLayout extends JetElement<ojFormLayoutSettableProperties> {
+    direction: 'column' | 'row';
+    labelEdge: 'start' | 'top';
+    labelWidth: string;
+    labelWrapping: 'truncate' | 'wrap';
+    maxColumns: number;
+    onDirectionChanged: ((event: JetElementCustomEvent<ojFormLayout["direction"]>) => any) | null;
+    onLabelEdgeChanged: ((event: JetElementCustomEvent<ojFormLayout["labelEdge"]>) => any) | null;
+    onLabelWidthChanged: ((event: JetElementCustomEvent<ojFormLayout["labelWidth"]>) => any) | null;
+    onLabelWrappingChanged: ((event: JetElementCustomEvent<ojFormLayout["labelWrapping"]>) => any) | null;
+    onMaxColumnsChanged: ((event: JetElementCustomEvent<ojFormLayout["maxColumns"]>) => any) | null;
+    addEventListener<T extends keyof ojFormLayoutEventMap>(type: T, listener: (this: HTMLElement, ev: ojFormLayoutEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojFormLayoutSettableProperties>(property: T): ojFormLayout[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojFormLayoutSettableProperties>(property: T, value: ojFormLayoutSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojFormLayoutSettableProperties>): void;
+    setProperties(properties: ojFormLayoutSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface ojFormLayoutEventMap extends HTMLElementEventMap {
+    'directionChanged': JetElementCustomEvent<ojFormLayout["direction"]>;
+    'labelEdgeChanged': JetElementCustomEvent<ojFormLayout["labelEdge"]>;
+    'labelWidthChanged': JetElementCustomEvent<ojFormLayout["labelWidth"]>;
+    'labelWrappingChanged': JetElementCustomEvent<ojFormLayout["labelWrapping"]>;
+    'maxColumnsChanged': JetElementCustomEvent<ojFormLayout["maxColumns"]>;
+}
+export interface ojFormLayoutSettableProperties extends JetSettableProperties {
+    direction: 'column' | 'row';
+    labelEdge: 'start' | 'top';
+    labelWidth: string;
+    labelWrapping: 'truncate' | 'wrap';
+    maxColumns: number;
+}
+export interface ojFormLayoutSettablePropertiesLenient extends Partial<ojFormLayoutSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojgantt/index.d.ts

@@ -0,0 +1,679 @@
+import { ojTimeAxis } from '../ojtimeaxis';
+import { Converter } from '../ojvalidation-base';
+import { DataProvider } from '../ojdataprovider';
+import { dvtTimeComponent, dvtTimeComponentEventMap, dvtTimeComponentSettableProperties } from '../ojtime-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojGantt<K1, K2, D1, D2> extends dvtTimeComponent<ojGanttSettableProperties<K1, K2, D1, D2>> {
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    as: string;
+    axisPosition: 'bottom' | 'top';
+    dependencyData?: (DataProvider<K1, D1>);
+    dnd: {
+        move?: {
+            tasks?: 'disabled' | 'enabled';
+        };
+    };
+    end: string;
+    gridlines: {
+        horizontal?: 'hidden' | 'visible' | 'auto';
+        vertical?: 'hidden' | 'visible' | 'auto';
+    };
+    majorAxis: {
+        converter?: (ojTimeAxis.Converters | Converter<string>);
+        height?: number;
+        scale: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'quarters' | 'years';
+        zoomOrder?: string[];
+    };
+    minorAxis: {
+        converter?: (ojTimeAxis.Converters | Converter<string>);
+        height?: number;
+        scale: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'quarters' | 'years';
+        zoomOrder?: string[];
+    };
+    referenceObjects: ojGantt.ReferenceObject[];
+    rowAxis: {
+        label?: {
+            renderer: ((context: ojGantt.RowAxisLabelRendererContext<K2, D2>) => ({
+                insert: Element;
+            }));
+        };
+        maxWidth?: string;
+        rendered?: 'on' | 'off';
+        width?: string;
+    };
+    rowDefaults: {
+        height?: number;
+    };
+    scrollPosition: {
+        offsetY?: number;
+        rowIndex?: number;
+        y?: number;
+    };
+    selection: K2[];
+    selectionMode: 'single' | 'multiple' | 'none';
+    start: string;
+    taskData?: (DataProvider<K2, D2>);
+    taskDefaults: {
+        baseline?: {
+            borderRadius?: string;
+            height?: number;
+            svgClassName?: string;
+            svgStyle?: object;
+        };
+        borderRadius?: string;
+        height?: number;
+        labelPosition?: (string | string[]);
+        progress?: {
+            borderRadius?: string;
+            height?: string;
+            svgClassName?: string;
+            svgStyle?: object;
+        };
+        svgClassName?: string;
+        svgStyle?: object;
+        type?: 'normal' | 'milestone' | 'summary' | 'auto';
+    };
+    tooltip: {
+        renderer: ((context: ojGantt.TooltipContext<K2, D2>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    valueFormats: {
+        baselineDate?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        baselineEnd?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        baselineStart?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        date?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        end?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        label?: {
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        progress?: {
+            converter?: (Converter<number>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        row?: {
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        start?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+    };
+    viewportEnd: string;
+    viewportStart: string;
+    translations: {
+        accessibleDependencyInfo?: string;
+        accessiblePredecessorInfo?: string;
+        accessibleSuccessorInfo?: string;
+        accessibleTaskTypeMilestone?: string;
+        accessibleTaskTypeSummary?: string;
+        componentName?: string;
+        finishFinishDependencyAriaDesc?: string;
+        finishStartDependencyAriaDesc?: string;
+        labelAndValue?: string;
+        labelBaselineDate?: string;
+        labelBaselineEnd?: string;
+        labelBaselineStart?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelDate?: string;
+        labelEnd?: string;
+        labelInvalidData?: string;
+        labelLabel?: string;
+        labelMoveBy?: string;
+        labelNoData?: string;
+        labelProgress?: string;
+        labelRow?: string;
+        labelStart?: string;
+        startFinishDependencyAriaDesc?: string;
+        startStartDependencyAriaDesc?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+        taskMoveCancelled?: string;
+        taskMoveFinalized?: string;
+        taskMoveInitiated?: string;
+        taskMoveInitiatedInstruction?: string;
+        taskMoveSelectionInfo?: string;
+        tooltipZoomIn?: string;
+        tooltipZoomOut?: string;
+    };
+    onAnimationOnDataChangeChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["animationOnDataChange"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["animationOnDisplay"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["as"]>) => any) | null;
+    onAxisPositionChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["axisPosition"]>) => any) | null;
+    onDependencyDataChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["dependencyData"]>) => any) | null;
+    onDndChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["dnd"]>) => any) | null;
+    onEndChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["end"]>) => any) | null;
+    onGridlinesChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["gridlines"]>) => any) | null;
+    onMajorAxisChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["majorAxis"]>) => any) | null;
+    onMinorAxisChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["minorAxis"]>) => any) | null;
+    onReferenceObjectsChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["referenceObjects"]>) => any) | null;
+    onRowAxisChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["rowAxis"]>) => any) | null;
+    onRowDefaultsChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["rowDefaults"]>) => any) | null;
+    onScrollPositionChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["scrollPosition"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["selectionMode"]>) => any) | null;
+    onStartChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["start"]>) => any) | null;
+    onTaskDataChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["taskData"]>) => any) | null;
+    onTaskDefaultsChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["taskDefaults"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["tooltip"]>) => any) | null;
+    onValueFormatsChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["valueFormats"]>) => any) | null;
+    onViewportEndChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["viewportEnd"]>) => any) | null;
+    onViewportStartChanged: ((event: JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["viewportStart"]>) => any) | null;
+    onOjMove: ((event: ojGantt.ojMove<K2, D2>) => any) | null;
+    onOjViewportChange: ((event: ojGantt.ojViewportChange) => any) | null;
+    addEventListener<T extends keyof ojGanttEventMap<K1, K2, D1, D2>>(type: T, listener: (this: HTMLElement, ev: ojGanttEventMap<K1, K2, D1, D2>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojGanttSettableProperties<K1, K2, D1, D2>>(property: T): ojGantt<K1, K2, D1, D2>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojGanttSettableProperties<K1, K2, D1, D2>>(property: T, value: ojGanttSettableProperties<K1, K2, D1, D2>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojGanttSettableProperties<K1, K2, D1, D2>>): void;
+    setProperties(properties: ojGanttSettablePropertiesLenient<K1, K2, D1, D2>): void;
+    getContextByNode(node: Element): {
+        subId: 'oj-gantt-row-label';
+        index: number;
+    } | {
+        subId: 'oj-gantt-taskbar';
+        rowIndex: number;
+        index: number;
+    } | null;
+}
+export namespace ojGantt {
+    interface ojMove<K2, D2> extends CustomEvent<{
+        taskContexts: Array<{
+            data: RowTask<K2>;
+            rowData: Row<K2>;
+            itemData: D2 | null;
+            color: string;
+        }>;
+        value: string;
+        start: string;
+        end: string;
+        baselineStart: string;
+        baselineEnd: string;
+        rowContext: {
+            rowData: Row<K2>;
+            componentElement: Element;
+        };
+        [propName: string]: any;
+    }> {
+    }
+    interface ojViewportChange extends CustomEvent<{
+        viewportStart: string;
+        viewportEnd: string;
+        majorAxisScale: string;
+        minorAxisScale: string;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type Dependency<K1, K2> = {
+        id: K1;
+        predecessorTaskId: K2;
+        shortDesc?: string;
+        successorTaskId: K2;
+        svgClassName?: string;
+        svgStyle?: object;
+        type?: 'startStart' | 'startFinish' | 'finishFinish' | 'finishStart';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type ReferenceObject = {
+        svgClassName?: string;
+        svgStyle?: object;
+        value?: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type Row<K2> = {
+        id?: any;
+        label?: string;
+        labelStyle?: object;
+        tasks?: Array<RowTask<K2>>;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RowAxisLabelRendererContext<K2, D2> = {
+        parentElement: Element;
+        rowData: Row<K2>;
+        itemData: D2[];
+        componentElement: Element;
+        maxWidth: number;
+        maxHeight: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RowTask<K2> = {
+        borderRadius?: string;
+        end?: string;
+        height?: number;
+        id: K2;
+        label?: string;
+        labelPosition?: string | string[];
+        labelStyle?: object;
+        start?: string;
+        shortDesc?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+        type?: 'normal' | 'milestone' | 'summary' | 'auto';
+        progress?: {
+            borderRadius?: string;
+            height?: string;
+            svgClassName?: string;
+            svgStyle?: object;
+            value?: number;
+        };
+        baseline?: {
+            borderRadius?: string;
+            end?: string;
+            height?: number;
+            start?: string;
+            svgClassName?: string;
+            svgStyle?: object;
+        };
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext<K2, D2> = {
+        parentElement: Element;
+        data: RowTask<K2>;
+        rowData: Row<K2>;
+        itemData: D2;
+        componentElement: Element;
+        color: string;
+    };
+}
+export interface ojGanttEventMap<K1, K2, D1, D2> extends dvtTimeComponentEventMap<ojGanttSettableProperties<K1, K2, D1, D2>> {
+    'ojMove': ojGantt.ojMove<K2, D2>;
+    'ojViewportChange': ojGantt.ojViewportChange;
+    'animationOnDataChangeChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["animationOnDataChange"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["animationOnDisplay"]>;
+    'asChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["as"]>;
+    'axisPositionChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["axisPosition"]>;
+    'dependencyDataChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["dependencyData"]>;
+    'dndChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["dnd"]>;
+    'endChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["end"]>;
+    'gridlinesChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["gridlines"]>;
+    'majorAxisChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["majorAxis"]>;
+    'minorAxisChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["minorAxis"]>;
+    'referenceObjectsChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["referenceObjects"]>;
+    'rowAxisChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["rowAxis"]>;
+    'rowDefaultsChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["rowDefaults"]>;
+    'scrollPositionChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["scrollPosition"]>;
+    'selectionChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["selectionMode"]>;
+    'startChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["start"]>;
+    'taskDataChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["taskData"]>;
+    'taskDefaultsChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["taskDefaults"]>;
+    'tooltipChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["tooltip"]>;
+    'valueFormatsChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["valueFormats"]>;
+    'viewportEndChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["viewportEnd"]>;
+    'viewportStartChanged': JetElementCustomEvent<ojGantt<K1, K2, D1, D2>["viewportStart"]>;
+}
+export interface ojGanttSettableProperties<K1, K2, D1, D2> extends dvtTimeComponentSettableProperties {
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    as: string;
+    axisPosition: 'bottom' | 'top';
+    dependencyData?: (DataProvider<K1, D1>);
+    dnd: {
+        move?: {
+            tasks?: 'disabled' | 'enabled';
+        };
+    };
+    end: string;
+    gridlines: {
+        horizontal?: 'hidden' | 'visible' | 'auto';
+        vertical?: 'hidden' | 'visible' | 'auto';
+    };
+    majorAxis: {
+        converter?: (ojTimeAxis.Converters | Converter<string>);
+        height?: number;
+        scale: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'quarters' | 'years';
+        zoomOrder?: string[];
+    };
+    minorAxis: {
+        converter?: (ojTimeAxis.Converters | Converter<string>);
+        height?: number;
+        scale: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'quarters' | 'years';
+        zoomOrder?: string[];
+    };
+    referenceObjects: ojGantt.ReferenceObject[];
+    rowAxis: {
+        label?: {
+            renderer: ((context: ojGantt.RowAxisLabelRendererContext<K2, D2>) => ({
+                insert: Element;
+            }));
+        };
+        maxWidth?: string;
+        rendered?: 'on' | 'off';
+        width?: string;
+    };
+    rowDefaults: {
+        height?: number;
+    };
+    scrollPosition: {
+        offsetY?: number;
+        rowIndex?: number;
+        y?: number;
+    };
+    selection: K2[];
+    selectionMode: 'single' | 'multiple' | 'none';
+    start: string;
+    taskData?: (DataProvider<K2, D2>);
+    taskDefaults: {
+        baseline?: {
+            borderRadius?: string;
+            height?: number;
+            svgClassName?: string;
+            svgStyle?: object;
+        };
+        borderRadius?: string;
+        height?: number;
+        labelPosition?: (string | string[]);
+        progress?: {
+            borderRadius?: string;
+            height?: string;
+            svgClassName?: string;
+            svgStyle?: object;
+        };
+        svgClassName?: string;
+        svgStyle?: object;
+        type?: 'normal' | 'milestone' | 'summary' | 'auto';
+    };
+    tooltip: {
+        renderer: ((context: ojGantt.TooltipContext<K2, D2>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    valueFormats: {
+        baselineDate?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        baselineEnd?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        baselineStart?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        date?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        end?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        label?: {
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        progress?: {
+            converter?: (Converter<number>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        row?: {
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+        start?: {
+            converter?: (Converter<string>);
+            tooltipDisplay?: 'off' | 'auto';
+            tooltipLabel?: string;
+        };
+    };
+    viewportEnd: string;
+    viewportStart: string;
+    translations: {
+        accessibleDependencyInfo?: string;
+        accessiblePredecessorInfo?: string;
+        accessibleSuccessorInfo?: string;
+        accessibleTaskTypeMilestone?: string;
+        accessibleTaskTypeSummary?: string;
+        componentName?: string;
+        finishFinishDependencyAriaDesc?: string;
+        finishStartDependencyAriaDesc?: string;
+        labelAndValue?: string;
+        labelBaselineDate?: string;
+        labelBaselineEnd?: string;
+        labelBaselineStart?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelDate?: string;
+        labelEnd?: string;
+        labelInvalidData?: string;
+        labelLabel?: string;
+        labelMoveBy?: string;
+        labelNoData?: string;
+        labelProgress?: string;
+        labelRow?: string;
+        labelStart?: string;
+        startFinishDependencyAriaDesc?: string;
+        startStartDependencyAriaDesc?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+        taskMoveCancelled?: string;
+        taskMoveFinalized?: string;
+        taskMoveInitiated?: string;
+        taskMoveInitiatedInstruction?: string;
+        taskMoveSelectionInfo?: string;
+        tooltipZoomIn?: string;
+        tooltipZoomOut?: string;
+    };
+}
+export interface ojGanttSettablePropertiesLenient<K1, K2, D1, D2> extends Partial<ojGanttSettableProperties<K1, K2, D1, D2>> {
+    [key: string]: any;
+}
+export interface ojGanttDependency extends JetElement<ojGanttDependencySettableProperties> {
+    predecessorTaskId: any;
+    shortDesc: string | null;
+    successorTaskId: any;
+    svgClassName: string;
+    svgStyle: object;
+    type: 'finishStart' | 'finishFinish' | 'startStart' | 'startFinish';
+    onPredecessorTaskIdChanged: ((event: JetElementCustomEvent<ojGanttDependency["predecessorTaskId"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojGanttDependency["shortDesc"]>) => any) | null;
+    onSuccessorTaskIdChanged: ((event: JetElementCustomEvent<ojGanttDependency["successorTaskId"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojGanttDependency["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojGanttDependency["svgStyle"]>) => any) | null;
+    onTypeChanged: ((event: JetElementCustomEvent<ojGanttDependency["type"]>) => any) | null;
+    addEventListener<T extends keyof ojGanttDependencyEventMap>(type: T, listener: (this: HTMLElement, ev: ojGanttDependencyEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojGanttDependencySettableProperties>(property: T): ojGanttDependency[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojGanttDependencySettableProperties>(property: T, value: ojGanttDependencySettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojGanttDependencySettableProperties>): void;
+    setProperties(properties: ojGanttDependencySettablePropertiesLenient): void;
+}
+export interface ojGanttDependencyEventMap extends HTMLElementEventMap {
+    'predecessorTaskIdChanged': JetElementCustomEvent<ojGanttDependency["predecessorTaskId"]>;
+    'shortDescChanged': JetElementCustomEvent<ojGanttDependency["shortDesc"]>;
+    'successorTaskIdChanged': JetElementCustomEvent<ojGanttDependency["successorTaskId"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojGanttDependency["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojGanttDependency["svgStyle"]>;
+    'typeChanged': JetElementCustomEvent<ojGanttDependency["type"]>;
+}
+export interface ojGanttDependencySettableProperties extends JetSettableProperties {
+    predecessorTaskId: any;
+    shortDesc: string | null;
+    successorTaskId: any;
+    svgClassName: string;
+    svgStyle: object;
+    type: 'finishStart' | 'finishFinish' | 'startStart' | 'startFinish';
+}
+export interface ojGanttDependencySettablePropertiesLenient extends Partial<ojGanttDependencySettableProperties> {
+    [key: string]: any;
+}
+export interface ojGanttRow extends JetElement<ojGanttRowSettableProperties> {
+    label: string;
+    labelStyle: object;
+    onLabelChanged: ((event: JetElementCustomEvent<ojGanttRow["label"]>) => any) | null;
+    onLabelStyleChanged: ((event: JetElementCustomEvent<ojGanttRow["labelStyle"]>) => any) | null;
+    addEventListener<T extends keyof ojGanttRowEventMap>(type: T, listener: (this: HTMLElement, ev: ojGanttRowEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojGanttRowSettableProperties>(property: T): ojGanttRow[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojGanttRowSettableProperties>(property: T, value: ojGanttRowSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojGanttRowSettableProperties>): void;
+    setProperties(properties: ojGanttRowSettablePropertiesLenient): void;
+}
+export interface ojGanttRowEventMap extends HTMLElementEventMap {
+    'labelChanged': JetElementCustomEvent<ojGanttRow["label"]>;
+    'labelStyleChanged': JetElementCustomEvent<ojGanttRow["labelStyle"]>;
+}
+export interface ojGanttRowSettableProperties extends JetSettableProperties {
+    label: string;
+    labelStyle: object;
+}
+export interface ojGanttRowSettablePropertiesLenient extends Partial<ojGanttRowSettableProperties> {
+    [key: string]: any;
+}
+export interface ojGanttTask extends JetElement<ojGanttTaskSettableProperties> {
+    baseline: {
+        borderRadius?: string;
+        end?: string;
+        height?: number;
+        start?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    borderRadius: string;
+    end: string;
+    height: number | null;
+    label: string;
+    labelPosition: 'start' | 'innerCenter' | 'innerStart' | 'innerEnd' | 'end' | 'none';
+    labelStyle: object;
+    progress: {
+        borderRadius?: string;
+        height?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+        value?: number;
+    };
+    rowId?: any;
+    shortDesc: string | null;
+    start: string;
+    svgClassName: string;
+    svgStyle: object;
+    type: 'normal' | 'milestone' | 'summary' | 'auto';
+    onBaselineChanged: ((event: JetElementCustomEvent<ojGanttTask["baseline"]>) => any) | null;
+    onBorderRadiusChanged: ((event: JetElementCustomEvent<ojGanttTask["borderRadius"]>) => any) | null;
+    onEndChanged: ((event: JetElementCustomEvent<ojGanttTask["end"]>) => any) | null;
+    onHeightChanged: ((event: JetElementCustomEvent<ojGanttTask["height"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojGanttTask["label"]>) => any) | null;
+    onLabelPositionChanged: ((event: JetElementCustomEvent<ojGanttTask["labelPosition"]>) => any) | null;
+    onLabelStyleChanged: ((event: JetElementCustomEvent<ojGanttTask["labelStyle"]>) => any) | null;
+    onProgressChanged: ((event: JetElementCustomEvent<ojGanttTask["progress"]>) => any) | null;
+    onRowIdChanged: ((event: JetElementCustomEvent<ojGanttTask["rowId"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojGanttTask["shortDesc"]>) => any) | null;
+    onStartChanged: ((event: JetElementCustomEvent<ojGanttTask["start"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojGanttTask["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojGanttTask["svgStyle"]>) => any) | null;
+    onTypeChanged: ((event: JetElementCustomEvent<ojGanttTask["type"]>) => any) | null;
+    addEventListener<T extends keyof ojGanttTaskEventMap>(type: T, listener: (this: HTMLElement, ev: ojGanttTaskEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojGanttTaskSettableProperties>(property: T): ojGanttTask[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojGanttTaskSettableProperties>(property: T, value: ojGanttTaskSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojGanttTaskSettableProperties>): void;
+    setProperties(properties: ojGanttTaskSettablePropertiesLenient): void;
+}
+export interface ojGanttTaskEventMap extends HTMLElementEventMap {
+    'baselineChanged': JetElementCustomEvent<ojGanttTask["baseline"]>;
+    'borderRadiusChanged': JetElementCustomEvent<ojGanttTask["borderRadius"]>;
+    'endChanged': JetElementCustomEvent<ojGanttTask["end"]>;
+    'heightChanged': JetElementCustomEvent<ojGanttTask["height"]>;
+    'labelChanged': JetElementCustomEvent<ojGanttTask["label"]>;
+    'labelPositionChanged': JetElementCustomEvent<ojGanttTask["labelPosition"]>;
+    'labelStyleChanged': JetElementCustomEvent<ojGanttTask["labelStyle"]>;
+    'progressChanged': JetElementCustomEvent<ojGanttTask["progress"]>;
+    'rowIdChanged': JetElementCustomEvent<ojGanttTask["rowId"]>;
+    'shortDescChanged': JetElementCustomEvent<ojGanttTask["shortDesc"]>;
+    'startChanged': JetElementCustomEvent<ojGanttTask["start"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojGanttTask["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojGanttTask["svgStyle"]>;
+    'typeChanged': JetElementCustomEvent<ojGanttTask["type"]>;
+}
+export interface ojGanttTaskSettableProperties extends JetSettableProperties {
+    baseline: {
+        borderRadius?: string;
+        end?: string;
+        height?: number;
+        start?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    borderRadius: string;
+    end: string;
+    height: number | null;
+    label: string;
+    labelPosition: 'start' | 'innerCenter' | 'innerStart' | 'innerEnd' | 'end' | 'none';
+    labelStyle: object;
+    progress: {
+        borderRadius?: string;
+        height?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+        value?: number;
+    };
+    rowId?: any;
+    shortDesc: string | null;
+    start: string;
+    svgClassName: string;
+    svgStyle: object;
+    type: 'normal' | 'milestone' | 'summary' | 'auto';
+}
+export interface ojGanttTaskSettablePropertiesLenient extends Partial<ojGanttTaskSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojganttutils/index.d.ts

@@ -0,0 +1,4 @@
+export function computeTableColumnHeaderHeight(table: Element, gantt: Element, axisInfo: {
+    majorAxis: object;
+    minorAxis: object;
+}): number;

types/oracle__oraclejet/ojgauge/index.d.ts

@@ -0,0 +1,574 @@
+import { Converter } from '../ojvalidation-base';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface dvtBaseGauge<SP extends dvtBaseGaugeSettableProperties = dvtBaseGaugeSettableProperties> extends dvtBaseComponent<SP> {
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    addEventListener<T extends keyof dvtBaseGaugeEventMap<SP>>(type: T, listener: (this: HTMLElement, ev: dvtBaseGaugeEventMap<SP>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof dvtBaseGaugeSettableProperties>(property: T): dvtBaseGauge<SP>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof dvtBaseGaugeSettableProperties>(property: T, value: dvtBaseGaugeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, dvtBaseGaugeSettableProperties>): void;
+    setProperties(properties: dvtBaseGaugeSettablePropertiesLenient): void;
+}
+// These interfaces are empty but required to keep the event chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface dvtBaseGaugeEventMap<SP extends dvtBaseGaugeSettableProperties = dvtBaseGaugeSettableProperties> extends dvtBaseComponentEventMap<SP> {
+}
+export interface dvtBaseGaugeSettableProperties extends dvtBaseComponentSettableProperties {
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface dvtBaseGaugeSettablePropertiesLenient extends Partial<dvtBaseGaugeSettableProperties> {
+    [key: string]: any;
+}
+export interface ojLedGauge extends dvtBaseGauge<ojLedGaugeSettableProperties> {
+    borderColor: string;
+    color: string;
+    label: {
+        style?: object;
+        text?: string;
+    };
+    max: number;
+    metricLabel: {
+        converter?: Converter<string>;
+        rendered?: 'on' | 'off';
+        scaling?: 'none' | 'thousand' | 'million' | 'billion' | 'trillion' | 'quadrillion' | 'auto';
+        style?: object;
+        text?: string;
+        textType?: 'percent' | 'number';
+    };
+    min: number;
+    rotation: 90 | 180 | 270 | 0;
+    size: number;
+    svgClassName: string;
+    svgStyle: object;
+    thresholds: ojLedGauge.Threshold[];
+    tooltip: {
+        renderer: ((context: ojLedGauge.TooltipContext) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    type: 'arrow' | 'diamond' | 'square' | 'rectangle' | 'triangle' | 'star' | 'human' | 'circle';
+    value: number | null;
+    visualEffects: 'none' | 'auto';
+    onBorderColorChanged: ((event: JetElementCustomEvent<ojLedGauge["borderColor"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojLedGauge["color"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojLedGauge["label"]>) => any) | null;
+    onMaxChanged: ((event: JetElementCustomEvent<ojLedGauge["max"]>) => any) | null;
+    onMetricLabelChanged: ((event: JetElementCustomEvent<ojLedGauge["metricLabel"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojLedGauge["min"]>) => any) | null;
+    onRotationChanged: ((event: JetElementCustomEvent<ojLedGauge["rotation"]>) => any) | null;
+    onSizeChanged: ((event: JetElementCustomEvent<ojLedGauge["size"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojLedGauge["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojLedGauge["svgStyle"]>) => any) | null;
+    onThresholdsChanged: ((event: JetElementCustomEvent<ojLedGauge["thresholds"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojLedGauge["tooltip"]>) => any) | null;
+    onTypeChanged: ((event: JetElementCustomEvent<ojLedGauge["type"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojLedGauge["value"]>) => any) | null;
+    onVisualEffectsChanged: ((event: JetElementCustomEvent<ojLedGauge["visualEffects"]>) => any) | null;
+    addEventListener<T extends keyof ojLedGaugeEventMap>(type: T, listener: (this: HTMLElement, ev: ojLedGaugeEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojLedGaugeSettableProperties>(property: T): ojLedGauge[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojLedGaugeSettableProperties>(property: T, value: ojLedGaugeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojLedGaugeSettableProperties>): void;
+    setProperties(properties: ojLedGaugeSettablePropertiesLenient): void;
+    getMetricLabel(): string;
+}
+export interface ojLedGaugeEventMap extends dvtBaseGaugeEventMap<ojLedGaugeSettableProperties> {
+    'borderColorChanged': JetElementCustomEvent<ojLedGauge["borderColor"]>;
+    'colorChanged': JetElementCustomEvent<ojLedGauge["color"]>;
+    'labelChanged': JetElementCustomEvent<ojLedGauge["label"]>;
+    'maxChanged': JetElementCustomEvent<ojLedGauge["max"]>;
+    'metricLabelChanged': JetElementCustomEvent<ojLedGauge["metricLabel"]>;
+    'minChanged': JetElementCustomEvent<ojLedGauge["min"]>;
+    'rotationChanged': JetElementCustomEvent<ojLedGauge["rotation"]>;
+    'sizeChanged': JetElementCustomEvent<ojLedGauge["size"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojLedGauge["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojLedGauge["svgStyle"]>;
+    'thresholdsChanged': JetElementCustomEvent<ojLedGauge["thresholds"]>;
+    'tooltipChanged': JetElementCustomEvent<ojLedGauge["tooltip"]>;
+    'typeChanged': JetElementCustomEvent<ojLedGauge["type"]>;
+    'valueChanged': JetElementCustomEvent<ojLedGauge["value"]>;
+    'visualEffectsChanged': JetElementCustomEvent<ojLedGauge["visualEffects"]>;
+}
+export interface ojLedGaugeSettableProperties extends dvtBaseGaugeSettableProperties {
+    borderColor: string;
+    color: string;
+    label: {
+        style?: object;
+        text?: string;
+    };
+    max: number;
+    metricLabel: {
+        converter?: Converter<string>;
+        rendered?: 'on' | 'off';
+        scaling?: 'none' | 'thousand' | 'million' | 'billion' | 'trillion' | 'quadrillion' | 'auto';
+        style?: object;
+        text?: string;
+        textType?: 'percent' | 'number';
+    };
+    min: number;
+    rotation: 90 | 180 | 270 | 0;
+    size: number;
+    svgClassName: string;
+    svgStyle: object;
+    thresholds: ojLedGauge.Threshold[];
+    tooltip: {
+        renderer: ((context: ojLedGauge.TooltipContext) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    type: 'arrow' | 'diamond' | 'square' | 'rectangle' | 'triangle' | 'star' | 'human' | 'circle';
+    value: number | null;
+    visualEffects: 'none' | 'auto';
+}
+export interface ojLedGaugeSettablePropertiesLenient extends Partial<ojLedGaugeSettableProperties> {
+    [key: string]: any;
+}
+export namespace ojLedGauge {
+    // tslint:disable-next-line interface-over-type-literal
+    type Threshold = {
+        borderColor?: string;
+        color?: string;
+        max?: number;
+        shortDesc?: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext = {
+        color: string;
+        componentElement: Element;
+        label: string;
+        parentElement: Element;
+    };
+}
+export interface ojRatingGauge extends dvtBaseGauge<ojRatingGaugeSettableProperties> {
+    changed: boolean;
+    changedState: {
+        borderColor?: string;
+        color?: string;
+        shape?: 'circle' | 'diamond' | 'human' | 'square' | 'star' | 'triangle' | string;
+        source?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    hoverState: {
+        borderColor?: string;
+        color?: string;
+        shape?: 'circle' | 'diamond' | 'human' | 'square' | 'star' | 'triangle' | string;
+        source?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    max: number;
+    min: number;
+    orientation: 'vertical' | 'horizontal';
+    preserveAspectRatio: 'none' | 'meet';
+    readonly: boolean;
+    selectedState: {
+        borderColor?: string;
+        color?: string;
+        shape?: 'circle' | 'diamond' | 'human' | 'square' | 'star' | 'triangle' | string;
+        source?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    step: 0.5 | 1;
+    thresholds: ojRatingGauge.Threshold[];
+    tooltip: {
+        renderer: ((context: ojRatingGauge.TooltipContext) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    readonly transientValue: number | null;
+    unselectedState: {
+        borderColor?: string;
+        color?: string;
+        shape?: 'circle' | 'diamond' | 'human' | 'square' | 'star' | 'triangle' | string;
+        source?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    value: number | null;
+    visualEffects: 'none' | 'auto';
+    onChangedChanged: ((event: JetElementCustomEvent<ojRatingGauge["changed"]>) => any) | null;
+    onChangedStateChanged: ((event: JetElementCustomEvent<ojRatingGauge["changedState"]>) => any) | null;
+    onHoverStateChanged: ((event: JetElementCustomEvent<ojRatingGauge["hoverState"]>) => any) | null;
+    onMaxChanged: ((event: JetElementCustomEvent<ojRatingGauge["max"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojRatingGauge["min"]>) => any) | null;
+    onOrientationChanged: ((event: JetElementCustomEvent<ojRatingGauge["orientation"]>) => any) | null;
+    onPreserveAspectRatioChanged: ((event: JetElementCustomEvent<ojRatingGauge["preserveAspectRatio"]>) => any) | null;
+    onReadonlyChanged: ((event: JetElementCustomEvent<ojRatingGauge["readonly"]>) => any) | null;
+    onSelectedStateChanged: ((event: JetElementCustomEvent<ojRatingGauge["selectedState"]>) => any) | null;
+    onStepChanged: ((event: JetElementCustomEvent<ojRatingGauge["step"]>) => any) | null;
+    onThresholdsChanged: ((event: JetElementCustomEvent<ojRatingGauge["thresholds"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojRatingGauge["tooltip"]>) => any) | null;
+    onTransientValueChanged: ((event: JetElementCustomEvent<ojRatingGauge["transientValue"]>) => any) | null;
+    onUnselectedStateChanged: ((event: JetElementCustomEvent<ojRatingGauge["unselectedState"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojRatingGauge["value"]>) => any) | null;
+    onVisualEffectsChanged: ((event: JetElementCustomEvent<ojRatingGauge["visualEffects"]>) => any) | null;
+    addEventListener<T extends keyof ojRatingGaugeEventMap>(type: T, listener: (this: HTMLElement, ev: ojRatingGaugeEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojRatingGaugeSettableProperties>(property: T): ojRatingGauge[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojRatingGaugeSettableProperties>(property: T, value: ojRatingGaugeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojRatingGaugeSettableProperties>): void;
+    setProperties(properties: ojRatingGaugeSettablePropertiesLenient): void;
+}
+export interface ojRatingGaugeEventMap extends dvtBaseGaugeEventMap<ojRatingGaugeSettableProperties> {
+    'changedChanged': JetElementCustomEvent<ojRatingGauge["changed"]>;
+    'changedStateChanged': JetElementCustomEvent<ojRatingGauge["changedState"]>;
+    'hoverStateChanged': JetElementCustomEvent<ojRatingGauge["hoverState"]>;
+    'maxChanged': JetElementCustomEvent<ojRatingGauge["max"]>;
+    'minChanged': JetElementCustomEvent<ojRatingGauge["min"]>;
+    'orientationChanged': JetElementCustomEvent<ojRatingGauge["orientation"]>;
+    'preserveAspectRatioChanged': JetElementCustomEvent<ojRatingGauge["preserveAspectRatio"]>;
+    'readonlyChanged': JetElementCustomEvent<ojRatingGauge["readonly"]>;
+    'selectedStateChanged': JetElementCustomEvent<ojRatingGauge["selectedState"]>;
+    'stepChanged': JetElementCustomEvent<ojRatingGauge["step"]>;
+    'thresholdsChanged': JetElementCustomEvent<ojRatingGauge["thresholds"]>;
+    'tooltipChanged': JetElementCustomEvent<ojRatingGauge["tooltip"]>;
+    'transientValueChanged': JetElementCustomEvent<ojRatingGauge["transientValue"]>;
+    'unselectedStateChanged': JetElementCustomEvent<ojRatingGauge["unselectedState"]>;
+    'valueChanged': JetElementCustomEvent<ojRatingGauge["value"]>;
+    'visualEffectsChanged': JetElementCustomEvent<ojRatingGauge["visualEffects"]>;
+}
+export interface ojRatingGaugeSettableProperties extends dvtBaseGaugeSettableProperties {
+    changed: boolean;
+    changedState: {
+        borderColor?: string;
+        color?: string;
+        shape?: 'circle' | 'diamond' | 'human' | 'square' | 'star' | 'triangle' | string;
+        source?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    hoverState: {
+        borderColor?: string;
+        color?: string;
+        shape?: 'circle' | 'diamond' | 'human' | 'square' | 'star' | 'triangle' | string;
+        source?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    max: number;
+    min: number;
+    orientation: 'vertical' | 'horizontal';
+    preserveAspectRatio: 'none' | 'meet';
+    readonly: boolean;
+    selectedState: {
+        borderColor?: string;
+        color?: string;
+        shape?: 'circle' | 'diamond' | 'human' | 'square' | 'star' | 'triangle' | string;
+        source?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    step: 0.5 | 1;
+    thresholds: ojRatingGauge.Threshold[];
+    tooltip: {
+        renderer: ((context: ojRatingGauge.TooltipContext) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    readonly transientValue: number | null;
+    unselectedState: {
+        borderColor?: string;
+        color?: string;
+        shape?: 'circle' | 'diamond' | 'human' | 'square' | 'star' | 'triangle' | string;
+        source?: string;
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    value: number | null;
+    visualEffects: 'none' | 'auto';
+}
+export interface ojRatingGaugeSettablePropertiesLenient extends Partial<ojRatingGaugeSettableProperties> {
+    [key: string]: any;
+}
+export namespace ojRatingGauge {
+    // tslint:disable-next-line interface-over-type-literal
+    type Threshold = {
+        borderColor?: string;
+        color?: string;
+        max?: number;
+        shortDesc?: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext = {
+        color: string;
+        componentElement: Element;
+        label: string;
+        parentElement: Element;
+    };
+}
+export interface ojStatusMeterGauge extends dvtBaseGauge<ojStatusMeterGaugeSettableProperties> {
+    angleExtent: number;
+    animationDuration?: number;
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    borderColor: string;
+    borderRadius: string;
+    center: {
+        renderer: ((context: ojStatusMeterGauge.CenterContext) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    color: string;
+    indicatorSize: number;
+    innerRadius: number;
+    label: {
+        position?: 'center' | 'start' | 'auto';
+        style?: object;
+        text?: string;
+    };
+    max: number;
+    metricLabel: {
+        converter?: Converter<string>;
+        position?: 'center' | 'insideIndicatorEdge' | 'outsideIndicatorEdge' | 'outsidePlotArea' | 'withLabel' | 'auto';
+        rendered?: 'on' | 'off' | 'auto';
+        scaling?: 'none' | 'thousand' | 'million' | 'billion' | 'trillion' | 'quadrillion' | 'auto';
+        style?: object;
+        text?: string;
+        textType?: 'percent' | 'number';
+    };
+    min: number;
+    orientation: 'circular' | 'vertical' | 'horizontal';
+    plotArea: {
+        borderColor?: string;
+        borderRadius?: string;
+        color?: string;
+        rendered?: 'on' | 'off' | 'auto';
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    readonly: boolean;
+    referenceLines: ojStatusMeterGauge.ReferenceLine[];
+    startAngle: number;
+    step: number | null;
+    svgClassName: string;
+    svgStyle: object;
+    thresholdDisplay: 'currentOnly' | 'all' | 'onIndicator';
+    thresholds: ojStatusMeterGauge.Threshold[];
+    tooltip: {
+        renderer: ((context: ojStatusMeterGauge.TooltipContext) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    readonly transientValue: number | null;
+    value: number | null;
+    visualEffects: 'none' | 'auto';
+    onAngleExtentChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["angleExtent"]>) => any) | null;
+    onAnimationDurationChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["animationDuration"]>) => any) | null;
+    onAnimationOnDataChangeChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["animationOnDataChange"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["animationOnDisplay"]>) => any) | null;
+    onBorderColorChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["borderColor"]>) => any) | null;
+    onBorderRadiusChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["borderRadius"]>) => any) | null;
+    onCenterChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["center"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["color"]>) => any) | null;
+    onIndicatorSizeChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["indicatorSize"]>) => any) | null;
+    onInnerRadiusChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["innerRadius"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["label"]>) => any) | null;
+    onMaxChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["max"]>) => any) | null;
+    onMetricLabelChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["metricLabel"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["min"]>) => any) | null;
+    onOrientationChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["orientation"]>) => any) | null;
+    onPlotAreaChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["plotArea"]>) => any) | null;
+    onReadonlyChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["readonly"]>) => any) | null;
+    onReferenceLinesChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["referenceLines"]>) => any) | null;
+    onStartAngleChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["startAngle"]>) => any) | null;
+    onStepChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["step"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["svgStyle"]>) => any) | null;
+    onThresholdDisplayChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["thresholdDisplay"]>) => any) | null;
+    onThresholdsChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["thresholds"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["tooltip"]>) => any) | null;
+    onTransientValueChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["transientValue"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["value"]>) => any) | null;
+    onVisualEffectsChanged: ((event: JetElementCustomEvent<ojStatusMeterGauge["visualEffects"]>) => any) | null;
+    addEventListener<T extends keyof ojStatusMeterGaugeEventMap>(type: T, listener: (this: HTMLElement, ev: ojStatusMeterGaugeEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojStatusMeterGaugeSettableProperties>(property: T): ojStatusMeterGauge[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojStatusMeterGaugeSettableProperties>(property: T, value: ojStatusMeterGaugeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojStatusMeterGaugeSettableProperties>): void;
+    setProperties(properties: ojStatusMeterGaugeSettablePropertiesLenient): void;
+    getMetricLabel(): string;
+}
+export interface ojStatusMeterGaugeEventMap extends dvtBaseGaugeEventMap<ojStatusMeterGaugeSettableProperties> {
+    'angleExtentChanged': JetElementCustomEvent<ojStatusMeterGauge["angleExtent"]>;
+    'animationDurationChanged': JetElementCustomEvent<ojStatusMeterGauge["animationDuration"]>;
+    'animationOnDataChangeChanged': JetElementCustomEvent<ojStatusMeterGauge["animationOnDataChange"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojStatusMeterGauge["animationOnDisplay"]>;
+    'borderColorChanged': JetElementCustomEvent<ojStatusMeterGauge["borderColor"]>;
+    'borderRadiusChanged': JetElementCustomEvent<ojStatusMeterGauge["borderRadius"]>;
+    'centerChanged': JetElementCustomEvent<ojStatusMeterGauge["center"]>;
+    'colorChanged': JetElementCustomEvent<ojStatusMeterGauge["color"]>;
+    'indicatorSizeChanged': JetElementCustomEvent<ojStatusMeterGauge["indicatorSize"]>;
+    'innerRadiusChanged': JetElementCustomEvent<ojStatusMeterGauge["innerRadius"]>;
+    'labelChanged': JetElementCustomEvent<ojStatusMeterGauge["label"]>;
+    'maxChanged': JetElementCustomEvent<ojStatusMeterGauge["max"]>;
+    'metricLabelChanged': JetElementCustomEvent<ojStatusMeterGauge["metricLabel"]>;
+    'minChanged': JetElementCustomEvent<ojStatusMeterGauge["min"]>;
+    'orientationChanged': JetElementCustomEvent<ojStatusMeterGauge["orientation"]>;
+    'plotAreaChanged': JetElementCustomEvent<ojStatusMeterGauge["plotArea"]>;
+    'readonlyChanged': JetElementCustomEvent<ojStatusMeterGauge["readonly"]>;
+    'referenceLinesChanged': JetElementCustomEvent<ojStatusMeterGauge["referenceLines"]>;
+    'startAngleChanged': JetElementCustomEvent<ojStatusMeterGauge["startAngle"]>;
+    'stepChanged': JetElementCustomEvent<ojStatusMeterGauge["step"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojStatusMeterGauge["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojStatusMeterGauge["svgStyle"]>;
+    'thresholdDisplayChanged': JetElementCustomEvent<ojStatusMeterGauge["thresholdDisplay"]>;
+    'thresholdsChanged': JetElementCustomEvent<ojStatusMeterGauge["thresholds"]>;
+    'tooltipChanged': JetElementCustomEvent<ojStatusMeterGauge["tooltip"]>;
+    'transientValueChanged': JetElementCustomEvent<ojStatusMeterGauge["transientValue"]>;
+    'valueChanged': JetElementCustomEvent<ojStatusMeterGauge["value"]>;
+    'visualEffectsChanged': JetElementCustomEvent<ojStatusMeterGauge["visualEffects"]>;
+}
+export interface ojStatusMeterGaugeSettableProperties extends dvtBaseGaugeSettableProperties {
+    angleExtent: number;
+    animationDuration?: number;
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    borderColor: string;
+    borderRadius: string;
+    center: {
+        renderer: ((context: ojStatusMeterGauge.CenterContext) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    color: string;
+    indicatorSize: number;
+    innerRadius: number;
+    label: {
+        position?: 'center' | 'start' | 'auto';
+        style?: object;
+        text?: string;
+    };
+    max: number;
+    metricLabel: {
+        converter?: Converter<string>;
+        position?: 'center' | 'insideIndicatorEdge' | 'outsideIndicatorEdge' | 'outsidePlotArea' | 'withLabel' | 'auto';
+        rendered?: 'on' | 'off' | 'auto';
+        scaling?: 'none' | 'thousand' | 'million' | 'billion' | 'trillion' | 'quadrillion' | 'auto';
+        style?: object;
+        text?: string;
+        textType?: 'percent' | 'number';
+    };
+    min: number;
+    orientation: 'circular' | 'vertical' | 'horizontal';
+    plotArea: {
+        borderColor?: string;
+        borderRadius?: string;
+        color?: string;
+        rendered?: 'on' | 'off' | 'auto';
+        svgClassName?: string;
+        svgStyle?: object;
+    };
+    readonly: boolean;
+    referenceLines: ojStatusMeterGauge.ReferenceLine[];
+    startAngle: number;
+    step: number | null;
+    svgClassName: string;
+    svgStyle: object;
+    thresholdDisplay: 'currentOnly' | 'all' | 'onIndicator';
+    thresholds: ojStatusMeterGauge.Threshold[];
+    tooltip: {
+        renderer: ((context: ojStatusMeterGauge.TooltipContext) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    readonly transientValue: number | null;
+    value: number | null;
+    visualEffects: 'none' | 'auto';
+}
+export interface ojStatusMeterGaugeSettablePropertiesLenient extends Partial<ojStatusMeterGaugeSettableProperties> {
+    [key: string]: any;
+}
+export namespace ojStatusMeterGauge {
+    // tslint:disable-next-line interface-over-type-literal
+    type Bounds = {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type CenterContext = {
+        componentElement: Element;
+        innerBounds: Bounds;
+        metricLabel: string;
+        outerBounds: Bounds;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type ReferenceLine = {
+        color?: string;
+        value?: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type Threshold = {
+        borderColor?: string;
+        color?: string;
+        max?: number;
+        shortDesc?: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext = {
+        color: string;
+        componentElement: Element;
+        label: string;
+        parentElement: Element;
+    };
+}

types/oracle__oraclejet/ojinputnumber/index.d.ts

@@ -0,0 +1,150 @@
+import { Converter, Validator, Validation, AsyncValidator } from '../ojvalidation-base';
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojInputNumber extends editableValue<number | null, ojInputNumberSettableProperties, number | null, string> {
+    asyncValidators: Array<AsyncValidator<number>>;
+    autocomplete: 'on' | 'off' | string;
+    autofocus: boolean;
+    converter: Converter<number> | Validation.RegisteredConverter;
+    max: number | null;
+    min: number | null;
+    placeholder: string | null;
+    readonly rawValue: string;
+    readonly: boolean | null;
+    required: boolean;
+    step: number | null;
+    validators: Array<Validator<number> | Validation.RegisteredValidator>;
+    value: number | null;
+    virtualKeyboard: 'auto' | 'number' | 'text';
+    translations: {
+        numberRange?: {
+            hint?: {
+                exact?: string;
+                inRange?: string;
+                max?: string;
+                min?: string;
+            };
+            messageDetail?: {
+                exact?: string;
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+            messageSummary?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        tooltipDecrement?: string;
+        tooltipIncrement?: string;
+    };
+    onAsyncValidatorsChanged: ((event: JetElementCustomEvent<ojInputNumber["asyncValidators"]>) => any) | null;
+    onAutocompleteChanged: ((event: JetElementCustomEvent<ojInputNumber["autocomplete"]>) => any) | null;
+    onAutofocusChanged: ((event: JetElementCustomEvent<ojInputNumber["autofocus"]>) => any) | null;
+    onConverterChanged: ((event: JetElementCustomEvent<ojInputNumber["converter"]>) => any) | null;
+    onMaxChanged: ((event: JetElementCustomEvent<ojInputNumber["max"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojInputNumber["min"]>) => any) | null;
+    onPlaceholderChanged: ((event: JetElementCustomEvent<ojInputNumber["placeholder"]>) => any) | null;
+    onRawValueChanged: ((event: JetElementCustomEvent<ojInputNumber["rawValue"]>) => any) | null;
+    onReadonlyChanged: ((event: JetElementCustomEvent<ojInputNumber["readonly"]>) => any) | null;
+    onRequiredChanged: ((event: JetElementCustomEvent<ojInputNumber["required"]>) => any) | null;
+    onStepChanged: ((event: JetElementCustomEvent<ojInputNumber["step"]>) => any) | null;
+    onValidatorsChanged: ((event: JetElementCustomEvent<ojInputNumber["validators"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojInputNumber["value"]>) => any) | null;
+    onVirtualKeyboardChanged: ((event: JetElementCustomEvent<ojInputNumber["virtualKeyboard"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojInputNumber.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojInputNumber.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojInputNumberEventMap>(type: T, listener: (this: HTMLElement, ev: ojInputNumberEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojInputNumberSettableProperties>(property: T): ojInputNumber[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojInputNumberSettableProperties>(property: T, value: ojInputNumberSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojInputNumberSettableProperties>): void;
+    setProperties(properties: ojInputNumberSettablePropertiesLenient): void;
+    refresh(): void;
+    stepDown(steps?: number): void;
+    stepUp(steps?: number): void;
+    validate(): Promise<string>;
+}
+export namespace ojInputNumber {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojInputNumberEventMap extends editableValueEventMap<number | null, ojInputNumberSettableProperties, number | null, string> {
+    'ojAnimateEnd': ojInputNumber.ojAnimateEnd;
+    'ojAnimateStart': ojInputNumber.ojAnimateStart;
+    'asyncValidatorsChanged': JetElementCustomEvent<ojInputNumber["asyncValidators"]>;
+    'autocompleteChanged': JetElementCustomEvent<ojInputNumber["autocomplete"]>;
+    'autofocusChanged': JetElementCustomEvent<ojInputNumber["autofocus"]>;
+    'converterChanged': JetElementCustomEvent<ojInputNumber["converter"]>;
+    'maxChanged': JetElementCustomEvent<ojInputNumber["max"]>;
+    'minChanged': JetElementCustomEvent<ojInputNumber["min"]>;
+    'placeholderChanged': JetElementCustomEvent<ojInputNumber["placeholder"]>;
+    'rawValueChanged': JetElementCustomEvent<ojInputNumber["rawValue"]>;
+    'readonlyChanged': JetElementCustomEvent<ojInputNumber["readonly"]>;
+    'requiredChanged': JetElementCustomEvent<ojInputNumber["required"]>;
+    'stepChanged': JetElementCustomEvent<ojInputNumber["step"]>;
+    'validatorsChanged': JetElementCustomEvent<ojInputNumber["validators"]>;
+    'valueChanged': JetElementCustomEvent<ojInputNumber["value"]>;
+    'virtualKeyboardChanged': JetElementCustomEvent<ojInputNumber["virtualKeyboard"]>;
+}
+export interface ojInputNumberSettableProperties extends editableValueSettableProperties<number | null, number | null, string> {
+    asyncValidators: Array<AsyncValidator<number>>;
+    autocomplete: 'on' | 'off' | string;
+    autofocus: boolean;
+    converter: Converter<number> | Validation.RegisteredConverter;
+    max: number | null;
+    min: number | null;
+    placeholder: string | null;
+    readonly rawValue: string;
+    readonly: boolean | null;
+    required: boolean;
+    step: number | null;
+    validators: Array<Validator<number> | Validation.RegisteredValidator>;
+    value: number | null;
+    virtualKeyboard: 'auto' | 'number' | 'text';
+    translations: {
+        numberRange?: {
+            hint?: {
+                exact?: string;
+                inRange?: string;
+                max?: string;
+                min?: string;
+            };
+            messageDetail?: {
+                exact?: string;
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+            messageSummary?: {
+                rangeOverflow?: string;
+                rangeUnderflow?: string;
+            };
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        tooltipDecrement?: string;
+        tooltipIncrement?: string;
+    };
+}
+export interface ojInputNumberSettablePropertiesLenient extends Partial<ojInputNumberSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojinputtext/index.d.ts

@@ -0,0 +1,249 @@
+import { Converter, Validator, Validation, AsyncValidator } from '../ojvalidation-base';
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface inputBase<V, SP extends inputBaseSettableProperties<V, SV>, SV = V, RV = V> extends editableValue<V, SP, SV, RV> {
+    asyncValidators: Array<AsyncValidator<V>>;
+    autocomplete: 'on' | 'off' | string;
+    autofocus: boolean;
+    placeholder: string;
+    readonly rawValue: RV;
+    readonly: boolean;
+    required: boolean;
+    validators: Array<Validator<V> | Validation.RegisteredValidator> | null;
+    translations: {
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+    onAsyncValidatorsChanged: ((event: JetElementCustomEvent<inputBase<V, SP, SV, RV>["asyncValidators"]>) => any) | null;
+    onAutocompleteChanged: ((event: JetElementCustomEvent<inputBase<V, SP, SV, RV>["autocomplete"]>) => any) | null;
+    onAutofocusChanged: ((event: JetElementCustomEvent<inputBase<V, SP, SV, RV>["autofocus"]>) => any) | null;
+    onPlaceholderChanged: ((event: JetElementCustomEvent<inputBase<V, SP, SV, RV>["placeholder"]>) => any) | null;
+    onRawValueChanged: ((event: JetElementCustomEvent<inputBase<V, SP, SV, RV>["rawValue"]>) => any) | null;
+    onReadonlyChanged: ((event: JetElementCustomEvent<inputBase<V, SP, SV, RV>["readonly"]>) => any) | null;
+    onRequiredChanged: ((event: JetElementCustomEvent<inputBase<V, SP, SV, RV>["required"]>) => any) | null;
+    onValidatorsChanged: ((event: JetElementCustomEvent<inputBase<V, SP, SV, RV>["validators"]>) => any) | null;
+    onOjAnimateEnd: ((event: inputBase.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: inputBase.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof inputBaseEventMap<V, SP, SV, RV>>(type: T, listener: (this: HTMLElement, ev: inputBaseEventMap<V, SP, SV, RV>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof inputBaseSettableProperties<V, SV, RV>>(property: T): inputBase<V, SP, SV, RV>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof inputBaseSettableProperties<V, SV, RV>>(property: T, value: inputBaseSettableProperties<V, SV, RV>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, inputBaseSettableProperties<V, SV, RV>>): void;
+    setProperties(properties: inputBaseSettablePropertiesLenient<V, SV, RV>): void;
+    refresh(): void;
+    validate(): Promise<'valid' | 'invalid'>;
+}
+export namespace inputBase {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface inputBaseEventMap<V, SP extends inputBaseSettableProperties<V, SV>, SV = V, RV = V> extends editableValueEventMap<V, SP, SV, RV> {
+    'ojAnimateEnd': inputBase.ojAnimateEnd;
+    'ojAnimateStart': inputBase.ojAnimateStart;
+    'asyncValidatorsChanged': JetElementCustomEvent<inputBase<V, SP, SV, RV>["asyncValidators"]>;
+    'autocompleteChanged': JetElementCustomEvent<inputBase<V, SP, SV, RV>["autocomplete"]>;
+    'autofocusChanged': JetElementCustomEvent<inputBase<V, SP, SV, RV>["autofocus"]>;
+    'placeholderChanged': JetElementCustomEvent<inputBase<V, SP, SV, RV>["placeholder"]>;
+    'rawValueChanged': JetElementCustomEvent<inputBase<V, SP, SV, RV>["rawValue"]>;
+    'readonlyChanged': JetElementCustomEvent<inputBase<V, SP, SV, RV>["readonly"]>;
+    'requiredChanged': JetElementCustomEvent<inputBase<V, SP, SV, RV>["required"]>;
+    'validatorsChanged': JetElementCustomEvent<inputBase<V, SP, SV, RV>["validators"]>;
+}
+export interface inputBaseSettableProperties<V, SV = V, RV = V> extends editableValueSettableProperties<V, SV, RV> {
+    asyncValidators: Array<AsyncValidator<V>>;
+    autocomplete: 'on' | 'off' | string;
+    autofocus: boolean;
+    placeholder: string;
+    readonly rawValue: RV;
+    readonly: boolean;
+    required: boolean;
+    validators: Array<Validator<V> | Validation.RegisteredValidator> | null;
+    translations: {
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+}
+export interface inputBaseSettablePropertiesLenient<V, SV, RV> extends Partial<inputBaseSettableProperties<V, SV, RV>> {
+    [key: string]: any;
+}
+export interface ojInputPassword extends inputBase<string | null, ojInputPasswordSettableProperties> {
+    value: string | null;
+    translations: {
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+    onValueChanged: ((event: JetElementCustomEvent<ojInputPassword["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojInputPassword.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojInputPassword.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojInputPasswordEventMap>(type: T, listener: (this: HTMLElement, ev: ojInputPasswordEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojInputPasswordSettableProperties>(property: T): ojInputPassword[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojInputPasswordSettableProperties>(property: T, value: ojInputPasswordSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojInputPasswordSettableProperties>): void;
+    setProperties(properties: ojInputPasswordSettablePropertiesLenient): void;
+}
+export namespace ojInputPassword {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojInputPasswordEventMap extends inputBaseEventMap<string | null, ojInputPasswordSettableProperties> {
+    'ojAnimateEnd': ojInputPassword.ojAnimateEnd;
+    'ojAnimateStart': ojInputPassword.ojAnimateStart;
+    'valueChanged': JetElementCustomEvent<ojInputPassword["value"]>;
+}
+export interface ojInputPasswordSettableProperties extends inputBaseSettableProperties<string | null> {
+    value: string | null;
+    translations: {
+        regexp?: {
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+}
+export interface ojInputPasswordSettablePropertiesLenient extends Partial<ojInputPasswordSettableProperties> {
+    [key: string]: any;
+}
+export interface ojInputText extends inputBase<any, ojInputTextSettableProperties> {
+    clearIcon: 'never' | 'always' | 'conditional';
+    converter: Converter<any> | Validation.RegisteredConverter | null;
+    list: string;
+    virtualKeyboard: 'auto' | 'email' | 'number' | 'search' | 'tel' | 'text' | 'url';
+    onClearIconChanged: ((event: JetElementCustomEvent<ojInputText["clearIcon"]>) => any) | null;
+    onConverterChanged: ((event: JetElementCustomEvent<ojInputText["converter"]>) => any) | null;
+    onListChanged: ((event: JetElementCustomEvent<ojInputText["list"]>) => any) | null;
+    onVirtualKeyboardChanged: ((event: JetElementCustomEvent<ojInputText["virtualKeyboard"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojInputText.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojInputText.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojInputTextEventMap>(type: T, listener: (this: HTMLElement, ev: ojInputTextEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojInputTextSettableProperties>(property: T): ojInputText[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojInputTextSettableProperties>(property: T, value: ojInputTextSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojInputTextSettableProperties>): void;
+    setProperties(properties: ojInputTextSettablePropertiesLenient): void;
+}
+export namespace ojInputText {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojInputTextEventMap extends inputBaseEventMap<any, ojInputTextSettableProperties> {
+    'ojAnimateEnd': ojInputText.ojAnimateEnd;
+    'ojAnimateStart': ojInputText.ojAnimateStart;
+    'clearIconChanged': JetElementCustomEvent<ojInputText["clearIcon"]>;
+    'converterChanged': JetElementCustomEvent<ojInputText["converter"]>;
+    'listChanged': JetElementCustomEvent<ojInputText["list"]>;
+    'virtualKeyboardChanged': JetElementCustomEvent<ojInputText["virtualKeyboard"]>;
+}
+export interface ojInputTextSettableProperties extends inputBaseSettableProperties<any> {
+    clearIcon: 'never' | 'always' | 'conditional';
+    converter: Converter<any> | Validation.RegisteredConverter | null;
+    list: string;
+    virtualKeyboard: 'auto' | 'email' | 'number' | 'search' | 'tel' | 'text' | 'url';
+}
+export interface ojInputTextSettablePropertiesLenient extends Partial<ojInputTextSettableProperties> {
+    [key: string]: any;
+}
+export interface ojTextArea extends inputBase<any, ojTextAreaSettableProperties> {
+    converter: Converter<any> | Validation.RegisteredConverter | null;
+    rows: number;
+    onConverterChanged: ((event: JetElementCustomEvent<ojTextArea["converter"]>) => any) | null;
+    onRowsChanged: ((event: JetElementCustomEvent<ojTextArea["rows"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojTextArea.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojTextArea.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojTextAreaEventMap>(type: T, listener: (this: HTMLElement, ev: ojTextAreaEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTextAreaSettableProperties>(property: T): ojTextArea[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTextAreaSettableProperties>(property: T, value: ojTextAreaSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTextAreaSettableProperties>): void;
+    setProperties(properties: ojTextAreaSettablePropertiesLenient): void;
+}
+export namespace ojTextArea {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojTextAreaEventMap extends inputBaseEventMap<any, ojTextAreaSettableProperties> {
+    'ojAnimateEnd': ojTextArea.ojAnimateEnd;
+    'ojAnimateStart': ojTextArea.ojAnimateStart;
+    'converterChanged': JetElementCustomEvent<ojTextArea["converter"]>;
+    'rowsChanged': JetElementCustomEvent<ojTextArea["rows"]>;
+}
+export interface ojTextAreaSettableProperties extends inputBaseSettableProperties<any> {
+    converter: Converter<any> | Validation.RegisteredConverter | null;
+    rows: number;
+}
+export interface ojTextAreaSettablePropertiesLenient extends Partial<ojTextAreaSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojkeyset/index.d.ts

@@ -0,0 +1,28 @@
+export class ExpandAllKeySet<K> extends KeySet<K> {
+    constructor();
+    add(keys: Set<K> | K[]): ExpandAllKeySet<K>;
+    addAll(): ExpandAllKeySet<K>;
+    clear(): ExpandedKeySet<K>;
+    delete(keys: Set<K> | K[]): ExpandAllKeySet<K>;
+    deletedValues(): Set<K>;
+    has(key: K): boolean;
+    isAddAll(): boolean;
+}
+export class ExpandedKeySet<K> extends KeySet<K> {
+    constructor(keys?: Set<K> | K[]);
+    add(keys: Set<K> | K[]): ExpandedKeySet<K>;
+    addAll(): ExpandAllKeySet<K>;
+    clear(): ExpandedKeySet<K>;
+    delete(keys: Set<K> | K[]): ExpandedKeySet<K>;
+    has(key: K): boolean;
+    isAddAll(): boolean;
+    values(): Set<K>;
+}
+export abstract class KeySet<K> {
+    abstract add(keys: Set<K> | K[]): KeySet<K>;
+    abstract addAll(): KeySet<K>;
+    abstract clear(): KeySet<K>;
+    abstract delete(keys: Set<K> | K[]): KeySet<K>;
+    abstract has(key: K): boolean;
+    abstract isAddAll(): boolean;
+}

types/oracle__oraclejet/ojknockout-keyset/index.d.ts

@@ -0,0 +1,8 @@
+import { ExpandedKeySet, ExpandAllKeySet } from '../ojkeyset';
+export class ObservableExpandedKeySet<K> {
+    constructor(initialValue?: ExpandedKeySet<K> | ExpandAllKeySet<K>);
+    add(keys: Set<K> | K[]): ObservableExpandedKeySet<K>;
+    addAll(): ObservableExpandedKeySet<K>;
+    clear(): ObservableExpandedKeySet<K>;
+    delete(keys: Set<K> | K[]): ObservableExpandedKeySet<K>;
+}

types/oracle__oraclejet/ojknockout-model/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types='knockout'/>
+/// <reference types="knockout" />
+export function map(m: object, callback?: ((param0: object) => void), array?: boolean): Array<KnockoutObservable<any>> | KnockoutObservableArray<any>;

types/oracle__oraclejet/ojknockouttemplateutils/index.d.ts

@@ -0,0 +1 @@
+export function getRenderer(template: string, bReplaceNode?: boolean): ((param0: object) => void);

types/oracle__oraclejet/ojlabel/index.d.ts

@@ -0,0 +1,48 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojLabel extends baseComponent<ojLabelSettableProperties> {
+    for: string | null;
+    help: {
+        definition?: string | null;
+        source?: string | null;
+    };
+    labelId: string | null;
+    showRequired: boolean | null;
+    translations: {
+        tooltipHelp?: string;
+        tooltipRequired?: string;
+    };
+    onForChanged: ((event: JetElementCustomEvent<ojLabel["for"]>) => any) | null;
+    onHelpChanged: ((event: JetElementCustomEvent<ojLabel["help"]>) => any) | null;
+    onLabelIdChanged: ((event: JetElementCustomEvent<ojLabel["labelId"]>) => any) | null;
+    onShowRequiredChanged: ((event: JetElementCustomEvent<ojLabel["showRequired"]>) => any) | null;
+    addEventListener<T extends keyof ojLabelEventMap>(type: T, listener: (this: HTMLElement, ev: ojLabelEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojLabelSettableProperties>(property: T): ojLabel[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojLabelSettableProperties>(property: T, value: ojLabelSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojLabelSettableProperties>): void;
+    setProperties(properties: ojLabelSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface ojLabelEventMap extends baseComponentEventMap<ojLabelSettableProperties> {
+    'forChanged': JetElementCustomEvent<ojLabel["for"]>;
+    'helpChanged': JetElementCustomEvent<ojLabel["help"]>;
+    'labelIdChanged': JetElementCustomEvent<ojLabel["labelId"]>;
+    'showRequiredChanged': JetElementCustomEvent<ojLabel["showRequired"]>;
+}
+export interface ojLabelSettableProperties extends baseComponentSettableProperties {
+    for: string | null;
+    help: {
+        definition?: string | null;
+        source?: string | null;
+    };
+    labelId: string | null;
+    showRequired: boolean | null;
+    translations: {
+        tooltipHelp?: string;
+        tooltipRequired?: string;
+    };
+}
+export interface ojLabelSettablePropertiesLenient extends Partial<ojLabelSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojlabelvalue/index.d.ts

@@ -0,0 +1,26 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojLabelValue extends JetElement<ojLabelValueSettableProperties> {
+    labelEdge: 'start' | 'top' | 'inherit';
+    labelWidth: string;
+    onLabelEdgeChanged: ((event: JetElementCustomEvent<ojLabelValue["labelEdge"]>) => any) | null;
+    onLabelWidthChanged: ((event: JetElementCustomEvent<ojLabelValue["labelWidth"]>) => any) | null;
+    addEventListener<T extends keyof ojLabelValueEventMap>(type: T, listener: (this: HTMLElement, ev: ojLabelValueEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojLabelValueSettableProperties>(property: T): ojLabelValue[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojLabelValueSettableProperties>(property: T, value: ojLabelValueSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojLabelValueSettableProperties>): void;
+    setProperties(properties: ojLabelValueSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface ojLabelValueEventMap extends HTMLElementEventMap {
+    'labelEdgeChanged': JetElementCustomEvent<ojLabelValue["labelEdge"]>;
+    'labelWidthChanged': JetElementCustomEvent<ojLabelValue["labelWidth"]>;
+}
+export interface ojLabelValueSettableProperties extends JetSettableProperties {
+    labelEdge: 'start' | 'top' | 'inherit';
+    labelWidth: string;
+}
+export interface ojLabelValueSettablePropertiesLenient extends Partial<ojLabelValueSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojlegend/index.d.ts

@@ -0,0 +1,286 @@
+import { KeySet } from '../ojkeyset';
+import { DataProvider } from '../ojdataprovider';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojLegend<K, D> extends dvtBaseComponent<ojLegendSettableProperties<K, D>> {
+    as: string;
+    data: DataProvider<K, D> | null;
+    drilling: 'on' | 'off';
+    expanded: KeySet<K> | null;
+    halign: 'center' | 'end' | 'start';
+    hiddenCategories: string[];
+    hideAndShowBehavior: 'on' | 'off';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverBehaviorDelay: number;
+    orientation: 'horizontal' | 'vertical';
+    scrolling: 'off' | 'asNeeded';
+    symbolHeight: number;
+    symbolWidth: number;
+    textStyle?: object;
+    valign: 'middle' | 'bottom' | 'top';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    onAsChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["as"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["data"]>) => any) | null;
+    onDrillingChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["drilling"]>) => any) | null;
+    onExpandedChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["expanded"]>) => any) | null;
+    onHalignChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["halign"]>) => any) | null;
+    onHiddenCategoriesChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["hiddenCategories"]>) => any) | null;
+    onHideAndShowBehaviorChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["hideAndShowBehavior"]>) => any) | null;
+    onHighlightedCategoriesChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["highlightedCategories"]>) => any) | null;
+    onHoverBehaviorChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["hoverBehavior"]>) => any) | null;
+    onHoverBehaviorDelayChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["hoverBehaviorDelay"]>) => any) | null;
+    onOrientationChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["orientation"]>) => any) | null;
+    onScrollingChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["scrolling"]>) => any) | null;
+    onSymbolHeightChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["symbolHeight"]>) => any) | null;
+    onSymbolWidthChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["symbolWidth"]>) => any) | null;
+    onTextStyleChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["textStyle"]>) => any) | null;
+    onValignChanged: ((event: JetElementCustomEvent<ojLegend<K, D>["valign"]>) => any) | null;
+    onOjDrill: ((event: ojLegend.ojDrill) => any) | null;
+    addEventListener<T extends keyof ojLegendEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojLegendEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojLegendSettableProperties<K, D>>(property: T): ojLegend<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojLegendSettableProperties<K, D>>(property: T, value: ojLegendSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojLegendSettableProperties<K, D>>): void;
+    setProperties(properties: ojLegendSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojLegend.NodeContext | null;
+    getItem(subIdPath: any[]): ojLegend.ItemContext | null;
+    getPreferredSize(): ojLegend.PreferredSize | null;
+    getSection(subIdPath: any[]): ojLegend.SectionContext | null;
+}
+export namespace ojLegend {
+    interface ojDrill extends CustomEvent<{
+        id: any;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type ItemContext = {
+        text: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContext = {
+        itemIndex: number;
+        sectionIndexPath: number[];
+        subId: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PreferredSize = {
+        width: number;
+        height: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type SectionContext = {
+        title: string;
+        sections: object[];
+        items: object[];
+        getSection: {
+            title: string;
+            sections: string;
+            items: boolean;
+        };
+        getItems: {
+            text: string;
+        };
+    };
+}
+export interface ojLegendEventMap<K, D> extends dvtBaseComponentEventMap<ojLegendSettableProperties<K, D>> {
+    'ojDrill': ojLegend.ojDrill;
+    'asChanged': JetElementCustomEvent<ojLegend<K, D>["as"]>;
+    'dataChanged': JetElementCustomEvent<ojLegend<K, D>["data"]>;
+    'drillingChanged': JetElementCustomEvent<ojLegend<K, D>["drilling"]>;
+    'expandedChanged': JetElementCustomEvent<ojLegend<K, D>["expanded"]>;
+    'halignChanged': JetElementCustomEvent<ojLegend<K, D>["halign"]>;
+    'hiddenCategoriesChanged': JetElementCustomEvent<ojLegend<K, D>["hiddenCategories"]>;
+    'hideAndShowBehaviorChanged': JetElementCustomEvent<ojLegend<K, D>["hideAndShowBehavior"]>;
+    'highlightedCategoriesChanged': JetElementCustomEvent<ojLegend<K, D>["highlightedCategories"]>;
+    'hoverBehaviorChanged': JetElementCustomEvent<ojLegend<K, D>["hoverBehavior"]>;
+    'hoverBehaviorDelayChanged': JetElementCustomEvent<ojLegend<K, D>["hoverBehaviorDelay"]>;
+    'orientationChanged': JetElementCustomEvent<ojLegend<K, D>["orientation"]>;
+    'scrollingChanged': JetElementCustomEvent<ojLegend<K, D>["scrolling"]>;
+    'symbolHeightChanged': JetElementCustomEvent<ojLegend<K, D>["symbolHeight"]>;
+    'symbolWidthChanged': JetElementCustomEvent<ojLegend<K, D>["symbolWidth"]>;
+    'textStyleChanged': JetElementCustomEvent<ojLegend<K, D>["textStyle"]>;
+    'valignChanged': JetElementCustomEvent<ojLegend<K, D>["valign"]>;
+}
+export interface ojLegendSettableProperties<K, D> extends dvtBaseComponentSettableProperties {
+    as: string;
+    data: DataProvider<K, D> | null;
+    drilling: 'on' | 'off';
+    expanded: KeySet<K> | null;
+    halign: 'center' | 'end' | 'start';
+    hiddenCategories: string[];
+    hideAndShowBehavior: 'on' | 'off';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverBehaviorDelay: number;
+    orientation: 'horizontal' | 'vertical';
+    scrolling: 'off' | 'asNeeded';
+    symbolHeight: number;
+    symbolWidth: number;
+    textStyle?: object;
+    valign: 'middle' | 'bottom' | 'top';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface ojLegendSettablePropertiesLenient<K, D> extends Partial<ojLegendSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ojLegendItem extends JetElement<ojLegendItemSettableProperties> {
+    borderColor?: string;
+    categories?: string[];
+    categoryVisibility?: 'hidden' | 'visible';
+    color?: string;
+    drilling?: 'on' | 'off' | 'inherit';
+    lineStyle?: 'dotted' | 'dashed' | 'solid';
+    lineWidth?: number;
+    markerColor?: string;
+    markerShape: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+    markerSvgClassName?: string;
+    markerSvgStyle?: object;
+    pattern?: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+       'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+    shortDesc?: string;
+    source?: string;
+    svgClassName?: string;
+    svgStyle?: object;
+    symbolType?: 'line' | 'lineWithMarker' | 'image' | 'marker';
+    text: string;
+    onBorderColorChanged: ((event: JetElementCustomEvent<ojLegendItem["borderColor"]>) => any) | null;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojLegendItem["categories"]>) => any) | null;
+    onCategoryVisibilityChanged: ((event: JetElementCustomEvent<ojLegendItem["categoryVisibility"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojLegendItem["color"]>) => any) | null;
+    onDrillingChanged: ((event: JetElementCustomEvent<ojLegendItem["drilling"]>) => any) | null;
+    onLineStyleChanged: ((event: JetElementCustomEvent<ojLegendItem["lineStyle"]>) => any) | null;
+    onLineWidthChanged: ((event: JetElementCustomEvent<ojLegendItem["lineWidth"]>) => any) | null;
+    onMarkerColorChanged: ((event: JetElementCustomEvent<ojLegendItem["markerColor"]>) => any) | null;
+    onMarkerShapeChanged: ((event: JetElementCustomEvent<ojLegendItem["markerShape"]>) => any) | null;
+    onMarkerSvgClassNameChanged: ((event: JetElementCustomEvent<ojLegendItem["markerSvgClassName"]>) => any) | null;
+    onMarkerSvgStyleChanged: ((event: JetElementCustomEvent<ojLegendItem["markerSvgStyle"]>) => any) | null;
+    onPatternChanged: ((event: JetElementCustomEvent<ojLegendItem["pattern"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojLegendItem["shortDesc"]>) => any) | null;
+    onSourceChanged: ((event: JetElementCustomEvent<ojLegendItem["source"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojLegendItem["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojLegendItem["svgStyle"]>) => any) | null;
+    onSymbolTypeChanged: ((event: JetElementCustomEvent<ojLegendItem["symbolType"]>) => any) | null;
+    onTextChanged: ((event: JetElementCustomEvent<ojLegendItem["text"]>) => any) | null;
+    addEventListener<T extends keyof ojLegendItemEventMap>(type: T, listener: (this: HTMLElement, ev: ojLegendItemEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojLegendItemSettableProperties>(property: T): ojLegendItem[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojLegendItemSettableProperties>(property: T, value: ojLegendItemSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojLegendItemSettableProperties>): void;
+    setProperties(properties: ojLegendItemSettablePropertiesLenient): void;
+}
+export interface ojLegendItemEventMap extends HTMLElementEventMap {
+    'borderColorChanged': JetElementCustomEvent<ojLegendItem["borderColor"]>;
+    'categoriesChanged': JetElementCustomEvent<ojLegendItem["categories"]>;
+    'categoryVisibilityChanged': JetElementCustomEvent<ojLegendItem["categoryVisibility"]>;
+    'colorChanged': JetElementCustomEvent<ojLegendItem["color"]>;
+    'drillingChanged': JetElementCustomEvent<ojLegendItem["drilling"]>;
+    'lineStyleChanged': JetElementCustomEvent<ojLegendItem["lineStyle"]>;
+    'lineWidthChanged': JetElementCustomEvent<ojLegendItem["lineWidth"]>;
+    'markerColorChanged': JetElementCustomEvent<ojLegendItem["markerColor"]>;
+    'markerShapeChanged': JetElementCustomEvent<ojLegendItem["markerShape"]>;
+    'markerSvgClassNameChanged': JetElementCustomEvent<ojLegendItem["markerSvgClassName"]>;
+    'markerSvgStyleChanged': JetElementCustomEvent<ojLegendItem["markerSvgStyle"]>;
+    'patternChanged': JetElementCustomEvent<ojLegendItem["pattern"]>;
+    'shortDescChanged': JetElementCustomEvent<ojLegendItem["shortDesc"]>;
+    'sourceChanged': JetElementCustomEvent<ojLegendItem["source"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojLegendItem["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojLegendItem["svgStyle"]>;
+    'symbolTypeChanged': JetElementCustomEvent<ojLegendItem["symbolType"]>;
+    'textChanged': JetElementCustomEvent<ojLegendItem["text"]>;
+}
+export interface ojLegendItemSettableProperties extends JetSettableProperties {
+    borderColor?: string;
+    categories?: string[];
+    categoryVisibility?: 'hidden' | 'visible';
+    color?: string;
+    drilling?: 'on' | 'off' | 'inherit';
+    lineStyle?: 'dotted' | 'dashed' | 'solid';
+    lineWidth?: number;
+    markerColor?: string;
+    markerShape: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+    markerSvgClassName?: string;
+    markerSvgStyle?: object;
+    pattern?: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+       'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+    shortDesc?: string;
+    source?: string;
+    svgClassName?: string;
+    svgStyle?: object;
+    symbolType?: 'line' | 'lineWithMarker' | 'image' | 'marker';
+    text: string;
+}
+export interface ojLegendItemSettablePropertiesLenient extends Partial<ojLegendItemSettableProperties> {
+    [key: string]: any;
+}
+export interface ojLegendSection extends JetElement<ojLegendSectionSettableProperties> {
+    collapsible?: 'on' | 'off';
+    text?: string;
+    textHalign?: 'center' | 'end' | 'start';
+    textStyle?: object;
+    onCollapsibleChanged: ((event: JetElementCustomEvent<ojLegendSection["collapsible"]>) => any) | null;
+    onTextChanged: ((event: JetElementCustomEvent<ojLegendSection["text"]>) => any) | null;
+    onTextHalignChanged: ((event: JetElementCustomEvent<ojLegendSection["textHalign"]>) => any) | null;
+    onTextStyleChanged: ((event: JetElementCustomEvent<ojLegendSection["textStyle"]>) => any) | null;
+    addEventListener<T extends keyof ojLegendSectionEventMap>(type: T, listener: (this: HTMLElement, ev: ojLegendSectionEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojLegendSectionSettableProperties>(property: T): ojLegendSection[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojLegendSectionSettableProperties>(property: T, value: ojLegendSectionSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojLegendSectionSettableProperties>): void;
+    setProperties(properties: ojLegendSectionSettablePropertiesLenient): void;
+}
+export interface ojLegendSectionEventMap extends HTMLElementEventMap {
+    'collapsibleChanged': JetElementCustomEvent<ojLegendSection["collapsible"]>;
+    'textChanged': JetElementCustomEvent<ojLegendSection["text"]>;
+    'textHalignChanged': JetElementCustomEvent<ojLegendSection["textHalign"]>;
+    'textStyleChanged': JetElementCustomEvent<ojLegendSection["textStyle"]>;
+}
+export interface ojLegendSectionSettableProperties extends JetSettableProperties {
+    collapsible?: 'on' | 'off';
+    text?: string;
+    textHalign?: 'center' | 'end' | 'start';
+    textStyle?: object;
+}
+export interface ojLegendSectionSettablePropertiesLenient extends Partial<ojLegendSectionSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojlistdataproviderview/index.d.ts

@@ -0,0 +1,25 @@
+import { DataProvider, SortCriterion, FetchByKeysParameters, ContainsKeysResults, FetchByKeysResults, FetchByOffsetParameters, FetchByOffsetResults, DataMapping, FetchListResult,
+   FetchListParameters } from '../ojdataprovider';
+declare class ListDataProviderView<K, D, Kin, Din> implements DataProvider<K, D> {
+    dataMapping: DataMapping<K, D, Kin, Din>;
+    from: any;
+    offset: number;
+    sortCriteria: Array<SortCriterion<D>>;
+    constructor(dataProvider: DataProvider<K, D>, options?: {
+        from?: object;
+        offset?: number;
+        sortCriteria?: Array<SortCriterion<D>>;
+        dataMapping?: DataMapping<K, D, Kin, Din>;
+    });
+    addEventListener(eventType: string, listener: EventListener): void;
+    containsKeys(params: FetchByKeysParameters<K>): Promise<ContainsKeysResults<K>>;
+    dispatchEvent(evt: Event): boolean;
+    fetchByKeys(params: FetchByKeysParameters<K>): Promise<FetchByKeysResults<K, D>>;
+    fetchByOffset(params: FetchByOffsetParameters<D>): Promise<FetchByOffsetResults<K, D>>;
+    fetchFirst(params?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>;
+    getCapability(capabilityName: string): any;
+    getTotalSize(): Promise<number>;
+    isEmpty(): 'yes' | 'no' | 'unknown';
+    removeEventListener(eventType: string, listener: EventListener): void;
+}
+export = ListDataProviderView;

types/oracle__oraclejet/ojlistview/index.d.ts

@@ -0,0 +1,335 @@
+import { KeySet } from '../ojkeyset';
+import { DataProvider } from '../ojdataprovider';
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojListView<K, D> extends baseComponent<ojListViewSettableProperties<K, D>> {
+    as: string;
+    currentItem: K;
+    data: DataProvider<K, D>;
+    dnd: {
+        drag?: {
+            items: {
+                dataTypes?: string | string[];
+                drag?: ((param0: Event) => void);
+                dragEnd?: ((param0: Event) => void);
+                dragStart?: ((param0: Event, param1: {
+                    items: Element[];
+                }) => void);
+            };
+        };
+        drop?: {
+            items: {
+                dataTypes?: string | string[];
+                dragEnter?: ((param0: Event, param1: {
+                    item: Element;
+                }) => void);
+                dragLeave?: ((param0: Event, param1: {
+                    item: Element;
+                }) => void);
+                dragOver?: ((param0: Event, param1: {
+                    item: Element;
+                }) => void);
+                drop?: ((param0: Event, param1: ojListView.ItemsDropContext) => void);
+            };
+        };
+        reorder: {
+            items: 'enabled' | 'disabled';
+        };
+    };
+    drillMode: 'collapsible' | 'none';
+    expanded: KeySet<K>;
+    readonly firstSelectedItem: {
+        key: K;
+        data: D;
+    };
+    groupHeaderPosition: 'static' | 'sticky';
+    item: {
+        focusable?: ((param0: ojListView.ItemContext<K, D>) => boolean) | boolean;
+        renderer?: ((param0: ojListView.ItemContext<K, D>) => {
+            insert: Element | string;
+        } | undefined) | null;
+        selectable?: ((param0: ojListView.ItemContext<K, D>) => boolean) | boolean;
+    };
+    scrollPolicy: 'auto' | 'loadMoreOnScroll';
+    scrollPolicyOptions: {
+        fetchSize?: number;
+        maxCount?: number;
+        scroller?: Element;
+    };
+    scrollPosition: {
+        x?: number;
+        y?: number;
+        index?: number;
+        parent?: K;
+        key?: K;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    selection: K[];
+    selectionMode: 'none' | 'single' | 'multiple';
+    selectionRequired: boolean;
+    translations: {
+        accessibleNavigateSkipItems?: string;
+        accessibleReorderAfterItem?: string;
+        accessibleReorderBeforeItem?: string;
+        accessibleReorderInsideItem?: string;
+        accessibleReorderTouchInstructionText?: string;
+        indexerCharacters?: string;
+        labelCopy?: string;
+        labelCut?: string;
+        labelPaste?: string;
+        labelPasteAfter?: string;
+        labelPasteBefore?: string;
+        msgFetchingData?: string;
+        msgNoData?: string;
+    };
+    onAsChanged: ((event: JetElementCustomEvent<ojListView<K, D>["as"]>) => any) | null;
+    onCurrentItemChanged: ((event: JetElementCustomEvent<ojListView<K, D>["currentItem"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojListView<K, D>["data"]>) => any) | null;
+    onDndChanged: ((event: JetElementCustomEvent<ojListView<K, D>["dnd"]>) => any) | null;
+    onDrillModeChanged: ((event: JetElementCustomEvent<ojListView<K, D>["drillMode"]>) => any) | null;
+    onExpandedChanged: ((event: JetElementCustomEvent<ojListView<K, D>["expanded"]>) => any) | null;
+    onFirstSelectedItemChanged: ((event: JetElementCustomEvent<ojListView<K, D>["firstSelectedItem"]>) => any) | null;
+    onGroupHeaderPositionChanged: ((event: JetElementCustomEvent<ojListView<K, D>["groupHeaderPosition"]>) => any) | null;
+    onItemChanged: ((event: JetElementCustomEvent<ojListView<K, D>["item"]>) => any) | null;
+    onScrollPolicyChanged: ((event: JetElementCustomEvent<ojListView<K, D>["scrollPolicy"]>) => any) | null;
+    onScrollPolicyOptionsChanged: ((event: JetElementCustomEvent<ojListView<K, D>["scrollPolicyOptions"]>) => any) | null;
+    onScrollPositionChanged: ((event: JetElementCustomEvent<ojListView<K, D>["scrollPosition"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojListView<K, D>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojListView<K, D>["selectionMode"]>) => any) | null;
+    onSelectionRequiredChanged: ((event: JetElementCustomEvent<ojListView<K, D>["selectionRequired"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojListView.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojListView.ojAnimateStart) => any) | null;
+    onOjBeforeCollapse: ((event: ojListView.ojBeforeCollapse<K>) => any) | null;
+    onOjBeforeCurrentItem: ((event: ojListView.ojBeforeCurrentItem<K>) => any) | null;
+    onOjBeforeExpand: ((event: ojListView.ojBeforeExpand<K>) => any) | null;
+    onOjCollapse: ((event: ojListView.ojCollapse<K>) => any) | null;
+    onOjCopy: ((event: ojListView.ojCopy) => any) | null;
+    onOjCut: ((event: ojListView.ojCut) => any) | null;
+    onOjExpand: ((event: ojListView.ojExpand<K>) => any) | null;
+    onOjPaste: ((event: ojListView.ojPaste) => any) | null;
+    onOjReorder: ((event: ojListView.ojReorder) => any) | null;
+    addEventListener<T extends keyof ojListViewEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojListViewEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojListViewSettableProperties<K, D>>(property: T): ojListView<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojListViewSettableProperties<K, D>>(property: T, value: ojListViewSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojListViewSettableProperties<K, D>>): void;
+    setProperties(properties: ojListViewSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojListView.ContextByNode<K> | null;
+    getDataForVisibleItem(context: {
+        key?: K;
+        index?: number;
+        parent?: Element;
+    }): D;
+    refresh(): void;
+    scrollToItem(item: {
+        key: K;
+    }): void;
+}
+export namespace ojListView {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeCollapse<K> extends CustomEvent<{
+        key: K;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeCurrentItem<K> extends CustomEvent<{
+        previousKey: K;
+        previousItem: Element;
+        key: K;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeExpand<K> extends CustomEvent<{
+        key: K;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojCollapse<K> extends CustomEvent<{
+        key: K;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojCopy extends CustomEvent<{
+        items: Element[];
+        [propName: string]: any;
+    }> {
+    }
+    interface ojCut extends CustomEvent<{
+        items: Element[];
+        [propName: string]: any;
+    }> {
+    }
+    interface ojExpand<K> extends CustomEvent<{
+        key: K;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojPaste extends CustomEvent<{
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojReorder extends CustomEvent<{
+        items: Element[];
+        position: string;
+        reference: Element;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type ContextByNode<K> = {
+        subId: string;
+        key: K;
+        index: number;
+        parent?: Element;
+        group?: boolean;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type ItemContext<K, D> = {
+        datasource: DataProvider<K, D>;
+        index: number;
+        key: K;
+        data: D;
+        parentElement: Element;
+        depth?: number;
+        parentKey?: K;
+        leaf?: boolean;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type ItemsDropContext = {
+        item: Element;
+        position: 'before' | 'after' | 'inside';
+        reorder: boolean;
+    };
+}
+export interface ojListViewEventMap<K, D> extends baseComponentEventMap<ojListViewSettableProperties<K, D>> {
+    'ojAnimateEnd': ojListView.ojAnimateEnd;
+    'ojAnimateStart': ojListView.ojAnimateStart;
+    'ojBeforeCollapse': ojListView.ojBeforeCollapse<K>;
+    'ojBeforeCurrentItem': ojListView.ojBeforeCurrentItem<K>;
+    'ojBeforeExpand': ojListView.ojBeforeExpand<K>;
+    'ojCollapse': ojListView.ojCollapse<K>;
+    'ojCopy': ojListView.ojCopy;
+    'ojCut': ojListView.ojCut;
+    'ojExpand': ojListView.ojExpand<K>;
+    'ojPaste': ojListView.ojPaste;
+    'ojReorder': ojListView.ojReorder;
+    'asChanged': JetElementCustomEvent<ojListView<K, D>["as"]>;
+    'currentItemChanged': JetElementCustomEvent<ojListView<K, D>["currentItem"]>;
+    'dataChanged': JetElementCustomEvent<ojListView<K, D>["data"]>;
+    'dndChanged': JetElementCustomEvent<ojListView<K, D>["dnd"]>;
+    'drillModeChanged': JetElementCustomEvent<ojListView<K, D>["drillMode"]>;
+    'expandedChanged': JetElementCustomEvent<ojListView<K, D>["expanded"]>;
+    'firstSelectedItemChanged': JetElementCustomEvent<ojListView<K, D>["firstSelectedItem"]>;
+    'groupHeaderPositionChanged': JetElementCustomEvent<ojListView<K, D>["groupHeaderPosition"]>;
+    'itemChanged': JetElementCustomEvent<ojListView<K, D>["item"]>;
+    'scrollPolicyChanged': JetElementCustomEvent<ojListView<K, D>["scrollPolicy"]>;
+    'scrollPolicyOptionsChanged': JetElementCustomEvent<ojListView<K, D>["scrollPolicyOptions"]>;
+    'scrollPositionChanged': JetElementCustomEvent<ojListView<K, D>["scrollPosition"]>;
+    'selectionChanged': JetElementCustomEvent<ojListView<K, D>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojListView<K, D>["selectionMode"]>;
+    'selectionRequiredChanged': JetElementCustomEvent<ojListView<K, D>["selectionRequired"]>;
+}
+export interface ojListViewSettableProperties<K, D> extends baseComponentSettableProperties {
+    as: string;
+    currentItem: K;
+    data: DataProvider<K, D>;
+    dnd: {
+        drag?: {
+            items: {
+                dataTypes?: string | string[];
+                drag?: ((param0: Event) => void);
+                dragEnd?: ((param0: Event) => void);
+                dragStart?: ((param0: Event, param1: {
+                    items: Element[];
+                }) => void);
+            };
+        };
+        drop?: {
+            items: {
+                dataTypes?: string | string[];
+                dragEnter?: ((param0: Event, param1: {
+                    item: Element;
+                }) => void);
+                dragLeave?: ((param0: Event, param1: {
+                    item: Element;
+                }) => void);
+                dragOver?: ((param0: Event, param1: {
+                    item: Element;
+                }) => void);
+                drop?: ((param0: Event, param1: ojListView.ItemsDropContext) => void);
+            };
+        };
+        reorder: {
+            items: 'enabled' | 'disabled';
+        };
+    };
+    drillMode: 'collapsible' | 'none';
+    expanded: KeySet<K>;
+    readonly firstSelectedItem: {
+        key: K;
+        data: D;
+    };
+    groupHeaderPosition: 'static' | 'sticky';
+    item: {
+        focusable?: ((param0: ojListView.ItemContext<K, D>) => boolean) | boolean;
+        renderer?: ((param0: ojListView.ItemContext<K, D>) => {
+            insert: Element | string;
+        } | undefined) | null;
+        selectable?: ((param0: ojListView.ItemContext<K, D>) => boolean) | boolean;
+    };
+    scrollPolicy: 'auto' | 'loadMoreOnScroll';
+    scrollPolicyOptions: {
+        fetchSize?: number;
+        maxCount?: number;
+        scroller?: Element;
+    };
+    scrollPosition: {
+        x?: number;
+        y?: number;
+        index?: number;
+        parent?: K;
+        key?: K;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    selection: K[];
+    selectionMode: 'none' | 'single' | 'multiple';
+    selectionRequired: boolean;
+    translations: {
+        accessibleNavigateSkipItems?: string;
+        accessibleReorderAfterItem?: string;
+        accessibleReorderBeforeItem?: string;
+        accessibleReorderInsideItem?: string;
+        accessibleReorderTouchInstructionText?: string;
+        indexerCharacters?: string;
+        labelCopy?: string;
+        labelCut?: string;
+        labelPaste?: string;
+        labelPasteAfter?: string;
+        labelPasteBefore?: string;
+        msgFetchingData?: string;
+        msgNoData?: string;
+    };
+}
+export interface ojListViewSettablePropertiesLenient<K, D> extends Partial<ojListViewSettableProperties<K, D>> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojlocaledata/index.d.ts

@@ -0,0 +1,7 @@
+export function getDayNames(type?: 'abbreviated' | 'narrow' | 'wide'): string[];
+export function getFirstDayOfWeek(): number;
+export function getMonthNames(type?: 'abbreviated' | 'narrow' | 'wide'): string[];
+export function getWeekendEnd(): number;
+export function getWeekendStart(): number;
+export function isMonthPriorToYear(): boolean;
+export function setBundle(bundle: object): void;

types/oracle__oraclejet/ojlogger/index.d.ts

@@ -0,0 +1,10 @@
+export let LEVEL_ERROR: number;
+export let LEVEL_INFO: number;
+export let LEVEL_LOG: number;
+export let LEVEL_NONE: number;
+export let LEVEL_WARN: number;
+export function error(...args: Array<object | string | number>): void;
+export function info(...args: Array<object | string | number>): void;
+export function log(...args: Array<object | string | number>): void;
+export function option(key?: object | string, value?: any): any;
+export function warn(...args: Array<object | string | number>): void;

types/oracle__oraclejet/ojmasonrylayout/index.d.ts

@@ -0,0 +1,119 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojMasonryLayout extends baseComponent<ojMasonryLayoutSettableProperties> {
+    reorderHandle: string | null;
+    translations: {
+        labelCut?: string;
+        labelPasteAfter?: string;
+        labelPasteBefore?: string;
+    };
+    onReorderHandleChanged: ((event: JetElementCustomEvent<ojMasonryLayout["reorderHandle"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojMasonryLayout.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojMasonryLayout.ojAnimateStart) => any) | null;
+    onOjBeforeInsert: ((event: ojMasonryLayout.ojBeforeInsert) => any) | null;
+    onOjBeforeRemove: ((event: ojMasonryLayout.ojBeforeRemove) => any) | null;
+    onOjBeforeReorder: ((event: ojMasonryLayout.ojBeforeReorder) => any) | null;
+    onOjBeforeResize: ((event: ojMasonryLayout.ojBeforeResize) => any) | null;
+    onOjInsert: ((event: ojMasonryLayout.ojInsert) => any) | null;
+    onOjRemove: ((event: ojMasonryLayout.ojRemove) => any) | null;
+    onOjReorder: ((event: ojMasonryLayout.ojReorder) => any) | null;
+    onOjResize: ((event: ojMasonryLayout.ojResize) => any) | null;
+    addEventListener<T extends keyof ojMasonryLayoutEventMap>(type: T, listener: (this: HTMLElement, ev: ojMasonryLayoutEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojMasonryLayoutSettableProperties>(property: T): ojMasonryLayout[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojMasonryLayoutSettableProperties>(property: T, value: ojMasonryLayoutSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojMasonryLayoutSettableProperties>): void;
+    setProperties(properties: ojMasonryLayoutSettablePropertiesLenient): void;
+    insertTile(selector: string, index: number): void;
+    refresh(): void;
+    removeTile(selector: string): void;
+    resizeTile(selector: string, sizeStyleClass: string): void;
+}
+export namespace ojMasonryLayout {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeInsert extends CustomEvent<{
+        tile: Element;
+        index: number;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeRemove extends CustomEvent<{
+        tile: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeReorder extends CustomEvent<{
+        tile: Element;
+        fromIndex: number;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeResize extends CustomEvent<{
+        tile: Element;
+        previousSizeStyleClass: string;
+        sizeStyleClass: string;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojInsert extends CustomEvent<{
+        tile: Element;
+        index: number;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojRemove extends CustomEvent<{
+        tile: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojReorder extends CustomEvent<{
+        tile: Element;
+        fromIndex: number;
+        toIndex: number;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojResize extends CustomEvent<{
+        tile: Element;
+        previousSizeStyleClass: string;
+        sizeStyleClass: string;
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojMasonryLayoutEventMap extends baseComponentEventMap<ojMasonryLayoutSettableProperties> {
+    'ojAnimateEnd': ojMasonryLayout.ojAnimateEnd;
+    'ojAnimateStart': ojMasonryLayout.ojAnimateStart;
+    'ojBeforeInsert': ojMasonryLayout.ojBeforeInsert;
+    'ojBeforeRemove': ojMasonryLayout.ojBeforeRemove;
+    'ojBeforeReorder': ojMasonryLayout.ojBeforeReorder;
+    'ojBeforeResize': ojMasonryLayout.ojBeforeResize;
+    'ojInsert': ojMasonryLayout.ojInsert;
+    'ojRemove': ojMasonryLayout.ojRemove;
+    'ojReorder': ojMasonryLayout.ojReorder;
+    'ojResize': ojMasonryLayout.ojResize;
+    'reorderHandleChanged': JetElementCustomEvent<ojMasonryLayout["reorderHandle"]>;
+}
+export interface ojMasonryLayoutSettableProperties extends baseComponentSettableProperties {
+    reorderHandle: string | null;
+    translations: {
+        labelCut?: string;
+        labelPasteAfter?: string;
+        labelPasteBefore?: string;
+    };
+}
+export interface ojMasonryLayoutSettablePropertiesLenient extends Partial<ojMasonryLayoutSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojmenu/index.d.ts

@@ -0,0 +1,105 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojMenu extends baseComponent<ojMenuSettableProperties> {
+    disabled: boolean;
+    openOptions: ojMenu.OpenOptions;
+    translations: {
+        ariaFocusSkipLink?: string;
+        labelCancel?: string;
+    };
+    onDisabledChanged: ((event: JetElementCustomEvent<ojMenu["disabled"]>) => any) | null;
+    onOpenOptionsChanged: ((event: JetElementCustomEvent<ojMenu["openOptions"]>) => any) | null;
+    onOjAction: ((event: ojMenu.ojAction) => any) | null;
+    onOjAnimateEnd: ((event: ojMenu.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojMenu.ojAnimateStart) => any) | null;
+    onOjBeforeOpen: ((event: ojMenu.ojBeforeOpen) => any) | null;
+    onOjClose: ((event: ojMenu.ojClose) => any) | null;
+    onOjOpen: ((event: ojMenu.ojOpen) => any) | null;
+    addEventListener<T extends keyof ojMenuEventMap>(type: T, listener: (this: HTMLElement, ev: ojMenuEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojMenuSettableProperties>(property: T): ojMenu[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojMenuSettableProperties>(property: T, value: ojMenuSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojMenuSettableProperties>): void;
+    setProperties(properties: ojMenuSettablePropertiesLenient): void;
+    open(event?: object, openOptions?: ojMenu.OpenOptions): void;
+    refresh(): void;
+}
+export namespace ojMenu {
+    interface ojAction extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateEnd extends CustomEvent<{
+        element: Element;
+        action: 'open' | 'close';
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: 'open' | 'close';
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeOpen extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+    interface ojClose extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojOpen extends CustomEvent<{
+        event: Event;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type OpenOptions = {
+        display?: string;
+        initialFocus?: string;
+        launcher?: string | Element;
+        position?: Position;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type Position = {
+        my?: PositionAlign;
+        at?: PositionAlign;
+        offset?: PositionPoint;
+        of?: string | PositionPoint;
+        collision?: 'flip' | 'fit' | 'flipfit' | 'flipcenter' | 'none';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PositionAlign = {
+        vertical?: 'top' | 'bottom' | 'center';
+        horizontal?: 'start' | 'end' | 'left' | 'center' | 'bottom';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PositionPoint = {
+        x?: number;
+        y?: number;
+    };
+}
+export interface ojMenuEventMap extends baseComponentEventMap<ojMenuSettableProperties> {
+    'ojAction': ojMenu.ojAction;
+    'ojAnimateEnd': ojMenu.ojAnimateEnd;
+    'ojAnimateStart': ojMenu.ojAnimateStart;
+    'ojBeforeOpen': ojMenu.ojBeforeOpen;
+    'ojClose': ojMenu.ojClose;
+    'ojOpen': ojMenu.ojOpen;
+    'disabledChanged': JetElementCustomEvent<ojMenu["disabled"]>;
+    'openOptionsChanged': JetElementCustomEvent<ojMenu["openOptions"]>;
+}
+export interface ojMenuSettableProperties extends baseComponentSettableProperties {
+    disabled: boolean;
+    openOptions: ojMenu.OpenOptions;
+    translations: {
+        ariaFocusSkipLink?: string;
+        labelCancel?: string;
+    };
+}
+export interface ojMenuSettablePropertiesLenient extends Partial<ojMenuSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojmenuselectmany/index.d.ts

@@ -0,0 +1,39 @@
+import { DataProvider } from '../ojdataprovider';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojMenuSelectMany extends JetElement<ojMenuSelectManySettableProperties> {
+    disabled: boolean;
+    options: ojMenuSelectMany.Option[] | DataProvider<any, any> | null;
+    value: any[];
+    onDisabledChanged: ((event: JetElementCustomEvent<ojMenuSelectMany["disabled"]>) => any) | null;
+    onOptionsChanged: ((event: JetElementCustomEvent<ojMenuSelectMany["options"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojMenuSelectMany["value"]>) => any) | null;
+    addEventListener<T extends keyof ojMenuSelectManyEventMap>(type: T, listener: (this: HTMLElement, ev: ojMenuSelectManyEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojMenuSelectManySettableProperties>(property: T): ojMenuSelectMany[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojMenuSelectManySettableProperties>(property: T, value: ojMenuSelectManySettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojMenuSelectManySettableProperties>): void;
+    setProperties(properties: ojMenuSelectManySettablePropertiesLenient): void;
+}
+export interface ojMenuSelectManyEventMap extends HTMLElementEventMap {
+    'disabledChanged': JetElementCustomEvent<ojMenuSelectMany["disabled"]>;
+    'optionsChanged': JetElementCustomEvent<ojMenuSelectMany["options"]>;
+    'valueChanged': JetElementCustomEvent<ojMenuSelectMany["value"]>;
+}
+export interface ojMenuSelectManySettableProperties extends JetSettableProperties {
+    disabled: boolean;
+    options: ojMenuSelectMany.Option[] | DataProvider<any, any> | null;
+    value: any[];
+}
+export interface ojMenuSelectManySettablePropertiesLenient extends Partial<ojMenuSelectManySettableProperties> {
+    [key: string]: any;
+}
+export namespace ojMenuSelectMany {
+    // tslint:disable-next-line interface-over-type-literal
+    type Option = {
+        id?: string;
+        disabled?: boolean;
+        label: string;
+        value: any;
+    };
+}

types/oracle__oraclejet/ojmessage/index.d.ts

@@ -0,0 +1,80 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojMessage extends JetElement<ojMessageSettableProperties> {
+    message: ojMessage.Message;
+    translations: {
+        categories?: {
+            confirmation?: string;
+            error?: string;
+            info?: string;
+            warning?: string;
+        };
+        labelCloseIcon?: string;
+    };
+    onMessageChanged: ((event: JetElementCustomEvent<ojMessage["message"]>) => any) | null;
+    onTranslationsChanged: ((event: JetElementCustomEvent<ojMessage["translations"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojMessage.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojMessage.ojAnimateStart) => any) | null;
+    onOjClose: ((event: ojMessage.ojClose) => any) | null;
+    addEventListener<T extends keyof ojMessageEventMap>(type: T, listener: (this: HTMLElement, ev: ojMessageEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojMessageSettableProperties>(property: T): ojMessage[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojMessageSettableProperties>(property: T, value: ojMessageSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojMessageSettableProperties>): void;
+    setProperties(properties: ojMessageSettablePropertiesLenient): void;
+    close(): void;
+}
+export namespace ojMessage {
+    interface ojAnimateEnd extends CustomEvent<{
+        element: Element;
+        action: 'open' | 'close';
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        element: Element;
+        action: 'open' | 'close';
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojClose extends CustomEvent<{
+        message: object;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type Message = {
+        icon?: string;
+        category?: string;
+        severity?: 'error' | 'warning' | 'confirmation' | 'info' | 'none';
+        timestamp?: string;
+        summary?: string;
+        detail?: string;
+        autoTimeout?: number;
+        closeAffordance?: 'none' | 'defaults';
+        sound?: string;
+    };
+}
+export interface ojMessageEventMap extends HTMLElementEventMap {
+    'ojAnimateEnd': ojMessage.ojAnimateEnd;
+    'ojAnimateStart': ojMessage.ojAnimateStart;
+    'ojClose': ojMessage.ojClose;
+    'messageChanged': JetElementCustomEvent<ojMessage["message"]>;
+    'translationsChanged': JetElementCustomEvent<ojMessage["translations"]>;
+}
+export interface ojMessageSettableProperties extends JetSettableProperties {
+    message: ojMessage.Message;
+    translations: {
+        categories?: {
+            confirmation?: string;
+            error?: string;
+            info?: string;
+            warning?: string;
+        };
+        labelCloseIcon?: string;
+    };
+}
+export interface ojMessageSettablePropertiesLenient extends Partial<ojMessageSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojmessages/index.d.ts

@@ -0,0 +1,73 @@
+import { DataProvider } from '../ojdataprovider';
+import { ojMessage } from '../ojmessage';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojMessages extends JetElement<ojMessagesSettableProperties> {
+    display: 'general' | 'notification';
+    messages: ojMessage.Message[] | null | DataProvider<any, ojMessage.Message>;
+    position: ojMessages.Position | null;
+    translations: {
+        ariaLiveRegion?: {
+            navigationFromKeyboard?: string;
+            navigationToKeyboard?: string;
+            navigationToTouch?: string;
+            newMessage?: string;
+        };
+        labelLandmark?: string;
+    };
+    onDisplayChanged: ((event: JetElementCustomEvent<ojMessages["display"]>) => any) | null;
+    onMessagesChanged: ((event: JetElementCustomEvent<ojMessages["messages"]>) => any) | null;
+    onPositionChanged: ((event: JetElementCustomEvent<ojMessages["position"]>) => any) | null;
+    onTranslationsChanged: ((event: JetElementCustomEvent<ojMessages["translations"]>) => any) | null;
+    addEventListener<T extends keyof ojMessagesEventMap>(type: T, listener: (this: HTMLElement, ev: ojMessagesEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojMessagesSettableProperties>(property: T): ojMessages[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojMessagesSettableProperties>(property: T, value: ojMessagesSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojMessagesSettableProperties>): void;
+    setProperties(properties: ojMessagesSettablePropertiesLenient): void;
+    close(associated: object): void;
+    closeAll(closeFilter?: (message: ojMessage.Message) => boolean): void;
+}
+export interface ojMessagesEventMap extends HTMLElementEventMap {
+    'displayChanged': JetElementCustomEvent<ojMessages["display"]>;
+    'messagesChanged': JetElementCustomEvent<ojMessages["messages"]>;
+    'positionChanged': JetElementCustomEvent<ojMessages["position"]>;
+    'translationsChanged': JetElementCustomEvent<ojMessages["translations"]>;
+}
+export interface ojMessagesSettableProperties extends JetSettableProperties {
+    display: 'general' | 'notification';
+    messages: ojMessage.Message[] | null | DataProvider<any, ojMessage.Message>;
+    position: ojMessages.Position | null;
+    translations: {
+        ariaLiveRegion?: {
+            navigationFromKeyboard?: string;
+            navigationToKeyboard?: string;
+            navigationToTouch?: string;
+            newMessage?: string;
+        };
+        labelLandmark?: string;
+    };
+}
+export interface ojMessagesSettablePropertiesLenient extends Partial<ojMessagesSettableProperties> {
+    [key: string]: any;
+}
+export namespace ojMessages {
+    // tslint:disable-next-line interface-over-type-literal
+    type Position = {
+        my?: PositionAlign;
+        at?: PositionAlign;
+        offset?: PositionPoint;
+        of?: string | PositionPoint;
+        collision?: 'flip' | 'fit' | 'flipfit' | 'none';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PositionAlign = {
+        vertical?: 'top' | 'bottom' | 'center';
+        horizontal?: 'start' | 'end' | 'left' | 'center' | 'bottom';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PositionPoint = {
+        x?: number;
+        y?: number;
+    };
+}

types/oracle__oraclejet/ojmessaging/index.d.ts

@@ -0,0 +1,15 @@
+declare class Message {
+    detail: string;
+    severity: Message.SEVERITY_TYPE | Message.SEVERITY_LEVEL;
+    summary: string;
+    constructor(summary: string, detail: string, severity?: Message.SEVERITY_TYPE | Message.SEVERITY_LEVEL);
+    static getMaxSeverity(messages?: Message[]): Message.SEVERITY_LEVEL | -1;
+    static getSeverityLevel(severity?: Message.SEVERITY_TYPE | Message.SEVERITY_LEVEL): Message.SEVERITY_LEVEL;
+    static getSeverityType(level?: Message.SEVERITY_TYPE | Message.SEVERITY_LEVEL): Message.SEVERITY_TYPE;
+    static isValid(messages: Message[]): boolean;
+}
+declare namespace Message {
+    type SEVERITY_LEVEL = 5 | 4 | 3 | 2 | 1;
+    type SEVERITY_TYPE = "confirmation" | "info" | "warning" | "error" | "fatal";
+}
+export = Message;

types/oracle__oraclejet/ojmodel/index.d.ts

@@ -0,0 +1,280 @@
+export class Collection {
+    changes: number[];
+    comparator: null | string | ((param0: Model, param1?: Model) => number);
+    customPagingOptions: ((response: object) => Collection.CustomPagingOptionsReturn | null) | null;
+    customURL: ((param0: string, param1: Collection, param2: object) => string | object | null) | null;
+    fetchSize: number;
+    hasMore: boolean;
+    lastFetchCount: number;
+    lastFetchSize: number;
+    length: number;
+    model: object;
+    modelLimit: number;
+    models: Model[];
+    offset: number;
+    omitLanguageHeader: boolean;
+    parse: ((param0: object) => object);
+    sortDirection: number;
+    totalResults: number;
+    url: null | string | (() => string);
+    constructor(models?: Model[], options?: object);
+    static extend(properties?: {
+        parse?: (data: any) => any;
+        model?: Model;
+        url?: string;
+        initialize?: (models: Model[], options: object) => void;
+        comparator?: null | string | ((model1: Model, model2?: Model) => number);
+        fetchSize?: number;
+        modelLimit?: number;
+        [propName: string]: any;
+    }, classProperties?: object): any;
+    abort(): Promise<null>;
+    add(m: Model | object | object[] | Model[], options?: {
+        silent?: boolean;
+        at?: number;
+        merge?: boolean;
+        sort?: boolean;
+        force?: boolean;
+        deferred?: boolean;
+        [propName: string]: any;
+    }): Promise<Model[]> | Model[];
+    any(iterator: ((param0: object) => void), context?: object): boolean;
+    at(index: number, options?: {
+        fetchSize?: number;
+        deferred?: boolean;
+        [propName: string]: any;
+    }): Model | Promise<Model> | null;
+    clone(): Collection;
+    contains(model: object, options?: object): boolean | Promise<boolean>;
+    create(attributes?: object, options?: {
+        silent?: boolean;
+        at?: number;
+        merge?: boolean;
+        sort?: boolean;
+        force?: boolean;
+        deferred?: boolean;
+        [propName: string]: any;
+    }): Model | boolean | Promise<Model>;
+    difference(...var_args: Model[][]): Model[];
+    each(iterator: ((param0: Model) => void), context?: object): undefined;
+    fetch(options?: {
+        success?: (collection: Collection, response: any, options: object) => void;
+        error?: (collection: Collection, xhr: any, options: object) => void;
+        add?: boolean;
+        set?: boolean;
+        startIndex?: number;
+        startID?: any;
+        since?: any;
+        until?: any;
+        fetchSize?: number;
+        [propName: string]: any;
+    }): object;
+    filter(iterator: ((param0: Model) => void), context?: object): Model[];
+    findWhere(attrs: object | object[], options?: {
+        deferred?: boolean;
+        [propName: string]: any;
+    }): Model | Promise<Model>;
+    first(n?: number, options?: object): Model[] | null | Promise<any>;
+    get(id: object | string, options?: object): Model | null | Promise<Model>;
+    getByCid(clientId: string): Model | null;
+    groupBy(iterator: string | ((param0: Model) => object), context?: object): object;
+    include(model: object, options?: object): boolean | Promise<boolean>;
+    indexBy(iterator: string | ((param0: Model) => void), context?: object): object;
+    indexOf(model: object, options?: object): number | Promise<number>;
+    initial(n?: number): Model[];
+    isEmpty(): boolean;
+    isRangeLocal(start: number, count: number): boolean;
+    last(n?: number, options?: object): Promise<Model> | Model[] | null;
+    lastIndexOf(model: Model, fromIndex?: number): number;
+    listenTo(otherObj: object, eventType: string, callback: (eventType: string, data: object) => void): undefined;
+    listenToOnce(otherObj: object, eventType: string, callback: (eventType: string, data: object) => void): undefined;
+    map(iterator: ((param0: Model) => object), context?: object): object[];
+    max(iterator: ((param0: Model) => object), context?: object): object;
+    min(iterator: ((param0: object) => void), context?: object): object;
+    modelId(attrs: object): null | string;
+    next(n: number, options?: {
+        success?: (collection: Collection, response: any, options: object) => void;
+        error?: (collection: Collection, xhr: any, options: object) => void;
+        [propName: string]: any;
+    }): object | null;
+    off(eventType?: string | object, callback?: (eventType: string, data: object) => void, context?: object): undefined;
+    on(eventType: string | object, callback: (eventType: string, data: object) => void, context?: object): undefined;
+    once(eventType: string, callback: (eventType: string, data: object) => void, context?: object): undefined;
+    pluck(attr: string): object[];
+    pop(options?: {
+        silent?: boolean;
+        deferred?: boolean;
+        [propName: string]: any;
+    }): Model | Promise<Model>;
+    previous(n: number, options?: {
+        success?: (collection: Collection, response: any, options: object) => void;
+        error?: (collection: Collection, xhr: any, options: object) => void;
+        [propName: string]: any;
+    }): object;
+    push(m: Model | object, options?: {
+        silent?: boolean;
+        at?: number;
+        merge?: boolean;
+        sort?: boolean;
+        force?: boolean;
+        deferred?: boolean;
+        [propName: string]: any;
+    }): Promise<Model[]> | undefined;
+    refresh(options?: {
+        silent?: boolean;
+        startIndex?: number;
+        [propName: string]: any;
+    }): Promise<Collection.SetRangeLocalPromise | undefined>;
+    remove(m: Model | Model[], options?: object): Model[] | object;
+    reset(data?: object, options?: {
+        silent?: boolean;
+        [propName: string]: any;
+    }): Model | Model[];
+    rest(n?: number, options?: object): object[] | Promise<any>;
+    set(models: object, options?: {
+        add?: boolean;
+        remove?: boolean;
+        merge?: boolean;
+        silent?: boolean;
+        deferred?: boolean;
+        [propName: string]: any;
+    }): Promise<any> | null;
+    setFetchSize(n: number): undefined;
+    setModelLimit(n: number): undefined;
+    setRangeLocal(start: number, count: number): Promise<Collection.SetRangeLocalPromise>;
+    shift(options?: object): Model | Promise<Model> | null;
+    size(): number;
+    slice(start: number, end?: number, options?: object): Promise<Model[]> | Model[];
+    sort(options?: {
+        silent?: boolean;
+        startIndex?: number;
+        [propName: string]: any;
+    }): Promise<Collection.SetRangeLocalPromise> | null;
+    sortBy(iterator: string | ((param0: Model) => object), context?: object): Model[];
+    sortedIndex(comparator: string | ((param0: Model, param1?: Model) => object)): number;
+    stopListening(otherObj?: object, eventType?: string, callback?: (eventType: string, data: object) => void): undefined;
+    sync(method: string, collection: Collection, options?: {
+        success?: (json?: any[]) => void;
+        error?: (xhr: any, status: any, error: any) => void;
+        [propName: string]: any;
+    }): object;
+    toJSON(): object[];
+    trigger(eventType: string): undefined;
+    unshift(m: object, options?: {
+        silent?: boolean;
+        at?: number;
+        merge?: boolean;
+        sort?: boolean;
+        force?: boolean;
+        deferred?: boolean;
+        [propName: string]: any;
+    }): Promise<Model[]> | Model[];
+    whenReady(): Promise<any>;
+    where(attrs: object | object[], options?: object): Promise<Model[]> | Model[];
+    whereToCollection(attrs: object | object[], options?: object): Collection | Promise<Collection>;
+    without(...var_args: Model[]): Model[];
+}
+export namespace Collection {
+    // tslint:disable-next-line interface-over-type-literal
+    type CustomPagingOptionsReturn = {
+        totalResults?: number;
+        limit?: number;
+        count?: number;
+        offset?: number;
+        hasMore?: boolean;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type SetRangeLocalPromise = {
+        start: number;
+        count: number;
+        models: Model[];
+    };
+}
+export class Model {
+    attributes: object;
+    customURL: ((param0: string, param1: Model, param2: object) => string | object | null) | null;
+    defaults: object;
+    id: string | null;
+    idAttribute: string | null;
+    omitLanguageHeader: boolean;
+    parse: ((param0: object) => object);
+    parseSave: ((param0: object) => object);
+    urlRoot: string | null;
+    validate: ((param0: object, param1: object) => string | object | null) | null;
+    validationError: string | object | null;
+    constructor(attributes?: object, options?: object);
+    static extend(properties?: {
+        parse?: (data: any) => any;
+        parseSave?: (data: any) => any;
+        urlRoot?: string;
+        initialize?: (models: Model[], options: object) => void;
+        validate?: null | object | string | ((attributes: object, options?: Model) => number);
+        [propName: string]: any;
+    }, classProperties?: object): any;
+    changedAttributes(attributes?: object): object | boolean;
+    clear(options?: object): Model | boolean;
+    clone(): Model;
+    destroy(options?: {
+        success?: (model: Model, response: any, options: object) => void;
+        error?: (model: Model, xhr: any, options: object) => void;
+        wait?: boolean;
+        [propName: string]: any;
+    }): boolean;
+    fetch(options?: {
+        success?: (model: Model, response: any, options: object) => void;
+        error?: (model: Model, xhr: any, options: object) => void;
+        [propName: string]: any;
+    }): object;
+    get(property: string): object;
+    has(property: string): boolean;
+    hasChanged(attribute?: string): boolean;
+    invert(): object;
+    isNew(): boolean;
+    isValid(): boolean;
+    keys(): object[];
+    listenTo(otherObj: object, eventType: string, callback: (eventType: string, data: object) => void): undefined;
+    listenToOnce(otherObj: object, eventType: string, callback: (eventType: string, data: object) => void): undefined;
+    matches(attrs: object): ((param0: Model) => boolean);
+    off(eventType?: string | object, callback?: (eventType: string, data: object) => void, context?: object): undefined;
+    omit(keys: object[] | object): object;
+    on(eventType: string | object, callback: (eventType: string, data: object) => void, context?: object): undefined;
+    once(eventType: string, callback: (eventType: string, data: object) => void, context?: object): undefined;
+    pairs(): object;
+    pick(keys: object[] | object): object;
+    previous(attr: string): object;
+    previousAttributes(): object;
+    save(attributes?: object, options?: {
+        success?: (model: Model, response: any, options: object) => void;
+        error?: (model: Model, xhr: any, options: object) => void;
+        contentType?: string;
+        valdiate?: boolean;
+        wait?: boolean;
+        patch?: boolean;
+        attrs?: object;
+        [propName: string]: any;
+    }): object | boolean;
+    set(property: string | object, value?: object, options?: object): Model | boolean;
+    stopListening(otherObj?: object, eventType?: string, callback?: (eventType: string, data: object) => void): undefined;
+    sync(method: string, model: Model, options?: object): object;
+    toJSON(): object;
+    trigger(eventType: string): undefined;
+    unset(property: string, options?: object): boolean;
+    url(): string | null;
+    values(): object[];
+}
+export class OAuth {
+    constructor(attributes: object, header: string);
+    cleanAccessTokenRequest(): undefined;
+    cleanAccessTokenResponse(): undefined;
+    clientCredentialGrant(): undefined;
+    getAccessTokenRequest(): object;
+    getAccessTokenResponse(): object;
+    getHeader(): object;
+    isInitialized(): boolean;
+    setAccessTokenRequest(data: object): undefined;
+    setAccessTokenResponse(data: object): undefined;
+}
+// tslint:disable-next-line no-unnecessary-class
+export class URLError {
+    constructor();
+}

types/oracle__oraclejet/ojmodule-element-utils/index.d.ts

@@ -0,0 +1,8 @@
+export function createView(options: {
+    viewPath: string;
+    require?: ((module: string) => any) | ((modules: string[], ready?: any, errback?: any) => void);
+}): Promise<any>;
+export function createViewModel(options: {
+    viewModelPath: string;
+    require?: ((module: string) => any) | ((modules: string[], ready?: any, errback?: any) => void);
+}): Promise<any>;

types/oracle__oraclejet/ojmodule-element/index.d.ts

@@ -0,0 +1,89 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ModuleElementAnimation {
+    animate(context: {
+        node: Node;
+        isInitial: boolean;
+        oldViewModel: object;
+        newViewModel: object;
+        newViewParent: Node;
+        oldViewParent: Node;
+        removeOldView: () => undefined;
+        insertNewView: () => undefined;
+        oldDomNodes: any[];
+    }): Promise<any>;
+    canAnimate(context: {
+        node: Node;
+        isInitial: boolean;
+        oldViewModel: object;
+        newViewModel: object;
+    }): boolean;
+    prepareAnimation(context: {
+        node: Node;
+        isInitial: boolean;
+        oldViewModel: object;
+        newViewModel: object;
+    }): object;
+}
+export interface ojModule extends JetElement<ojModuleSettableProperties> {
+    animation: object;
+    config: {
+        cleanupMode: 'onDisconnect' | 'none';
+        view: Node[];
+        viewModel: object;
+    };
+    onAnimationChanged: ((event: JetElementCustomEvent<ojModule["animation"]>) => any) | null;
+    onConfigChanged: ((event: JetElementCustomEvent<ojModule["config"]>) => any) | null;
+    onOjTransitionEnd: ((event: ojModule.ojTransitionEnd) => any) | null;
+    onOjTransitionStart: ((event: ojModule.ojTransitionStart) => any) | null;
+    onOjViewConnected: ((event: ojModule.ojViewConnected) => any) | null;
+    onOjViewDisconnected: ((event: ojModule.ojViewDisconnected) => any) | null;
+    addEventListener<T extends keyof ojModuleEventMap>(type: T, listener: (this: HTMLElement, ev: ojModuleEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojModuleSettableProperties>(property: T): ojModule[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojModuleSettableProperties>(property: T, value: ojModuleSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojModuleSettableProperties>): void;
+    setProperties(properties: ojModuleSettablePropertiesLenient): void;
+}
+export namespace ojModule {
+    interface ojTransitionEnd extends CustomEvent<{
+        viewModel: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojTransitionStart extends CustomEvent<{
+        viewModel: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojViewConnected extends CustomEvent<{
+        viewModel: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojViewDisconnected extends CustomEvent<{
+        viewModel: object;
+        view: Node[];
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojModuleEventMap extends HTMLElementEventMap {
+    'ojTransitionEnd': ojModule.ojTransitionEnd;
+    'ojTransitionStart': ojModule.ojTransitionStart;
+    'ojViewConnected': ojModule.ojViewConnected;
+    'ojViewDisconnected': ojModule.ojViewDisconnected;
+    'animationChanged': JetElementCustomEvent<ojModule["animation"]>;
+    'configChanged': JetElementCustomEvent<ojModule["config"]>;
+}
+export interface ojModuleSettableProperties extends JetSettableProperties {
+    animation: object;
+    config: {
+        cleanupMode: 'onDisconnect' | 'none';
+        view: Node[];
+        viewModel: object;
+    };
+}
+export interface ojModuleSettablePropertiesLenient extends Partial<ojModuleSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojmoduleanimations/index.d.ts

@@ -0,0 +1,34 @@
+import { ModuleElementAnimation } from '../ojmodule-element';
+import AnimationUtils = require('../ojanimation');
+export let coverStart: ModuleElementAnimation;
+export let coverUp: ModuleElementAnimation;
+export let fade: ModuleElementAnimation;
+export let navChild: ModuleElementAnimation;
+export let navParent: ModuleElementAnimation;
+export let navSiblingEarlier: ModuleElementAnimation;
+export let navSiblingLater: ModuleElementAnimation;
+export let pushEnd: ModuleElementAnimation;
+export let pushStart: ModuleElementAnimation;
+export let revealDown: ModuleElementAnimation;
+export let revealEnd: ModuleElementAnimation;
+export let zoomIn: ModuleElementAnimation;
+export let zoomOut: ModuleElementAnimation;
+export function createAnimation(oldViewEffect: {
+    effect: AnimationUtils.AnimationMethods;
+    [key: string]: any;
+} | AnimationUtils.AnimationMethods | null, newViewEffect: {
+    effect: AnimationUtils.AnimationMethods;
+    [key: string]: any;
+} | AnimationUtils.AnimationMethods | null, newViewOnTop: boolean): ModuleElementAnimation;
+export function switcher(callback: (param0: SwitcherCallBackParam) => Animations): ModuleElementAnimation;
+// tslint:disable-next-line interface-over-type-literal
+export type Animations = 'coverStart' | 'coverUp' | 'fade' | 'navChild' | 'navParent' | 'navSiblingEarlier' | 'navSiblingLater' | 'pushEnd' | 'pushStart' | 'revealDown' | 'revealEnd' | 'zoomIn' |
+   'zoomOut';
+// tslint:disable-next-line interface-over-type-literal
+export type SwitcherCallBackParam = {
+    node: Element;
+    valueAccessor: (() => any);
+    isInitial: boolean;
+    oldViewModel: any;
+    newViewModel: any;
+};

types/oracle__oraclejet/ojnavigationlist/index.d.ts

@@ -0,0 +1,360 @@
+import { KeySet } from '../ojkeyset';
+import { DataProvider } from '../ojdataprovider';
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojNavigationList<K, D> extends baseComponent<ojNavigationListSettableProperties<K, D>> {
+    as: string;
+    currentItem: K;
+    data: DataProvider<K, D> | null;
+    display: 'all' | 'icons';
+    drillMode: 'none' | 'collapsible' | 'sliding';
+    edge: 'top' | 'start';
+    expanded: KeySet<K>;
+    hierarchyMenuThreshold: number;
+    item: {
+        renderer?: (((context: ojNavigationList.ItemContext<K, D>) => void) | null);
+        selectable?: (((context: ojNavigationList.ItemContext<K, D>) => boolean) | boolean);
+    };
+    overflow: 'popup' | 'hidden';
+    rootLabel: string | null;
+    selection: K;
+    translations: {
+        defaultRootLabel?: string;
+        hierMenuBtnLabel?: string;
+        previousIcon?: string;
+    };
+    onAsChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["as"]>) => any) | null;
+    onCurrentItemChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["currentItem"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["data"]>) => any) | null;
+    onDisplayChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["display"]>) => any) | null;
+    onDrillModeChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["drillMode"]>) => any) | null;
+    onEdgeChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["edge"]>) => any) | null;
+    onExpandedChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["expanded"]>) => any) | null;
+    onHierarchyMenuThresholdChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["hierarchyMenuThreshold"]>) => any) | null;
+    onItemChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["item"]>) => any) | null;
+    onOverflowChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["overflow"]>) => any) | null;
+    onRootLabelChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["rootLabel"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojNavigationList<K, D>["selection"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojNavigationList.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojNavigationList.ojAnimateStart) => any) | null;
+    onOjBeforeCollapse: ((event: ojNavigationList.ojBeforeCollapse) => any) | null;
+    onOjBeforeCurrentItem: ((event: ojNavigationList.ojBeforeCurrentItem) => any) | null;
+    onOjBeforeExpand: ((event: ojNavigationList.ojBeforeExpand) => any) | null;
+    onOjBeforeSelect: ((event: ojNavigationList.ojBeforeSelect) => any) | null;
+    onOjCollapse: ((event: ojNavigationList.ojCollapse) => any) | null;
+    onOjExpand: ((event: ojNavigationList.ojExpand) => any) | null;
+    addEventListener<T extends keyof ojNavigationListEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojNavigationListEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojNavigationListSettableProperties<K, D>>(property: T): ojNavigationList<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojNavigationListSettableProperties<K, D>>(property: T, value: ojNavigationListSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojNavigationListSettableProperties<K, D>>): void;
+    setProperties(properties: ojNavigationListSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojNavigationList.NodeContext<K> | null;
+    refresh(): void;
+}
+export namespace ojNavigationList {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeCollapse extends CustomEvent<{
+        key: any;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeCurrentItem extends CustomEvent<{
+        previousKey: any;
+        previousItem: Element;
+        key: any;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeExpand extends CustomEvent<{
+        key: any;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeSelect extends CustomEvent<{
+        key: any;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojCollapse extends CustomEvent<{
+        key: any;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojExpand extends CustomEvent<{
+        key: any;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type ItemContext<K, D> = {
+        componentElement: Element;
+        datasource?: DataProvider<K, D>;
+        index: number;
+        key: any;
+        data: any;
+        parentElement: Element;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContext<K> = {
+        subId: string;
+        index: number;
+        key: K;
+        group: boolean;
+        parent?: Element;
+    };
+}
+export interface ojNavigationListEventMap<K, D> extends baseComponentEventMap<ojNavigationListSettableProperties<K, D>> {
+    'ojAnimateEnd': ojNavigationList.ojAnimateEnd;
+    'ojAnimateStart': ojNavigationList.ojAnimateStart;
+    'ojBeforeCollapse': ojNavigationList.ojBeforeCollapse;
+    'ojBeforeCurrentItem': ojNavigationList.ojBeforeCurrentItem;
+    'ojBeforeExpand': ojNavigationList.ojBeforeExpand;
+    'ojBeforeSelect': ojNavigationList.ojBeforeSelect;
+    'ojCollapse': ojNavigationList.ojCollapse;
+    'ojExpand': ojNavigationList.ojExpand;
+    'asChanged': JetElementCustomEvent<ojNavigationList<K, D>["as"]>;
+    'currentItemChanged': JetElementCustomEvent<ojNavigationList<K, D>["currentItem"]>;
+    'dataChanged': JetElementCustomEvent<ojNavigationList<K, D>["data"]>;
+    'displayChanged': JetElementCustomEvent<ojNavigationList<K, D>["display"]>;
+    'drillModeChanged': JetElementCustomEvent<ojNavigationList<K, D>["drillMode"]>;
+    'edgeChanged': JetElementCustomEvent<ojNavigationList<K, D>["edge"]>;
+    'expandedChanged': JetElementCustomEvent<ojNavigationList<K, D>["expanded"]>;
+    'hierarchyMenuThresholdChanged': JetElementCustomEvent<ojNavigationList<K, D>["hierarchyMenuThreshold"]>;
+    'itemChanged': JetElementCustomEvent<ojNavigationList<K, D>["item"]>;
+    'overflowChanged': JetElementCustomEvent<ojNavigationList<K, D>["overflow"]>;
+    'rootLabelChanged': JetElementCustomEvent<ojNavigationList<K, D>["rootLabel"]>;
+    'selectionChanged': JetElementCustomEvent<ojNavigationList<K, D>["selection"]>;
+}
+export interface ojNavigationListSettableProperties<K, D> extends baseComponentSettableProperties {
+    as: string;
+    currentItem: K;
+    data: DataProvider<K, D> | null;
+    display: 'all' | 'icons';
+    drillMode: 'none' | 'collapsible' | 'sliding';
+    edge: 'top' | 'start';
+    expanded: KeySet<K>;
+    hierarchyMenuThreshold: number;
+    item: {
+        renderer?: (((context: ojNavigationList.ItemContext<K, D>) => void) | null);
+        selectable?: (((context: ojNavigationList.ItemContext<K, D>) => boolean) | boolean);
+    };
+    overflow: 'popup' | 'hidden';
+    rootLabel: string | null;
+    selection: K;
+    translations: {
+        defaultRootLabel?: string;
+        hierMenuBtnLabel?: string;
+        previousIcon?: string;
+    };
+}
+export interface ojNavigationListSettablePropertiesLenient<K, D> extends Partial<ojNavigationListSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ojTabBar<K, D> extends baseComponent<ojTabBarSettableProperties<K, D>> {
+    as: string;
+    currentItem: any;
+    data: DataProvider<K, D> | null;
+    display: 'all' | 'icons';
+    edge: 'top' | 'bottom' | 'start' | 'end';
+    item: {
+        renderer?: (((context: ojTabBar.ItemContext<K, D>) => void) | null);
+        selectable?: (((context: ojTabBar.ItemContext<K, D>) => boolean) | boolean);
+    };
+    overflow: 'popup' | 'hidden';
+    reorderable: 'enabled' | 'disabled';
+    selection: any;
+    truncation: 'none' | 'progressive';
+    translations: {
+        accessibleReorderAfterItem?: string;
+        accessibleReorderBeforeItem?: string;
+        accessibleReorderTouchInstructionText?: string;
+        labelCut?: string;
+        labelPasteAfter?: string;
+        labelPasteBefore?: string;
+        labelRemove?: string;
+        msgFetchingData?: string;
+        msgNoData?: string;
+        overflowItemLabel?: string;
+        removeCueText?: string;
+        selectedLabel?: string;
+    };
+    onAsChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["as"]>) => any) | null;
+    onCurrentItemChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["currentItem"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["data"]>) => any) | null;
+    onDisplayChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["display"]>) => any) | null;
+    onEdgeChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["edge"]>) => any) | null;
+    onItemChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["item"]>) => any) | null;
+    onOverflowChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["overflow"]>) => any) | null;
+    onReorderableChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["reorderable"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["selection"]>) => any) | null;
+    onTruncationChanged: ((event: JetElementCustomEvent<ojTabBar<K, D>["truncation"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojTabBar.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojTabBar.ojAnimateStart) => any) | null;
+    onOjBeforeCurrentItem: ((event: ojTabBar.ojBeforeCurrentItem) => any) | null;
+    onOjBeforeDeselect: ((event: ojTabBar.ojBeforeDeselect) => any) | null;
+    onOjBeforeRemove: ((event: ojTabBar.ojBeforeRemove) => any) | null;
+    onOjBeforeSelect: ((event: ojTabBar.ojBeforeSelect) => any) | null;
+    onOjDeselect: ((event: ojTabBar.ojDeselect) => any) | null;
+    onOjRemove: ((event: ojTabBar.ojRemove) => any) | null;
+    onOjReorder: ((event: ojTabBar.ojReorder) => any) | null;
+    addEventListener<T extends keyof ojTabBarEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojTabBarEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTabBarSettableProperties<K, D>>(property: T): ojTabBar<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTabBarSettableProperties<K, D>>(property: T, value: ojTabBarSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTabBarSettableProperties<K, D>>): void;
+    setProperties(properties: ojTabBarSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojTabBar.NodeContext<K> | null;
+    refresh(): void;
+}
+export namespace ojTabBar {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeCurrentItem extends CustomEvent<{
+        previousKey: any;
+        previousItem: Element;
+        key: any;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeDeselect extends CustomEvent<{
+        fromKey: any;
+        fromItem: Element;
+        toKey: any;
+        toItem: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeRemove extends CustomEvent<{
+        item: Element;
+        key: any;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeSelect extends CustomEvent<{
+        key: any;
+        item: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojDeselect extends CustomEvent<{
+        fromKey: any;
+        fromItem: Element;
+        toKey: any;
+        toItem: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojRemove extends CustomEvent<{
+        item: Element;
+        key: any;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojReorder extends CustomEvent<{
+        item: Element;
+        position: 'before' | 'after';
+        reference: Element;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type ItemContext<K, D> = {
+        componentElement: Element;
+        datasource?: DataProvider<K, D>;
+        index: number;
+        key: K;
+        data: D;
+        parentElement: Element;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContext<K> = {
+        subId: string;
+        index: number;
+        key: K;
+    };
+}
+export interface ojTabBarEventMap<K, D> extends baseComponentEventMap<ojTabBarSettableProperties<K, D>> {
+    'ojAnimateEnd': ojTabBar.ojAnimateEnd;
+    'ojAnimateStart': ojTabBar.ojAnimateStart;
+    'ojBeforeCurrentItem': ojTabBar.ojBeforeCurrentItem;
+    'ojBeforeDeselect': ojTabBar.ojBeforeDeselect;
+    'ojBeforeRemove': ojTabBar.ojBeforeRemove;
+    'ojBeforeSelect': ojTabBar.ojBeforeSelect;
+    'ojDeselect': ojTabBar.ojDeselect;
+    'ojRemove': ojTabBar.ojRemove;
+    'ojReorder': ojTabBar.ojReorder;
+    'asChanged': JetElementCustomEvent<ojTabBar<K, D>["as"]>;
+    'currentItemChanged': JetElementCustomEvent<ojTabBar<K, D>["currentItem"]>;
+    'dataChanged': JetElementCustomEvent<ojTabBar<K, D>["data"]>;
+    'displayChanged': JetElementCustomEvent<ojTabBar<K, D>["display"]>;
+    'edgeChanged': JetElementCustomEvent<ojTabBar<K, D>["edge"]>;
+    'itemChanged': JetElementCustomEvent<ojTabBar<K, D>["item"]>;
+    'overflowChanged': JetElementCustomEvent<ojTabBar<K, D>["overflow"]>;
+    'reorderableChanged': JetElementCustomEvent<ojTabBar<K, D>["reorderable"]>;
+    'selectionChanged': JetElementCustomEvent<ojTabBar<K, D>["selection"]>;
+    'truncationChanged': JetElementCustomEvent<ojTabBar<K, D>["truncation"]>;
+}
+export interface ojTabBarSettableProperties<K, D> extends baseComponentSettableProperties {
+    as: string;
+    currentItem: any;
+    data: DataProvider<K, D> | null;
+    display: 'all' | 'icons';
+    edge: 'top' | 'bottom' | 'start' | 'end';
+    item: {
+        renderer?: (((context: ojTabBar.ItemContext<K, D>) => void) | null);
+        selectable?: (((context: ojTabBar.ItemContext<K, D>) => boolean) | boolean);
+    };
+    overflow: 'popup' | 'hidden';
+    reorderable: 'enabled' | 'disabled';
+    selection: any;
+    truncation: 'none' | 'progressive';
+    translations: {
+        accessibleReorderAfterItem?: string;
+        accessibleReorderBeforeItem?: string;
+        accessibleReorderTouchInstructionText?: string;
+        labelCut?: string;
+        labelPasteAfter?: string;
+        labelPasteBefore?: string;
+        labelRemove?: string;
+        msgFetchingData?: string;
+        msgNoData?: string;
+        overflowItemLabel?: string;
+        removeCueText?: string;
+        selectedLabel?: string;
+    };
+}
+export interface ojTabBarSettablePropertiesLenient<K, D> extends Partial<ojTabBarSettableProperties<K, D>> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojnbox/index.d.ts

@@ -0,0 +1,490 @@
+import { DataProvider } from '../ojdataprovider';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojNBox<K, D> extends dvtBaseComponent<ojNBoxSettableProperties<K, D>> {
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    as: string;
+    cellContent: 'counts' | 'auto';
+    cellMaximize: 'off' | 'on';
+    cells: Promise<ojNBox.Cell[]> | null;
+    columns: Promise<ojNBox.Column[]> | null;
+    columnsTitle: string;
+    countLabel: ((context: ojNBox.CountLabelContext) => (string | null));
+    data: DataProvider<K, D> | null;
+    groupAttributes: 'color' | 'indicatorColor' | 'indicatorIconColor' | 'indicatorIconPattern' | 'indicatorIconShape';
+    groupBehavior: 'acrossCells' | 'none' | 'withinCell';
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    labelTruncation: 'ifRequired' | 'on';
+    maximizedColumn: string;
+    maximizedRow: string;
+    otherColor: string;
+    otherThreshold: number;
+    rows: Promise<ojNBox.Row[]> | null;
+    rowsTitle: string;
+    selection: K[];
+    selectionMode: 'none' | 'single' | 'multiple';
+    styleDefaults: {
+        animationDuration: number;
+        cellDefaults: {
+            labelHalign: 'center' | 'end' | 'start';
+            labelStyle: object;
+            maximizedSvgStyle: object;
+            minimizedSvgStyle: object;
+            showCount: 'on' | 'off' | 'auto';
+            svgStyle: object;
+        };
+        columnLabelStyle: object;
+        columnsTitleStyle: object;
+        hoverBehaviorDelay: number;
+        nodeDefaults: {
+            borderColor: string;
+            borderWidth: number;
+            color: string;
+            iconDefaults: {
+                borderColor: string;
+                borderRadius: string;
+                borderWidth: number;
+                color: string;
+                height: number;
+                opacity: number;
+                pattern: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+                   'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+                shape: 'circle' | 'ellipse' | 'square' | 'plus' | 'diamond' | 'triangleUp' | 'triangleDown' | 'human' | 'rectangle' | 'star';
+                source: string;
+                width: number;
+            };
+            indicatorColor: string;
+            indicatorIconDefaults: {
+                borderColor: string;
+                borderRadius: string;
+                borderWidth: number;
+                color: string;
+                height: number;
+                opacity: number;
+                pattern: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+                   'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+                shape: 'circle' | 'ellipse' | 'square' | 'plus' | 'diamond' | 'triangleUp' | 'triangleDown' | 'human' | 'rectangle' | 'star';
+                source: string;
+                width: number;
+            };
+            labelStyle: object;
+            secondaryLabelStyle: object;
+        };
+        rowLabelStyle: object;
+        rowsTitleStyle: object;
+    };
+    tooltip: {
+        renderer: ((context: ojNBox.TooltipContext<K>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        })) | null;
+    };
+    touchResponse: 'touchStart' | 'auto';
+    translations: {
+        componentName?: string;
+        highlightedCount?: string;
+        labelAdditionalData?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelGroup?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        labelOther?: string;
+        labelSize?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    onAnimationOnDataChangeChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["animationOnDataChange"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["animationOnDisplay"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["as"]>) => any) | null;
+    onCellContentChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["cellContent"]>) => any) | null;
+    onCellMaximizeChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["cellMaximize"]>) => any) | null;
+    onCellsChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["cells"]>) => any) | null;
+    onColumnsChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["columns"]>) => any) | null;
+    onColumnsTitleChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["columnsTitle"]>) => any) | null;
+    onCountLabelChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["countLabel"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["data"]>) => any) | null;
+    onGroupAttributesChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["groupAttributes"]>) => any) | null;
+    onGroupBehaviorChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["groupBehavior"]>) => any) | null;
+    onHiddenCategoriesChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["hiddenCategories"]>) => any) | null;
+    onHighlightMatchChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["highlightMatch"]>) => any) | null;
+    onHighlightedCategoriesChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["highlightedCategories"]>) => any) | null;
+    onHoverBehaviorChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["hoverBehavior"]>) => any) | null;
+    onLabelTruncationChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["labelTruncation"]>) => any) | null;
+    onMaximizedColumnChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["maximizedColumn"]>) => any) | null;
+    onMaximizedRowChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["maximizedRow"]>) => any) | null;
+    onOtherColorChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["otherColor"]>) => any) | null;
+    onOtherThresholdChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["otherThreshold"]>) => any) | null;
+    onRowsChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["rows"]>) => any) | null;
+    onRowsTitleChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["rowsTitle"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["selectionMode"]>) => any) | null;
+    onStyleDefaultsChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["styleDefaults"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["tooltip"]>) => any) | null;
+    onTouchResponseChanged: ((event: JetElementCustomEvent<ojNBox<K, D>["touchResponse"]>) => any) | null;
+    addEventListener<T extends keyof ojNBoxEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojNBoxEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojNBoxSettableProperties<K, D>>(property: T): ojNBox<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojNBoxSettableProperties<K, D>>(property: T, value: ojNBoxSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojNBoxSettableProperties<K, D>>): void;
+    setProperties(properties: ojNBoxSettablePropertiesLenient<K, D>): void;
+    getCell(rowValue: string, columnValue: string): object | null;
+    getColumn(columnValue: string): object | null;
+    getColumnCount(): number;
+    getColumnsTitle(): string;
+    getContextByNode(node: Element): object | null;
+    getDialog(): object | null;
+    getGroupBehavior(): string;
+    getGroupNode(groupCategory: string): object | null;
+    getRow(rowValue: string): object | null;
+    getRowCount(): number;
+    getRowsTitle(): string;
+}
+export interface ojNBoxEventMap<K, D> extends dvtBaseComponentEventMap<ojNBoxSettableProperties<K, D>> {
+    'animationOnDataChangeChanged': JetElementCustomEvent<ojNBox<K, D>["animationOnDataChange"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojNBox<K, D>["animationOnDisplay"]>;
+    'asChanged': JetElementCustomEvent<ojNBox<K, D>["as"]>;
+    'cellContentChanged': JetElementCustomEvent<ojNBox<K, D>["cellContent"]>;
+    'cellMaximizeChanged': JetElementCustomEvent<ojNBox<K, D>["cellMaximize"]>;
+    'cellsChanged': JetElementCustomEvent<ojNBox<K, D>["cells"]>;
+    'columnsChanged': JetElementCustomEvent<ojNBox<K, D>["columns"]>;
+    'columnsTitleChanged': JetElementCustomEvent<ojNBox<K, D>["columnsTitle"]>;
+    'countLabelChanged': JetElementCustomEvent<ojNBox<K, D>["countLabel"]>;
+    'dataChanged': JetElementCustomEvent<ojNBox<K, D>["data"]>;
+    'groupAttributesChanged': JetElementCustomEvent<ojNBox<K, D>["groupAttributes"]>;
+    'groupBehaviorChanged': JetElementCustomEvent<ojNBox<K, D>["groupBehavior"]>;
+    'hiddenCategoriesChanged': JetElementCustomEvent<ojNBox<K, D>["hiddenCategories"]>;
+    'highlightMatchChanged': JetElementCustomEvent<ojNBox<K, D>["highlightMatch"]>;
+    'highlightedCategoriesChanged': JetElementCustomEvent<ojNBox<K, D>["highlightedCategories"]>;
+    'hoverBehaviorChanged': JetElementCustomEvent<ojNBox<K, D>["hoverBehavior"]>;
+    'labelTruncationChanged': JetElementCustomEvent<ojNBox<K, D>["labelTruncation"]>;
+    'maximizedColumnChanged': JetElementCustomEvent<ojNBox<K, D>["maximizedColumn"]>;
+    'maximizedRowChanged': JetElementCustomEvent<ojNBox<K, D>["maximizedRow"]>;
+    'otherColorChanged': JetElementCustomEvent<ojNBox<K, D>["otherColor"]>;
+    'otherThresholdChanged': JetElementCustomEvent<ojNBox<K, D>["otherThreshold"]>;
+    'rowsChanged': JetElementCustomEvent<ojNBox<K, D>["rows"]>;
+    'rowsTitleChanged': JetElementCustomEvent<ojNBox<K, D>["rowsTitle"]>;
+    'selectionChanged': JetElementCustomEvent<ojNBox<K, D>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojNBox<K, D>["selectionMode"]>;
+    'styleDefaultsChanged': JetElementCustomEvent<ojNBox<K, D>["styleDefaults"]>;
+    'tooltipChanged': JetElementCustomEvent<ojNBox<K, D>["tooltip"]>;
+    'touchResponseChanged': JetElementCustomEvent<ojNBox<K, D>["touchResponse"]>;
+}
+export interface ojNBoxSettableProperties<K, D> extends dvtBaseComponentSettableProperties {
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    as: string;
+    cellContent: 'counts' | 'auto';
+    cellMaximize: 'off' | 'on';
+    cells: ojNBox.Cell[] | Promise<ojNBox.Cell[]> | null;
+    columns: ojNBox.Column[] | Promise<ojNBox.Column[]> | null;
+    columnsTitle: string;
+    countLabel: ((context: ojNBox.CountLabelContext) => (string | null));
+    data: DataProvider<K, D> | null;
+    groupAttributes: 'color' | 'indicatorColor' | 'indicatorIconColor' | 'indicatorIconPattern' | 'indicatorIconShape';
+    groupBehavior: 'acrossCells' | 'none' | 'withinCell';
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    labelTruncation: 'ifRequired' | 'on';
+    maximizedColumn: string;
+    maximizedRow: string;
+    otherColor: string;
+    otherThreshold: number;
+    rows: ojNBox.Row[] | Promise<ojNBox.Row[]> | null;
+    rowsTitle: string;
+    selection: K[];
+    selectionMode: 'none' | 'single' | 'multiple';
+    styleDefaults: {
+        animationDuration: number;
+        cellDefaults: {
+            labelHalign: 'center' | 'end' | 'start';
+            labelStyle: object;
+            maximizedSvgStyle: object;
+            minimizedSvgStyle: object;
+            showCount: 'on' | 'off' | 'auto';
+            svgStyle: object;
+        };
+        columnLabelStyle: object;
+        columnsTitleStyle: object;
+        hoverBehaviorDelay: number;
+        nodeDefaults: {
+            borderColor: string;
+            borderWidth: number;
+            color: string;
+            iconDefaults: {
+                borderColor: string;
+                borderRadius: string;
+                borderWidth: number;
+                color: string;
+                height: number;
+                opacity: number;
+                pattern: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+                   'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+                shape: 'circle' | 'ellipse' | 'square' | 'plus' | 'diamond' | 'triangleUp' | 'triangleDown' | 'human' | 'rectangle' | 'star';
+                source: string;
+                width: number;
+            };
+            indicatorColor: string;
+            indicatorIconDefaults: {
+                borderColor: string;
+                borderRadius: string;
+                borderWidth: number;
+                color: string;
+                height: number;
+                opacity: number;
+                pattern: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+                   'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+                shape: 'circle' | 'ellipse' | 'square' | 'plus' | 'diamond' | 'triangleUp' | 'triangleDown' | 'human' | 'rectangle' | 'star';
+                source: string;
+                width: number;
+            };
+            labelStyle: object;
+            secondaryLabelStyle: object;
+        };
+        rowLabelStyle: object;
+        rowsTitleStyle: object;
+    };
+    tooltip: {
+        renderer: ((context: ojNBox.TooltipContext<K>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        })) | null;
+    };
+    touchResponse: 'touchStart' | 'auto';
+    translations: {
+        componentName?: string;
+        highlightedCount?: string;
+        labelAdditionalData?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelGroup?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        labelOther?: string;
+        labelSize?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface ojNBoxSettablePropertiesLenient<K, D> extends Partial<ojNBoxSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export namespace ojNBox {
+    // tslint:disable-next-line interface-over-type-literal
+    type Cell = {
+        label?: string;
+        column: string;
+        labelHalign?: string;
+        labelStyle?: object;
+        svgClassName?: string;
+        svgStyle?: object;
+        maximizedSvgStyle?: object;
+        maximizedSvgClassName?: string;
+        minimizedSvgStyle?: object;
+        minimizedSvgClassName?: string;
+        row: string;
+        showCount?: 'on' | 'off' | 'auto' | string;
+        shortDesc?: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type Column = {
+        id: string;
+        label?: string;
+        labelStyle?: object;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type CountLabelContext = {
+        row: string;
+        column: string;
+        nodeCount: number;
+        totalNodeCount: number;
+        highlightedNodeCount: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type Row = {
+        id: string;
+        label?: string;
+        labelStyle?: object;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext<K> = {
+        parentElement: Element;
+        id: K;
+        label: string;
+        secondaryLabel: string;
+        row: string;
+        column: string;
+        color: string;
+        indicatorColor: string;
+        componentElement: Element;
+    };
+}
+export interface ojNBoxNode extends JetElement<ojNBoxNodeSettableProperties> {
+    borderColor: string;
+    borderWidth: number;
+    categories: string[];
+    color?: string;
+    column: string;
+    groupCategory?: string;
+    icon?: {
+        borderColor?: string;
+        borderRadius?: string;
+        borderWidth: number;
+        color?: string;
+        height?: number | null;
+        opacity: number;
+        pattern?: 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' | 'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none' | 'mallChecker' | 'smallCrosshatch' |
+           'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle';
+        shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+        source?: string;
+        svgClassName: string;
+        svgStyle?: object;
+        width?: number | null;
+    };
+    indicatorColor?: string;
+    indicatorIcon?: {
+        borderColor?: string;
+        borderRadius?: string;
+        borderWidth: number;
+        color?: string;
+        height?: number | null;
+        opacity: number;
+        pattern?: 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' | 'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none' | 'smallChecker' | 'smallCrosshatch' |
+           'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle';
+        shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+        source?: string | null;
+        svgClassName: string;
+        svgStyle?: object | null;
+        width?: number | null;
+    };
+    label: string;
+    row: string;
+    secondaryLabel: string;
+    shortDesc: string;
+    svgClassName: string;
+    svgStyle: object | null;
+    xPercentage?: number | null;
+    yPercentage?: number | null;
+    onBorderColorChanged: ((event: JetElementCustomEvent<ojNBoxNode["borderColor"]>) => any) | null;
+    onBorderWidthChanged: ((event: JetElementCustomEvent<ojNBoxNode["borderWidth"]>) => any) | null;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojNBoxNode["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojNBoxNode["color"]>) => any) | null;
+    onColumnChanged: ((event: JetElementCustomEvent<ojNBoxNode["column"]>) => any) | null;
+    onGroupCategoryChanged: ((event: JetElementCustomEvent<ojNBoxNode["groupCategory"]>) => any) | null;
+    onIconChanged: ((event: JetElementCustomEvent<ojNBoxNode["icon"]>) => any) | null;
+    onIndicatorColorChanged: ((event: JetElementCustomEvent<ojNBoxNode["indicatorColor"]>) => any) | null;
+    onIndicatorIconChanged: ((event: JetElementCustomEvent<ojNBoxNode["indicatorIcon"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojNBoxNode["label"]>) => any) | null;
+    onRowChanged: ((event: JetElementCustomEvent<ojNBoxNode["row"]>) => any) | null;
+    onSecondaryLabelChanged: ((event: JetElementCustomEvent<ojNBoxNode["secondaryLabel"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojNBoxNode["shortDesc"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojNBoxNode["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojNBoxNode["svgStyle"]>) => any) | null;
+    onXPercentageChanged: ((event: JetElementCustomEvent<ojNBoxNode["xPercentage"]>) => any) | null;
+    onYPercentageChanged: ((event: JetElementCustomEvent<ojNBoxNode["yPercentage"]>) => any) | null;
+    addEventListener<T extends keyof ojNBoxNodeEventMap>(type: T, listener: (this: HTMLElement, ev: ojNBoxNodeEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojNBoxNodeSettableProperties>(property: T): ojNBoxNode[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojNBoxNodeSettableProperties>(property: T, value: ojNBoxNodeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojNBoxNodeSettableProperties>): void;
+    setProperties(properties: ojNBoxNodeSettablePropertiesLenient): void;
+}
+export interface ojNBoxNodeEventMap extends HTMLElementEventMap {
+    'borderColorChanged': JetElementCustomEvent<ojNBoxNode["borderColor"]>;
+    'borderWidthChanged': JetElementCustomEvent<ojNBoxNode["borderWidth"]>;
+    'categoriesChanged': JetElementCustomEvent<ojNBoxNode["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojNBoxNode["color"]>;
+    'columnChanged': JetElementCustomEvent<ojNBoxNode["column"]>;
+    'groupCategoryChanged': JetElementCustomEvent<ojNBoxNode["groupCategory"]>;
+    'iconChanged': JetElementCustomEvent<ojNBoxNode["icon"]>;
+    'indicatorColorChanged': JetElementCustomEvent<ojNBoxNode["indicatorColor"]>;
+    'indicatorIconChanged': JetElementCustomEvent<ojNBoxNode["indicatorIcon"]>;
+    'labelChanged': JetElementCustomEvent<ojNBoxNode["label"]>;
+    'rowChanged': JetElementCustomEvent<ojNBoxNode["row"]>;
+    'secondaryLabelChanged': JetElementCustomEvent<ojNBoxNode["secondaryLabel"]>;
+    'shortDescChanged': JetElementCustomEvent<ojNBoxNode["shortDesc"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojNBoxNode["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojNBoxNode["svgStyle"]>;
+    'xPercentageChanged': JetElementCustomEvent<ojNBoxNode["xPercentage"]>;
+    'yPercentageChanged': JetElementCustomEvent<ojNBoxNode["yPercentage"]>;
+}
+export interface ojNBoxNodeSettableProperties extends JetSettableProperties {
+    borderColor: string;
+    borderWidth: number;
+    categories: string[];
+    color?: string;
+    column: string;
+    groupCategory?: string;
+    icon?: {
+        borderColor?: string;
+        borderRadius?: string;
+        borderWidth: number;
+        color?: string;
+        height?: number | null;
+        opacity: number;
+        pattern?: 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' | 'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none' | 'mallChecker' | 'smallCrosshatch' |
+           'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle';
+        shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+        source?: string;
+        svgClassName: string;
+        svgStyle?: object;
+        width?: number | null;
+    };
+    indicatorColor?: string;
+    indicatorIcon?: {
+        borderColor?: string;
+        borderRadius?: string;
+        borderWidth: number;
+        color?: string;
+        height?: number | null;
+        opacity: number;
+        pattern?: 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' | 'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none' | 'smallChecker' | 'smallCrosshatch' |
+           'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle';
+        shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+        source?: string | null;
+        svgClassName: string;
+        svgStyle?: object | null;
+        width?: number | null;
+    };
+    label: string;
+    row: string;
+    secondaryLabel: string;
+    shortDesc: string;
+    svgClassName: string;
+    svgStyle: object | null;
+    xPercentage?: number | null;
+    yPercentage?: number | null;
+}
+export interface ojNBoxNodeSettablePropertiesLenient extends Partial<ojNBoxNodeSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojoptgroup/index.d.ts

@@ -0,0 +1,26 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojOptgroup extends JetElement<ojOptgroupSettableProperties> {
+    disabled: boolean;
+    label: string;
+    onDisabledChanged: ((event: JetElementCustomEvent<ojOptgroup["disabled"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojOptgroup["label"]>) => any) | null;
+    addEventListener<T extends keyof ojOptgroupEventMap>(type: T, listener: (this: HTMLElement, ev: ojOptgroupEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojOptgroupSettableProperties>(property: T): ojOptgroup[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojOptgroupSettableProperties>(property: T, value: ojOptgroupSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojOptgroupSettableProperties>): void;
+    setProperties(properties: ojOptgroupSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface ojOptgroupEventMap extends HTMLElementEventMap {
+    'disabledChanged': JetElementCustomEvent<ojOptgroup["disabled"]>;
+    'labelChanged': JetElementCustomEvent<ojOptgroup["label"]>;
+}
+export interface ojOptgroupSettableProperties extends JetSettableProperties {
+    disabled: boolean;
+    label: string;
+}
+export interface ojOptgroupSettablePropertiesLenient extends Partial<ojOptgroupSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojoption/index.d.ts

@@ -0,0 +1,26 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojOption extends JetElement<ojOptionSettableProperties> {
+    disabled: boolean;
+    value: any;
+    onDisabledChanged: ((event: JetElementCustomEvent<ojOption["disabled"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojOption["value"]>) => any) | null;
+    addEventListener<T extends keyof ojOptionEventMap>(type: T, listener: (this: HTMLElement, ev: ojOptionEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojOptionSettableProperties>(property: T): ojOption[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojOptionSettableProperties>(property: T, value: ojOptionSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojOptionSettableProperties>): void;
+    setProperties(properties: ojOptionSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface ojOptionEventMap extends HTMLElementEventMap {
+    'disabledChanged': JetElementCustomEvent<ojOption["disabled"]>;
+    'valueChanged': JetElementCustomEvent<ojOption["value"]>;
+}
+export interface ojOptionSettableProperties extends JetSettableProperties {
+    disabled: boolean;
+    value: any;
+}
+export interface ojOptionSettablePropertiesLenient extends Partial<ojOptionSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojpictochart/index.d.ts

@@ -0,0 +1,268 @@
+import { DataProvider } from '../ojdataprovider';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojPictoChart<K, D> extends dvtBaseComponent<ojPictoChartSettableProperties<K, D>> {
+    animationDuration?: number;
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'popIn' | 'alphaFade' | 'zoom' | 'none';
+    as: string;
+    columnCount: number | null;
+    columnWidth: number | null;
+    data: DataProvider<K, D> | null;
+    drilling: 'on' | 'off';
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverBehaviorDelay: number;
+    layout: 'vertical' | 'horizontal';
+    layoutOrigin: 'topEnd' | 'bottomStart' | 'bottomEnd' | 'topStart';
+    rowCount: number | null;
+    rowHeight: number | null;
+    selection: K[];
+    selectionMode: 'single' | 'multiple' | 'none';
+    tooltip: {
+        renderer: ((context: ojPictoChart.TooltipContext<K>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        })) | null;
+    };
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    onAnimationDurationChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["animationDuration"]>) => any) | null;
+    onAnimationOnDataChangeChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["animationOnDataChange"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["animationOnDisplay"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["as"]>) => any) | null;
+    onColumnCountChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["columnCount"]>) => any) | null;
+    onColumnWidthChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["columnWidth"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["data"]>) => any) | null;
+    onDrillingChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["drilling"]>) => any) | null;
+    onHiddenCategoriesChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["hiddenCategories"]>) => any) | null;
+    onHighlightMatchChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["highlightMatch"]>) => any) | null;
+    onHighlightedCategoriesChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["highlightedCategories"]>) => any) | null;
+    onHoverBehaviorChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["hoverBehavior"]>) => any) | null;
+    onHoverBehaviorDelayChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["hoverBehaviorDelay"]>) => any) | null;
+    onLayoutChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["layout"]>) => any) | null;
+    onLayoutOriginChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["layoutOrigin"]>) => any) | null;
+    onRowCountChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["rowCount"]>) => any) | null;
+    onRowHeightChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["rowHeight"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["selectionMode"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojPictoChart<K, D>["tooltip"]>) => any) | null;
+    onOjDrill: ((event: ojPictoChart.ojDrill) => any) | null;
+    addEventListener<T extends keyof ojPictoChartEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojPictoChartEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojPictoChartSettableProperties<K, D>>(property: T): ojPictoChart<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojPictoChartSettableProperties<K, D>>(property: T, value: ojPictoChartSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojPictoChartSettableProperties<K, D>>): void;
+    setProperties(properties: ojPictoChartSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojPictoChart.NodeContext | null;
+    getItem(index: number): ojPictoChart.ItemContext<K> | null;
+    getItemCount(): number;
+}
+export namespace ojPictoChart {
+    interface ojDrill extends CustomEvent<{
+        id: any;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type ItemContext<K> = {
+        color: string;
+        count: number;
+        id: K;
+        name: string;
+        selected: boolean;
+        tooltip: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContext = {
+        subId: string;
+        index: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext<K> = {
+        parentElement: Element;
+        id: K;
+        name: string;
+        count: number;
+        color: string;
+        componentElement: Element;
+    };
+}
+export interface ojPictoChartEventMap<K, D> extends dvtBaseComponentEventMap<ojPictoChartSettableProperties<K, D>> {
+    'ojDrill': ojPictoChart.ojDrill;
+    'animationDurationChanged': JetElementCustomEvent<ojPictoChart<K, D>["animationDuration"]>;
+    'animationOnDataChangeChanged': JetElementCustomEvent<ojPictoChart<K, D>["animationOnDataChange"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojPictoChart<K, D>["animationOnDisplay"]>;
+    'asChanged': JetElementCustomEvent<ojPictoChart<K, D>["as"]>;
+    'columnCountChanged': JetElementCustomEvent<ojPictoChart<K, D>["columnCount"]>;
+    'columnWidthChanged': JetElementCustomEvent<ojPictoChart<K, D>["columnWidth"]>;
+    'dataChanged': JetElementCustomEvent<ojPictoChart<K, D>["data"]>;
+    'drillingChanged': JetElementCustomEvent<ojPictoChart<K, D>["drilling"]>;
+    'hiddenCategoriesChanged': JetElementCustomEvent<ojPictoChart<K, D>["hiddenCategories"]>;
+    'highlightMatchChanged': JetElementCustomEvent<ojPictoChart<K, D>["highlightMatch"]>;
+    'highlightedCategoriesChanged': JetElementCustomEvent<ojPictoChart<K, D>["highlightedCategories"]>;
+    'hoverBehaviorChanged': JetElementCustomEvent<ojPictoChart<K, D>["hoverBehavior"]>;
+    'hoverBehaviorDelayChanged': JetElementCustomEvent<ojPictoChart<K, D>["hoverBehaviorDelay"]>;
+    'layoutChanged': JetElementCustomEvent<ojPictoChart<K, D>["layout"]>;
+    'layoutOriginChanged': JetElementCustomEvent<ojPictoChart<K, D>["layoutOrigin"]>;
+    'rowCountChanged': JetElementCustomEvent<ojPictoChart<K, D>["rowCount"]>;
+    'rowHeightChanged': JetElementCustomEvent<ojPictoChart<K, D>["rowHeight"]>;
+    'selectionChanged': JetElementCustomEvent<ojPictoChart<K, D>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojPictoChart<K, D>["selectionMode"]>;
+    'tooltipChanged': JetElementCustomEvent<ojPictoChart<K, D>["tooltip"]>;
+}
+export interface ojPictoChartSettableProperties<K, D> extends dvtBaseComponentSettableProperties {
+    animationDuration?: number;
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'popIn' | 'alphaFade' | 'zoom' | 'none';
+    as: string;
+    columnCount: number | null;
+    columnWidth: number | null;
+    data: DataProvider<K, D> | null;
+    drilling: 'on' | 'off';
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverBehaviorDelay: number;
+    layout: 'vertical' | 'horizontal';
+    layoutOrigin: 'topEnd' | 'bottomStart' | 'bottomEnd' | 'topStart';
+    rowCount: number | null;
+    rowHeight: number | null;
+    selection: K[];
+    selectionMode: 'single' | 'multiple' | 'none';
+    tooltip: {
+        renderer: ((context: ojPictoChart.TooltipContext<K>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        })) | null;
+    };
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface ojPictoChartSettablePropertiesLenient<K, D> extends Partial<ojPictoChartSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ojPictoChartItem extends JetElement<ojPictoChartItemSettableProperties> {
+    borderColor: string;
+    borderWidth: number;
+    categories: string[];
+    color: string;
+    columnSpan: number;
+    count: number;
+    drilling: 'inherit' | 'off' | 'on';
+    name: string;
+    rowSpan: number;
+    shape?: 'circle' | 'diamond' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | 'none' | string;
+    shortDesc: string;
+    source: string;
+    sourceHover: string;
+    sourceHoverSelected: string;
+    sourceSelected: string;
+    svgClassName: string;
+    svgStyle: object;
+    onBorderColorChanged: ((event: JetElementCustomEvent<ojPictoChartItem["borderColor"]>) => any) | null;
+    onBorderWidthChanged: ((event: JetElementCustomEvent<ojPictoChartItem["borderWidth"]>) => any) | null;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojPictoChartItem["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojPictoChartItem["color"]>) => any) | null;
+    onColumnSpanChanged: ((event: JetElementCustomEvent<ojPictoChartItem["columnSpan"]>) => any) | null;
+    onCountChanged: ((event: JetElementCustomEvent<ojPictoChartItem["count"]>) => any) | null;
+    onDrillingChanged: ((event: JetElementCustomEvent<ojPictoChartItem["drilling"]>) => any) | null;
+    onNameChanged: ((event: JetElementCustomEvent<ojPictoChartItem["name"]>) => any) | null;
+    onRowSpanChanged: ((event: JetElementCustomEvent<ojPictoChartItem["rowSpan"]>) => any) | null;
+    onShapeChanged: ((event: JetElementCustomEvent<ojPictoChartItem["shape"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojPictoChartItem["shortDesc"]>) => any) | null;
+    onSourceChanged: ((event: JetElementCustomEvent<ojPictoChartItem["source"]>) => any) | null;
+    onSourceHoverChanged: ((event: JetElementCustomEvent<ojPictoChartItem["sourceHover"]>) => any) | null;
+    onSourceHoverSelectedChanged: ((event: JetElementCustomEvent<ojPictoChartItem["sourceHoverSelected"]>) => any) | null;
+    onSourceSelectedChanged: ((event: JetElementCustomEvent<ojPictoChartItem["sourceSelected"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojPictoChartItem["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojPictoChartItem["svgStyle"]>) => any) | null;
+    addEventListener<T extends keyof ojPictoChartItemEventMap>(type: T, listener: (this: HTMLElement, ev: ojPictoChartItemEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojPictoChartItemSettableProperties>(property: T): ojPictoChartItem[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojPictoChartItemSettableProperties>(property: T, value: ojPictoChartItemSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojPictoChartItemSettableProperties>): void;
+    setProperties(properties: ojPictoChartItemSettablePropertiesLenient): void;
+}
+export interface ojPictoChartItemEventMap extends HTMLElementEventMap {
+    'borderColorChanged': JetElementCustomEvent<ojPictoChartItem["borderColor"]>;
+    'borderWidthChanged': JetElementCustomEvent<ojPictoChartItem["borderWidth"]>;
+    'categoriesChanged': JetElementCustomEvent<ojPictoChartItem["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojPictoChartItem["color"]>;
+    'columnSpanChanged': JetElementCustomEvent<ojPictoChartItem["columnSpan"]>;
+    'countChanged': JetElementCustomEvent<ojPictoChartItem["count"]>;
+    'drillingChanged': JetElementCustomEvent<ojPictoChartItem["drilling"]>;
+    'nameChanged': JetElementCustomEvent<ojPictoChartItem["name"]>;
+    'rowSpanChanged': JetElementCustomEvent<ojPictoChartItem["rowSpan"]>;
+    'shapeChanged': JetElementCustomEvent<ojPictoChartItem["shape"]>;
+    'shortDescChanged': JetElementCustomEvent<ojPictoChartItem["shortDesc"]>;
+    'sourceChanged': JetElementCustomEvent<ojPictoChartItem["source"]>;
+    'sourceHoverChanged': JetElementCustomEvent<ojPictoChartItem["sourceHover"]>;
+    'sourceHoverSelectedChanged': JetElementCustomEvent<ojPictoChartItem["sourceHoverSelected"]>;
+    'sourceSelectedChanged': JetElementCustomEvent<ojPictoChartItem["sourceSelected"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojPictoChartItem["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojPictoChartItem["svgStyle"]>;
+}
+export interface ojPictoChartItemSettableProperties extends JetSettableProperties {
+    borderColor: string;
+    borderWidth: number;
+    categories: string[];
+    color: string;
+    columnSpan: number;
+    count: number;
+    drilling: 'inherit' | 'off' | 'on';
+    name: string;
+    rowSpan: number;
+    shape?: 'circle' | 'diamond' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | 'none' | string;
+    shortDesc: string;
+    source: string;
+    sourceHover: string;
+    sourceHoverSelected: string;
+    sourceSelected: string;
+    svgClassName: string;
+    svgStyle: object;
+}
+export interface ojPictoChartItemSettablePropertiesLenient extends Partial<ojPictoChartItemSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojpopup/index.d.ts

@@ -0,0 +1,128 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojPopup extends baseComponent<ojPopupSettableProperties> {
+    autoDismiss: 'none' | 'focusLoss';
+    chrome: 'default' | 'none';
+    initialFocus: 'auto' | 'none' | 'firstFocusable' | 'popup';
+    modality: 'modeless' | 'modal';
+    position: ojPopup.Position;
+    tail: 'none' | 'simple';
+    translations: {
+        ariaCloseSkipLink?: string;
+        ariaFocusSkipLink?: string;
+        ariaLiveRegionInitialFocusFirstFocusable?: string;
+        ariaLiveRegionInitialFocusFirstFocusableTouch?: string;
+        ariaLiveRegionInitialFocusNone?: string;
+        ariaLiveRegionInitialFocusNoneTouch?: string;
+    };
+    onAutoDismissChanged: ((event: JetElementCustomEvent<ojPopup["autoDismiss"]>) => any) | null;
+    onChromeChanged: ((event: JetElementCustomEvent<ojPopup["chrome"]>) => any) | null;
+    onInitialFocusChanged: ((event: JetElementCustomEvent<ojPopup["initialFocus"]>) => any) | null;
+    onModalityChanged: ((event: JetElementCustomEvent<ojPopup["modality"]>) => any) | null;
+    onPositionChanged: ((event: JetElementCustomEvent<ojPopup["position"]>) => any) | null;
+    onTailChanged: ((event: JetElementCustomEvent<ojPopup["tail"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojPopup.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojPopup.ojAnimateStart) => any) | null;
+    onOjBeforeClose: ((event: ojPopup.ojBeforeClose) => any) | null;
+    onOjBeforeOpen: ((event: ojPopup.ojBeforeOpen) => any) | null;
+    onOjClose: ((event: ojPopup.ojClose) => any) | null;
+    onOjFocus: ((event: ojPopup.ojFocus) => any) | null;
+    onOjOpen: ((event: ojPopup.ojOpen) => any) | null;
+    addEventListener<T extends keyof ojPopupEventMap>(type: T, listener: (this: HTMLElement, ev: ojPopupEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojPopupSettableProperties>(property: T): ojPopup[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojPopupSettableProperties>(property: T, value: ojPopupSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojPopupSettableProperties>): void;
+    setProperties(properties: ojPopupSettablePropertiesLenient): void;
+    close(): void;
+    isOpen(): boolean;
+    open(launcher: string | Element, position?: ojPopup.Position): void;
+    refresh(): void;
+}
+export namespace ojPopup {
+    interface ojAnimateEnd extends CustomEvent<{
+        element: Element;
+        action: 'open' | 'close';
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: 'open' | 'close';
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeClose extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeOpen extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+    interface ojClose extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+    interface ojFocus extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+    interface ojOpen extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type Position = {
+        my?: PositionAlign;
+        at?: PositionAlign;
+        offset?: PositionPoint;
+        of?: string | PositionPoint;
+        collision?: 'flip' | 'fit' | 'flipfit' | 'flipcenter' | 'none';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PositionAlign = {
+        vertical?: 'top' | 'bottom' | 'center';
+        horizontal?: 'start' | 'end' | 'left' | 'center' | 'bottom';
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type PositionPoint = {
+        x?: number;
+        y?: number;
+    };
+}
+export interface ojPopupEventMap extends baseComponentEventMap<ojPopupSettableProperties> {
+    'ojAnimateEnd': ojPopup.ojAnimateEnd;
+    'ojAnimateStart': ojPopup.ojAnimateStart;
+    'ojBeforeClose': ojPopup.ojBeforeClose;
+    'ojBeforeOpen': ojPopup.ojBeforeOpen;
+    'ojClose': ojPopup.ojClose;
+    'ojFocus': ojPopup.ojFocus;
+    'ojOpen': ojPopup.ojOpen;
+    'autoDismissChanged': JetElementCustomEvent<ojPopup["autoDismiss"]>;
+    'chromeChanged': JetElementCustomEvent<ojPopup["chrome"]>;
+    'initialFocusChanged': JetElementCustomEvent<ojPopup["initialFocus"]>;
+    'modalityChanged': JetElementCustomEvent<ojPopup["modality"]>;
+    'positionChanged': JetElementCustomEvent<ojPopup["position"]>;
+    'tailChanged': JetElementCustomEvent<ojPopup["tail"]>;
+}
+export interface ojPopupSettableProperties extends baseComponentSettableProperties {
+    autoDismiss: 'none' | 'focusLoss';
+    chrome: 'default' | 'none';
+    initialFocus: 'auto' | 'none' | 'firstFocusable' | 'popup';
+    modality: 'modeless' | 'modal';
+    position: ojPopup.Position;
+    tail: 'none' | 'simple';
+    translations: {
+        ariaCloseSkipLink?: string;
+        ariaFocusSkipLink?: string;
+        ariaLiveRegionInitialFocusFirstFocusable?: string;
+        ariaLiveRegionInitialFocusFirstFocusableTouch?: string;
+        ariaLiveRegionInitialFocusNone?: string;
+        ariaLiveRegionInitialFocusNoneTouch?: string;
+    };
+}
+export interface ojPopupSettablePropertiesLenient extends Partial<ojPopupSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojprogress/index.d.ts

@@ -0,0 +1,35 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojProgress extends baseComponent<ojProgressSettableProperties> {
+    max: number;
+    type: 'bar' | 'circle';
+    value: number;
+    translations: {
+        ariaIndeterminateProgressText?: string;
+    };
+    onMaxChanged: ((event: JetElementCustomEvent<ojProgress["max"]>) => any) | null;
+    onTypeChanged: ((event: JetElementCustomEvent<ojProgress["type"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojProgress["value"]>) => any) | null;
+    addEventListener<T extends keyof ojProgressEventMap>(type: T, listener: (this: HTMLElement, ev: ojProgressEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojProgressSettableProperties>(property: T): ojProgress[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojProgressSettableProperties>(property: T, value: ojProgressSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojProgressSettableProperties>): void;
+    setProperties(properties: ojProgressSettablePropertiesLenient): void;
+}
+export interface ojProgressEventMap extends baseComponentEventMap<ojProgressSettableProperties> {
+    'maxChanged': JetElementCustomEvent<ojProgress["max"]>;
+    'typeChanged': JetElementCustomEvent<ojProgress["type"]>;
+    'valueChanged': JetElementCustomEvent<ojProgress["value"]>;
+}
+export interface ojProgressSettableProperties extends baseComponentSettableProperties {
+    max: number;
+    type: 'bar' | 'circle';
+    value: number;
+    translations: {
+        ariaIndeterminateProgressText?: string;
+    };
+}
+export interface ojProgressSettablePropertiesLenient extends Partial<ojProgressSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojprogresslist/index.d.ts

@@ -0,0 +1,30 @@
+import { DataProvider } from '../ojdataprovider';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojProgressList extends JetElement<ojProgressListSettableProperties> {
+    data: DataProvider<any, any> | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojProgressList["data"]>) => any) | null;
+    addEventListener<T extends keyof ojProgressListEventMap>(type: T, listener: (this: HTMLElement, ev: ojProgressListEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojProgressListSettableProperties>(property: T): ojProgressList[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojProgressListSettableProperties>(property: T, value: ojProgressListSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojProgressListSettableProperties>): void;
+    setProperties(properties: ojProgressListSettablePropertiesLenient): void;
+}
+export interface ojProgressListEventMap extends HTMLElementEventMap {
+    'dataChanged': JetElementCustomEvent<ojProgressList["data"]>;
+}
+export interface ojProgressListSettableProperties extends JetSettableProperties {
+    data: DataProvider<any, any> | null;
+}
+export interface ojProgressListSettablePropertiesLenient extends Partial<ojProgressListSettableProperties> {
+    [key: string]: any;
+}
+export interface ProgressItem {
+    addEventListener(eventType: ProgressItem.EventType, listener: EventListener): void;
+    removeEventListener(eventType: ProgressItem.EventType, listener: EventListener): void;
+}
+export namespace ProgressItem {
+    type EventType = "loadstart" | "progress" | "abort" | "error" | "load" | "timeout" | "loadend";
+    type Status = "queued" | "loadstarted" | "aborted" | "errored" | "timedout" | "loaded";
+}

types/oracle__oraclejet/ojpulltorefresh/index.d.ts

@@ -0,0 +1,6 @@
+export function setupPullToRefresh(element: Element, refreshFunc: (() => Promise<any>), options?: {
+    threshold?: number;
+    primaryText?: string;
+    secondaryText?: string;
+}): void;
+export function tearDownPullToRefresh(element: Element): void;

types/oracle__oraclejet/ojradioset/index.d.ts

@@ -0,0 +1,69 @@
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojRadioset extends editableValue<any, ojRadiosetSettableProperties> {
+    disabled: boolean;
+    labelledBy: string | null;
+    required: boolean;
+    value: any;
+    translations: {
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+    onDisabledChanged: ((event: JetElementCustomEvent<ojRadioset["disabled"]>) => any) | null;
+    onLabelledByChanged: ((event: JetElementCustomEvent<ojRadioset["labelledBy"]>) => any) | null;
+    onRequiredChanged: ((event: JetElementCustomEvent<ojRadioset["required"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojRadioset["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojRadioset.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojRadioset.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojRadiosetEventMap>(type: T, listener: (this: HTMLElement, ev: ojRadiosetEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojRadiosetSettableProperties>(property: T): ojRadioset[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojRadiosetSettableProperties>(property: T, value: ojRadiosetSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojRadiosetSettableProperties>): void;
+    setProperties(properties: ojRadiosetSettablePropertiesLenient): void;
+    refresh(): void;
+    validate(): Promise<string>;
+}
+export namespace ojRadioset {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojRadiosetEventMap extends editableValueEventMap<any, ojRadiosetSettableProperties> {
+    'ojAnimateEnd': ojRadioset.ojAnimateEnd;
+    'ojAnimateStart': ojRadioset.ojAnimateStart;
+    'disabledChanged': JetElementCustomEvent<ojRadioset["disabled"]>;
+    'labelledByChanged': JetElementCustomEvent<ojRadioset["labelledBy"]>;
+    'requiredChanged': JetElementCustomEvent<ojRadioset["required"]>;
+    'valueChanged': JetElementCustomEvent<ojRadioset["value"]>;
+}
+export interface ojRadiosetSettableProperties extends editableValueSettableProperties<any> {
+    disabled: boolean;
+    labelledBy: string | null;
+    required: boolean;
+    value: any;
+    translations: {
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+}
+export interface ojRadiosetSettablePropertiesLenient extends Partial<ojRadiosetSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojrefresher/index.d.ts

@@ -0,0 +1,33 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojRefresher extends baseComponent<ojRefresherSettableProperties> {
+    refreshContent: (() => Promise<any>);
+    target: Element;
+    text: string;
+    threshold: number;
+    onRefreshContentChanged: ((event: JetElementCustomEvent<ojRefresher["refreshContent"]>) => any) | null;
+    onTargetChanged: ((event: JetElementCustomEvent<ojRefresher["target"]>) => any) | null;
+    onTextChanged: ((event: JetElementCustomEvent<ojRefresher["text"]>) => any) | null;
+    onThresholdChanged: ((event: JetElementCustomEvent<ojRefresher["threshold"]>) => any) | null;
+    addEventListener<T extends keyof ojRefresherEventMap>(type: T, listener: (this: HTMLElement, ev: ojRefresherEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojRefresherSettableProperties>(property: T): ojRefresher[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojRefresherSettableProperties>(property: T, value: ojRefresherSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojRefresherSettableProperties>): void;
+    setProperties(properties: ojRefresherSettablePropertiesLenient): void;
+}
+export interface ojRefresherEventMap extends baseComponentEventMap<ojRefresherSettableProperties> {
+    'refreshContentChanged': JetElementCustomEvent<ojRefresher["refreshContent"]>;
+    'targetChanged': JetElementCustomEvent<ojRefresher["target"]>;
+    'textChanged': JetElementCustomEvent<ojRefresher["text"]>;
+    'thresholdChanged': JetElementCustomEvent<ojRefresher["threshold"]>;
+}
+export interface ojRefresherSettableProperties extends baseComponentSettableProperties {
+    refreshContent: (() => Promise<any>);
+    target: Element;
+    text: string;
+    threshold: number;
+}
+export interface ojRefresherSettablePropertiesLenient extends Partial<ojRefresherSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojresponsiveknockoututils/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types='knockout'/>
+/// <reference types="knockout" />
+export function createMediaQueryObservable(queryString: string): KnockoutObservable<boolean>;
+export function createScreenRangeObservable(): KnockoutObservable<string>;

types/oracle__oraclejet/ojresponsiveutils/index.d.ts

@@ -0,0 +1,4 @@
+export function compare(size1: SCREEN_RANGE, size2: SCREEN_RANGE): number;
+export function getFrameworkQuery(frameworkQueryKey: FRAMEWORK_QUERY_KEY): string | null;
+export type FRAMEWORK_QUERY_KEY = "sm-up" | "md-up" | "lg-up" | "xl-up" | "xxl-up" | "sm-only" | "md-only" | "lg-only" | "xl-only" | "md-down" | "lg-down" | "xl-down" | "high-resolution";
+export type SCREEN_RANGE = "sm" | "md" | "lg" | "xl" | "xxl";

types/oracle__oraclejet/ojrouter/index.d.ts

@@ -0,0 +1,131 @@
+/// <reference types="knockout" />
+/// <reference types='knockout'/>
+declare class Router {
+    readonly currentState: (() => RouterState | undefined);
+    readonly currentValue: (() => string | undefined);
+    defaultStateId: string | undefined;
+    static defaults: {
+        urlAdapter?: Router.urlPathAdapter | Router.urlParamAdapter;
+        baseUrl?: string;
+        rootInstanceName?: string;
+    };
+    readonly direction: string | undefined;
+    readonly moduleConfig: {
+        name: KnockoutObservable<string>;
+        params: {
+            ojRouter: {
+                parentRouter: Router;
+                direction: string;
+            };
+        };
+        lifecycleListener: {
+            attached: ((param0: string) => void);
+        };
+    };
+    readonly name: string;
+    readonly observableModuleConfig: KnockoutObservable<Router.ModuleConfigType>;
+    readonly parent: Router | undefined;
+    static readonly rootInstance: Router;
+    readonly stateId: ((param0?: string) => string);
+    readonly states: RouterState[] | null;
+    static readonly transitionedToState: object;
+    static sync(): Promise<{
+        hasChanged: boolean;
+    }>;
+    configure(option: {
+        [key: string]: RouterState.ConfigOptions;
+    } | ((id: string) => RouterState | undefined | null)): any;
+    createChildRouter(name: string, parentStateId?: string): Router;
+    dispose(): undefined;
+    getChildRouter(name: string): Router | undefined;
+    getCurrentChildRouter(): Router | undefined;
+    getState(stateId: string): RouterState | undefined;
+    go(stateIdPath?: string | string[], options?: {
+        historyUpdate: string;
+    }): Promise<{
+        hasChanged: boolean;
+    }>;
+    retrieve(): any;
+    store(data: object): undefined;
+}
+declare namespace Router {
+    // tslint:disable-next-line interface-over-type-literal
+    type ModuleConfigType = {
+        name: KnockoutObservable<string>;
+        params: {
+            ojRouter: {
+                parentRouter: Router;
+                direction: string;
+                parameters: object;
+            };
+        };
+        lifecycleListener: {
+            attached: ((param0: object) => void);
+        };
+    };
+    // tslint:disable-next-line no-unnecessary-class
+    class urlParamAdapter {
+        constructor();
+    }
+    // tslint:disable-next-line no-unnecessary-class
+    class urlPathAdapter {
+        constructor();
+    }
+    interface RouterState {
+        canEnter: (() => boolean) | (() => Promise<boolean>);
+        canExit: (() => boolean) | (() => Promise<boolean>);
+        enter: (() => void) | (() => Promise<void>);
+        exit: (() => void) | (() => Promise<void>);
+        readonly id: string;
+        label: string | undefined;
+        parameters: object;
+        title: string | (() => string | undefined);
+        value: any;
+        // constructor(id: string, options?: RouterState.ConfigOptions, router?: Router);
+        go(): Promise<{
+            hasChanged: boolean;
+        }>;
+        isCurrent(): boolean;
+    }
+    namespace RouterState {
+        // tslint:disable-next-line interface-over-type-literal
+        type ConfigOptions = {
+            label?: string;
+            value?: any;
+            isDefault?: boolean;
+            canEnter?: (() => boolean) | (() => Promise<boolean>);
+            enter?: (() => void) | (() => Promise<void>);
+            canExit?: (() => boolean) | (() => Promise<boolean>);
+            exit?: (() => void) | (() => Promise<void>);
+        };
+    }
+}
+export = Router;
+declare class RouterState {
+    canEnter: (() => boolean) | (() => Promise<boolean>);
+    canExit: (() => boolean) | (() => Promise<boolean>);
+    enter: (() => void) | (() => Promise<void>);
+    exit: (() => void) | (() => Promise<void>);
+    readonly id: string;
+    label: string | undefined;
+    parameters: object;
+    title: string | (() => string | undefined);
+    value: any;
+    constructor(id: string, options?: RouterState.ConfigOptions, router?: Router);
+    go(): Promise<{
+        hasChanged: boolean;
+    }>;
+    isCurrent(): boolean;
+}
+declare namespace RouterState {
+    // tslint:disable-next-line interface-over-type-literal
+    type ConfigOptions = {
+        label?: string;
+        value?: any;
+        isDefault?: boolean;
+        canEnter?: (() => boolean) | (() => Promise<boolean>);
+        enter?: (() => void) | (() => Promise<void>);
+        canExit?: (() => boolean) | (() => Promise<boolean>);
+        exit?: (() => void) | (() => Promise<void>);
+    };
+}

types/oracle__oraclejet/ojselectcombobox/index.d.ts

@@ -0,0 +1,714 @@
+import { Converter, Validator, Validation, AsyncValidator } from '../ojvalidation-base';
+import { DataProvider } from '../ojdataprovider';
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojCombobox<V, SP extends ojComboboxSettableProperties<V, SV, RV>, SV = V, RV = V> extends editableValue<V, SP, SV, RV> {
+    onOjAnimateEnd: ((event: ojCombobox.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojCombobox.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojComboboxEventMap<V, SP, SV, RV>>(type: T, listener: (this: HTMLElement, ev: ojComboboxEventMap<V, SP, SV, RV>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojComboboxSettableProperties<V, SV, RV>>(property: T): ojCombobox<V, SP, SV, RV>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojComboboxSettableProperties<V, SV, RV>>(property: T, value: ojComboboxSettableProperties<V, SV, RV>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojComboboxSettableProperties<V, SV, RV>>): void;
+    setProperties(properties: ojComboboxSettablePropertiesLenient<V, SV, RV>): void;
+    refresh(): void;
+    validate(): Promise<any>;
+}
+export namespace ojCombobox {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type Optgroup = {
+        disabled?: boolean;
+        label: string;
+        children: Array<(Option | Optgroup)>;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type Option = {
+        disabled?: boolean;
+        label?: string;
+        value: any;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type OptionContext = {
+        component: Element;
+        parent: Element;
+        index: number;
+        depth: number;
+        leaf: boolean;
+        data: object;
+        parentElement: Element;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type OptionsKeys = {
+        label?: string;
+        value?: string;
+        children?: string;
+        childKeys?: OptionsKeys;
+    };
+}
+export interface ojComboboxEventMap<V, SP extends ojComboboxSettableProperties<V, SV, RV>, SV = V, RV = V> extends editableValueEventMap<V, SP, SV, RV> {
+    'ojAnimateEnd': ojCombobox.ojAnimateEnd;
+    'ojAnimateStart': ojCombobox.ojAnimateStart;
+}
+// These interfaces are empty but required to keep the component chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface ojComboboxSettableProperties<V, SV = V, RV = V> extends editableValueSettableProperties<V, SV, RV> {
+}
+export interface ojComboboxSettablePropertiesLenient<V, SV, RV> extends Partial<ojComboboxSettableProperties<V, SV, RV>> {
+    [key: string]: any;
+}
+export interface ojComboboxMany<K, D> extends ojCombobox<any[] | null, ojComboboxManySettableProperties<K, D>, any[] | null, string> {
+    asyncValidators: Array<AsyncValidator<any[]>>;
+    converter: Converter<any> | Validation.RegisteredConverter | null;
+    minLength: number;
+    optionRenderer?: ((param0: ojCombobox.OptionContext) => {
+        insert: Element;
+    } | undefined) | null;
+    options: Array<ojCombobox.Option | ojCombobox.Optgroup> | DataProvider<K, D> | null;
+    optionsKeys: {
+        childKeys: {
+            label?: string;
+            value?: string;
+            children?: string;
+            childKeys?: ojCombobox.OptionsKeys;
+        };
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    placeholder: string | null;
+    readonly rawValue: string | null;
+    required: boolean;
+    validators: Array<Validator<any[]> | Validation.RegisteredValidator> | null;
+    value: any[] | null;
+    valueOptions: Array<{
+        value: any;
+        label?: string;
+    }> | null;
+    translations: {
+        filterFurther?: string;
+        noMatchesFound?: string;
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+    onAsyncValidatorsChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["asyncValidators"]>) => any) | null;
+    onConverterChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["converter"]>) => any) | null;
+    onMinLengthChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["minLength"]>) => any) | null;
+    onOptionRendererChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["optionRenderer"]>) => any) | null;
+    onOptionsChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["options"]>) => any) | null;
+    onOptionsKeysChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["optionsKeys"]>) => any) | null;
+    onPickerAttributesChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["pickerAttributes"]>) => any) | null;
+    onPlaceholderChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["placeholder"]>) => any) | null;
+    onRawValueChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["rawValue"]>) => any) | null;
+    onRequiredChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["required"]>) => any) | null;
+    onValidatorsChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["validators"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["value"]>) => any) | null;
+    onValueOptionsChanged: ((event: JetElementCustomEvent<ojComboboxMany<K, D>["valueOptions"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojComboboxMany.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojComboboxMany.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojComboboxManyEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojComboboxManyEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojComboboxManySettableProperties<K, D>>(property: T): ojComboboxMany<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojComboboxManySettableProperties<K, D>>(property: T, value: ojComboboxManySettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojComboboxManySettableProperties<K, D>>): void;
+    setProperties(properties: ojComboboxManySettablePropertiesLenient<K, D>): void;
+}
+export namespace ojComboboxMany {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojComboboxManyEventMap<K, D> extends ojComboboxEventMap<any[] | null, ojComboboxManySettableProperties<K, D>, any[] | null, string> {
+    'ojAnimateEnd': ojComboboxMany.ojAnimateEnd;
+    'ojAnimateStart': ojComboboxMany.ojAnimateStart;
+    'asyncValidatorsChanged': JetElementCustomEvent<ojComboboxMany<K, D>["asyncValidators"]>;
+    'converterChanged': JetElementCustomEvent<ojComboboxMany<K, D>["converter"]>;
+    'minLengthChanged': JetElementCustomEvent<ojComboboxMany<K, D>["minLength"]>;
+    'optionRendererChanged': JetElementCustomEvent<ojComboboxMany<K, D>["optionRenderer"]>;
+    'optionsChanged': JetElementCustomEvent<ojComboboxMany<K, D>["options"]>;
+    'optionsKeysChanged': JetElementCustomEvent<ojComboboxMany<K, D>["optionsKeys"]>;
+    'pickerAttributesChanged': JetElementCustomEvent<ojComboboxMany<K, D>["pickerAttributes"]>;
+    'placeholderChanged': JetElementCustomEvent<ojComboboxMany<K, D>["placeholder"]>;
+    'rawValueChanged': JetElementCustomEvent<ojComboboxMany<K, D>["rawValue"]>;
+    'requiredChanged': JetElementCustomEvent<ojComboboxMany<K, D>["required"]>;
+    'validatorsChanged': JetElementCustomEvent<ojComboboxMany<K, D>["validators"]>;
+    'valueChanged': JetElementCustomEvent<ojComboboxMany<K, D>["value"]>;
+    'valueOptionsChanged': JetElementCustomEvent<ojComboboxMany<K, D>["valueOptions"]>;
+}
+export interface ojComboboxManySettableProperties<K, D> extends ojComboboxSettableProperties<any[] | null, any[] | null, string> {
+    asyncValidators: Array<AsyncValidator<any[]>>;
+    converter: Converter<any> | Validation.RegisteredConverter | null;
+    minLength: number;
+    optionRenderer?: ((param0: ojCombobox.OptionContext) => {
+        insert: Element;
+    } | undefined) | null;
+    options: Array<ojCombobox.Option | ojCombobox.Optgroup> | DataProvider<K, D> | null;
+    optionsKeys: {
+        childKeys: {
+            label?: string;
+            value?: string;
+            children?: string;
+            childKeys?: ojCombobox.OptionsKeys;
+        };
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    placeholder: string | null;
+    readonly rawValue: string | null;
+    required: boolean;
+    validators: Array<Validator<any[]> | Validation.RegisteredValidator> | null;
+    value: any[] | null;
+    valueOptions: Array<{
+        value: any;
+        label?: string;
+    }> | null;
+    translations: {
+        filterFurther?: string;
+        noMatchesFound?: string;
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+}
+export interface ojComboboxManySettablePropertiesLenient<K, D> extends Partial<ojComboboxManySettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ojComboboxOne<K, D> extends ojCombobox<any, ojComboboxOneSettableProperties<K, D>, any, string> {
+    asyncValidators: Array<AsyncValidator<any>>;
+    converter: Converter<any> | Validation.RegisteredConverter | null;
+    filterOnOpen: 'none' | 'rawValue';
+    minLength: number;
+    optionRenderer?: ((param0: ojCombobox.OptionContext) => {
+        insert: Element;
+    } | undefined) | null;
+    options: Array<ojCombobox.Option | ojCombobox.Optgroup> | DataProvider<K, D> | null;
+    optionsKeys: {
+        childKeys: {
+            label?: string;
+            value?: string;
+            children?: string;
+            childKeys?: ojCombobox.OptionsKeys;
+        };
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    placeholder: string | null;
+    readonly rawValue: string | null;
+    required: boolean;
+    validators: Array<Validator<any> | Validation.RegisteredValidator> | null;
+    value: any;
+    valueOption: {
+        value: any;
+        label?: string;
+    };
+    translations: {
+        filterFurther?: string;
+        noMatchesFound?: string;
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+    onAsyncValidatorsChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["asyncValidators"]>) => any) | null;
+    onConverterChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["converter"]>) => any) | null;
+    onFilterOnOpenChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["filterOnOpen"]>) => any) | null;
+    onMinLengthChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["minLength"]>) => any) | null;
+    onOptionRendererChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["optionRenderer"]>) => any) | null;
+    onOptionsChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["options"]>) => any) | null;
+    onOptionsKeysChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["optionsKeys"]>) => any) | null;
+    onPickerAttributesChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["pickerAttributes"]>) => any) | null;
+    onPlaceholderChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["placeholder"]>) => any) | null;
+    onRawValueChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["rawValue"]>) => any) | null;
+    onRequiredChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["required"]>) => any) | null;
+    onValidatorsChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["validators"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["value"]>) => any) | null;
+    onValueOptionChanged: ((event: JetElementCustomEvent<ojComboboxOne<K, D>["valueOption"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojComboboxOne.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojComboboxOne.ojAnimateStart) => any) | null;
+    onOjValueUpdated: ((event: ojComboboxOne.ojValueUpdated) => any) | null;
+    addEventListener<T extends keyof ojComboboxOneEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojComboboxOneEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojComboboxOneSettableProperties<K, D>>(property: T): ojComboboxOne<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojComboboxOneSettableProperties<K, D>>(property: T, value: ojComboboxOneSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojComboboxOneSettableProperties<K, D>>): void;
+    setProperties(properties: ojComboboxOneSettablePropertiesLenient<K, D>): void;
+}
+export namespace ojComboboxOne {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojValueUpdated extends CustomEvent<{
+        value: any;
+        previousValue: any;
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojComboboxOneEventMap<K, D> extends ojComboboxEventMap<any, ojComboboxOneSettableProperties<K, D>, any, string> {
+    'ojAnimateEnd': ojComboboxOne.ojAnimateEnd;
+    'ojAnimateStart': ojComboboxOne.ojAnimateStart;
+    'ojValueUpdated': ojComboboxOne.ojValueUpdated;
+    'asyncValidatorsChanged': JetElementCustomEvent<ojComboboxOne<K, D>["asyncValidators"]>;
+    'converterChanged': JetElementCustomEvent<ojComboboxOne<K, D>["converter"]>;
+    'filterOnOpenChanged': JetElementCustomEvent<ojComboboxOne<K, D>["filterOnOpen"]>;
+    'minLengthChanged': JetElementCustomEvent<ojComboboxOne<K, D>["minLength"]>;
+    'optionRendererChanged': JetElementCustomEvent<ojComboboxOne<K, D>["optionRenderer"]>;
+    'optionsChanged': JetElementCustomEvent<ojComboboxOne<K, D>["options"]>;
+    'optionsKeysChanged': JetElementCustomEvent<ojComboboxOne<K, D>["optionsKeys"]>;
+    'pickerAttributesChanged': JetElementCustomEvent<ojComboboxOne<K, D>["pickerAttributes"]>;
+    'placeholderChanged': JetElementCustomEvent<ojComboboxOne<K, D>["placeholder"]>;
+    'rawValueChanged': JetElementCustomEvent<ojComboboxOne<K, D>["rawValue"]>;
+    'requiredChanged': JetElementCustomEvent<ojComboboxOne<K, D>["required"]>;
+    'validatorsChanged': JetElementCustomEvent<ojComboboxOne<K, D>["validators"]>;
+    'valueChanged': JetElementCustomEvent<ojComboboxOne<K, D>["value"]>;
+    'valueOptionChanged': JetElementCustomEvent<ojComboboxOne<K, D>["valueOption"]>;
+}
+export interface ojComboboxOneSettableProperties<K, D> extends ojComboboxSettableProperties<any, any, string> {
+    asyncValidators: Array<AsyncValidator<any>>;
+    converter: Converter<any> | Validation.RegisteredConverter | null;
+    filterOnOpen: 'none' | 'rawValue';
+    minLength: number;
+    optionRenderer?: ((param0: ojCombobox.OptionContext) => {
+        insert: Element;
+    } | undefined) | null;
+    options: Array<ojCombobox.Option | ojCombobox.Optgroup> | DataProvider<K, D> | null;
+    optionsKeys: {
+        childKeys: {
+            label?: string;
+            value?: string;
+            children?: string;
+            childKeys?: ojCombobox.OptionsKeys;
+        };
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    placeholder: string | null;
+    readonly rawValue: string | null;
+    required: boolean;
+    validators: Array<Validator<any> | Validation.RegisteredValidator> | null;
+    value: any;
+    valueOption: {
+        value: any;
+        label?: string;
+    };
+    translations: {
+        filterFurther?: string;
+        noMatchesFound?: string;
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+    };
+}
+export interface ojComboboxOneSettablePropertiesLenient<K, D> extends Partial<ojComboboxOneSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ojSelect<V, SP extends ojSelectSettableProperties<V, SV>, SV = V> extends editableValue<V, SP, SV> {
+    onOjAnimateEnd: ((event: ojSelect.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojSelect.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojSelectEventMap<V, SP, SV>>(type: T, listener: (this: HTMLElement, ev: ojSelectEventMap<V, SP, SV>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSelectSettableProperties<V, SV>>(property: T): ojSelect<V, SP, SV>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSelectSettableProperties<V, SV>>(property: T, value: ojSelectSettableProperties<V, SV>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSelectSettableProperties<V, SV>>): void;
+    setProperties(properties: ojSelectSettablePropertiesLenient<V, SV>): void;
+    refresh(): void;
+    validate(): Promise<any>;
+}
+export namespace ojSelect {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type Optgroup = {
+        disabled?: boolean;
+        label: string;
+        children: Array<(Option | Optgroup)>;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type Option = {
+        disabled?: boolean;
+        label?: string;
+        value: any;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type OptionContext = {
+        component: Element;
+        parent: Element;
+        index: number;
+        depth: number;
+        leaf: boolean;
+        data: object;
+        parentElement: Element;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type OptionsKeys = {
+        label?: string;
+        value?: string;
+        children?: string;
+        childKeys?: OptionsKeys;
+    };
+}
+export interface ojSelectEventMap<V, SP extends ojSelectSettableProperties<V, SV>, SV = V> extends editableValueEventMap<V, SP, SV> {
+    'ojAnimateEnd': ojSelect.ojAnimateEnd;
+    'ojAnimateStart': ojSelect.ojAnimateStart;
+}
+// These interfaces are empty but required to keep the component chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface ojSelectSettableProperties<V, SV = V> extends editableValueSettableProperties<V, SV> {
+}
+export interface ojSelectSettablePropertiesLenient<V, SV> extends Partial<ojSelectSettableProperties<V, SV>> {
+    [key: string]: any;
+}
+export interface ojSelectMany<K, D> extends ojSelect<any[] | null, ojSelectManySettableProperties<K, D>> {
+    minimumResultsForSearch: number;
+    optionRenderer?: ((param0: ojSelect.OptionContext) => {
+        insert: Element;
+    } | undefined) | null;
+    options: Array<ojSelect.Option | ojSelect.Optgroup> | DataProvider<K, D> | null;
+    optionsKeys: {
+        childKeys?: {
+            label?: string;
+            value?: string;
+            children?: string;
+            childKeys?: ojSelect.OptionsKeys;
+        };
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    placeholder: string | null;
+    renderMode: 'jet' | 'native';
+    required: boolean;
+    value: any[] | null;
+    valueOptions: Array<{
+        value: any;
+        label?: string;
+    }> | null;
+    translations: {
+        filterFurther?: string;
+        moreMatchesFound?: string;
+        noMatchesFound?: string;
+        oneMatchesFound?: string;
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        searchField?: string;
+    };
+    onMinimumResultsForSearchChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["minimumResultsForSearch"]>) => any) | null;
+    onOptionRendererChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["optionRenderer"]>) => any) | null;
+    onOptionsChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["options"]>) => any) | null;
+    onOptionsKeysChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["optionsKeys"]>) => any) | null;
+    onPickerAttributesChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["pickerAttributes"]>) => any) | null;
+    onPlaceholderChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["placeholder"]>) => any) | null;
+    onRenderModeChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["renderMode"]>) => any) | null;
+    onRequiredChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["required"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["value"]>) => any) | null;
+    onValueOptionsChanged: ((event: JetElementCustomEvent<ojSelectMany<K, D>["valueOptions"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojSelectMany.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojSelectMany.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojSelectManyEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojSelectManyEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSelectManySettableProperties<K, D>>(property: T): ojSelectMany<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSelectManySettableProperties<K, D>>(property: T, value: ojSelectManySettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSelectManySettableProperties<K, D>>): void;
+    setProperties(properties: ojSelectManySettablePropertiesLenient<K, D>): void;
+}
+export namespace ojSelectMany {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojSelectManyEventMap<K, D> extends ojSelectEventMap<any[] | null, ojSelectManySettableProperties<K, D>> {
+    'ojAnimateEnd': ojSelectMany.ojAnimateEnd;
+    'ojAnimateStart': ojSelectMany.ojAnimateStart;
+    'minimumResultsForSearchChanged': JetElementCustomEvent<ojSelectMany<K, D>["minimumResultsForSearch"]>;
+    'optionRendererChanged': JetElementCustomEvent<ojSelectMany<K, D>["optionRenderer"]>;
+    'optionsChanged': JetElementCustomEvent<ojSelectMany<K, D>["options"]>;
+    'optionsKeysChanged': JetElementCustomEvent<ojSelectMany<K, D>["optionsKeys"]>;
+    'pickerAttributesChanged': JetElementCustomEvent<ojSelectMany<K, D>["pickerAttributes"]>;
+    'placeholderChanged': JetElementCustomEvent<ojSelectMany<K, D>["placeholder"]>;
+    'renderModeChanged': JetElementCustomEvent<ojSelectMany<K, D>["renderMode"]>;
+    'requiredChanged': JetElementCustomEvent<ojSelectMany<K, D>["required"]>;
+    'valueChanged': JetElementCustomEvent<ojSelectMany<K, D>["value"]>;
+    'valueOptionsChanged': JetElementCustomEvent<ojSelectMany<K, D>["valueOptions"]>;
+}
+export interface ojSelectManySettableProperties<K, D> extends ojSelectSettableProperties<any[] | null> {
+    minimumResultsForSearch: number;
+    optionRenderer?: ((param0: ojSelect.OptionContext) => {
+        insert: Element;
+    } | undefined) | null;
+    options: Array<ojSelect.Option | ojSelect.Optgroup> | DataProvider<K, D> | null;
+    optionsKeys: {
+        childKeys?: {
+            label?: string;
+            value?: string;
+            children?: string;
+            childKeys?: ojSelect.OptionsKeys;
+        };
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    placeholder: string | null;
+    renderMode: 'jet' | 'native';
+    required: boolean;
+    value: any[] | null;
+    valueOptions: Array<{
+        value: any;
+        label?: string;
+    }> | null;
+    translations: {
+        filterFurther?: string;
+        moreMatchesFound?: string;
+        noMatchesFound?: string;
+        oneMatchesFound?: string;
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        searchField?: string;
+    };
+}
+export interface ojSelectManySettablePropertiesLenient<K, D> extends Partial<ojSelectManySettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ojSelectOne<K, D> extends ojSelect<any, ojSelectOneSettableProperties<K, D>> {
+    minimumResultsForSearch: number;
+    optionRenderer?: ((param0: ojSelect.OptionContext) => {
+        insert: Element;
+    } | undefined) | null;
+    options: Array<ojSelect.Option | ojSelect.Optgroup> | DataProvider<K, D> | null;
+    optionsKeys: {
+        childKeys?: {
+            label?: string;
+            value?: string;
+            children?: string;
+            childKeys?: ojSelect.OptionsKeys;
+        };
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    placeholder: string | null;
+    renderMode: 'jet' | 'native';
+    required: boolean;
+    value: any;
+    valueOption: {
+        value: any;
+        label?: string;
+    };
+    translations: {
+        filterFurther?: string;
+        moreMatchesFound?: string;
+        noMatchesFound?: string;
+        oneMatchesFound?: string;
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        searchField?: string;
+    };
+    onMinimumResultsForSearchChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["minimumResultsForSearch"]>) => any) | null;
+    onOptionRendererChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["optionRenderer"]>) => any) | null;
+    onOptionsChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["options"]>) => any) | null;
+    onOptionsKeysChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["optionsKeys"]>) => any) | null;
+    onPickerAttributesChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["pickerAttributes"]>) => any) | null;
+    onPlaceholderChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["placeholder"]>) => any) | null;
+    onRenderModeChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["renderMode"]>) => any) | null;
+    onRequiredChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["required"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["value"]>) => any) | null;
+    onValueOptionChanged: ((event: JetElementCustomEvent<ojSelectOne<K, D>["valueOption"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojSelectOne.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojSelectOne.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojSelectOneEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojSelectOneEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSelectOneSettableProperties<K, D>>(property: T): ojSelectOne<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSelectOneSettableProperties<K, D>>(property: T, value: ojSelectOneSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSelectOneSettableProperties<K, D>>): void;
+    setProperties(properties: ojSelectOneSettablePropertiesLenient<K, D>): void;
+}
+export namespace ojSelectOne {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojSelectOneEventMap<K, D> extends ojSelectEventMap<any, ojSelectOneSettableProperties<K, D>> {
+    'ojAnimateEnd': ojSelectOne.ojAnimateEnd;
+    'ojAnimateStart': ojSelectOne.ojAnimateStart;
+    'minimumResultsForSearchChanged': JetElementCustomEvent<ojSelectOne<K, D>["minimumResultsForSearch"]>;
+    'optionRendererChanged': JetElementCustomEvent<ojSelectOne<K, D>["optionRenderer"]>;
+    'optionsChanged': JetElementCustomEvent<ojSelectOne<K, D>["options"]>;
+    'optionsKeysChanged': JetElementCustomEvent<ojSelectOne<K, D>["optionsKeys"]>;
+    'pickerAttributesChanged': JetElementCustomEvent<ojSelectOne<K, D>["pickerAttributes"]>;
+    'placeholderChanged': JetElementCustomEvent<ojSelectOne<K, D>["placeholder"]>;
+    'renderModeChanged': JetElementCustomEvent<ojSelectOne<K, D>["renderMode"]>;
+    'requiredChanged': JetElementCustomEvent<ojSelectOne<K, D>["required"]>;
+    'valueChanged': JetElementCustomEvent<ojSelectOne<K, D>["value"]>;
+    'valueOptionChanged': JetElementCustomEvent<ojSelectOne<K, D>["valueOption"]>;
+}
+export interface ojSelectOneSettableProperties<K, D> extends ojSelectSettableProperties<any> {
+    minimumResultsForSearch: number;
+    optionRenderer?: ((param0: ojSelect.OptionContext) => {
+        insert: Element;
+    } | undefined) | null;
+    options: Array<ojSelect.Option | ojSelect.Optgroup> | DataProvider<K, D> | null;
+    optionsKeys: {
+        childKeys?: {
+            label?: string;
+            value?: string;
+            children?: string;
+            childKeys?: ojSelect.OptionsKeys;
+        };
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    pickerAttributes: {
+        style?: string;
+        class?: string;
+    };
+    placeholder: string | null;
+    renderMode: 'jet' | 'native';
+    required: boolean;
+    value: any;
+    valueOption: {
+        value: any;
+        label?: string;
+    };
+    translations: {
+        filterFurther?: string;
+        moreMatchesFound?: string;
+        noMatchesFound?: string;
+        oneMatchesFound?: string;
+        required?: {
+            hint?: string;
+            messageDetail?: string;
+            messageSummary?: string;
+        };
+        searchField?: string;
+    };
+}
+export interface ojSelectOneSettablePropertiesLenient<K, D> extends Partial<ojSelectOneSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface Optgroup {
+    children: Array<(Option | Optgroup)>;
+    disabled?: boolean;
+    label: string;
+}
+export interface Option {
+    disabled?: boolean;
+    label?: string;
+    value: object;
+}

types/oracle__oraclejet/ojslider/index.d.ts

@@ -0,0 +1,83 @@
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojSlider extends editableValue<number | null, ojSliderSettableProperties> {
+    disabled: boolean;
+    max: number | null;
+    min: number | null;
+    orientation: 'horizontal' | 'vertical';
+    step: number | null;
+    readonly transientValue: number;
+    type: 'fromMin' | 'fromMax' | 'single';
+    value: number | null;
+    translations: {
+        invalidStep?: string;
+        maxMin?: string;
+        noValue?: string;
+        optionNum?: string;
+        valueRange?: string;
+    };
+    onDisabledChanged: ((event: JetElementCustomEvent<ojSlider["disabled"]>) => any) | null;
+    onMaxChanged: ((event: JetElementCustomEvent<ojSlider["max"]>) => any) | null;
+    onMinChanged: ((event: JetElementCustomEvent<ojSlider["min"]>) => any) | null;
+    onOrientationChanged: ((event: JetElementCustomEvent<ojSlider["orientation"]>) => any) | null;
+    onStepChanged: ((event: JetElementCustomEvent<ojSlider["step"]>) => any) | null;
+    onTransientValueChanged: ((event: JetElementCustomEvent<ojSlider["transientValue"]>) => any) | null;
+    onTypeChanged: ((event: JetElementCustomEvent<ojSlider["type"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojSlider["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojSlider.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojSlider.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojSliderEventMap>(type: T, listener: (this: HTMLElement, ev: ojSliderEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSliderSettableProperties>(property: T): ojSlider[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSliderSettableProperties>(property: T, value: ojSliderSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSliderSettableProperties>): void;
+    setProperties(properties: ojSliderSettablePropertiesLenient): void;
+}
+export namespace ojSlider {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojSliderEventMap extends editableValueEventMap<number | null, ojSliderSettableProperties> {
+    'ojAnimateEnd': ojSlider.ojAnimateEnd;
+    'ojAnimateStart': ojSlider.ojAnimateStart;
+    'disabledChanged': JetElementCustomEvent<ojSlider["disabled"]>;
+    'maxChanged': JetElementCustomEvent<ojSlider["max"]>;
+    'minChanged': JetElementCustomEvent<ojSlider["min"]>;
+    'orientationChanged': JetElementCustomEvent<ojSlider["orientation"]>;
+    'stepChanged': JetElementCustomEvent<ojSlider["step"]>;
+    'transientValueChanged': JetElementCustomEvent<ojSlider["transientValue"]>;
+    'typeChanged': JetElementCustomEvent<ojSlider["type"]>;
+    'valueChanged': JetElementCustomEvent<ojSlider["value"]>;
+}
+export interface ojSliderSettableProperties extends editableValueSettableProperties<number | null> {
+    disabled: boolean;
+    max: number | null;
+    min: number | null;
+    orientation: 'horizontal' | 'vertical';
+    step: number | null;
+    readonly transientValue: number;
+    type: 'fromMin' | 'fromMax' | 'single';
+    value: number | null;
+    translations: {
+        invalidStep?: string;
+        maxMin?: string;
+        noValue?: string;
+        optionNum?: string;
+        valueRange?: string;
+    };
+}
+export interface ojSliderSettablePropertiesLenient extends Partial<ojSliderSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojsunburst/index.d.ts

@@ -0,0 +1,407 @@
+import { KeySet } from '../ojkeyset';
+import { DataProvider } from '../ojdataprovider';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojSunburst<K, D> extends dvtBaseComponent<ojSunburstSettableProperties<K, D>> {
+    animationDuration: number;
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    animationUpdateColor: string;
+    as: string;
+    colorLabel: string;
+    data: DataProvider<K, D> | null;
+    displayLevels: number;
+    drilling: 'on' | 'off';
+    expanded: KeySet<K>;
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverBehaviorDelay: number;
+    nodeDefaults: {
+        borderColor: string;
+        borderWidth: number;
+        hoverColor: string;
+        labelDisplay: 'horizontal' | 'rotated' | 'off' | 'auto';
+        labelHalign: 'inner' | 'outer' | 'center';
+        labelMinLength: number;
+        labelStyle: object;
+        selectedInnerColor: string;
+        selectedOuterColor: string;
+        showDisclosure: 'on' | 'off';
+    };
+    rootNode: any;
+    rootNodeContent: {
+        renderer: ((context: ojSunburst.RootNodeContext<K, D>) => ({
+            insert: Element | string;
+        }));
+    };
+    rotation: 'off' | 'on';
+    selection: any[];
+    selectionMode: 'none' | 'single' | 'multiple';
+    sizeLabel: string;
+    sorting: 'on' | 'off';
+    startAngle: number;
+    tooltip: {
+        renderer: ((context: ojSunburst.TooltipContext<K, D>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    touchResponse: 'touchStart' | 'auto';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelColor?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        labelSize?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+        tooltipCollapse?: string;
+        tooltipExpand?: string;
+    };
+    onAnimationDurationChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["animationDuration"]>) => any) | null;
+    onAnimationOnDataChangeChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["animationOnDataChange"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["animationOnDisplay"]>) => any) | null;
+    onAnimationUpdateColorChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["animationUpdateColor"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["as"]>) => any) | null;
+    onColorLabelChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["colorLabel"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["data"]>) => any) | null;
+    onDisplayLevelsChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["displayLevels"]>) => any) | null;
+    onDrillingChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["drilling"]>) => any) | null;
+    onExpandedChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["expanded"]>) => any) | null;
+    onHiddenCategoriesChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["hiddenCategories"]>) => any) | null;
+    onHighlightMatchChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["highlightMatch"]>) => any) | null;
+    onHighlightedCategoriesChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["highlightedCategories"]>) => any) | null;
+    onHoverBehaviorChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["hoverBehavior"]>) => any) | null;
+    onHoverBehaviorDelayChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["hoverBehaviorDelay"]>) => any) | null;
+    onNodeDefaultsChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["nodeDefaults"]>) => any) | null;
+    onRootNodeChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["rootNode"]>) => any) | null;
+    onRootNodeContentChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["rootNodeContent"]>) => any) | null;
+    onRotationChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["rotation"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["selectionMode"]>) => any) | null;
+    onSizeLabelChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["sizeLabel"]>) => any) | null;
+    onSortingChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["sorting"]>) => any) | null;
+    onStartAngleChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["startAngle"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["tooltip"]>) => any) | null;
+    onTouchResponseChanged: ((event: JetElementCustomEvent<ojSunburst<K, D>["touchResponse"]>) => any) | null;
+    onOjBeforeCollapse: ((event: ojSunburst.ojBeforeCollapse) => any) | null;
+    onOjBeforeDrill: ((event: ojSunburst.ojBeforeDrill) => any) | null;
+    onOjBeforeExpand: ((event: ojSunburst.ojBeforeExpand) => any) | null;
+    onOjCollapse: ((event: ojSunburst.ojCollapse) => any) | null;
+    onOjDrill: ((event: ojSunburst.ojDrill) => any) | null;
+    onOjExpand: ((event: ojSunburst.ojExpand) => any) | null;
+    onOjRotateInput: ((event: ojSunburst.ojRotateInput) => any) | null;
+    addEventListener<T extends keyof ojSunburstEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojSunburstEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSunburstSettableProperties<K, D>>(property: T): ojSunburst<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSunburstSettableProperties<K, D>>(property: T, value: ojSunburstSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSunburstSettableProperties<K, D>>): void;
+    setProperties(properties: ojSunburstSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojSunburst.NodeContext | null;
+    getNode(subIdPath: any[]): ojSunburst.DataContext | null;
+}
+export namespace ojSunburst {
+    interface ojBeforeCollapse extends CustomEvent<{
+        id: any;
+        data: object;
+        itemData: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeDrill extends CustomEvent<{
+        id: any;
+        data: object;
+        itemData: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeExpand extends CustomEvent<{
+        id: any;
+        data: object;
+        itemData: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojCollapse extends CustomEvent<{
+        id: any;
+        data: object;
+        itemData: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojDrill extends CustomEvent<{
+        id: any;
+        data: object;
+        itemData: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojExpand extends CustomEvent<{
+        id: any;
+        data: object;
+        itemData: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojRotateInput extends CustomEvent<{
+        value: number;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type DataContext = {
+        color: string;
+        label: string;
+        selected: boolean;
+        size: number;
+        tooltip: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContext = {
+        subId: string;
+        indexPath: number[];
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RootNodeContext<K, D> = {
+        outerBounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        innerBounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        id: K;
+        data: object;
+        itemData: D;
+        componentElement: Element;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext<K, D> = {
+        parentElement: Element;
+        id: K;
+        label: string;
+        value: number;
+        radius: number;
+        color: string;
+        data: object;
+        itemData: D;
+        componentElement: Element;
+    };
+}
+export interface ojSunburstEventMap<K, D> extends dvtBaseComponentEventMap<ojSunburstSettableProperties<K, D>> {
+    'ojBeforeCollapse': ojSunburst.ojBeforeCollapse;
+    'ojBeforeDrill': ojSunburst.ojBeforeDrill;
+    'ojBeforeExpand': ojSunburst.ojBeforeExpand;
+    'ojCollapse': ojSunburst.ojCollapse;
+    'ojDrill': ojSunburst.ojDrill;
+    'ojExpand': ojSunburst.ojExpand;
+    'ojRotateInput': ojSunburst.ojRotateInput;
+    'animationDurationChanged': JetElementCustomEvent<ojSunburst<K, D>["animationDuration"]>;
+    'animationOnDataChangeChanged': JetElementCustomEvent<ojSunburst<K, D>["animationOnDataChange"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojSunburst<K, D>["animationOnDisplay"]>;
+    'animationUpdateColorChanged': JetElementCustomEvent<ojSunburst<K, D>["animationUpdateColor"]>;
+    'asChanged': JetElementCustomEvent<ojSunburst<K, D>["as"]>;
+    'colorLabelChanged': JetElementCustomEvent<ojSunburst<K, D>["colorLabel"]>;
+    'dataChanged': JetElementCustomEvent<ojSunburst<K, D>["data"]>;
+    'displayLevelsChanged': JetElementCustomEvent<ojSunburst<K, D>["displayLevels"]>;
+    'drillingChanged': JetElementCustomEvent<ojSunburst<K, D>["drilling"]>;
+    'expandedChanged': JetElementCustomEvent<ojSunburst<K, D>["expanded"]>;
+    'hiddenCategoriesChanged': JetElementCustomEvent<ojSunburst<K, D>["hiddenCategories"]>;
+    'highlightMatchChanged': JetElementCustomEvent<ojSunburst<K, D>["highlightMatch"]>;
+    'highlightedCategoriesChanged': JetElementCustomEvent<ojSunburst<K, D>["highlightedCategories"]>;
+    'hoverBehaviorChanged': JetElementCustomEvent<ojSunburst<K, D>["hoverBehavior"]>;
+    'hoverBehaviorDelayChanged': JetElementCustomEvent<ojSunburst<K, D>["hoverBehaviorDelay"]>;
+    'nodeDefaultsChanged': JetElementCustomEvent<ojSunburst<K, D>["nodeDefaults"]>;
+    'rootNodeChanged': JetElementCustomEvent<ojSunburst<K, D>["rootNode"]>;
+    'rootNodeContentChanged': JetElementCustomEvent<ojSunburst<K, D>["rootNodeContent"]>;
+    'rotationChanged': JetElementCustomEvent<ojSunburst<K, D>["rotation"]>;
+    'selectionChanged': JetElementCustomEvent<ojSunburst<K, D>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojSunburst<K, D>["selectionMode"]>;
+    'sizeLabelChanged': JetElementCustomEvent<ojSunburst<K, D>["sizeLabel"]>;
+    'sortingChanged': JetElementCustomEvent<ojSunburst<K, D>["sorting"]>;
+    'startAngleChanged': JetElementCustomEvent<ojSunburst<K, D>["startAngle"]>;
+    'tooltipChanged': JetElementCustomEvent<ojSunburst<K, D>["tooltip"]>;
+    'touchResponseChanged': JetElementCustomEvent<ojSunburst<K, D>["touchResponse"]>;
+}
+export interface ojSunburstSettableProperties<K, D> extends dvtBaseComponentSettableProperties {
+    animationDuration: number;
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    animationUpdateColor: string;
+    as: string;
+    colorLabel: string;
+    data: DataProvider<K, D> | null;
+    displayLevels: number;
+    drilling: 'on' | 'off';
+    expanded: KeySet<K>;
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverBehaviorDelay: number;
+    nodeDefaults: {
+        borderColor: string;
+        borderWidth: number;
+        hoverColor: string;
+        labelDisplay: 'horizontal' | 'rotated' | 'off' | 'auto';
+        labelHalign: 'inner' | 'outer' | 'center';
+        labelMinLength: number;
+        labelStyle: object;
+        selectedInnerColor: string;
+        selectedOuterColor: string;
+        showDisclosure: 'on' | 'off';
+    };
+    rootNode: any;
+    rootNodeContent: {
+        renderer: ((context: ojSunburst.RootNodeContext<K, D>) => ({
+            insert: Element | string;
+        }));
+    };
+    rotation: 'off' | 'on';
+    selection: any[];
+    selectionMode: 'none' | 'single' | 'multiple';
+    sizeLabel: string;
+    sorting: 'on' | 'off';
+    startAngle: number;
+    tooltip: {
+        renderer: ((context: ojSunburst.TooltipContext<K, D>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    touchResponse: 'touchStart' | 'auto';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelColor?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        labelSize?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+        tooltipCollapse?: string;
+        tooltipExpand?: string;
+    };
+}
+export interface ojSunburstSettablePropertiesLenient<K, D> extends Partial<ojSunburstSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ojSunburstNode extends JetElement<ojSunburstNodeSettableProperties> {
+    borderColor?: string;
+    borderWidth?: number;
+    categories?: string[];
+    color?: string;
+    drilling?: 'on' | 'off' | 'inherit';
+    label?: string;
+    labelDisplay?: 'horizontal' | 'rotated' | 'off' | 'auto';
+    labelHalign?: 'inner' | 'outer' | 'center';
+    labelStyle?: object;
+    pattern?: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+       'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+    radius?: number;
+    selectable?: 'off' | 'auto';
+    shortDesc?: string;
+    showDisclosure?: 'on' | 'off' | 'inherit';
+    svgClassName?: string;
+    svgStyle?: object;
+    value: number;
+    onBorderColorChanged: ((event: JetElementCustomEvent<ojSunburstNode["borderColor"]>) => any) | null;
+    onBorderWidthChanged: ((event: JetElementCustomEvent<ojSunburstNode["borderWidth"]>) => any) | null;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojSunburstNode["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojSunburstNode["color"]>) => any) | null;
+    onDrillingChanged: ((event: JetElementCustomEvent<ojSunburstNode["drilling"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojSunburstNode["label"]>) => any) | null;
+    onLabelDisplayChanged: ((event: JetElementCustomEvent<ojSunburstNode["labelDisplay"]>) => any) | null;
+    onLabelHalignChanged: ((event: JetElementCustomEvent<ojSunburstNode["labelHalign"]>) => any) | null;
+    onLabelStyleChanged: ((event: JetElementCustomEvent<ojSunburstNode["labelStyle"]>) => any) | null;
+    onPatternChanged: ((event: JetElementCustomEvent<ojSunburstNode["pattern"]>) => any) | null;
+    onRadiusChanged: ((event: JetElementCustomEvent<ojSunburstNode["radius"]>) => any) | null;
+    onSelectableChanged: ((event: JetElementCustomEvent<ojSunburstNode["selectable"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojSunburstNode["shortDesc"]>) => any) | null;
+    onShowDisclosureChanged: ((event: JetElementCustomEvent<ojSunburstNode["showDisclosure"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojSunburstNode["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojSunburstNode["svgStyle"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojSunburstNode["value"]>) => any) | null;
+    addEventListener<T extends keyof ojSunburstNodeEventMap>(type: T, listener: (this: HTMLElement, ev: ojSunburstNodeEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSunburstNodeSettableProperties>(property: T): ojSunburstNode[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSunburstNodeSettableProperties>(property: T, value: ojSunburstNodeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSunburstNodeSettableProperties>): void;
+    setProperties(properties: ojSunburstNodeSettablePropertiesLenient): void;
+}
+export interface ojSunburstNodeEventMap extends HTMLElementEventMap {
+    'borderColorChanged': JetElementCustomEvent<ojSunburstNode["borderColor"]>;
+    'borderWidthChanged': JetElementCustomEvent<ojSunburstNode["borderWidth"]>;
+    'categoriesChanged': JetElementCustomEvent<ojSunburstNode["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojSunburstNode["color"]>;
+    'drillingChanged': JetElementCustomEvent<ojSunburstNode["drilling"]>;
+    'labelChanged': JetElementCustomEvent<ojSunburstNode["label"]>;
+    'labelDisplayChanged': JetElementCustomEvent<ojSunburstNode["labelDisplay"]>;
+    'labelHalignChanged': JetElementCustomEvent<ojSunburstNode["labelHalign"]>;
+    'labelStyleChanged': JetElementCustomEvent<ojSunburstNode["labelStyle"]>;
+    'patternChanged': JetElementCustomEvent<ojSunburstNode["pattern"]>;
+    'radiusChanged': JetElementCustomEvent<ojSunburstNode["radius"]>;
+    'selectableChanged': JetElementCustomEvent<ojSunburstNode["selectable"]>;
+    'shortDescChanged': JetElementCustomEvent<ojSunburstNode["shortDesc"]>;
+    'showDisclosureChanged': JetElementCustomEvent<ojSunburstNode["showDisclosure"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojSunburstNode["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojSunburstNode["svgStyle"]>;
+    'valueChanged': JetElementCustomEvent<ojSunburstNode["value"]>;
+}
+export interface ojSunburstNodeSettableProperties extends JetSettableProperties {
+    borderColor?: string;
+    borderWidth?: number;
+    categories?: string[];
+    color?: string;
+    drilling?: 'on' | 'off' | 'inherit';
+    label?: string;
+    labelDisplay?: 'horizontal' | 'rotated' | 'off' | 'auto';
+    labelHalign?: 'inner' | 'outer' | 'center';
+    labelStyle?: object;
+    pattern?: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+       'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+    radius?: number;
+    selectable?: 'off' | 'auto';
+    shortDesc?: string;
+    showDisclosure?: 'on' | 'off' | 'inherit';
+    svgClassName?: string;
+    svgStyle?: object;
+    value: number;
+}
+export interface ojSunburstNodeSettablePropertiesLenient extends Partial<ojSunburstNodeSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojswipeactions/index.d.ts

@@ -0,0 +1,36 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojSwipeActions extends baseComponent<ojSwipeActionsSettableProperties> {
+    translations: {
+        ariaHideActionsDescription?: string;
+        ariaShowEndActionsDescription?: string;
+        ariaShowStartActionsDescription?: string;
+    };
+    onOjAction: ((event: ojSwipeActions.ojAction) => any) | null;
+    addEventListener<T extends keyof ojSwipeActionsEventMap>(type: T, listener: (this: HTMLElement, ev: ojSwipeActionsEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSwipeActionsSettableProperties>(property: T): ojSwipeActions[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSwipeActionsSettableProperties>(property: T, value: ojSwipeActionsSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSwipeActionsSettableProperties>): void;
+    setProperties(properties: ojSwipeActionsSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export namespace ojSwipeActions {
+    interface ojAction extends CustomEvent<{
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojSwipeActionsEventMap extends baseComponentEventMap<ojSwipeActionsSettableProperties> {
+    'ojAction': ojSwipeActions.ojAction;
+}
+export interface ojSwipeActionsSettableProperties extends baseComponentSettableProperties {
+    translations: {
+        ariaHideActionsDescription?: string;
+        ariaShowEndActionsDescription?: string;
+        ariaShowStartActionsDescription?: string;
+    };
+}
+export interface ojSwipeActionsSettablePropertiesLenient extends Partial<ojSwipeActionsSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojswipetoreveal/index.d.ts

@@ -0,0 +1,4 @@
+export function setupSwipeActions(elem: Element, options?: {
+    threshold?: number;
+}): void;
+export function tearDownSwipeActions(elem: Element): void;

types/oracle__oraclejet/ojswitch/index.d.ts

@@ -0,0 +1,49 @@
+import { editableValue, editableValueEventMap, editableValueSettableProperties } from '../ojeditablevalue';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojSwitch extends editableValue<boolean, ojSwitchSettableProperties> {
+    disabled: boolean;
+    readonly: boolean;
+    value: boolean;
+    onDisabledChanged: ((event: JetElementCustomEvent<ojSwitch["disabled"]>) => any) | null;
+    onReadonlyChanged: ((event: JetElementCustomEvent<ojSwitch["readonly"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojSwitch["value"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojSwitch.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojSwitch.ojAnimateStart) => any) | null;
+    addEventListener<T extends keyof ojSwitchEventMap>(type: T, listener: (this: HTMLElement, ev: ojSwitchEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSwitchSettableProperties>(property: T): ojSwitch[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSwitchSettableProperties>(property: T, value: ojSwitchSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSwitchSettableProperties>): void;
+    setProperties(properties: ojSwitchSettablePropertiesLenient): void;
+}
+export namespace ojSwitch {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: string;
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: string;
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+}
+export interface ojSwitchEventMap extends editableValueEventMap<boolean, ojSwitchSettableProperties> {
+    'ojAnimateEnd': ojSwitch.ojAnimateEnd;
+    'ojAnimateStart': ojSwitch.ojAnimateStart;
+    'disabledChanged': JetElementCustomEvent<ojSwitch["disabled"]>;
+    'readonlyChanged': JetElementCustomEvent<ojSwitch["readonly"]>;
+    'valueChanged': JetElementCustomEvent<ojSwitch["value"]>;
+}
+export interface ojSwitchSettableProperties extends editableValueSettableProperties<boolean> {
+    disabled: boolean;
+    readonly: boolean;
+    value: boolean;
+}
+export interface ojSwitchSettablePropertiesLenient extends Partial<ojSwitchSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojswitcher/index.d.ts

@@ -0,0 +1,22 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojSwitcher extends JetElement<ojSwitcherSettableProperties> {
+    value: string;
+    onValueChanged: ((event: JetElementCustomEvent<ojSwitcher["value"]>) => any) | null;
+    addEventListener<T extends keyof ojSwitcherEventMap>(type: T, listener: (this: HTMLElement, ev: ojSwitcherEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojSwitcherSettableProperties>(property: T): ojSwitcher[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojSwitcherSettableProperties>(property: T, value: ojSwitcherSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojSwitcherSettableProperties>): void;
+    setProperties(properties: ojSwitcherSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface ojSwitcherEventMap extends HTMLElementEventMap {
+    'valueChanged': JetElementCustomEvent<ojSwitcher["value"]>;
+}
+export interface ojSwitcherSettableProperties extends JetSettableProperties {
+    value: string;
+}
+export interface ojSwitcherSettablePropertiesLenient extends Partial<ojSwitcherSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojtable/index.d.ts

@@ -0,0 +1,595 @@
+import { DataProvider } from '../ojdataprovider';
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojTable<K, D> extends baseComponent<ojTableSettableProperties<K, D>> {
+    accessibility: {
+        rowHeader: string;
+    };
+    as: string;
+    columns: Array<{
+        className?: string | null;
+        field?: string | null;
+        footerClassName?: string | null;
+        footerRenderer?: ((context: ojTable.FooterRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        footerStyle?: string | null;
+        footerTemplate?: {
+            componentElement: Element;
+        };
+        headerClassName?: string | null;
+        headerRenderer?: ((context: ojTable.HeaderRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        headerStyle?: string | null;
+        headerTemplate?: {
+            componentElement: Element;
+            data: object;
+        };
+        headerText?: string | null;
+        id?: string | null;
+        renderer?: ((context: ojTable.ColumnsRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        resizable?: 'enabled' | 'disabled';
+        sortProperty?: string | null;
+        sortable?: 'auto' | 'enabled' | 'disabled';
+        style?: string | null;
+        template?: {
+            componentElement: Element;
+            data: object;
+            row: object;
+            index: number;
+            columnIndex: number;
+            key: any;
+            mode: string;
+        };
+        width?: number | null;
+    }> | null;
+    columnsDefault: {
+        className?: string | null;
+        field?: string | null;
+        footerClassName?: string | null;
+        footerRenderer?: ((context: ojTable.FooterRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        footerStyle?: string | null;
+        footerTemplate?: {
+            componentElement: Element;
+        };
+        headerClassName?: string | null;
+        headerRenderer?: ((context: ojTable.HeaderRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        headerStyle?: string | null;
+        headerTemplate?: {
+            componentElement: Element;
+            data: object;
+        };
+        headerText?: string | null;
+        renderer?: ((context: ojTable.ColumnsRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        resizable?: 'enabled' | 'disabled';
+        sortProperty?: string | null;
+        sortable?: 'auto' | 'enabled' | 'disabled';
+        style?: string | null;
+        template?: {
+            componentElement: Element;
+            data: object;
+            row: object;
+            index: number;
+            columnIndex: number;
+            key: any;
+            mode: string;
+        };
+        width?: number | null;
+    };
+    currentRow: ojTable.CurrentRow<K> | null;
+    data: DataProvider<K, D> | null;
+    display: 'list' | 'grid';
+    dnd: {
+        drag: {
+            rows: {
+                dataTypes?: string | string[];
+                dragStart?: ((param0: DragEvent, param1: ojTable.DragRowContext<K, D>) => void);
+                drag?: ((param0: DragEvent) => void);
+                dragEnd?: ((param0: DragEvent) => void);
+            };
+        };
+        drop: {
+            columns: {
+                dataTypes: string | string[];
+                dragEnter?: ((param0: DragEvent, param1: ojTable.DropColumnContext) => void);
+                dragOver?: ((param0: DragEvent, param1: ojTable.DropColumnContext) => void);
+                dragLeave?: ((param0: DragEvent, param1: ojTable.DropColumnContext) => void);
+                drop: ((param0: DragEvent, param1: ojTable.DropColumnContext) => void);
+            };
+            rows: {
+                dataTypes: string | string[];
+                dragEnter?: ((param0: DragEvent, param1: ojTable.DropRowContext) => void);
+                dragOver?: ((param0: DragEvent, param1: ojTable.DropRowContext) => void);
+                dragLeave?: ((param0: DragEvent, param1: ojTable.DropRowContext) => void);
+                drop: ((param0: DragEvent, param1: ojTable.DropRowContext) => void);
+            };
+        };
+        reorder: {
+            columns: 'enabled' | 'disabled';
+        };
+    };
+    editMode: 'none' | 'rowEdit';
+    readonly firstSelectedRow: object;
+    horizontalGridVisible: 'auto' | 'enabled' | 'disabled';
+    rowRenderer: ((context: ojTable.RowRendererContext<K, D>) => string | HTMLElement | void) | null;
+    scrollPolicy: 'auto' | 'loadMoreOnScroll';
+    scrollPolicyOptions: {
+        fetchSize: number;
+        maxCount: number;
+    };
+    scrollPosition: {
+        x?: number;
+        y?: number;
+        columnIndex?: number;
+        rowIndex?: number;
+        columnKey?: any;
+        rowKey?: any;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    selection: Array<ojTable.RowSelectionStart<K> & ojTable.RowSelectionEnd<K>> | Array<ojTable.ColumnSelectionStart<K> & ojTable.ColumnSelectionEnd<K>>;
+    selectionMode: {
+        column: 'single' | 'multiple';
+        row: 'single' | 'multiple';
+    };
+    selectionRequired: boolean;
+    verticalGridVisible: 'auto' | 'enabled' | 'disabled';
+    translations: {
+        labelAccSelectionAffordanceBottom?: string;
+        labelAccSelectionAffordanceTop?: string;
+        labelDisableNonContiguousSelection?: string;
+        labelEditRow?: string;
+        labelEnableNonContiguousSelection?: string;
+        labelResize?: string;
+        labelResizePopupSpinner?: string;
+        labelResizePopupSubmit?: string;
+        labelSelectAndEditRow?: string;
+        labelSelectColum?: string;
+        labelSelectRow?: string;
+        labelSort?: string;
+        labelSortAsc?: string;
+        labelSortDsc?: string;
+        msgColumnResizeWidthValidation?: string;
+        msgFetchingData?: string;
+        msgInitializing?: string;
+        msgNoData?: string;
+        msgScrollPolicyMaxCountDetail?: string;
+        msgScrollPolicyMaxCountSummary?: string;
+        msgStatusSortAscending?: string;
+        msgStatusSortDescending?: string;
+    };
+    onAccessibilityChanged: ((event: JetElementCustomEvent<ojTable<K, D>["accessibility"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojTable<K, D>["as"]>) => any) | null;
+    onColumnsChanged: ((event: JetElementCustomEvent<ojTable<K, D>["columns"]>) => any) | null;
+    onColumnsDefaultChanged: ((event: JetElementCustomEvent<ojTable<K, D>["columnsDefault"]>) => any) | null;
+    onCurrentRowChanged: ((event: JetElementCustomEvent<ojTable<K, D>["currentRow"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojTable<K, D>["data"]>) => any) | null;
+    onDisplayChanged: ((event: JetElementCustomEvent<ojTable<K, D>["display"]>) => any) | null;
+    onDndChanged: ((event: JetElementCustomEvent<ojTable<K, D>["dnd"]>) => any) | null;
+    onEditModeChanged: ((event: JetElementCustomEvent<ojTable<K, D>["editMode"]>) => any) | null;
+    onFirstSelectedRowChanged: ((event: JetElementCustomEvent<ojTable<K, D>["firstSelectedRow"]>) => any) | null;
+    onHorizontalGridVisibleChanged: ((event: JetElementCustomEvent<ojTable<K, D>["horizontalGridVisible"]>) => any) | null;
+    onRowRendererChanged: ((event: JetElementCustomEvent<ojTable<K, D>["rowRenderer"]>) => any) | null;
+    onScrollPolicyChanged: ((event: JetElementCustomEvent<ojTable<K, D>["scrollPolicy"]>) => any) | null;
+    onScrollPolicyOptionsChanged: ((event: JetElementCustomEvent<ojTable<K, D>["scrollPolicyOptions"]>) => any) | null;
+    onScrollPositionChanged: ((event: JetElementCustomEvent<ojTable<K, D>["scrollPosition"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojTable<K, D>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojTable<K, D>["selectionMode"]>) => any) | null;
+    onSelectionRequiredChanged: ((event: JetElementCustomEvent<ojTable<K, D>["selectionRequired"]>) => any) | null;
+    onVerticalGridVisibleChanged: ((event: JetElementCustomEvent<ojTable<K, D>["verticalGridVisible"]>) => any) | null;
+    onOjAnimateEnd: ((event: ojTable.ojAnimateEnd) => any) | null;
+    onOjAnimateStart: ((event: ojTable.ojAnimateStart) => any) | null;
+    onOjBeforeCurrentRow: ((event: ojTable.ojBeforeCurrentRow<K>) => any) | null;
+    onOjBeforeRowEdit: ((event: ojTable.ojBeforeRowEdit) => any) | null;
+    onOjBeforeRowEditEnd: ((event: ojTable.ojBeforeRowEditEnd) => any) | null;
+    onOjSort: ((event: ojTable.ojSort) => any) | null;
+    addEventListener<T extends keyof ojTableEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojTableEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTableSettableProperties<K, D>>(property: T): ojTable<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTableSettableProperties<K, D>>(property: T, value: ojTableSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTableSettableProperties<K, D>>): void;
+    setProperties(properties: ojTableSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): {
+        subId: 'oj-table-cell';
+        rowIndex: number;
+        columnIndex: number;
+        key: string;
+    } | {
+        subId: 'oj-table-footer' | 'oj-table-header';
+        index: number;
+    };
+    getDataForVisibleRow(rowIndex: number): {
+        data: D;
+        index: number;
+        key: K;
+    } | null;
+    refresh(): void;
+    refreshRow(rowIdx: number): Promise<boolean>;
+}
+export namespace ojTable {
+    interface ojAnimateEnd extends CustomEvent<{
+        action: 'add' | 'remove' | 'update';
+        element: Element;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojAnimateStart extends CustomEvent<{
+        action: 'add' | 'remove' | 'update';
+        element: Element;
+        endCallback: (() => void);
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeCurrentRow<K> extends CustomEvent<{
+        currentRow: CurrentRow<K>;
+        previousCurrentRow: CurrentRow<K>;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeRowEdit extends CustomEvent<{
+        rowContext: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeRowEditEnd extends CustomEvent<{
+        rowContext: object;
+        cancelEdit: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojSort extends CustomEvent<{
+        header: Element;
+        direction: 'ascending' | 'descending';
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type ColumnSelectionEnd<K> = {
+        endIndex: {
+            column: number;
+        };
+        endKey?: {
+            column: K;
+        };
+    } | {
+        endIndex?: {
+            column: number;
+        };
+        endKey: {
+            column: K;
+        };
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type ColumnSelectionStart<K> = {
+        startIndex: {
+            column: number;
+        };
+        startKey?: {
+            column: K;
+        };
+    } | {
+        startIndex?: {
+            column: number;
+        };
+        startKey: {
+            column: K;
+        };
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type ColumnsRendererContext<K, D> = {
+        cellContext: {
+            datasource: DataProvider<K, D> | null;
+            mode: 'edit' | 'navigation';
+            status: ContextStatus<K>;
+        };
+        columnIndex: number;
+        componentElement: Element;
+        data: D;
+        parentElement: Element;
+        row: {
+            [name: string]: any;
+        };
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type ContextStatus<K> = {
+        rowIndex: number;
+        rowKey: K;
+        currentRow: CurrentRow<K>;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type CurrentRow<K> = {
+        rowIndex: number;
+        rowKey?: K;
+    } | {
+        rowIndex?: number;
+        rowKey: K;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type DragRowContext<K, D> = {
+        rows: Array<{
+            data: D;
+            index: number;
+            key: K;
+        }>;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type DropColumnContext = {
+        columnIndex: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type DropRowContext = {
+        rowIndex: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type FooterRendererContext<K, D> = {
+        columnIndex: number;
+        componentElement: Element;
+        footerContext: {
+            datasource: DataProvider<K, D> | null;
+        };
+        parentElement: Element;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type HeaderRendererContext<K, D> = {
+        columnIndex: number;
+        columnHeaderDefaultRenderer?: ((param0: object, param1: ((param0: object) => void)) => void);
+        columnHeaderSortableIconRenderer?: ((param0: object, param1: ((param0: object) => void)) => void);
+        componentElement: Element;
+        data: string;
+        headerContext: {
+            datasource: DataProvider<K, D> | null;
+        };
+        parentElement: Element;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RowRendererContext<K, D> = {
+        componentElement: Element;
+        data: {
+            [name: string]: any;
+        };
+        parentElement: Element;
+        rowContext: {
+            datasource: DataProvider<K, D> | null;
+            mode: 'edit' | 'navigation';
+            status: ContextStatus<K>;
+        };
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RowSelectionEnd<K> = {
+        endIndex: {
+            row: number;
+        };
+        endKey?: {
+            row: K;
+        };
+    } | {
+        endIndex?: {
+            row: number;
+        };
+        endKey: {
+            row: K;
+        };
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RowSelectionStart<K> = {
+        startIndex: {
+            row: number;
+        };
+        startKey?: {
+            row: K;
+        };
+    } | {
+        startIndex?: {
+            row: number;
+        };
+        startKey: {
+            row: K;
+        };
+    };
+}
+export interface ojTableEventMap<K, D> extends baseComponentEventMap<ojTableSettableProperties<K, D>> {
+    'ojAnimateEnd': ojTable.ojAnimateEnd;
+    'ojAnimateStart': ojTable.ojAnimateStart;
+    'ojBeforeCurrentRow': ojTable.ojBeforeCurrentRow<K>;
+    'ojBeforeRowEdit': ojTable.ojBeforeRowEdit;
+    'ojBeforeRowEditEnd': ojTable.ojBeforeRowEditEnd;
+    'ojSort': ojTable.ojSort;
+    'accessibilityChanged': JetElementCustomEvent<ojTable<K, D>["accessibility"]>;
+    'asChanged': JetElementCustomEvent<ojTable<K, D>["as"]>;
+    'columnsChanged': JetElementCustomEvent<ojTable<K, D>["columns"]>;
+    'columnsDefaultChanged': JetElementCustomEvent<ojTable<K, D>["columnsDefault"]>;
+    'currentRowChanged': JetElementCustomEvent<ojTable<K, D>["currentRow"]>;
+    'dataChanged': JetElementCustomEvent<ojTable<K, D>["data"]>;
+    'displayChanged': JetElementCustomEvent<ojTable<K, D>["display"]>;
+    'dndChanged': JetElementCustomEvent<ojTable<K, D>["dnd"]>;
+    'editModeChanged': JetElementCustomEvent<ojTable<K, D>["editMode"]>;
+    'firstSelectedRowChanged': JetElementCustomEvent<ojTable<K, D>["firstSelectedRow"]>;
+    'horizontalGridVisibleChanged': JetElementCustomEvent<ojTable<K, D>["horizontalGridVisible"]>;
+    'rowRendererChanged': JetElementCustomEvent<ojTable<K, D>["rowRenderer"]>;
+    'scrollPolicyChanged': JetElementCustomEvent<ojTable<K, D>["scrollPolicy"]>;
+    'scrollPolicyOptionsChanged': JetElementCustomEvent<ojTable<K, D>["scrollPolicyOptions"]>;
+    'scrollPositionChanged': JetElementCustomEvent<ojTable<K, D>["scrollPosition"]>;
+    'selectionChanged': JetElementCustomEvent<ojTable<K, D>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojTable<K, D>["selectionMode"]>;
+    'selectionRequiredChanged': JetElementCustomEvent<ojTable<K, D>["selectionRequired"]>;
+    'verticalGridVisibleChanged': JetElementCustomEvent<ojTable<K, D>["verticalGridVisible"]>;
+}
+export interface ojTableSettableProperties<K, D> extends baseComponentSettableProperties {
+    accessibility: {
+        rowHeader: string;
+    };
+    as: string;
+    columns: Array<{
+        className?: string | null;
+        field?: string | null;
+        footerClassName?: string | null;
+        footerRenderer?: ((context: ojTable.FooterRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        footerStyle?: string | null;
+        footerTemplate?: {
+            componentElement: Element;
+        };
+        headerClassName?: string | null;
+        headerRenderer?: ((context: ojTable.HeaderRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        headerStyle?: string | null;
+        headerTemplate?: {
+            componentElement: Element;
+            data: object;
+        };
+        headerText?: string | null;
+        id?: string | null;
+        renderer?: ((context: ojTable.ColumnsRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        resizable?: 'enabled' | 'disabled';
+        sortProperty?: string | null;
+        sortable?: 'auto' | 'enabled' | 'disabled';
+        style?: string | null;
+        template?: {
+            componentElement: Element;
+            data: object;
+            row: object;
+            index: number;
+            columnIndex: number;
+            key: any;
+            mode: string;
+        };
+        width?: number | null;
+    }> | null;
+    columnsDefault: {
+        className?: string | null;
+        field?: string | null;
+        footerClassName?: string | null;
+        footerRenderer?: ((context: ojTable.FooterRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        footerStyle?: string | null;
+        footerTemplate?: {
+            componentElement: Element;
+        };
+        headerClassName?: string | null;
+        headerRenderer?: ((context: ojTable.HeaderRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        headerStyle?: string | null;
+        headerTemplate?: {
+            componentElement: Element;
+            data: object;
+        };
+        headerText?: string | null;
+        renderer?: ((context: ojTable.ColumnsRendererContext<K, D>) => {
+            insert: HTMLElement | string;
+        } | void) | null;
+        resizable?: 'enabled' | 'disabled';
+        sortProperty?: string | null;
+        sortable?: 'auto' | 'enabled' | 'disabled';
+        style?: string | null;
+        template?: {
+            componentElement: Element;
+            data: object;
+            row: object;
+            index: number;
+            columnIndex: number;
+            key: any;
+            mode: string;
+        };
+        width?: number | null;
+    };
+    currentRow: ojTable.CurrentRow<K> | null;
+    data: DataProvider<K, D> | null;
+    display: 'list' | 'grid';
+    dnd: {
+        drag: {
+            rows: {
+                dataTypes?: string | string[];
+                dragStart?: ((param0: DragEvent, param1: ojTable.DragRowContext<K, D>) => void);
+                drag?: ((param0: DragEvent) => void);
+                dragEnd?: ((param0: DragEvent) => void);
+            };
+        };
+        drop: {
+            columns: {
+                dataTypes: string | string[];
+                dragEnter?: ((param0: DragEvent, param1: ojTable.DropColumnContext) => void);
+                dragOver?: ((param0: DragEvent, param1: ojTable.DropColumnContext) => void);
+                dragLeave?: ((param0: DragEvent, param1: ojTable.DropColumnContext) => void);
+                drop: ((param0: DragEvent, param1: ojTable.DropColumnContext) => void);
+            };
+            rows: {
+                dataTypes: string | string[];
+                dragEnter?: ((param0: DragEvent, param1: ojTable.DropRowContext) => void);
+                dragOver?: ((param0: DragEvent, param1: ojTable.DropRowContext) => void);
+                dragLeave?: ((param0: DragEvent, param1: ojTable.DropRowContext) => void);
+                drop: ((param0: DragEvent, param1: ojTable.DropRowContext) => void);
+            };
+        };
+        reorder: {
+            columns: 'enabled' | 'disabled';
+        };
+    };
+    editMode: 'none' | 'rowEdit';
+    readonly firstSelectedRow: object;
+    horizontalGridVisible: 'auto' | 'enabled' | 'disabled';
+    rowRenderer: ((context: ojTable.RowRendererContext<K, D>) => string | HTMLElement | void) | null;
+    scrollPolicy: 'auto' | 'loadMoreOnScroll';
+    scrollPolicyOptions: {
+        fetchSize: number;
+        maxCount: number;
+    };
+    scrollPosition: {
+        x?: number;
+        y?: number;
+        columnIndex?: number;
+        rowIndex?: number;
+        columnKey?: any;
+        rowKey?: any;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    selection: Array<ojTable.RowSelectionStart<K> & ojTable.RowSelectionEnd<K>> | Array<ojTable.ColumnSelectionStart<K> & ojTable.ColumnSelectionEnd<K>>;
+    selectionMode: {
+        column: 'single' | 'multiple';
+        row: 'single' | 'multiple';
+    };
+    selectionRequired: boolean;
+    verticalGridVisible: 'auto' | 'enabled' | 'disabled';
+    translations: {
+        labelAccSelectionAffordanceBottom?: string;
+        labelAccSelectionAffordanceTop?: string;
+        labelDisableNonContiguousSelection?: string;
+        labelEditRow?: string;
+        labelEnableNonContiguousSelection?: string;
+        labelResize?: string;
+        labelResizePopupSpinner?: string;
+        labelResizePopupSubmit?: string;
+        labelSelectAndEditRow?: string;
+        labelSelectColum?: string;
+        labelSelectRow?: string;
+        labelSort?: string;
+        labelSortAsc?: string;
+        labelSortDsc?: string;
+        msgColumnResizeWidthValidation?: string;
+        msgFetchingData?: string;
+        msgInitializing?: string;
+        msgNoData?: string;
+        msgScrollPolicyMaxCountDetail?: string;
+        msgScrollPolicyMaxCountSummary?: string;
+        msgStatusSortAscending?: string;
+        msgStatusSortDescending?: string;
+    };
+}
+export interface ojTableSettablePropertiesLenient<K, D> extends Partial<ojTableSettableProperties<K, D>> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojtagcloud/index.d.ts

@@ -0,0 +1,208 @@
+import { DataProvider } from '../ojdataprovider';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojTagCloud<K, D> extends dvtBaseComponent<ojTagCloudSettableProperties<K, D>> {
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    as: string;
+    data: DataProvider<K, D> | null;
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    layout: 'cloud' | 'rectangular';
+    selection: K[];
+    selectionMode: 'single' | 'multiple' | 'none';
+    styleDefaults: {
+        animationDuration?: number;
+        hoverBehaviorDelay?: number;
+        svgStyle?: object;
+    };
+    tooltip: {
+        renderer: ((context: ojTagCloud.TooltipContext<K>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    touchResponse: 'touchStart' | 'auto';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    onAnimationOnDataChangeChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["animationOnDataChange"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["animationOnDisplay"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["as"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["data"]>) => any) | null;
+    onHiddenCategoriesChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["hiddenCategories"]>) => any) | null;
+    onHighlightMatchChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["highlightMatch"]>) => any) | null;
+    onHighlightedCategoriesChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["highlightedCategories"]>) => any) | null;
+    onHoverBehaviorChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["hoverBehavior"]>) => any) | null;
+    onLayoutChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["layout"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["selectionMode"]>) => any) | null;
+    onStyleDefaultsChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["styleDefaults"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["tooltip"]>) => any) | null;
+    onTouchResponseChanged: ((event: JetElementCustomEvent<ojTagCloud<K, D>["touchResponse"]>) => any) | null;
+    addEventListener<T extends keyof ojTagCloudEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojTagCloudEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTagCloudSettableProperties<K, D>>(property: T): ojTagCloud<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTagCloudSettableProperties<K, D>>(property: T, value: ojTagCloudSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTagCloudSettableProperties<K, D>>): void;
+    setProperties(properties: ojTagCloudSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojTagCloud.NodeContext | null;
+    getItem(index: number): ojTagCloud.ItemContext | null;
+    getItemCount(): number;
+}
+export interface ojTagCloudEventMap<K, D> extends dvtBaseComponentEventMap<ojTagCloudSettableProperties<K, D>> {
+    'animationOnDataChangeChanged': JetElementCustomEvent<ojTagCloud<K, D>["animationOnDataChange"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojTagCloud<K, D>["animationOnDisplay"]>;
+    'asChanged': JetElementCustomEvent<ojTagCloud<K, D>["as"]>;
+    'dataChanged': JetElementCustomEvent<ojTagCloud<K, D>["data"]>;
+    'hiddenCategoriesChanged': JetElementCustomEvent<ojTagCloud<K, D>["hiddenCategories"]>;
+    'highlightMatchChanged': JetElementCustomEvent<ojTagCloud<K, D>["highlightMatch"]>;
+    'highlightedCategoriesChanged': JetElementCustomEvent<ojTagCloud<K, D>["highlightedCategories"]>;
+    'hoverBehaviorChanged': JetElementCustomEvent<ojTagCloud<K, D>["hoverBehavior"]>;
+    'layoutChanged': JetElementCustomEvent<ojTagCloud<K, D>["layout"]>;
+    'selectionChanged': JetElementCustomEvent<ojTagCloud<K, D>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojTagCloud<K, D>["selectionMode"]>;
+    'styleDefaultsChanged': JetElementCustomEvent<ojTagCloud<K, D>["styleDefaults"]>;
+    'tooltipChanged': JetElementCustomEvent<ojTagCloud<K, D>["tooltip"]>;
+    'touchResponseChanged': JetElementCustomEvent<ojTagCloud<K, D>["touchResponse"]>;
+}
+export interface ojTagCloudSettableProperties<K, D> extends dvtBaseComponentSettableProperties {
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    as: string;
+    data: DataProvider<K, D> | null;
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    layout: 'cloud' | 'rectangular';
+    selection: K[];
+    selectionMode: 'single' | 'multiple' | 'none';
+    styleDefaults: {
+        animationDuration?: number;
+        hoverBehaviorDelay?: number;
+        svgStyle?: object;
+    };
+    tooltip: {
+        renderer: ((context: ojTagCloud.TooltipContext<K>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    touchResponse: 'touchStart' | 'auto';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface ojTagCloudSettablePropertiesLenient<K, D> extends Partial<ojTagCloudSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export namespace ojTagCloud {
+    // tslint:disable-next-line interface-over-type-literal
+    type ItemContext = {
+        color: string;
+        label: string;
+        selected: boolean;
+        tooltip: string;
+        value: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContext = {
+        subId: string;
+        index: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext<K> = {
+        color: string;
+        componentElement: Element;
+        id: K;
+        label: string;
+        parentElement: Element;
+        value: number;
+    };
+}
+export interface ojTagCloudItem extends JetElement<ojTagCloudItemSettableProperties> {
+    categories: string[];
+    color?: string;
+    label: string;
+    shortDesc: string;
+    svgClassName: string;
+    svgStyle: object;
+    url: string;
+    value: number | null;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojTagCloudItem["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojTagCloudItem["color"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojTagCloudItem["label"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojTagCloudItem["shortDesc"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojTagCloudItem["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojTagCloudItem["svgStyle"]>) => any) | null;
+    onUrlChanged: ((event: JetElementCustomEvent<ojTagCloudItem["url"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojTagCloudItem["value"]>) => any) | null;
+    addEventListener<T extends keyof ojTagCloudItemEventMap>(type: T, listener: (this: HTMLElement, ev: ojTagCloudItemEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTagCloudItemSettableProperties>(property: T): ojTagCloudItem[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTagCloudItemSettableProperties>(property: T, value: ojTagCloudItemSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTagCloudItemSettableProperties>): void;
+    setProperties(properties: ojTagCloudItemSettablePropertiesLenient): void;
+}
+export interface ojTagCloudItemEventMap extends HTMLElementEventMap {
+    'categoriesChanged': JetElementCustomEvent<ojTagCloudItem["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojTagCloudItem["color"]>;
+    'labelChanged': JetElementCustomEvent<ojTagCloudItem["label"]>;
+    'shortDescChanged': JetElementCustomEvent<ojTagCloudItem["shortDesc"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojTagCloudItem["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojTagCloudItem["svgStyle"]>;
+    'urlChanged': JetElementCustomEvent<ojTagCloudItem["url"]>;
+    'valueChanged': JetElementCustomEvent<ojTagCloudItem["value"]>;
+}
+export interface ojTagCloudItemSettableProperties extends JetSettableProperties {
+    categories: string[];
+    color?: string;
+    label: string;
+    shortDesc: string;
+    svgClassName: string;
+    svgStyle: object;
+    url: string;
+    value: number | null;
+}
+export interface ojTagCloudItemSettablePropertiesLenient extends Partial<ojTagCloudItemSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojthematicmap/index.d.ts

@@ -0,0 +1,576 @@
+import { DataProvider } from '../ojdataprovider';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojThematicMap<K1, K2, K3, D1, D2, D3> extends dvtBaseComponent<ojThematicMapSettableProperties<K1, K2, K3, D1, D2, D3>> {
+    animationDuration: number;
+    animationOnDisplay: 'auto' | 'none';
+    areaData: DataProvider<K1, D1> | null;
+    as: string;
+    focusRenderer: ((context: ojThematicMap.RendererContext<K1, K2, K3, D1, D2, D3>) => {
+        insert: SVGElement;
+    } | void) | null;
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverRenderer: ((context: ojThematicMap.RendererContext<K1, K2, K3, D1, D2, D3>) => {
+        insert: SVGElement;
+    } | void) | null;
+    initialZooming: 'auto' | 'none';
+    isolatedItem: K1;
+    labelDisplay: 'on' | 'off' | 'auto';
+    labelType: 'long' | 'short';
+    linkData: DataProvider<K2, D2> | null;
+    mapProvider: {
+        geo: object;
+        propertiesKeys: {
+            id: string;
+            longLabel?: string;
+            shortLabel?: string;
+        };
+    };
+    markerData: DataProvider<K3, D3> | null;
+    markerZoomBehavior: 'zoom' | 'fixed';
+    maxZoom: number;
+    panning: 'auto' | 'none';
+    renderer: ((context: ojThematicMap.RendererContext<K1, K2, K3, D1, D2, D3>) => {
+        insert: SVGElement;
+    } | void) | null;
+    selection: Array<K1 | K2 | K3>;
+    selectionMode: 'single' | 'multiple' | 'none';
+    selectionRenderer: ((context: ojThematicMap.RendererContext<K1, K2, K3, D1, D2, D3>) => {
+        insert: SVGElement;
+    } | void) | null;
+    styleDefaults: {
+        areaSvgStyle?: object;
+        dataAreaDefaults?: {
+            borderColor?: string;
+            hoverColor?: string;
+            selectedInnerColor?: string;
+            selectedOuterColor?: string;
+        };
+        dataMarkerDefaults?: {
+            borderColor?: string;
+            borderStyle?: 'none' | 'solid';
+            borderWidth?: number;
+            color?: string;
+            height?: number;
+            labelStyle?: object;
+            opacity?: number;
+            shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+            width?: number;
+        };
+        hoverBehaviorDelay?: number;
+        labelStyle?: object;
+        linkDefaults?: {
+            color?: string;
+            width?: number;
+        };
+    };
+    tooltip: {
+        renderer: ((context: ojThematicMap.TooltipContext<K1, K2, K3, D1, D2, D3>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    tooltipDisplay: 'auto' | 'labelAndShortDesc' | 'none' | 'shortDesc';
+    touchResponse: 'touchStart' | 'auto';
+    zooming: 'auto' | 'none';
+    translations: {
+        areasRegion?: string;
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        linksRegion?: string;
+        markersRegion?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    onAnimationDurationChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["animationDuration"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["animationOnDisplay"]>) => any) | null;
+    onAreaDataChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["areaData"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["as"]>) => any) | null;
+    onFocusRendererChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["focusRenderer"]>) => any) | null;
+    onHiddenCategoriesChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["hiddenCategories"]>) => any) | null;
+    onHighlightMatchChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["highlightMatch"]>) => any) | null;
+    onHighlightedCategoriesChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["highlightedCategories"]>) => any) | null;
+    onHoverBehaviorChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["hoverBehavior"]>) => any) | null;
+    onHoverRendererChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["hoverRenderer"]>) => any) | null;
+    onInitialZoomingChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["initialZooming"]>) => any) | null;
+    onIsolatedItemChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["isolatedItem"]>) => any) | null;
+    onLabelDisplayChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["labelDisplay"]>) => any) | null;
+    onLabelTypeChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["labelType"]>) => any) | null;
+    onLinkDataChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["linkData"]>) => any) | null;
+    onMapProviderChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["mapProvider"]>) => any) | null;
+    onMarkerDataChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["markerData"]>) => any) | null;
+    onMarkerZoomBehaviorChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["markerZoomBehavior"]>) => any) | null;
+    onMaxZoomChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["maxZoom"]>) => any) | null;
+    onPanningChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["panning"]>) => any) | null;
+    onRendererChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["renderer"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["selectionMode"]>) => any) | null;
+    onSelectionRendererChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["selectionRenderer"]>) => any) | null;
+    onStyleDefaultsChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["styleDefaults"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["tooltip"]>) => any) | null;
+    onTooltipDisplayChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["tooltipDisplay"]>) => any) | null;
+    onTouchResponseChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["touchResponse"]>) => any) | null;
+    onZoomingChanged: ((event: JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["zooming"]>) => any) | null;
+    addEventListener<T extends keyof ojThematicMapEventMap<K1, K2, K3, D1, D2, D3>>(type: T, listener: (this: HTMLElement, ev: ojThematicMapEventMap<K1, K2, K3, D1, D2, D3>[T]) => any,
+       useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojThematicMapSettableProperties<K1, K2, K3, D1, D2, D3>>(property: T): ojThematicMap<K1, K2, K3, D1, D2, D3>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojThematicMapSettableProperties<K1, K2, K3, D1, D2, D3>>(property: T, value: ojThematicMapSettableProperties<K1, K2, K3, D1, D2, D3>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojThematicMapSettableProperties<K1, K2, K3, D1, D2, D3>>): void;
+    setProperties(properties: ojThematicMapSettablePropertiesLenient<K1, K2, K3, D1, D2, D3>): void;
+    getArea(index: number): ojThematicMap.DataContext | null;
+    getContextByNode(node: Element): ojThematicMap.NodeContext | null;
+    getLink(index: number): ojThematicMap.DataContext | null;
+    getMarker(index: number): ojThematicMap.DataContext | null;
+}
+export interface ojThematicMapEventMap<K1, K2, K3, D1, D2, D3> extends dvtBaseComponentEventMap<ojThematicMapSettableProperties<K1, K2, K3, D1, D2, D3>> {
+    'animationDurationChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["animationDuration"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["animationOnDisplay"]>;
+    'areaDataChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["areaData"]>;
+    'asChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["as"]>;
+    'focusRendererChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["focusRenderer"]>;
+    'hiddenCategoriesChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["hiddenCategories"]>;
+    'highlightMatchChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["highlightMatch"]>;
+    'highlightedCategoriesChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["highlightedCategories"]>;
+    'hoverBehaviorChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["hoverBehavior"]>;
+    'hoverRendererChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["hoverRenderer"]>;
+    'initialZoomingChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["initialZooming"]>;
+    'isolatedItemChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["isolatedItem"]>;
+    'labelDisplayChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["labelDisplay"]>;
+    'labelTypeChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["labelType"]>;
+    'linkDataChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["linkData"]>;
+    'mapProviderChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["mapProvider"]>;
+    'markerDataChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["markerData"]>;
+    'markerZoomBehaviorChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["markerZoomBehavior"]>;
+    'maxZoomChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["maxZoom"]>;
+    'panningChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["panning"]>;
+    'rendererChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["renderer"]>;
+    'selectionChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["selectionMode"]>;
+    'selectionRendererChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["selectionRenderer"]>;
+    'styleDefaultsChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["styleDefaults"]>;
+    'tooltipChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["tooltip"]>;
+    'tooltipDisplayChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["tooltipDisplay"]>;
+    'touchResponseChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["touchResponse"]>;
+    'zoomingChanged': JetElementCustomEvent<ojThematicMap<K1, K2, K3, D1, D2, D3>["zooming"]>;
+}
+export interface ojThematicMapSettableProperties<K1, K2, K3, D1, D2, D3> extends dvtBaseComponentSettableProperties {
+    animationDuration: number;
+    animationOnDisplay: 'auto' | 'none';
+    areaData: DataProvider<K1, D1> | null;
+    as: string;
+    focusRenderer: ((context: ojThematicMap.RendererContext<K1, K2, K3, D1, D2, D3>) => {
+        insert: SVGElement;
+    } | void) | null;
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverRenderer: ((context: ojThematicMap.RendererContext<K1, K2, K3, D1, D2, D3>) => {
+        insert: SVGElement;
+    } | void) | null;
+    initialZooming: 'auto' | 'none';
+    isolatedItem: K1;
+    labelDisplay: 'on' | 'off' | 'auto';
+    labelType: 'long' | 'short';
+    linkData: DataProvider<K2, D2> | null;
+    mapProvider: {
+        geo: object;
+        propertiesKeys: {
+            id: string;
+            longLabel?: string;
+            shortLabel?: string;
+        };
+    };
+    markerData: DataProvider<K3, D3> | null;
+    markerZoomBehavior: 'zoom' | 'fixed';
+    maxZoom: number;
+    panning: 'auto' | 'none';
+    renderer: ((context: ojThematicMap.RendererContext<K1, K2, K3, D1, D2, D3>) => {
+        insert: SVGElement;
+    } | void) | null;
+    selection: Array<K1 | K2 | K3>;
+    selectionMode: 'single' | 'multiple' | 'none';
+    selectionRenderer: ((context: ojThematicMap.RendererContext<K1, K2, K3, D1, D2, D3>) => {
+        insert: SVGElement;
+    } | void) | null;
+    styleDefaults: {
+        areaSvgStyle?: object;
+        dataAreaDefaults?: {
+            borderColor?: string;
+            hoverColor?: string;
+            selectedInnerColor?: string;
+            selectedOuterColor?: string;
+        };
+        dataMarkerDefaults?: {
+            borderColor?: string;
+            borderStyle?: 'none' | 'solid';
+            borderWidth?: number;
+            color?: string;
+            height?: number;
+            labelStyle?: object;
+            opacity?: number;
+            shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+            width?: number;
+        };
+        hoverBehaviorDelay?: number;
+        labelStyle?: object;
+        linkDefaults?: {
+            color?: string;
+            width?: number;
+        };
+    };
+    tooltip: {
+        renderer: ((context: ojThematicMap.TooltipContext<K1, K2, K3, D1, D2, D3>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    tooltipDisplay: 'auto' | 'labelAndShortDesc' | 'none' | 'shortDesc';
+    touchResponse: 'touchStart' | 'auto';
+    zooming: 'auto' | 'none';
+    translations: {
+        areasRegion?: string;
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        linksRegion?: string;
+        markersRegion?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface ojThematicMapSettablePropertiesLenient<K1, K2, K3, D1, D2, D3> extends Partial<ojThematicMapSettableProperties<K1, K2, K3, D1, D2, D3>> {
+    [key: string]: any;
+}
+export namespace ojThematicMap {
+    // tslint:disable-next-line interface-over-type-literal
+    type DataContext = {
+        color: string;
+        label: string;
+        selected: boolean;
+        tooltip: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContext = {
+        subId: string;
+        index: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RendererContext<K1, K2, K3, D1, D2, D3> = {
+        color: string;
+        componentElement: Element;
+        data: object;
+        id: K1 | K2 | K3;
+        itemData: D1 | D2 | D3;
+        label: string;
+        location: string | null;
+        parentElement: Element;
+        previousState: {
+            hovered: boolean;
+            selected: boolean;
+            focused: boolean;
+        };
+        renderDefaultFocus: (() => void);
+        renderDefaultHover: (() => void);
+        renderDefaultSelection: (() => void);
+        root: Element | null;
+        state: {
+            hovered: boolean;
+            selected: boolean;
+            focused: boolean;
+        };
+        x: number | null;
+        y: number | null;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext<K1, K2, K3, D1, D2, D3> = {
+        color: string | null;
+        componentElement: Element;
+        data: object | null;
+        id: K1 | K2 | K3;
+        itemData: D1 | D2 | D3;
+        label: string | null;
+        location: string | null;
+        locationName: string | null;
+        parentElement: Element;
+        tooltip: string;
+        x: number;
+        y: number;
+    };
+}
+export interface ojThematicMapArea extends JetElement<ojThematicMapAreaSettableProperties> {
+    categories: string[];
+    color: string;
+    label: string;
+    labelStyle: object;
+    location: string;
+    opacity: number;
+    selectable: 'auto' | 'off';
+    shortDesc: string;
+    svgClassName: string;
+    svgStyle: object;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojThematicMapArea["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojThematicMapArea["color"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojThematicMapArea["label"]>) => any) | null;
+    onLabelStyleChanged: ((event: JetElementCustomEvent<ojThematicMapArea["labelStyle"]>) => any) | null;
+    onLocationChanged: ((event: JetElementCustomEvent<ojThematicMapArea["location"]>) => any) | null;
+    onOpacityChanged: ((event: JetElementCustomEvent<ojThematicMapArea["opacity"]>) => any) | null;
+    onSelectableChanged: ((event: JetElementCustomEvent<ojThematicMapArea["selectable"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojThematicMapArea["shortDesc"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojThematicMapArea["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojThematicMapArea["svgStyle"]>) => any) | null;
+    addEventListener<T extends keyof ojThematicMapAreaEventMap>(type: T, listener: (this: HTMLElement, ev: ojThematicMapAreaEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojThematicMapAreaSettableProperties>(property: T): ojThematicMapArea[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojThematicMapAreaSettableProperties>(property: T, value: ojThematicMapAreaSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojThematicMapAreaSettableProperties>): void;
+    setProperties(properties: ojThematicMapAreaSettablePropertiesLenient): void;
+}
+export interface ojThematicMapAreaEventMap extends HTMLElementEventMap {
+    'categoriesChanged': JetElementCustomEvent<ojThematicMapArea["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojThematicMapArea["color"]>;
+    'labelChanged': JetElementCustomEvent<ojThematicMapArea["label"]>;
+    'labelStyleChanged': JetElementCustomEvent<ojThematicMapArea["labelStyle"]>;
+    'locationChanged': JetElementCustomEvent<ojThematicMapArea["location"]>;
+    'opacityChanged': JetElementCustomEvent<ojThematicMapArea["opacity"]>;
+    'selectableChanged': JetElementCustomEvent<ojThematicMapArea["selectable"]>;
+    'shortDescChanged': JetElementCustomEvent<ojThematicMapArea["shortDesc"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojThematicMapArea["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojThematicMapArea["svgStyle"]>;
+}
+export interface ojThematicMapAreaSettableProperties extends JetSettableProperties {
+    categories: string[];
+    color: string;
+    label: string;
+    labelStyle: object;
+    location: string;
+    opacity: number;
+    selectable: 'auto' | 'off';
+    shortDesc: string;
+    svgClassName: string;
+    svgStyle: object;
+}
+export interface ojThematicMapAreaSettablePropertiesLenient extends Partial<ojThematicMapAreaSettableProperties> {
+    [key: string]: any;
+}
+export interface ojThematicMapLink extends JetElement<ojThematicMapLinkSettableProperties> {
+    categories: string[];
+    color: string;
+    endLocation: {
+        id?: any;
+        location?: string;
+        x?: number;
+        y?: number;
+    };
+    selectable: 'auto' | 'off';
+    shortDesc: string;
+    startLocation: {
+        id?: any;
+        location?: string;
+        x?: number;
+        y?: number;
+    };
+    svgClassName: string;
+    svgStyle: object;
+    width: number;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojThematicMapLink["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojThematicMapLink["color"]>) => any) | null;
+    onEndLocationChanged: ((event: JetElementCustomEvent<ojThematicMapLink["endLocation"]>) => any) | null;
+    onSelectableChanged: ((event: JetElementCustomEvent<ojThematicMapLink["selectable"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojThematicMapLink["shortDesc"]>) => any) | null;
+    onStartLocationChanged: ((event: JetElementCustomEvent<ojThematicMapLink["startLocation"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojThematicMapLink["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojThematicMapLink["svgStyle"]>) => any) | null;
+    onWidthChanged: ((event: JetElementCustomEvent<ojThematicMapLink["width"]>) => any) | null;
+    addEventListener<T extends keyof ojThematicMapLinkEventMap>(type: T, listener: (this: HTMLElement, ev: ojThematicMapLinkEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojThematicMapLinkSettableProperties>(property: T): ojThematicMapLink[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojThematicMapLinkSettableProperties>(property: T, value: ojThematicMapLinkSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojThematicMapLinkSettableProperties>): void;
+    setProperties(properties: ojThematicMapLinkSettablePropertiesLenient): void;
+}
+export interface ojThematicMapLinkEventMap extends HTMLElementEventMap {
+    'categoriesChanged': JetElementCustomEvent<ojThematicMapLink["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojThematicMapLink["color"]>;
+    'endLocationChanged': JetElementCustomEvent<ojThematicMapLink["endLocation"]>;
+    'selectableChanged': JetElementCustomEvent<ojThematicMapLink["selectable"]>;
+    'shortDescChanged': JetElementCustomEvent<ojThematicMapLink["shortDesc"]>;
+    'startLocationChanged': JetElementCustomEvent<ojThematicMapLink["startLocation"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojThematicMapLink["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojThematicMapLink["svgStyle"]>;
+    'widthChanged': JetElementCustomEvent<ojThematicMapLink["width"]>;
+}
+export interface ojThematicMapLinkSettableProperties extends JetSettableProperties {
+    categories: string[];
+    color: string;
+    endLocation: {
+        id?: any;
+        location?: string;
+        x?: number;
+        y?: number;
+    };
+    selectable: 'auto' | 'off';
+    shortDesc: string;
+    startLocation: {
+        id?: any;
+        location?: string;
+        x?: number;
+        y?: number;
+    };
+    svgClassName: string;
+    svgStyle: object;
+    width: number;
+}
+export interface ojThematicMapLinkSettablePropertiesLenient extends Partial<ojThematicMapLinkSettableProperties> {
+    [key: string]: any;
+}
+export interface ojThematicMapMarker extends JetElement<ojThematicMapMarkerSettableProperties> {
+    borderColor: string;
+    borderStyle: 'solid' | 'none';
+    borderWidth: number;
+    categories: string[];
+    color: string;
+    height: number;
+    label: string;
+    labelPosition: 'bottom' | 'center' | 'top';
+    labelStyle: object;
+    location: string;
+    opacity: number;
+    rotation: number;
+    selectable: 'auto' | 'off';
+    shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+    shortDesc: string;
+    source: string;
+    sourceHover: string;
+    sourceHoverSelected: string;
+    sourceSelected: string;
+    svgClassName: string;
+    svgStyle: object;
+    value: number;
+    width: number;
+    x: number | null;
+    y: number | null;
+    onBorderColorChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["borderColor"]>) => any) | null;
+    onBorderStyleChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["borderStyle"]>) => any) | null;
+    onBorderWidthChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["borderWidth"]>) => any) | null;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["color"]>) => any) | null;
+    onHeightChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["height"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["label"]>) => any) | null;
+    onLabelPositionChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["labelPosition"]>) => any) | null;
+    onLabelStyleChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["labelStyle"]>) => any) | null;
+    onLocationChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["location"]>) => any) | null;
+    onOpacityChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["opacity"]>) => any) | null;
+    onRotationChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["rotation"]>) => any) | null;
+    onSelectableChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["selectable"]>) => any) | null;
+    onShapeChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["shape"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["shortDesc"]>) => any) | null;
+    onSourceChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["source"]>) => any) | null;
+    onSourceHoverChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["sourceHover"]>) => any) | null;
+    onSourceHoverSelectedChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["sourceHoverSelected"]>) => any) | null;
+    onSourceSelectedChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["sourceSelected"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["svgStyle"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["value"]>) => any) | null;
+    onWidthChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["width"]>) => any) | null;
+    onXChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["x"]>) => any) | null;
+    onYChanged: ((event: JetElementCustomEvent<ojThematicMapMarker["y"]>) => any) | null;
+    addEventListener<T extends keyof ojThematicMapMarkerEventMap>(type: T, listener: (this: HTMLElement, ev: ojThematicMapMarkerEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojThematicMapMarkerSettableProperties>(property: T): ojThematicMapMarker[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojThematicMapMarkerSettableProperties>(property: T, value: ojThematicMapMarkerSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojThematicMapMarkerSettableProperties>): void;
+    setProperties(properties: ojThematicMapMarkerSettablePropertiesLenient): void;
+}
+export interface ojThematicMapMarkerEventMap extends HTMLElementEventMap {
+    'borderColorChanged': JetElementCustomEvent<ojThematicMapMarker["borderColor"]>;
+    'borderStyleChanged': JetElementCustomEvent<ojThematicMapMarker["borderStyle"]>;
+    'borderWidthChanged': JetElementCustomEvent<ojThematicMapMarker["borderWidth"]>;
+    'categoriesChanged': JetElementCustomEvent<ojThematicMapMarker["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojThematicMapMarker["color"]>;
+    'heightChanged': JetElementCustomEvent<ojThematicMapMarker["height"]>;
+    'labelChanged': JetElementCustomEvent<ojThematicMapMarker["label"]>;
+    'labelPositionChanged': JetElementCustomEvent<ojThematicMapMarker["labelPosition"]>;
+    'labelStyleChanged': JetElementCustomEvent<ojThematicMapMarker["labelStyle"]>;
+    'locationChanged': JetElementCustomEvent<ojThematicMapMarker["location"]>;
+    'opacityChanged': JetElementCustomEvent<ojThematicMapMarker["opacity"]>;
+    'rotationChanged': JetElementCustomEvent<ojThematicMapMarker["rotation"]>;
+    'selectableChanged': JetElementCustomEvent<ojThematicMapMarker["selectable"]>;
+    'shapeChanged': JetElementCustomEvent<ojThematicMapMarker["shape"]>;
+    'shortDescChanged': JetElementCustomEvent<ojThematicMapMarker["shortDesc"]>;
+    'sourceChanged': JetElementCustomEvent<ojThematicMapMarker["source"]>;
+    'sourceHoverChanged': JetElementCustomEvent<ojThematicMapMarker["sourceHover"]>;
+    'sourceHoverSelectedChanged': JetElementCustomEvent<ojThematicMapMarker["sourceHoverSelected"]>;
+    'sourceSelectedChanged': JetElementCustomEvent<ojThematicMapMarker["sourceSelected"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojThematicMapMarker["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojThematicMapMarker["svgStyle"]>;
+    'valueChanged': JetElementCustomEvent<ojThematicMapMarker["value"]>;
+    'widthChanged': JetElementCustomEvent<ojThematicMapMarker["width"]>;
+    'xChanged': JetElementCustomEvent<ojThematicMapMarker["x"]>;
+    'yChanged': JetElementCustomEvent<ojThematicMapMarker["y"]>;
+}
+export interface ojThematicMapMarkerSettableProperties extends JetSettableProperties {
+    borderColor: string;
+    borderStyle: 'solid' | 'none';
+    borderWidth: number;
+    categories: string[];
+    color: string;
+    height: number;
+    label: string;
+    labelPosition: 'bottom' | 'center' | 'top';
+    labelStyle: object;
+    location: string;
+    opacity: number;
+    rotation: number;
+    selectable: 'auto' | 'off';
+    shape?: 'circle' | 'diamond' | 'ellipse' | 'human' | 'plus' | 'rectangle' | 'square' | 'star' | 'triangleDown' | 'triangleUp' | string;
+    shortDesc: string;
+    source: string;
+    sourceHover: string;
+    sourceHoverSelected: string;
+    sourceSelected: string;
+    svgClassName: string;
+    svgStyle: object;
+    value: number;
+    width: number;
+    x: number | null;
+    y: number | null;
+}
+export interface ojThematicMapMarkerSettablePropertiesLenient extends Partial<ojThematicMapMarkerSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojthemeutils/index.d.ts

@@ -0,0 +1,4 @@
+export function clearCache(): void;
+export function getThemeName(): string | null;
+export function getThemeTargetPlatform(): string | null;
+export function parseJSONFromFontFamily(selector: string): any;

types/oracle__oraclejet/ojtime-base/index.d.ts

@@ -0,0 +1,22 @@
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface dvtTimeComponent<SP extends dvtTimeComponentSettableProperties = dvtTimeComponentSettableProperties> extends dvtBaseComponent<SP> {
+    addEventListener<T extends keyof dvtTimeComponentEventMap<SP>>(type: T, listener: (this: HTMLElement, ev: dvtTimeComponentEventMap<SP>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof dvtTimeComponentSettableProperties>(property: T): dvtTimeComponent<SP>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof dvtTimeComponentSettableProperties>(property: T, value: dvtTimeComponentSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, dvtTimeComponentSettableProperties>): void;
+    setProperties(properties: dvtTimeComponentSettablePropertiesLenient): void;
+}
+// These interfaces are empty but required to keep the event chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface dvtTimeComponentEventMap<SP extends dvtTimeComponentSettableProperties = dvtTimeComponentSettableProperties> extends dvtBaseComponentEventMap<SP> {
+}
+// These interfaces are empty but required to keep the component chain intact. Avoid lint-rule
+// tslint:disable-next-line no-empty-interface
+export interface dvtTimeComponentSettableProperties extends dvtBaseComponentSettableProperties {
+}
+export interface dvtTimeComponentSettablePropertiesLenient extends Partial<dvtTimeComponentSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojtimeaxis/index.d.ts

@@ -0,0 +1,87 @@
+import { Converter } from '../ojvalidation-base';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojTimeAxis extends dvtBaseComponent<ojTimeAxisSettableProperties> {
+    converter: ojTimeAxis.Converters | Converter<string>;
+    end: string;
+    scale: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'quarters' | 'years';
+    start: string;
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+    onConverterChanged: ((event: JetElementCustomEvent<ojTimeAxis["converter"]>) => any) | null;
+    onEndChanged: ((event: JetElementCustomEvent<ojTimeAxis["end"]>) => any) | null;
+    onScaleChanged: ((event: JetElementCustomEvent<ojTimeAxis["scale"]>) => any) | null;
+    onStartChanged: ((event: JetElementCustomEvent<ojTimeAxis["start"]>) => any) | null;
+    addEventListener<T extends keyof ojTimeAxisEventMap>(type: T, listener: (this: HTMLElement, ev: ojTimeAxisEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTimeAxisSettableProperties>(property: T): ojTimeAxis[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTimeAxisSettableProperties>(property: T, value: ojTimeAxisSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTimeAxisSettableProperties>): void;
+    setProperties(properties: ojTimeAxisSettablePropertiesLenient): void;
+}
+export interface ojTimeAxisEventMap extends dvtBaseComponentEventMap<ojTimeAxisSettableProperties> {
+    'converterChanged': JetElementCustomEvent<ojTimeAxis["converter"]>;
+    'endChanged': JetElementCustomEvent<ojTimeAxis["end"]>;
+    'scaleChanged': JetElementCustomEvent<ojTimeAxis["scale"]>;
+    'startChanged': JetElementCustomEvent<ojTimeAxis["start"]>;
+}
+export interface ojTimeAxisSettableProperties extends dvtBaseComponentSettableProperties {
+    converter: ojTimeAxis.Converters | Converter<string>;
+    end: string;
+    scale: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'quarters' | 'years';
+    start: string;
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+    };
+}
+export interface ojTimeAxisSettablePropertiesLenient extends Partial<ojTimeAxisSettableProperties> {
+    [key: string]: any;
+}
+export namespace ojTimeAxis {
+    // tslint:disable-next-line interface-over-type-literal
+    type Converters = {
+        default?: Converter<string>;
+        seconds?: Converter<string>;
+        minutes?: Converter<string>;
+        hours?: Converter<string>;
+        days?: Converter<string>;
+        weeks?: Converter<string>;
+        months?: Converter<string>;
+        quarters?: Converter<string>;
+        years?: Converter<string>;
+    };
+}

types/oracle__oraclejet/ojtimeutils/index.d.ts

@@ -0,0 +1,3 @@
+export function getDate(pos: number, rangeStartTime: Date | string | number, rangeEndTime: Date | string | number, rangeWidth: number): number;
+export function getLength(startTime: Date | string | number, endTime: Date | string | number, rangeStartTime: Date | string | number, rangeEndTime: Date | string | number, rangeWidth: number): number;
+export function getPosition(time: Date | string | number, rangeStartTime: Date | string | number, rangeEndTime: Date | string | number, rangeWidth: number): number;

types/oracle__oraclejet/ojtoolbar/index.d.ts

@@ -0,0 +1,22 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojToolbar extends baseComponent<ojToolbarSettableProperties> {
+    chroming: 'full' | 'half' | 'outlined';
+    onChromingChanged: ((event: JetElementCustomEvent<ojToolbar["chroming"]>) => any) | null;
+    addEventListener<T extends keyof ojToolbarEventMap>(type: T, listener: (this: HTMLElement, ev: ojToolbarEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojToolbarSettableProperties>(property: T): ojToolbar[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojToolbarSettableProperties>(property: T, value: ojToolbarSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojToolbarSettableProperties>): void;
+    setProperties(properties: ojToolbarSettablePropertiesLenient): void;
+    refresh(): void;
+}
+export interface ojToolbarEventMap extends baseComponentEventMap<ojToolbarSettableProperties> {
+    'chromingChanged': JetElementCustomEvent<ojToolbar["chroming"]>;
+}
+export interface ojToolbarSettableProperties extends baseComponentSettableProperties {
+    chroming: 'full' | 'half' | 'outlined';
+}
+export interface ojToolbarSettablePropertiesLenient extends Partial<ojToolbarSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojtrain/index.d.ts

@@ -0,0 +1,78 @@
+import { baseComponent, baseComponentEventMap, baseComponentSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojTrain extends baseComponent<ojTrainSettableProperties> {
+    selectedStep: string;
+    steps: ojTrain.Step[];
+    onSelectedStepChanged: ((event: JetElementCustomEvent<ojTrain["selectedStep"]>) => any) | null;
+    onStepsChanged: ((event: JetElementCustomEvent<ojTrain["steps"]>) => any) | null;
+    onOjBeforeDeselect: ((event: ojTrain.ojBeforeDeselect) => any) | null;
+    onOjBeforeSelect: ((event: ojTrain.ojBeforeSelect) => any) | null;
+    onOjDeselect: ((event: ojTrain.ojDeselect) => any) | null;
+    onOjSelect: ((event: ojTrain.ojSelect) => any) | null;
+    addEventListener<T extends keyof ojTrainEventMap>(type: T, listener: (this: HTMLElement, ev: ojTrainEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTrainSettableProperties>(property: T): ojTrain[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTrainSettableProperties>(property: T, value: ojTrainSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTrainSettableProperties>): void;
+    setProperties(properties: ojTrainSettablePropertiesLenient): void;
+    getNextSelectableStep(): string | null;
+    getPreviousSelectableStep(): string | null;
+    getStep(id: string): ojTrain.Step | null;
+    refresh(): void;
+    updateStep(id: string, stepProperties: {
+        id?: string;
+        label?: string;
+        disabled?: boolean;
+        visited?: boolean;
+        messageType?: 'info' | 'error' | 'fatal' | 'warning';
+    }): void;
+}
+export namespace ojTrain {
+    interface ojBeforeDeselect extends CustomEvent<{
+        toStep: string;
+        fromStep: string;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojBeforeSelect extends CustomEvent<{
+        toStep: string;
+        fromStep: string;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojDeselect extends CustomEvent<{
+        toStep: string;
+        fromStep: string;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojSelect extends CustomEvent<{
+        toStep: string;
+        fromStep: string;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type Step = {
+        id: string;
+        label: string;
+        disabled?: boolean;
+        visited?: boolean;
+        messageType?: 'info' | 'error' | 'fatal' | 'warning';
+    };
+}
+export interface ojTrainEventMap extends baseComponentEventMap<ojTrainSettableProperties> {
+    'ojBeforeDeselect': ojTrain.ojBeforeDeselect;
+    'ojBeforeSelect': ojTrain.ojBeforeSelect;
+    'ojDeselect': ojTrain.ojDeselect;
+    'ojSelect': ojTrain.ojSelect;
+    'selectedStepChanged': JetElementCustomEvent<ojTrain["selectedStep"]>;
+    'stepsChanged': JetElementCustomEvent<ojTrain["steps"]>;
+}
+export interface ojTrainSettableProperties extends baseComponentSettableProperties {
+    selectedStep: string;
+    steps: ojTrain.Step[];
+}
+export interface ojTrainSettablePropertiesLenient extends Partial<ojTrainSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojtranslation/index.d.ts

@@ -0,0 +1,5 @@
+export function applyParameters(pattern: string, parameters: object | any[]): string | null;
+export function getComponentTranslations(componentName: string): object;
+export function getResource(key: string): object | string | null;
+export function getTranslatedString(key: string, ...var_args: Array<string | object | any[]>): string;
+export function setBundle(bundle: object): void;

types/oracle__oraclejet/ojtreedataprovider/index.d.ts

@@ -0,0 +1,5 @@
+import { DataProvider } from '../ojdataprovider';
+interface TreeDataProvider<K, D> extends DataProvider<K, D> {
+    getChildDataProvider(parentKey: any): TreeDataProvider<K, D>;
+}
+export = TreeDataProvider;

types/oracle__oraclejet/ojtreemap/index.d.ts

@@ -0,0 +1,392 @@
+import { DataProvider } from '../ojdataprovider';
+import { dvtBaseComponent, dvtBaseComponentEventMap, dvtBaseComponentSettableProperties } from '../ojdvt-base';
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojTreemap<K, D> extends dvtBaseComponent<ojTreemapSettableProperties<K, D>> {
+    animationDuration: number;
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    animationUpdateColor: string;
+    as: string;
+    colorLabel: string;
+    data: DataProvider<K, D> | null;
+    displayLevels: number;
+    drilling: 'on' | 'off';
+    groupGaps: 'all' | 'none' | 'outer';
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverBehaviorDelay: number;
+    isolatedNode: any;
+    layout: 'sliceAndDiceHorizontal' | 'sliceAndDiceVertical' | 'squarified';
+    nodeContent: {
+        renderer: ((context: ojTreemap.NodeContentContext<K, D>) => ({
+            insert: Element | string;
+        }));
+    };
+    nodeDefaults: {
+        groupLabelDisplay: 'node' | 'off' | 'header';
+        header: {
+            backgroundColor: string;
+            borderColor: string;
+            hoverBackgroundColor: string;
+            hoverInnerColor: string;
+            hoverOuterColor: string;
+            isolate: 'off' | 'on';
+            labelHalign: 'center' | 'end' | 'start';
+            labelStyle: object;
+            selectedBackgroundColor: string;
+            selectedInnerColor: string;
+            selectedOuterColor: string;
+            useNodeColor: 'on' | 'off';
+        };
+        hoverColor: string;
+        labelDisplay: 'off' | 'node';
+        labelHalign: 'start' | 'end' | 'center';
+        labelMinLength: number;
+        labelStyle: object;
+        labelValign: 'top' | 'bottom' | 'center';
+        selectedInnerColor: string;
+        selectedOuterColor: string;
+    };
+    nodeSeparators: 'bevels' | 'gaps';
+    rootNode: any;
+    selection: any[];
+    selectionMode: 'none' | 'single' | 'multiple';
+    sizeLabel: string;
+    sorting: 'on' | 'off';
+    tooltip: {
+        renderer: ((context: ojTreemap.TooltipContext<K, D>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    touchResponse: 'touchStart' | 'auto';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelColor?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        labelSize?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+        tooltipIsolate?: string;
+        tooltipRestore?: string;
+    };
+    onAnimationDurationChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["animationDuration"]>) => any) | null;
+    onAnimationOnDataChangeChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["animationOnDataChange"]>) => any) | null;
+    onAnimationOnDisplayChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["animationOnDisplay"]>) => any) | null;
+    onAnimationUpdateColorChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["animationUpdateColor"]>) => any) | null;
+    onAsChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["as"]>) => any) | null;
+    onColorLabelChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["colorLabel"]>) => any) | null;
+    onDataChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["data"]>) => any) | null;
+    onDisplayLevelsChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["displayLevels"]>) => any) | null;
+    onDrillingChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["drilling"]>) => any) | null;
+    onGroupGapsChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["groupGaps"]>) => any) | null;
+    onHiddenCategoriesChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["hiddenCategories"]>) => any) | null;
+    onHighlightMatchChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["highlightMatch"]>) => any) | null;
+    onHighlightedCategoriesChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["highlightedCategories"]>) => any) | null;
+    onHoverBehaviorChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["hoverBehavior"]>) => any) | null;
+    onHoverBehaviorDelayChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["hoverBehaviorDelay"]>) => any) | null;
+    onIsolatedNodeChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["isolatedNode"]>) => any) | null;
+    onLayoutChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["layout"]>) => any) | null;
+    onNodeContentChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["nodeContent"]>) => any) | null;
+    onNodeDefaultsChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["nodeDefaults"]>) => any) | null;
+    onNodeSeparatorsChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["nodeSeparators"]>) => any) | null;
+    onRootNodeChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["rootNode"]>) => any) | null;
+    onSelectionChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["selection"]>) => any) | null;
+    onSelectionModeChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["selectionMode"]>) => any) | null;
+    onSizeLabelChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["sizeLabel"]>) => any) | null;
+    onSortingChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["sorting"]>) => any) | null;
+    onTooltipChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["tooltip"]>) => any) | null;
+    onTouchResponseChanged: ((event: JetElementCustomEvent<ojTreemap<K, D>["touchResponse"]>) => any) | null;
+    onOjBeforeDrill: ((event: ojTreemap.ojBeforeDrill) => any) | null;
+    onOjDrill: ((event: ojTreemap.ojDrill) => any) | null;
+    addEventListener<T extends keyof ojTreemapEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: ojTreemapEventMap<K, D>[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTreemapSettableProperties<K, D>>(property: T): ojTreemap<K, D>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTreemapSettableProperties<K, D>>(property: T, value: ojTreemapSettableProperties<K, D>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTreemapSettableProperties<K, D>>): void;
+    setProperties(properties: ojTreemapSettablePropertiesLenient<K, D>): void;
+    getContextByNode(node: Element): ojTreemap.NodeContext | null;
+    getNode(subIdPath: any[]): ojTreemap.DataContext | null;
+}
+export namespace ojTreemap {
+    interface ojBeforeDrill extends CustomEvent<{
+        id: any;
+        data: object;
+        itemData: object;
+        [propName: string]: any;
+    }> {
+    }
+    interface ojDrill extends CustomEvent<{
+        id: any;
+        data: object;
+        itemData: object;
+        [propName: string]: any;
+    }> {
+    }
+    // tslint:disable-next-line interface-over-type-literal
+    type DataContext = {
+        color: string;
+        label: string;
+        selected: boolean;
+        size: number;
+        tooltip: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContentContext<K, D> = {
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        id: K;
+        data: object;
+        itemData: D;
+        componentElement: Element;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type NodeContext = {
+        subId: string;
+        indexPath: number[];
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type TooltipContext<K, D> = {
+        parentElement: Element;
+        id: K;
+        label: string;
+        value: number;
+        color: string;
+        data: object;
+        itemData: D;
+        componentElement: Element;
+    };
+}
+export interface ojTreemapEventMap<K, D> extends dvtBaseComponentEventMap<ojTreemapSettableProperties<K, D>> {
+    'ojBeforeDrill': ojTreemap.ojBeforeDrill;
+    'ojDrill': ojTreemap.ojDrill;
+    'animationDurationChanged': JetElementCustomEvent<ojTreemap<K, D>["animationDuration"]>;
+    'animationOnDataChangeChanged': JetElementCustomEvent<ojTreemap<K, D>["animationOnDataChange"]>;
+    'animationOnDisplayChanged': JetElementCustomEvent<ojTreemap<K, D>["animationOnDisplay"]>;
+    'animationUpdateColorChanged': JetElementCustomEvent<ojTreemap<K, D>["animationUpdateColor"]>;
+    'asChanged': JetElementCustomEvent<ojTreemap<K, D>["as"]>;
+    'colorLabelChanged': JetElementCustomEvent<ojTreemap<K, D>["colorLabel"]>;
+    'dataChanged': JetElementCustomEvent<ojTreemap<K, D>["data"]>;
+    'displayLevelsChanged': JetElementCustomEvent<ojTreemap<K, D>["displayLevels"]>;
+    'drillingChanged': JetElementCustomEvent<ojTreemap<K, D>["drilling"]>;
+    'groupGapsChanged': JetElementCustomEvent<ojTreemap<K, D>["groupGaps"]>;
+    'hiddenCategoriesChanged': JetElementCustomEvent<ojTreemap<K, D>["hiddenCategories"]>;
+    'highlightMatchChanged': JetElementCustomEvent<ojTreemap<K, D>["highlightMatch"]>;
+    'highlightedCategoriesChanged': JetElementCustomEvent<ojTreemap<K, D>["highlightedCategories"]>;
+    'hoverBehaviorChanged': JetElementCustomEvent<ojTreemap<K, D>["hoverBehavior"]>;
+    'hoverBehaviorDelayChanged': JetElementCustomEvent<ojTreemap<K, D>["hoverBehaviorDelay"]>;
+    'isolatedNodeChanged': JetElementCustomEvent<ojTreemap<K, D>["isolatedNode"]>;
+    'layoutChanged': JetElementCustomEvent<ojTreemap<K, D>["layout"]>;
+    'nodeContentChanged': JetElementCustomEvent<ojTreemap<K, D>["nodeContent"]>;
+    'nodeDefaultsChanged': JetElementCustomEvent<ojTreemap<K, D>["nodeDefaults"]>;
+    'nodeSeparatorsChanged': JetElementCustomEvent<ojTreemap<K, D>["nodeSeparators"]>;
+    'rootNodeChanged': JetElementCustomEvent<ojTreemap<K, D>["rootNode"]>;
+    'selectionChanged': JetElementCustomEvent<ojTreemap<K, D>["selection"]>;
+    'selectionModeChanged': JetElementCustomEvent<ojTreemap<K, D>["selectionMode"]>;
+    'sizeLabelChanged': JetElementCustomEvent<ojTreemap<K, D>["sizeLabel"]>;
+    'sortingChanged': JetElementCustomEvent<ojTreemap<K, D>["sorting"]>;
+    'tooltipChanged': JetElementCustomEvent<ojTreemap<K, D>["tooltip"]>;
+    'touchResponseChanged': JetElementCustomEvent<ojTreemap<K, D>["touchResponse"]>;
+}
+export interface ojTreemapSettableProperties<K, D> extends dvtBaseComponentSettableProperties {
+    animationDuration: number;
+    animationOnDataChange: 'auto' | 'none';
+    animationOnDisplay: 'auto' | 'none';
+    animationUpdateColor: string;
+    as: string;
+    colorLabel: string;
+    data: DataProvider<K, D> | null;
+    displayLevels: number;
+    drilling: 'on' | 'off';
+    groupGaps: 'all' | 'none' | 'outer';
+    hiddenCategories: string[];
+    highlightMatch: 'any' | 'all';
+    highlightedCategories: string[];
+    hoverBehavior: 'dim' | 'none';
+    hoverBehaviorDelay: number;
+    isolatedNode: any;
+    layout: 'sliceAndDiceHorizontal' | 'sliceAndDiceVertical' | 'squarified';
+    nodeContent: {
+        renderer: ((context: ojTreemap.NodeContentContext<K, D>) => ({
+            insert: Element | string;
+        }));
+    };
+    nodeDefaults: {
+        groupLabelDisplay: 'node' | 'off' | 'header';
+        header: {
+            backgroundColor: string;
+            borderColor: string;
+            hoverBackgroundColor: string;
+            hoverInnerColor: string;
+            hoverOuterColor: string;
+            isolate: 'off' | 'on';
+            labelHalign: 'center' | 'end' | 'start';
+            labelStyle: object;
+            selectedBackgroundColor: string;
+            selectedInnerColor: string;
+            selectedOuterColor: string;
+            useNodeColor: 'on' | 'off';
+        };
+        hoverColor: string;
+        labelDisplay: 'off' | 'node';
+        labelHalign: 'start' | 'end' | 'center';
+        labelMinLength: number;
+        labelStyle: object;
+        labelValign: 'top' | 'bottom' | 'center';
+        selectedInnerColor: string;
+        selectedOuterColor: string;
+    };
+    nodeSeparators: 'bevels' | 'gaps';
+    rootNode: any;
+    selection: any[];
+    selectionMode: 'none' | 'single' | 'multiple';
+    sizeLabel: string;
+    sorting: 'on' | 'off';
+    tooltip: {
+        renderer: ((context: ojTreemap.TooltipContext<K, D>) => ({
+            insert: Element | string;
+        } | {
+            preventDefault: boolean;
+        }));
+    };
+    touchResponse: 'touchStart' | 'auto';
+    translations: {
+        componentName?: string;
+        labelAndValue?: string;
+        labelClearSelection?: string;
+        labelColor?: string;
+        labelCountWithTotal?: string;
+        labelDataVisualization?: string;
+        labelInvalidData?: string;
+        labelNoData?: string;
+        labelSize?: string;
+        stateCollapsed?: string;
+        stateDrillable?: string;
+        stateExpanded?: string;
+        stateHidden?: string;
+        stateIsolated?: string;
+        stateMaximized?: string;
+        stateMinimized?: string;
+        stateSelected?: string;
+        stateUnselected?: string;
+        stateVisible?: string;
+        tooltipIsolate?: string;
+        tooltipRestore?: string;
+    };
+}
+export interface ojTreemapSettablePropertiesLenient<K, D> extends Partial<ojTreemapSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface ojTreemapNode extends JetElement<ojTreemapNodeSettableProperties> {
+    categories?: string[];
+    color?: string;
+    drilling?: 'on' | 'off' | 'inherit';
+    groupLabelDisplay?: 'node' | 'off' | 'header';
+    header?: {
+        isolate?: 'off' | 'on';
+        labelHalign?: 'center' | 'end' | 'start';
+        labelStyle?: object;
+        useNodeColor?: 'on' | 'off';
+    };
+    label?: string;
+    labelDisplay?: 'off' | 'node';
+    labelHalign?: 'start' | 'end' | 'center';
+    labelStyle?: object;
+    labelValign?: 'top' | 'bottom' | 'center';
+    pattern?: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+       'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+    selectable?: 'off' | 'auto';
+    shortDesc?: string;
+    svgClassName?: string;
+    svgStyle?: object;
+    value: number;
+    onCategoriesChanged: ((event: JetElementCustomEvent<ojTreemapNode["categories"]>) => any) | null;
+    onColorChanged: ((event: JetElementCustomEvent<ojTreemapNode["color"]>) => any) | null;
+    onDrillingChanged: ((event: JetElementCustomEvent<ojTreemapNode["drilling"]>) => any) | null;
+    onGroupLabelDisplayChanged: ((event: JetElementCustomEvent<ojTreemapNode["groupLabelDisplay"]>) => any) | null;
+    onHeaderChanged: ((event: JetElementCustomEvent<ojTreemapNode["header"]>) => any) | null;
+    onLabelChanged: ((event: JetElementCustomEvent<ojTreemapNode["label"]>) => any) | null;
+    onLabelDisplayChanged: ((event: JetElementCustomEvent<ojTreemapNode["labelDisplay"]>) => any) | null;
+    onLabelHalignChanged: ((event: JetElementCustomEvent<ojTreemapNode["labelHalign"]>) => any) | null;
+    onLabelStyleChanged: ((event: JetElementCustomEvent<ojTreemapNode["labelStyle"]>) => any) | null;
+    onLabelValignChanged: ((event: JetElementCustomEvent<ojTreemapNode["labelValign"]>) => any) | null;
+    onPatternChanged: ((event: JetElementCustomEvent<ojTreemapNode["pattern"]>) => any) | null;
+    onSelectableChanged: ((event: JetElementCustomEvent<ojTreemapNode["selectable"]>) => any) | null;
+    onShortDescChanged: ((event: JetElementCustomEvent<ojTreemapNode["shortDesc"]>) => any) | null;
+    onSvgClassNameChanged: ((event: JetElementCustomEvent<ojTreemapNode["svgClassName"]>) => any) | null;
+    onSvgStyleChanged: ((event: JetElementCustomEvent<ojTreemapNode["svgStyle"]>) => any) | null;
+    onValueChanged: ((event: JetElementCustomEvent<ojTreemapNode["value"]>) => any) | null;
+    addEventListener<T extends keyof ojTreemapNodeEventMap>(type: T, listener: (this: HTMLElement, ev: ojTreemapNodeEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojTreemapNodeSettableProperties>(property: T): ojTreemapNode[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojTreemapNodeSettableProperties>(property: T, value: ojTreemapNodeSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojTreemapNodeSettableProperties>): void;
+    setProperties(properties: ojTreemapNodeSettablePropertiesLenient): void;
+}
+export interface ojTreemapNodeEventMap extends HTMLElementEventMap {
+    'categoriesChanged': JetElementCustomEvent<ojTreemapNode["categories"]>;
+    'colorChanged': JetElementCustomEvent<ojTreemapNode["color"]>;
+    'drillingChanged': JetElementCustomEvent<ojTreemapNode["drilling"]>;
+    'groupLabelDisplayChanged': JetElementCustomEvent<ojTreemapNode["groupLabelDisplay"]>;
+    'headerChanged': JetElementCustomEvent<ojTreemapNode["header"]>;
+    'labelChanged': JetElementCustomEvent<ojTreemapNode["label"]>;
+    'labelDisplayChanged': JetElementCustomEvent<ojTreemapNode["labelDisplay"]>;
+    'labelHalignChanged': JetElementCustomEvent<ojTreemapNode["labelHalign"]>;
+    'labelStyleChanged': JetElementCustomEvent<ojTreemapNode["labelStyle"]>;
+    'labelValignChanged': JetElementCustomEvent<ojTreemapNode["labelValign"]>;
+    'patternChanged': JetElementCustomEvent<ojTreemapNode["pattern"]>;
+    'selectableChanged': JetElementCustomEvent<ojTreemapNode["selectable"]>;
+    'shortDescChanged': JetElementCustomEvent<ojTreemapNode["shortDesc"]>;
+    'svgClassNameChanged': JetElementCustomEvent<ojTreemapNode["svgClassName"]>;
+    'svgStyleChanged': JetElementCustomEvent<ojTreemapNode["svgStyle"]>;
+    'valueChanged': JetElementCustomEvent<ojTreemapNode["value"]>;
+}
+export interface ojTreemapNodeSettableProperties extends JetSettableProperties {
+    categories?: string[];
+    color?: string;
+    drilling?: 'on' | 'off' | 'inherit';
+    groupLabelDisplay?: 'node' | 'off' | 'header';
+    header?: {
+        isolate?: 'off' | 'on';
+        labelHalign?: 'center' | 'end' | 'start';
+        labelStyle?: object;
+        useNodeColor?: 'on' | 'off';
+    };
+    label?: string;
+    labelDisplay?: 'off' | 'node';
+    labelHalign?: 'start' | 'end' | 'center';
+    labelStyle?: object;
+    labelValign?: 'top' | 'bottom' | 'center';
+    pattern?: 'smallChecker' | 'smallCrosshatch' | 'smallDiagonalLeft' | 'smallDiagonalRight' | 'smallDiamond' | 'smallTriangle' | 'largeChecker' | 'largeCrosshatch' | 'largeDiagonalLeft' |
+       'largeDiagonalRight' | 'largeDiamond' | 'largeTriangle' | 'none';
+    selectable?: 'off' | 'auto';
+    shortDesc?: string;
+    svgClassName?: string;
+    svgStyle?: object;
+    value: number;
+}
+export interface ojTreemapNodeSettablePropertiesLenient extends Partial<ojTreemapNodeSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/ojvalidation-base/index.d.ts

@@ -0,0 +1,144 @@
+import Message = require('../ojmessaging');
+import Color = require('../ojcolor');
+export interface AsyncValidator<V> {
+    hint: Promise<string>;
+    validate(value: V): Promise<boolean>;
+}
+export class ColorConverter implements Converter<Color> {
+    constructor(options?: ColorConverter.ConverterOptions);
+    format(color: Color): string | null;
+    getHint(): string;
+    parse(value: string): Color;
+    resolvedOptions(): ColorConverter.ConverterOptions;
+}
+export namespace ColorConverter {
+    // tslint:disable-next-line interface-over-type-literal
+    type ConverterOptions = {
+        format?: 'rgb' | 'hsl' | 'hsv' | 'hex' | 'hex3';
+    };
+}
+export interface ColorConverterFactory {
+    createConverter(options?: ColorConverter.ConverterOptions): ColorConverter;
+}
+export interface Converter<V> {
+    format(value: V): string | null;
+    getHint?(): string | null;
+    getOptions?(): object;
+    parse(value: string): V | null;
+    resolvedOptions?(): object;
+}
+export interface ConverterError {
+    // constructor(summary: string, detail: string);
+    getMessage(): Message;
+}
+export interface ConverterFactory<V> {
+    // static CONVERTER_TYPE_COLOR: string;
+    // static CONVERTER_TYPE_DATETIME: string;
+    // static CONVERTER_TYPE_NUMBER: string;
+    createConverter(options: object | null): Converter<V>;
+}
+export namespace IntlConverterUtils {
+    function dateToLocalIso(date: Date): string;
+    function getConverterInstance<T>(converterOption: string | Validation.RegisteredConverter | Converter<T>): Converter<T> | null;
+    function getInitials(firstName?: string, lastName?: string): string | undefined;
+    function getLocalTimeZoneOffset(): string;
+    function isoToDate(isoString: string): Date;
+    function isoToLocalDate(isoString: string): Date;
+}
+export class LengthValidator implements Validator<number | string> {
+    static defaults: {
+        countBy: string;
+    };
+    constructor(options?: LengthValidator.ValidatorOptions);
+    getHint(): string | null;
+    validate(value: string | number): void;
+}
+export namespace LengthValidator {
+    // tslint:disable-next-line interface-over-type-literal
+    type ValidatorOptions = {
+        countBy?: 'codeUnit' | 'codePoint';
+        min?: number;
+        max?: number;
+        hint?: {
+            max?: string;
+            min?: string;
+            inRange?: string;
+            exact?: string;
+        };
+        messageDetail?: {
+            tooLong?: string;
+            tooShort?: string;
+        };
+        messageSummary?: {
+            tooLong?: string;
+            tooShort?: string;
+        };
+    };
+}
+export interface LengthValidatorFactory {
+    createValidator(options?: LengthValidator.ValidatorOptions): LengthValidator;
+}
+export class RegExpValidator implements Validator<string | number> {
+    constructor(options?: RegExpValidator.ValidatorOptions);
+    getHint(): string | null;
+    validate(value: string | number): void;
+}
+export namespace RegExpValidator {
+    // tslint:disable-next-line interface-over-type-literal
+    type ValidatorOptions = {
+        pattern?: string;
+        hint?: string;
+        messageSummary?: string;
+        messageDetail?: string;
+    };
+}
+export interface RegExpValidatorFactory {
+    createValidator(options: RegExpValidator.ValidatorOptions): RegExpValidator;
+}
+export class RequiredValidator implements Validator<object | string | number> {
+    constructor(options?: RequiredValidator.ValidatorOptions);
+    getHint(): string | null;
+    validate(value: object | string | number): void;
+}
+export namespace RequiredValidator {
+    // tslint:disable-next-line interface-over-type-literal
+    type ValidatorOptions = {
+        hint?: string;
+        messageSummary?: string;
+        messageDetail?: string;
+    };
+}
+export interface RequiredValidatorFactory {
+    createValidator(options?: RequiredValidator.ValidatorOptions): RequiredValidator;
+}
+export namespace Validation {
+    function converterFactory<CF extends ConverterFactory<any>>(type: 'number' | 'color' | 'datetime' | string, instance?: CF): CF | null;
+    function validatorFactory<VF extends ValidatorFactory<any>>(type: 'required' | 'regexp' | 'numberRange' | 'length' | 'dateTimeRange' | 'dateRestriction' | string, instance?: VF): VF | null;
+    // tslint:disable-next-line interface-over-type-literal
+    type RegisteredConverter = {
+        type: string;
+        options?: object;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type RegisteredValidator = {
+        type: string;
+        options?: object;
+    };
+}
+export interface Validator<V> {
+    getHint?(): string | null;
+    validate(value: V): void;
+}
+export interface ValidatorError {
+    // constructor(summary: string, detail: string);
+    getMessage(): Message;
+}
+export interface ValidatorFactory<V> {
+    // static VALIDATOR_TYPE_DATERESTRICTION: string;
+    // static VALIDATOR_TYPE_DATETIMERANGE: string;
+    // static VALIDATOR_TYPE_LENGTH: string;
+    // static VALIDATOR_TYPE_NUMBERRANGE: string;
+    // static VALIDATOR_TYPE_REGEXP: string;
+    // static VALIDATOR_TYPE_REQUIRED: string;
+    createValidator(options: object | null): Validator<V>;
+}

types/oracle__oraclejet/ojvalidation-datetime/index.d.ts

@@ -0,0 +1,130 @@
+import { Converter, Validator, Validation } from '../ojvalidation-base';
+export class DateRestrictionValidator implements Validator<string> {
+    constructor(options?: DateRestrictionValidator.ValidatorOptions);
+    getHint(): string | null;
+    validate(value: string): void;
+}
+export namespace DateRestrictionValidator {
+    // tslint:disable-next-line interface-over-type-literal
+    type DayFormatterInput = {
+        fullYear: number;
+        month: number;
+        date: number;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type DayFormatterOutput = {
+        disabled?: boolean;
+        className?: string;
+        tooltip?: string;
+    };
+    // tslint:disable-next-line interface-over-type-literal
+    type ValidatorOptions = {
+        dayFormatter?: ((param0: DayFormatterInput) => DayFormatterOutput | null | 'all');
+        messageSummary?: string;
+        messageDetail?: string;
+    };
+}
+export interface DateRestrictionValidatorFactory {
+    createValidator(options?: DateRestrictionValidator.ValidatorOptions): DateRestrictionValidator;
+}
+export abstract class DateTimeConverter implements Converter<string> {
+    abstract calculateWeek(value: string): number | undefined;
+    compareISODates(isoStr: string, isoStr2: string): number;
+    format(value: string): string | null;
+    getAvailableTimeZones(): any[];
+    abstract isDayNameSet(): boolean;
+    abstract isDaySet(): boolean;
+    abstract isHourInAMPMSet(): boolean;
+    abstract isHourInDaySet(): boolean;
+    abstract isMilliSecondSet(): boolean;
+    abstract isMinuteSet(): boolean;
+    abstract isMonthSet(): boolean;
+    abstract isSecondSet(): boolean;
+    abstract isYearSet(): boolean;
+    parse(value: string): string | null;
+}
+export interface DateTimeConverterFactory {
+    createConverter(options?: IntlDateTimeConverter.ConverterOptions): IntlDateTimeConverter;
+}
+export class DateTimeRangeValidator implements Validator<string> {
+    constructor(options?: DateTimeRangeValidator.ValidatorOptions);
+    getHint(): string | null;
+    validate(value: string): void;
+}
+export namespace DateTimeRangeValidator {
+    // tslint:disable-next-line interface-over-type-literal
+    type ValidatorOptions = {
+        converter: DateTimeConverter;
+        min?: string;
+        max?: string;
+        hint?: {
+            max?: string;
+            min?: string;
+            inRange?: string;
+        };
+        translationKey?: string;
+        messageDetail?: {
+            rangeUnderflow?: string;
+            rangeOverflow?: string;
+        };
+        messageSummary?: {
+            rangeUnderflow?: string;
+            rangeOverflow?: string;
+        };
+    };
+}
+export interface DateTimeRangeValidatorFactory {
+    createValidator(options?: DateTimeRangeValidator.ValidatorOptions): DateTimeRangeValidator;
+}
+export class IntlDateTimeConverter extends DateTimeConverter {
+    constructor(options?: IntlDateTimeConverter.ConverterOptions);
+    calculateWeek(value: string): number;
+    compareISODates(isoStr: string, isoStr2: string): number;
+    format(value: string): string | null;
+    formatRelative(value: string, relativeOptions?: {
+        formatUsing?: string;
+        dateField?: string;
+        relativeTime?: string;
+        dateOnly?: boolean;
+        timeZone?: string;
+    }): string | null;
+    getAvailableTimeZones(): any[];
+    getHint(): null;
+    getOptions(): IntlDateTimeConverter.ConverterOptions;
+    isDayNameSet(): boolean;
+    isDaySet(): boolean;
+    isHourInAMPMSet(): boolean;
+    isHourInDaySet(): boolean;
+    isMilliSecondSet(): boolean;
+    isMinuteSet(): boolean;
+    isMonthSet(): boolean;
+    isSecondSet(): boolean;
+    isYearSet(): boolean;
+    parse(value: string): string | null;
+    resolvedOptions(): IntlDateTimeConverter.ConverterOptions;
+}
+export namespace IntlDateTimeConverter {
+    // tslint:disable-next-line interface-over-type-literal
+    type ConverterOptions = {
+        year?: '2-digit' | 'numeric';
+        'two-digit-year-start'?: number;
+        month?: '2-digit' | 'numeric' | 'narrow' | 'short' | 'long';
+        day?: '2-digit' | 'numeric';
+        hour?: '2-digit' | 'numeric';
+        minute?: '2-digit' | 'numeric';
+        second?: '2-digit' | 'numeric';
+        millisecond?: 'numeric';
+        weekday?: 'narrow' | 'short' | 'long';
+        era?: 'narrow' | 'short' | 'long';
+        timeZoneName?: 'short' | 'long';
+        timeZone?: string;
+        isoStrFormat?: 'offset' | 'zulu' | 'local' | 'auto';
+        dst?: boolean;
+        hour12?: boolean;
+        pattern?: string;
+        formatType?: 'date' | 'time' | 'datetime';
+        dateFormat?: 'short' | 'medium' | 'long' | 'full';
+        timeFormat?: 'short' | 'medium' | 'long' | 'full';
+        lenientParse?: 'full' | 'none';
+    };
+}

types/oracle__oraclejet/ojvalidation-number/index.d.ts

@@ -0,0 +1,67 @@
+import { Converter, Validator, Validation } from '../ojvalidation-base';
+export class IntlNumberConverter extends NumberConverter {
+    constructor(options?: IntlNumberConverter.ConverterOptions);
+    format(value: number): string;
+    getHint(): null;
+    getOptions(): IntlNumberConverter.ConverterOptions;
+    parse(value: string): number | null;
+    resolvedOptions(): IntlNumberConverter.ConverterOptions;
+}
+export namespace IntlNumberConverter {
+    // tslint:disable-next-line interface-over-type-literal
+    type ConverterOptions = {
+        style?: 'decimal' | 'currency' | 'percent' | 'unit';
+        currency?: string;
+        unit?: 'byte' | 'bit';
+        currencyDisplay?: 'code' | 'symbol' | 'name';
+        decimalFormat?: 'standard' | 'short' | 'long';
+        currencyFormat?: 'standard' | 'short' | 'long';
+        minimumIntegerDigits?: number;
+        minimumFractionDigits?: number;
+        maximumFractionDigits?: number;
+        useGrouping?: boolean;
+        pattern?: string;
+        roundingMode?: 'HALF_UP' | 'HALF_DOWN' | 'HALF_EVEN';
+        roundDuringParse?: boolean;
+        separators?: object;
+        lenientParse?: 'full' | 'none';
+    };
+}
+export class NumberConverter implements Converter<number> {
+    format(value: number): string | null;
+    parse(value: string): number | null;
+}
+export interface NumberConverterFactory {
+    createConverter(options?: IntlNumberConverter.ConverterOptions): IntlNumberConverter;
+}
+export class NumberRangeValidator implements Validator<string | number> {
+    constructor(options?: NumberRangeValidator.ValidatorOptions);
+    getHint(): string | null;
+    validate(value: string | number): void;
+}
+export namespace NumberRangeValidator {
+    // tslint:disable-next-line interface-over-type-literal
+    type ValidatorOptions = {
+        converter?: NumberConverter;
+        min?: number;
+        max?: number;
+        hint?: {
+            max?: string;
+            min?: string;
+            inRange?: string;
+            exact?: string;
+        };
+        messageDetail?: {
+            rangeUnderflow?: string;
+            rangeOverflow?: string;
+            exact?: string;
+        };
+        messageSummary?: {
+            rangeUnderflow?: string;
+            rangeOverflow?: string;
+        };
+    };
+}
+export interface NumberRangeValidatorFactory {
+    createValidator(options?: NumberRangeValidator.ValidatorOptions): NumberRangeValidator;
+}

types/oracle__oraclejet/ojvalidationgroup/index.d.ts

@@ -0,0 +1,23 @@
+import { JetElement, JetSettableProperties, JetElementCustomEvent, JetSetPropertyType } from '..';
+export interface ojValidationGroup extends JetElement<ojValidationGroupSettableProperties> {
+    readonly valid: 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+    onValidChanged: ((event: JetElementCustomEvent<ojValidationGroup["valid"]>) => any) | null;
+    addEventListener<T extends keyof ojValidationGroupEventMap>(type: T, listener: (this: HTMLElement, ev: ojValidationGroupEventMap[T]) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    getProperty<T extends keyof ojValidationGroupSettableProperties>(property: T): ojValidationGroup[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof ojValidationGroupSettableProperties>(property: T, value: ojValidationGroupSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, ojValidationGroupSettableProperties>): void;
+    setProperties(properties: ojValidationGroupSettablePropertiesLenient): void;
+    focusOn(key?: '@firstInvalidShown'): void;
+    showMessages(): void;
+}
+export interface ojValidationGroupEventMap extends HTMLElementEventMap {
+    'validChanged': JetElementCustomEvent<ojValidationGroup["valid"]>;
+}
+export interface ojValidationGroupSettableProperties extends JetSettableProperties {
+    readonly valid: 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+}
+export interface ojValidationGroupSettablePropertiesLenient extends Partial<ojValidationGroupSettableProperties> {
+    [key: string]: any;
+}

types/oracle__oraclejet/oracle__oraclejet-tests.ts

@@ -0,0 +1,113 @@
+// Since all the definitions are auto generated from jsdoc doclets and internally tested through application,
+// add some basic tests here.
+import { ojAccordion } from "@oracle/oraclejet/ojaccordion";
+import AnimationUtils = require("@oracle/oraclejet/ojanimation");
+import ArrayDataProvider = require("@oracle/oraclejet/ojarraydataprovider");
+import ArrayTreeDataProvider = require("@oracle/oraclejet/ojarraytreedataprovider");
+import { AttributeGroupHandler, ColorAttributeGroupHandler, ShapeAttributeGroupHandler } from '@oracle/oraclejet/ojattributegrouphandler';
+import { ojAvatar } from "@oracle/oraclejet/ojavatar";
+import { ojButton, ojButtonsetMany, ojButtonsetOne } from "@oracle/oraclejet/ojbutton";
+import { ojChart, ojChartGroup, ojChartItem, ojChartSeries, ojSparkChart, ojSparkChartItem } from "@oracle/oraclejet/ojchart";
+import { ojCheckboxset } from "@oracle/oraclejet/ojcheckboxset";
+import { ojCollapsible } from "@oracle/oraclejet/ojcollapsible";
+import CollectionDataprovider = require("@oracle/oraclejet/ojcollectiondataprovider");
+import Color = require("@oracle/oraclejet/ojcolor");
+import { ojColorPalette } from "@oracle/oraclejet/ojcolorpalette";
+import { ojColorSpectrum } from "@oracle/oraclejet/ojcolorspectrum";
+import Components = require("@oracle/oraclejet/ojcomponentcore");
+import Composite = require("@oracle/oraclejet/ojcomposite");
+import Config = require('@oracle/oraclejet/ojconfig');
+import Context = require("@oracle/oraclejet/ojcontext");
+import { ojConveyorBelt } from "@oracle/oraclejet/ojconveyorbelt";
+import { ojDataGrid } from "@oracle/oraclejet/ojdatagrid";
+import { DataMapping, DataProvider, DataProviderAddOperationEventDetail, DataProviderMutationEventDetail, DataProviderOperationEventDetail } from "@oracle/oraclejet/ojdataprovider";
+import { ojDatePicker, ojDateTimePicker, ojInputDate, ojInputDateTime, ojInputTime } from "@oracle/oraclejet/ojdatetimepicker";
+import { ojDefer } from "@oracle/oraclejet/ojdefer";
+import DeferredDataprovider = require("@oracle/oraclejet/ojdeferreddataprovider");
+import { ojDiagram, ojDiagramLink, ojDiagramNode } from "@oracle/oraclejet/ojdiagram";
+import { ojDialog } from "@oracle/oraclejet/ojdialog";
+import { dvtBaseComponent } from "@oracle/oraclejet/ojdvt-base";
+import { editableValue } from "@oracle/oraclejet/ojeditablevalue";
+import ExpressionUtils = require('@oracle/oraclejet/ojexpressionutils');
+import { ojFilePicker, FileUploadTransport } from "@oracle/oraclejet/ojfilepicker";
+import { ojFilmStrip } from "@oracle/oraclejet/ojfilmstrip";
+import { ojFormLayout } from "@oracle/oraclejet/ojformlayout";
+import { ojGantt, ojGanttRow, ojGanttTask, ojGanttDependency } from "@oracle/oraclejet/ojgantt";
+import GanttUtils = require ('@oracle/oraclejet/ojganttutils');
+import { ojLedGauge, ojRatingGauge, ojStatusMeterGauge } from "@oracle/oraclejet/ojgauge";
+import { ojInputNumber } from "@oracle/oraclejet/ojinputnumber";
+import { ojInputPassword, ojInputText, ojTextArea } from "@oracle/oraclejet/ojinputtext";
+import { KeySet, ExpandAllKeySet, ExpandedKeySet } from "@oracle/oraclejet/ojkeyset";
+import { ObservableExpandedKeySet } from "@oracle/oraclejet/ojknockout-keyset";
+import KnockoutUtils = require("@oracle/oraclejet/ojknockout-model");
+import KnockoutTemplateUtils = require('@oracle/oraclejet/ojknockouttemplateutils');
+import { ojLabel } from "@oracle/oraclejet/ojlabel";
+import { ojLabelValue } from "@oracle/oraclejet/ojlabelvalue";
+import { ojLegend } from "@oracle/oraclejet/ojlegend";
+import ListDataProviderView = require("@oracle/oraclejet/ojlistdataproviderview");
+import { ojListView } from "@oracle/oraclejet/ojlistview";
+import LocaleData = require('@oracle/oraclejet/ojlocaledata');
+import Logger = require('@oracle/oraclejet/ojlogger');
+import { ojMasonryLayout } from "@oracle/oraclejet/ojmasonrylayout";
+import { ojMenu } from "@oracle/oraclejet/ojmenu";
+import { ojMenuSelectMany } from "@oracle/oraclejet/ojmenuselectmany";
+import { ojMessages } from "@oracle/oraclejet/ojmessages";
+import { ojMessage } from "@oracle/oraclejet/ojmessage";
+import Message = require("@oracle/oraclejet/ojmessaging");
+import { Collection, Model, URLError, OAuth } from "@oracle/oraclejet/ojmodel";
+import { ojModule } from "@oracle/oraclejet/ojmodule-element";
+import ModuleElementUtils = require("@oracle/oraclejet/ojmodule-element-utils");
+import ModuleAnimations = require("@oracle/oraclejet/ojmoduleanimations") ;
+import { ojNavigationList, ojTabBar } from "@oracle/oraclejet/ojnavigationlist";
+import { ojNBox } from "@oracle/oraclejet/ojnbox";
+import { ojOptgroup } from "@oracle/oraclejet/ojoptgroup";
+import { ojOption } from "@oracle/oraclejet/ojoption";
+import { ojPictoChart, ojPictoChartItem } from "@oracle/oraclejet/ojpictochart";
+import { ojPopup } from "@oracle/oraclejet/ojpopup";
+import { ojProgress } from "@oracle/oraclejet/ojprogress";
+import { ojProgressList, ProgressItem } from "@oracle/oraclejet/ojprogresslist";
+import PullToRefreshUtils = require("@oracle/oraclejet/ojpulltorefresh");
+import { ojRadioset } from "@oracle/oraclejet/ojradioset";
+import { ojRefresher } from "@oracle/oraclejet/ojrefresher";
+import ResponsiveKnockoutUtils = require('@oracle/oraclejet/ojresponsiveknockoututils');
+import ResponsiveUtils = require('@oracle/oraclejet/ojresponsiveutils');
+import Router = require("@oracle/oraclejet/ojrouter");
+import { ojComboboxOne, ojComboboxMany, ojSelectOne, ojSelectMany } from "@oracle/oraclejet/ojselectcombobox";
+import { ojSlider } from "@oracle/oraclejet/ojslider";
+import { ojSunburst } from "@oracle/oraclejet/ojsunburst";
+import { ojSwipeActions } from "@oracle/oraclejet/ojswipeactions";
+import SwipeToRevealUtils = require("@oracle/oraclejet/ojswipetoreveal");
+import { ojSwitch } from "@oracle/oraclejet/ojswitch";
+import { ojSwitcher } from "@oracle/oraclejet/ojswitcher";
+import { ojTable } from "@oracle/oraclejet/ojtable";
+import { ojTagCloud } from "@oracle/oraclejet/ojtagcloud";
+import { ojThematicMap } from "@oracle/oraclejet/ojthematicmap";
+import ThemeUtils = require('@oracle/oraclejet/ojthemeutils');
+import { dvtTimeComponent } from "@oracle/oraclejet/ojtime-base";
+import { ojTimeAxis } from "@oracle/oraclejet/ojtimeaxis";
+import TimeUtils = require("@oracle/oraclejet/ojtimeutils");
+import { ojToolbar } from "@oracle/oraclejet/ojtoolbar";
+import { ojTrain } from "@oracle/oraclejet/ojtrain";
+import Translations = require("@oracle/oraclejet/ojtranslation");
+import TreeDataProvider = require("@oracle/oraclejet/ojtreedataprovider");
+import { ojTreemap } from "@oracle/oraclejet/ojtreemap";
+import { Validation, Validator, ValidatorError, ValidatorFactory,
+    AsyncValidator, LengthValidator, LengthValidatorFactory, RegExpValidator, RegExpValidatorFactory, RequiredValidator, RequiredValidatorFactory } from "@oracle/oraclejet/ojvalidation-base";
+import { DateRestrictionValidator, DateRestrictionValidatorFactory, DateTimeRangeValidator, DateTimeRangeValidatorFactory } from "@oracle/oraclejet/ojvalidation-datetime";
+import { NumberRangeValidator, NumberRangeValidatorFactory } from "@oracle/oraclejet/ojvalidation-number";
+import { ojValidationGroup } from "@oracle/oraclejet/ojvalidationgroup";
+
+const onChangedCallback = (event: CustomEvent) => {
+};
+const myHTMLElement = document.getElementById('myelement');
+const accordionElement =  myHTMLElement as ojAccordion;
+accordionElement.multiple = true;
+accordionElement.onMultipleChanged = onChangedCallback;
+
+const avatarElement = myHTMLElement as ojAvatar;
+avatarElement.size = "xxs";
+avatarElement.set("initials", "I");
+avatarElement.unset("src");
+
+const button = myHTMLElement as ojButtonsetOne;
+button.chroming = 'half';

types/oracle__oraclejet/tsconfig.json

@@ -0,0 +1,126 @@
+{
+    "compileOnSave": true,
+	"compilerOptions": {
+        "module": "commonjs",
+        "lib": ["dom","es5","scripthost", "es2015.core","es2015.collection","es2015","esnext.asynciterable"],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "types": [],
+        "forceConsistentCasingInFileNames": true,
+        "noEmit": true,
+        "target": "es5",
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "paths": {
+            "@oracle/oraclejet": [
+                "oracle__oraclejet"
+            ],
+            "@oracle/oraclejet/*": [
+                "oracle__oraclejet/*"
+            ]
+        } 
+    },
+    "files": [
+        "oracle__oraclejet-tests.ts",
+        "index.d.ts",
+        "ojaccordion/index.d.ts",
+        "ojanimation/index.d.ts",
+        "ojarraydataprovider/index.d.ts",
+        "ojarraytreedataprovider/index.d.ts",
+        "ojattributegrouphandler/index.d.ts",
+        "ojavatar/index.d.ts",
+        "ojbutton/index.d.ts",
+        "ojchart/index.d.ts",
+        "ojcheckboxset/index.d.ts",
+        "ojcollapsible/index.d.ts",
+        "ojcollectiondataprovider/index.d.ts",
+        "ojcolor/index.d.ts",
+        "ojcolorpalette/index.d.ts",
+        "ojcolorspectrum/index.d.ts",
+        "ojcomponentcore/index.d.ts",
+        "ojcomposite/index.d.ts",
+        "ojconfig/index.d.ts",
+        "ojcontext/index.d.ts",
+        "ojconveyorbelt/index.d.ts",
+        "ojdatagrid/index.d.ts",
+        "ojdataprovider/index.d.ts",
+        "ojdatetimepicker/index.d.ts",
+        "ojdefer/index.d.ts",
+        "ojdeferreddataprovider/index.d.ts",
+        "ojdiagram/index.d.ts",
+        "ojdialog/index.d.ts",
+        "ojdvt-base/index.d.ts",
+        "ojeditablevalue/index.d.ts",
+        "ojexpressionutils/index.d.ts",
+        "ojfilepicker/index.d.ts",
+        "ojfilmstrip/index.d.ts",
+        "ojformlayout/index.d.ts",
+        "ojgantt/index.d.ts",
+        "ojganttutils/index.d.ts",
+        "ojgauge/index.d.ts",
+        "ojinputnumber/index.d.ts",
+        "ojinputtext/index.d.ts",
+        "ojkeyset/index.d.ts",
+        "ojknockout-keyset/index.d.ts",
+        "ojknockout-model/index.d.ts",
+        "ojknockouttemplateutils/index.d.ts",
+        "ojlabel/index.d.ts",
+        "ojlabelvalue/index.d.ts",
+        "ojlegend/index.d.ts",
+        "ojlistdataproviderview/index.d.ts",
+        "ojlistview/index.d.ts",
+        "ojlocaledata/index.d.ts",
+        "ojlogger/index.d.ts",
+        "ojmasonrylayout/index.d.ts",
+        "ojmenu/index.d.ts",
+        "ojmenuselectmany/index.d.ts",
+        "ojmessage/index.d.ts",
+        "ojmessages/index.d.ts",
+        "ojmessaging/index.d.ts",
+        "ojmodel/index.d.ts",
+        "ojmodule-element/index.d.ts",
+        "ojmodule-element-utils/index.d.ts",
+        "ojmoduleanimations/index.d.ts",
+        "ojnavigationlist/index.d.ts",
+        "ojnbox/index.d.ts",
+        "ojoptgroup/index.d.ts",
+        "ojoption/index.d.ts",
+        "ojpictochart/index.d.ts",
+        "ojpopup/index.d.ts",
+        "ojprogress/index.d.ts",
+        "ojprogresslist/index.d.ts",
+        "ojpulltorefresh/index.d.ts",
+        "ojradioset/index.d.ts",
+        "ojrefresher/index.d.ts",
+        "ojresponsiveknockoututils/index.d.ts",
+        "ojresponsiveutils/index.d.ts",
+        "ojrouter/index.d.ts",
+        "ojselectcombobox/index.d.ts",
+        "ojslider/index.d.ts",
+        "ojsunburst/index.d.ts",
+        "ojswipeactions/index.d.ts",
+        "ojswipetoreveal/index.d.ts",
+        "ojswitch/index.d.ts",
+        "ojswitcher/index.d.ts",
+        "ojtable/index.d.ts",
+        "ojtagcloud/index.d.ts",
+        "ojthematicmap/index.d.ts",
+        "ojthemeutils/index.d.ts",
+        "ojtime-base/index.d.ts",
+        "ojtimeaxis/index.d.ts",
+        "ojtimeutils/index.d.ts",
+        "ojtoolbar/index.d.ts",
+        "ojtrain/index.d.ts",
+        "ojtranslation/index.d.ts",
+        "ojtreedataprovider/index.d.ts",
+        "ojtreemap/index.d.ts",
+        "ojvalidation-base/index.d.ts",
+        "ojvalidation-datetime/index.d.ts",
+        "ojvalidation-number/index.d.ts",
+        "ojvalidationgroup/index.d.ts"
+    ]
+}

types/oracle__oraclejet/tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}