fastapi-rtk 2.1.4 → 2.2.0

package/dist/.external/lib/@jsonforms/core/store/store.d.ts

@@ -0,0 +1,79 @@
+import type { Store } from './type';
+import { RankedTester, UISchemaTester } from '../testers';
+import { JsonSchema, UISchemaElement } from '../models';
+import type Ajv from '../../../ajv';
+import type { ErrorObject, ValidateFunction } from '../../../ajv';
+import { JsonFormsI18nState } from './i18nTypes';
+/**
+ * JSONForms store.
+ */
+export interface JsonFormsStore extends Store<JsonFormsState> {
+}
+/**
+ * The state shape of JSONForms.
+ */
+export interface JsonFormsState {
+    /**
+     * Represents JSONForm's sub-state.
+     */
+    jsonforms: JsonFormsSubStates;
+}
+export interface JsonFormsSubStates {
+    /**
+     * Substate for storing mandatory sub-state.
+     */
+    core?: JsonFormsCore;
+    /**
+     * Global configuration options.
+     */
+    config?: any;
+    /**
+     * All available renderers.
+     */
+    renderers?: JsonFormsRendererRegistryEntry[];
+    /**
+     * All available cell renderers.
+     */
+    cells?: JsonFormsCellRendererRegistryEntry[];
+    /**
+     * I18n settings.
+     */
+    i18n?: JsonFormsI18nState;
+    /**
+     * The UI schema registry used in detail renderers.
+     */
+    uischemas?: JsonFormsUISchemaRegistryEntry[];
+    /**
+     * If true, sets all controls to read-only.
+     */
+    readonly?: boolean;
+    [additionalState: string]: any;
+}
+export type ValidationMode = 'ValidateAndShow' | 'ValidateAndHide' | 'NoValidation';
+export interface JsonFormsCore {
+    data: any;
+    schema: JsonSchema;
+    uischema: UISchemaElement;
+    errors?: ErrorObject[];
+    additionalErrors?: ErrorObject[];
+    validator?: ValidateFunction;
+    ajv?: Ajv;
+    validationMode?: ValidationMode;
+}
+export interface JsonFormsRendererRegistryEntry {
+    tester: RankedTester;
+    renderer: any;
+}
+export interface JsonFormsUISchemaRegistryEntry {
+    tester: UISchemaTester;
+    uischema: UISchemaElement;
+}
+export interface JsonFormsCellRendererRegistryEntry {
+    tester: RankedTester;
+    cell: any;
+}
+export interface JsonFormsExtendedState<T> extends JsonFormsState {
+    jsonforms: {
+        [subState: string]: T;
+    };
+}

package/dist/.external/lib/@jsonforms/core/store/type.d.ts

@@ -0,0 +1,174 @@
+export interface Action<T = any> {
+    type: T;
+}
+/**
+ * An Action type which accepts any other properties.
+ * This is mainly for the use of the `Reducer` type.
+ * This is not part of `Action` itself to prevent types that extend `Action` from
+ * having an index signature.
+ */
+export interface AnyAction extends Action {
+    [extraProps: string]: any;
+}
+/**
+ * A *dispatching function* (or simply *dispatch function*) is a function that
+ * accepts an action or an async action; it then may or may not dispatch one
+ * or more actions to the store.
+ *
+ * We must distinguish between dispatching functions in general and the base
+ * `dispatch` function provided by the store instance without any middleware.
+ *
+ * The base dispatch function *always* synchronously sends an action to the
+ * store's reducer, along with the previous state returned by the store, to
+ * calculate a new state. It expects actions to be plain objects ready to be
+ * consumed by the reducer.
+ *
+ * Middleware wraps the base dispatch function. It allows the dispatch
+ * function to handle async actions in addition to actions. Middleware may
+ * transform, delay, ignore, or otherwise interpret actions or async actions
+ * before passing them to the next middleware.
+ *
+ * @template A The type of things (actions or otherwise) which may be
+ *   dispatched.
+ */
+export type Dispatch<A extends Action = AnyAction> = <T extends A>(action: T) => T;
+/**
+ * A store is an object that holds the application's state tree.
+ * There should only be a single store in a Redux app, as the composition
+ * happens on the reducer level.
+ *
+ * @template S The type of state held by this store.
+ * @template A the type of actions which may be dispatched by this store.
+ */
+export interface Store<S = any, A extends Action = AnyAction> {
+    /**
+     * Dispatches an action. It is the only way to trigger a state change.
+     *
+     * The `reducer` function, used to create the store, will be called with the
+     * current state tree and the given `action`. Its return value will be
+     * considered the **next** state of the tree, and the change listeners will
+     * be notified.
+     *
+     * The base implementation only supports plain object actions. If you want
+     * to dispatch a Promise, an Observable, a thunk, or something else, you
+     * need to wrap your store creating function into the corresponding
+     * middleware. For example, see the documentation for the `redux-thunk`
+     * package. Even the middleware will eventually dispatch plain object
+     * actions using this method.
+     *
+     * @param action A plain object representing “what changed”. It is a good
+     *   idea to keep actions serializable so you can record and replay user
+     *   sessions, or use the time travelling `redux-devtools`. An action must
+     *   have a `type` property which may not be `undefined`. It is a good idea
+     *   to use string constants for action types.
+     *
+     * @returns For convenience, the same action object you dispatched.
+     *
+     * Note that, if you use a custom middleware, it may wrap `dispatch()` to
+     * return something else (for example, a Promise you can await).
+     */
+    dispatch: Dispatch<A>;
+    /**
+     * Reads the state tree managed by the store.
+     *
+     * @returns The current state tree of your application.
+     */
+    getState(): S;
+    /**
+     * Adds a change listener. It will be called any time an action is
+     * dispatched, and some part of the state tree may potentially have changed.
+     * You may then call `getState()` to read the current state tree inside the
+     * callback.
+     *
+     * You may call `dispatch()` from a change listener, with the following
+     * caveats:
+     *
+     * 1. The subscriptions are snapshotted just before every `dispatch()` call.
+     * If you subscribe or unsubscribe while the listeners are being invoked,
+     * this will not have any effect on the `dispatch()` that is currently in
+     * progress. However, the next `dispatch()` call, whether nested or not,
+     * will use a more recent snapshot of the subscription list.
+     *
+     * 2. The listener should not expect to see all states changes, as the state
+     * might have been updated multiple times during a nested `dispatch()` before
+     * the listener is called. It is, however, guaranteed that all subscribers
+     * registered before the `dispatch()` started will be called with the latest
+     * state by the time it exits.
+     *
+     * @param listener A callback to be invoked on every dispatch.
+     * @returns A function to remove this change listener.
+     */
+    subscribe(listener: () => void): Unsubscribe;
+    /**
+     * Replaces the reducer currently used by the store to calculate the state.
+     *
+     * You might need this if your app implements code splitting and you want to
+     * load some of the reducers dynamically. You might also need this if you
+     * implement a hot reloading mechanism for Redux.
+     *
+     * @param nextReducer The reducer for the store to use instead.
+     */
+    replaceReducer(nextReducer: Reducer<S, A>): void;
+    /**
+     * Interoperability point for observable/reactive libraries.
+     * @returns {observable} A minimal observable of state changes.
+     * For more information, see the observable proposal:
+     * https://github.com/tc39/proposal-observable
+     */
+    [Symbol.observable](): Observable<S>;
+}
+/**
+ * A minimal observable of state changes.
+ * For more information, see the observable proposal:
+ * https://github.com/tc39/proposal-observable
+ */
+export type Observable<T> = {
+    /**
+     * The minimal observable subscription method.
+     * @param {Object} observer Any object that can be used as an observer.
+     * The observer object should have a `next` method.
+     * @returns {subscription} An object with an `unsubscribe` method that can
+     * be used to unsubscribe the observable from the store, and prevent further
+     * emission of values from the observable.
+     */
+    subscribe(observer: Observer<T>): {
+        unsubscribe: Unsubscribe;
+    };
+    [Symbol.observable](): Observable<T>;
+};
+/**
+ * An Observer is used to receive data from an Observable, and is supplied as
+ * an argument to subscribe.
+ */
+export type Observer<T> = {
+    next?(value: T): void;
+};
+/**
+ * A *reducer* (also called a *reducing function*) is a function that accepts
+ * an accumulation and a value and returns a new accumulation. They are used
+ * to reduce a collection of values down to a single value
+ *
+ * Reducers are not unique to Redux—they are a fundamental concept in
+ * functional programming.  Even most non-functional languages, like
+ * JavaScript, have a built-in API for reducing. In JavaScript, it's
+ * `Array.prototype.reduce()`.
+ *
+ * In Redux, the accumulated value is the state object, and the values being
+ * accumulated are actions. Reducers calculate a new state given the previous
+ * state and an action. They must be *pure functions*—functions that return
+ * the exact same output for given inputs. They should also be free of
+ * side-effects. This is what enables exciting features like hot reloading and
+ * time travel.
+ *
+ * Reducers are the most important concept in Redux.
+ *
+ * *Do not put API calls into reducers.*
+ *
+ * @template S The type of state consumed and produced by this reducer.
+ * @template A The type of actions the reducer can potentially respond to.
+ */
+export type Reducer<S = any, A extends Action = AnyAction> = (state: S | undefined, action: A) => S;
+/**
+ * Function to remove listener added by `Store.subscribe()`.
+ */
+export type Unsubscribe = () => void;

package/dist/.external/lib/@jsonforms/core/testers/index.d.ts

@@ -0,0 +1 @@
+export * from './testers';

package/dist/.external/lib/@jsonforms/core/testers/testers.d.ts

@@ -0,0 +1,221 @@
+import type { Categorization, ControlElement, JsonSchema, UISchemaElement } from '../models';
+/**
+ * Constant that indicates that a tester is not capable of handling
+ * a combination of schema/data.
+ * @type {number}
+ */
+export declare const NOT_APPLICABLE = -1;
+/**
+ * A tester is a function that receives an UI schema and a JSON schema and returns a boolean.
+ * The rootSchema is handed over as context. Can be used to resolve references.
+ */
+export type Tester = (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) => boolean;
+/**
+ * A ranked tester associates a tester with a number.
+ */
+export type RankedTester = (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) => number;
+/**
+ * Additional context given to a tester in addition to UISchema and JsonSchema.
+ */
+export interface TesterContext {
+    /** The root JsonSchema of the form. Can be used to resolve references. */
+    rootSchema: JsonSchema;
+    /** The form wide configuration object given to JsonForms. */
+    config: any;
+}
+export type UISchemaTester = (schema: JsonSchema, schemaPath: string, path: string) => number;
+export declare const isControl: (uischema: any) => uischema is ControlElement;
+/**
+ * Only applicable for Controls.
+ *
+ * This function checks whether the given UI schema is of type Control
+ * and if so, resolves the sub-schema referenced by the control and applies
+ * the given predicate
+ *
+ * @param {(JsonSchema) => boolean} predicate the predicate that should be
+ *        applied to the resolved sub-schema
+ */
+export declare const schemaMatches: (predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean) => Tester;
+export declare const schemaSubPathMatches: (subPath: string, predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean) => Tester;
+/**
+ * Only applicable for Controls.
+ *
+ * This function checks whether the given UI schema is of type Control
+ * and if so, resolves the sub-schema referenced by the control and checks
+ * whether the type of the sub-schema matches the expected one.
+ *
+ * @param {string} expectedType the expected type of the resolved sub-schema
+ */
+export declare const schemaTypeIs: (expectedType: string) => Tester;
+/**
+ * Only applicable for Controls.
+ *
+ * This function checks whether the given UI schema is of type Control
+ * and if so, resolves the sub-schema referenced by the control and checks
+ * whether the format of the sub-schema matches the expected one.
+ *
+ * @param {string} expectedFormat the expected format of the resolved sub-schema
+ */
+export declare const formatIs: (expectedFormat: string) => Tester;
+/**
+ * Checks whether the given UI schema has the expected type.
+ *
+ * @param {string} expected the expected UI schema type
+ */
+export declare const uiTypeIs: (expected: string) => Tester;
+/**
+ * Checks whether the given UI schema has an option with the given
+ * name and whether it has the expected value. If no options property
+ * is set, returns false.
+ *
+ * @param {string} optionName the name of the option to check
+ * @param {any} optionValue the expected value of the option
+ */
+export declare const optionIs: (optionName: string, optionValue: any) => Tester;
+/**
+ * Checks whether the given UI schema has an option with the given
+ * name. If no options property is set, returns false.
+ *
+ * @param {string} optionName the name of the option to check
+ */
+export declare const hasOption: (optionName: string) => Tester;
+/**
+ * Only applicable for Controls.
+ *
+ * Checks whether the scope of a control ends with the expected string.
+ *
+ * @param {string} expected the expected ending of the reference
+ */
+export declare const scopeEndsWith: (expected: string) => Tester;
+/**
+ * Only applicable for Controls.
+ *
+ * Checks whether the last segment of the scope matches the expected string.
+ *
+ * @param {string} expected the expected ending of the reference
+ */
+export declare const scopeEndIs: (expected: string) => Tester;
+/**
+ * A tester that allow composing other testers by && them.
+ *
+ * @param {Array<Tester>} testers the testers to be composed
+ */
+export declare const and: (...testers: Tester[]) => Tester;
+/**
+ * A tester that allow composing other testers by || them.
+ *
+ * @param {Array<Tester>} testers the testers to be composed
+ */
+export declare const or: (...testers: Tester[]) => Tester;
+/**
+ * Create a ranked tester that will associate a number with a given tester, if the
+ * latter returns true.
+ *
+ * @param {number} rank the rank to be returned in case the tester returns true
+ * @param {Tester} tester a tester
+ */
+export declare const rankWith: (rank: number, tester: Tester) => (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) => number;
+export declare const withIncreasedRank: (by: number, rankedTester: RankedTester) => (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) => number;
+/**
+ * Default tester for boolean.
+ * @type {RankedTester}
+ */
+export declare const isBooleanControl: Tester;
+export declare const isObjectControl: Tester;
+export declare const isAllOfControl: Tester;
+export declare const isAnyOfControl: Tester;
+export declare const isOneOfControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and if the schema
+ * has an enum.
+ * @type {Tester}
+ */
+export declare const isEnumControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and if the schema
+ * has an enum based on oneOf.
+ * @type {Tester}
+ */
+export declare const isOneOfEnumControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and if the schema
+ * is of type integer
+ * @type {Tester}
+ */
+export declare const isIntegerControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and if the schema
+ * is of type number
+ * @type {Tester}
+ */
+export declare const isNumberControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and if the schema
+ * is of type string
+ * @type {Tester}
+ */
+export declare const isStringControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and if is has
+ * a 'multi' option.
+ * @type {Tester}
+ */
+export declare const isMultiLineControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and whether the schema
+ * or uischema options has a 'date' format.
+ * @type {Tester}
+ */
+export declare const isDateControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and whether the schema
+ * or the uischema options has a 'time' format.
+ * @type {Tester}
+ */
+export declare const isTimeControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and whether the schema
+ * or the uischema options has a 'date-time' format.
+ * @type {Tester}
+ */
+export declare const isDateTimeControl: Tester;
+/**
+ * Tests whether the given schema is an array of objects.
+ * @type {Tester}
+ */
+export declare const isObjectArray: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and if the schema
+ * is an array of objects.
+ * @type {Tester}
+ */
+export declare const isObjectArrayControl: Tester;
+export declare const isObjectArrayWithNesting: (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) => boolean;
+/**
+ * Synonym for isObjectArrayControl
+ */
+export declare const isArrayObjectControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control and if the schema
+ * is an array of a primitive type.
+ * @type {Tester}
+ */
+export declare const isPrimitiveArrayControl: Tester;
+/**
+ * Tests whether a given UI schema is of type Control,
+ * if the schema is of type number or integer and
+ * whether the schema defines a numerical range with a default value.
+ * @type {Tester}
+ */
+export declare const isRangeControl: Tester;
+/**
+ * Tests whether the given UI schema is of type Control, if the schema
+ * is of type integer and has option format
+ * @type {Tester}
+ */
+export declare const isNumberFormatControl: Tester;
+export declare const isCategorization: (category: UISchemaElement) => category is Categorization;
+export declare const isCategory: (uischema: UISchemaElement) => boolean;
+export declare const hasCategory: (categorization: Categorization) => boolean;
+export declare const categorizationHasCategory: (uischema: UISchemaElement) => boolean;
+export declare const not: (tester: Tester) => Tester;

package/dist/.external/lib/@jsonforms/core/util/Formatted.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Interface for mapping a given type to a formatted string and back.
+ */
+export interface Formatted<A> {
+    /**
+     * Format the given value
+     *
+     * @param {A} value the value to be formatted
+     * @returns {string} the formatted string
+     */
+    toFormatted(value: A): string;
+    /**
+     * Retrieve a value from a given string.
+     *
+     * @param {string} formatted the format string from which to obtain a value
+     * @returns {A} the obtained value
+     */
+    fromFormatted(formatted: string): A;
+}

package/dist/.external/lib/@jsonforms/core/util/defaultDateFormat.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultDateFormat = "YYYY-MM-DD";
+export declare const defaultTimeFormat = "HH:mm:ss";
+export declare const defaultDateTimeFormat = "YYYY-MM-DDTHH:mm:ss.sssZ";

package/dist/.external/lib/@jsonforms/core/util/errors.d.ts

@@ -0,0 +1,5 @@
+import { ErrorObject } from '../../../ajv';
+import { JsonSchema } from '../models';
+export declare const getControlPath: (error: ErrorObject) => any;
+export declare const errorsAt: (instancePath: string, schema: JsonSchema, matchPath: (path: string) => boolean) => (errors: ErrorObject[]) => ErrorObject[];
+export declare const formatErrorMessage: (errors: string[]) => string;

package/dist/.external/lib/@jsonforms/core/util/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { ControlElement, JsonSchema, LabelDescription } from '../models';
+export declare const Helpers: {
+    createLabelDescriptionFrom(withLabel: ControlElement, schema: JsonSchema): LabelDescription;
+    convertToValidClassName(s: string): string;
+};

package/dist/.external/lib/@jsonforms/core/util/ids.d.ts

@@ -0,0 +1,3 @@
+export declare const createId: (proposedId: string) => string;
+export declare const removeId: (id: string) => boolean;
+export declare const clearAllIds: () => void;

package/dist/.external/lib/@jsonforms/core/util/index.d.ts

@@ -0,0 +1,13 @@
+export * from './Formatted';
+export * from './ids';
+export * from './label';
+export * from './path';
+export * from './resolvers';
+export * from './runtime';
+export * from './schema';
+export * from './uischema';
+export * from './util';
+export * from './validator';
+export * from './defaultDateFormat';
+export * from './errors';
+export * from './helpers';

package/dist/.external/lib/@jsonforms/core/util/label.d.ts

@@ -0,0 +1,9 @@
+import { ControlElement, JsonSchema, LabelDescription } from '../models';
+export declare const createCleanLabel: (label: string) => string;
+/**
+ * Return a label object based on the given control and schema element.
+ * @param {ControlElement} withLabel the UI schema to obtain a label object for
+ * @param {JsonSchema} schema optional: the corresponding schema element
+ * @returns {LabelDescription}
+ */
+export declare const createLabelDescriptionFrom: (withLabel: ControlElement, schema?: JsonSchema) => LabelDescription;

package/dist/.external/lib/@jsonforms/core/util/path.d.ts

@@ -0,0 +1,42 @@
+export declare const compose: (path1: string, path2: string) => string;
+export { compose as composePaths };
+/**
+ * Convert a schema path (i.e. JSON pointer) to an array by splitting
+ * at the '/' character and removing all schema-specific keywords.
+ *
+ * The returned value can be used to de-reference a root object by folding over it
+ * and de-referencing the single segments to obtain a new object.
+ *
+ *
+ * @param {string} schemaPath the schema path to be converted
+ * @returns {string[]} an array containing only non-schema-specific segments
+ */
+export declare const toDataPathSegments: (schemaPath: string) => string[];
+/**
+ * Convert a schema path (i.e. JSON pointer) to a data path.
+ *
+ * Data paths can be used in field change event handlers like handleChange.
+ *
+ * @example
+ * toDataPath('#/properties/foo/properties/bar') === 'foo.bar')
+ *
+ * @param {string} schemaPath the schema path to be converted
+ * @returns {string} the data path
+ */
+export declare const toDataPath: (schemaPath: string) => string;
+/**
+ * Encodes the given segment to be used as part of a JSON Pointer
+ *
+ * JSON Pointer has special meaning for "/" and "~", therefore these must be encoded
+ */
+export declare const encode: (segment: string) => string;
+/**
+ * Decodes a given JSON Pointer segment to its "normal" representation
+ */
+export declare const decode: (pointerSegment: string) => string;
+/**
+ * Transform a dotted path to a uiSchema properties path
+ * @param path a dotted prop path to a schema value (i.e. articles.comment.author)
+ * @return the uiSchema properties path (i.e. /properties/articles/properties/comment/properties/author)
+ */
+export declare const getPropPath: (path: string) => string;

package/dist/.external/lib/@jsonforms/core/util/resolvers.d.ts

@@ -0,0 +1,25 @@
+import type { JsonSchema } from '../models';
+/**
+ * Map for storing refs and the respective schemas they are pointing to.
+ */
+export interface ReferenceSchemaMap {
+    [ref: string]: JsonSchema;
+}
+export declare const resolveData: (instance: any, dataPath: string) => any;
+/**
+ * Finds all references inside the given schema.
+ *
+ * @param schema The {@link JsonSchema} to find the references in
+ * @param result The initial result map, default: empty map (this parameter is used for recursion
+ *               inside the function)
+ * @param resolveTuples Whether arrays of tuples should be considered; default: false
+ */
+export declare const findAllRefs: (schema: JsonSchema, result?: ReferenceSchemaMap, resolveTuples?: boolean) => ReferenceSchemaMap;
+/**
+ * Resolve the given schema path in order to obtain a subschema.
+ * @param {JsonSchema} schema the root schema from which to start
+ * @param {string} schemaPath the schema path to be resolved
+ * @param {JsonSchema} rootSchema the actual root schema
+ * @returns {JsonSchema} the resolved sub-schema or undefined
+ */
+export declare const resolveSchema: (schema: JsonSchema, schemaPath: string, rootSchema: JsonSchema) => JsonSchema | undefined;

package/dist/.external/lib/@jsonforms/core/util/runtime.d.ts

@@ -0,0 +1,8 @@
+import { UISchemaElement } from '../models';
+import type Ajv from '../../../ajv';
+export declare const evalVisibility: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv, config: unknown) => boolean;
+export declare const evalEnablement: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv, config: unknown) => boolean;
+export declare const hasShowRule: (uischema: UISchemaElement) => boolean;
+export declare const hasEnableRule: (uischema: UISchemaElement) => boolean;
+export declare const isVisible: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv, config: unknown) => boolean;
+export declare const isEnabled: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv, config: unknown) => boolean;

package/dist/.external/lib/@jsonforms/core/util/schema.d.ts

@@ -0,0 +1,10 @@
+import type { JsonSchema } from '../models';
+export declare const getFirstPrimitiveProp: (schema: unknown) => string;
+/**
+ * Tests whether the schema has an enum based on oneOf.
+ */
+export declare const isOneOfEnumSchema: (schema: JsonSchema) => boolean;
+/**
+ * Tests whether the schema has an enum.
+ */
+export declare const isEnumSchema: (schema: JsonSchema) => any;

package/dist/.external/lib/@jsonforms/core/util/uischema.d.ts

@@ -0,0 +1,21 @@
+import { ControlElement, GroupLayout, Internationalizable, Labelable, Labeled, Layout, Scopable, Scoped, UISchemaElement } from '../models';
+export type IterateCallback = (uischema: UISchemaElement) => void;
+export declare const setReadonly: (uischema: UISchemaElement) => void;
+export declare const unsetReadonly: (uischema: UISchemaElement) => void;
+export declare const iterateSchema: (uischema: UISchemaElement, toApply: IterateCallback) => void;
+/**
+ * Find a control in a uiSchema, based on the dotted path of the schema value
+ * @param {UISchemaElement} uiSchema the uiSchema to search from
+ * @param path a dotted prop path to a schema value (i.e. articles.comment.author)
+ * @return {UISchemaElement} or undefined if not found
+ */
+export declare const findUiControl: (uiSchema: UISchemaElement, path: string) => UISchemaElement | undefined;
+export declare const composeWithUi: (scopableUi: Scopable, path: string) => string;
+export declare const isInternationalized: (element: unknown) => element is Required<Internationalizable>;
+export declare const isGroup: (layout: Layout) => layout is GroupLayout;
+export declare const isLayout: (uischema: UISchemaElement) => uischema is Layout;
+export declare const isScopable: (obj: unknown) => obj is Scopable;
+export declare const isScoped: (obj: unknown) => obj is Scoped;
+export declare const isLabelable: (obj: unknown) => obj is Labelable;
+export declare const isLabeled: <T = never>(obj: unknown) => obj is Labeled<T>;
+export declare const isControlElement: (uiSchema: UISchemaElement) => uiSchema is ControlElement;