fastapi-rtk 2.1.5 → 2.2.0

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

@@ -0,0 +1,56 @@
+import type Ajv from '../../../ajv';
+import type { JsonSchema, Scoped, UISchemaElement } from '../models';
+/**
+ * Returns the string representation of the given date. The format of the output string can be specified:
+ * - 'date' for a date-only string (YYYY-MM-DD),
+ * - 'time' for a time-only string (HH:mm:ss), or
+ * - 'date-time' for a full date-time string in ISO format (YYYY-MM-DDTHH:mm:ss.sssZ).
+ * If no format is specified, the full date-time ISO string is returned by default.
+ *
+ * @returns {string} A string representation of the date in the specified format.
+ *
+ * @example
+ * // returns '2023-11-09'
+ * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'date');
+ *
+ * @example
+ * // returns '14:22:54'
+ * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'time');
+ *
+ * @example
+ * // returns '2023-11-09T14:22:54.131Z'
+ * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'date-time');
+ *
+ * @example
+ * // returns '2023-11-09T14:22:54.131Z'
+ * convertDateToString(new Date('2023-11-09T14:22:54.131Z'));
+ */
+export declare const convertDateToString: (date: Date, format?: "date" | "time" | "date-time") => string;
+/**
+ * Escape the given string such that it can be used as a class name,
+ * i.e. hashes and slashes will be replaced.
+ *
+ * @param {string} s the string that should be converted to a valid class name
+ * @returns {string} the escaped string
+ */
+export declare const convertToValidClassName: (s: string) => string;
+export declare const hasType: (jsonSchema: JsonSchema, expected: string) => boolean;
+/**
+ * Derives the type of the jsonSchema element
+ */
+export declare const deriveTypes: (jsonSchema: JsonSchema) => string[];
+/**
+ * Convenience wrapper around resolveData and resolveSchema.
+ */
+export declare const Resolve: {
+    schema(schema: JsonSchema, schemaPath: string, rootSchema: JsonSchema): JsonSchema;
+    data(data: any, path: string): any;
+};
+export declare const Paths: {
+    compose: (path1: string, path2: string) => string;
+    fromScoped: (scopable: Scoped) => string;
+};
+export declare const Runtime: {
+    isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv, config: unknown): boolean;
+    isVisible(uischema: UISchemaElement, data: any, ajv: Ajv, config: unknown): boolean;
+};

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

@@ -0,0 +1,4 @@
+import Ajv from '../../../ajv';
+import type { ErrorObject, Options, ValidateFunction } from '../../../ajv';
+export declare const createAjv: (options?: Options) => Ajv;
+export declare const validate: (validator: ValidateFunction | undefined, data: any) => ErrorObject[];

package/dist/.external/lib/@jsonforms/react/Control.d.ts

@@ -0,0 +1,26 @@
+import { RendererComponent } from './Renderer';
+import type { ControlProps, ControlState } from '../core';
+/**
+ * A controlled component convenience wrapper that additionally manages a focused state.
+ *
+ * @template P control specific properties
+ * @template S the state managed by the control
+ */
+export declare class Control<P extends ControlProps, S extends ControlState> extends RendererComponent<P, S> {
+    constructor(props: P);
+    /**
+     * Propagates a value change.
+     *
+     * @param value the updated value
+     */
+    handleChange: (value: any) => void;
+    /**
+     * Set the focused state to true.
+     */
+    onFocus: () => void;
+    /**
+     * Set the focused state to false.
+     */
+    onBlur: () => void;
+    private updateData;
+}

package/dist/.external/lib/@jsonforms/react/DispatchCell.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { DispatchCellProps } from '../core';
+/**
+ * Dispatch renderer component for cells.
+ */
+export declare const Dispatch: ({ uischema, schema, rootSchema, path, cells, id, enabled, renderers, config, }: DispatchCellProps) => React.JSX.Element;
+export declare const DispatchCell: React.ComponentType<import("../core").OwnPropsOfCell>;

package/dist/.external/lib/@jsonforms/react/JsonForms.d.ts

@@ -0,0 +1,48 @@
+import React, { ComponentType } from 'react';
+import type Ajv from '../../ajv';
+import type { ErrorObject } from '../../ajv';
+import { JsonFormsCellRendererRegistryEntry, JsonFormsCore, JsonFormsI18nState, JsonFormsProps, JsonFormsRendererRegistryEntry, JsonFormsUISchemaRegistryEntry, JsonSchema, Middleware, OwnPropsOfJsonFormsRenderer, UISchemaElement, ValidationMode } from '../core';
+interface JsonFormsRendererState {
+    id: string;
+}
+export interface JsonFormsReactProps {
+    onChange?(state: Pick<JsonFormsCore, 'data' | 'errors'>): void;
+    middleware?: Middleware;
+}
+export declare class JsonFormsDispatchRenderer extends React.Component<JsonFormsProps, JsonFormsRendererState> {
+    constructor(props: JsonFormsProps);
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: JsonFormsProps): void;
+    render(): React.JSX.Element;
+}
+/**
+ * @deprecated Since Version 3.0 this optimization renderer is no longer necessary.
+ * Use `JsonFormsDispatch` instead.
+ * We still export it for backward compatibility
+ */
+export declare class ResolvedJsonFormsDispatchRenderer extends JsonFormsDispatchRenderer {
+    constructor(props: JsonFormsProps);
+}
+export declare const JsonFormsDispatch: ComponentType<OwnPropsOfJsonFormsRenderer>;
+/**
+ * @deprecated Since Version 3.0 this optimization component is no longer necessary.
+ * Use `JsonFormsDispatch` instead.
+ * We still export it for backward compatibility
+ */
+export declare const ResolvedJsonFormsDispatch: ComponentType<OwnPropsOfJsonFormsRenderer>;
+export interface JsonFormsInitStateProps {
+    data: any;
+    schema?: JsonSchema;
+    uischema?: UISchemaElement;
+    renderers: JsonFormsRendererRegistryEntry[];
+    cells?: JsonFormsCellRendererRegistryEntry[];
+    ajv?: Ajv;
+    config?: any;
+    uischemas?: JsonFormsUISchemaRegistryEntry[];
+    readonly?: boolean;
+    validationMode?: ValidationMode;
+    i18n?: JsonFormsI18nState;
+    additionalErrors?: ErrorObject[];
+}
+export declare const JsonForms: (props: JsonFormsInitStateProps & JsonFormsReactProps) => React.JSX.Element;
+export {};

package/dist/.external/lib/@jsonforms/react/JsonFormsContext.d.ts

@@ -0,0 +1,197 @@
+import { ArrayControlProps, ArrayLayoutProps, CellProps, CombinatorRendererProps, ControlProps, DispatchCellProps, DispatchPropsOfControl, EnumCellProps, JsonFormsProps, JsonFormsSubStates, LayoutProps, OwnPropsOfCell, OwnPropsOfControl, OwnPropsOfEnum, OwnPropsOfEnumCell, OwnPropsOfJsonFormsRenderer, OwnPropsOfLayout, OwnPropsOfMasterListItem, StatePropsOfControlWithDetail, StatePropsOfMasterItem, coreReducer, DispatchPropsOfMultiEnumControl, Translator, OwnPropsOfLabel, LabelProps, ArrayTranslations } from '../core';
+import React, { ComponentType, Dispatch, ReducerAction } from 'react';
+export interface JsonFormsStateContext extends JsonFormsSubStates {
+    dispatch?: Dispatch<ReducerAction<typeof coreReducer>>;
+}
+export declare const JsonFormsContext: React.Context<JsonFormsStateContext>;
+export declare const JsonFormsStateProvider: ({ children, initState, onChange, middleware, }: any) => React.JSX.Element;
+export declare const useJsonForms: () => JsonFormsStateContext;
+export interface JsonFormsReduxContextProps extends JsonFormsSubStates {
+    children: any;
+    dispatch: Dispatch<ReducerAction<any>>;
+}
+export declare const ctxToArrayLayoutProps: (ctx: JsonFormsStateContext, props: OwnPropsOfControl) => import("../core").StatePropsOfArrayLayout;
+export declare const ctxToArrayControlProps: (ctx: JsonFormsStateContext, props: OwnPropsOfControl) => import("../core").StatePropsOfArrayControl;
+export declare const ctxToLayoutProps: (ctx: JsonFormsStateContext, props: OwnPropsOfLayout) => LayoutProps;
+export declare const ctxToControlProps: (ctx: JsonFormsStateContext, props: OwnPropsOfControl) => import("../core").StatePropsOfControl;
+export declare const ctxToEnumControlProps: (ctx: JsonFormsStateContext, props: OwnPropsOfEnum) => {
+    options: import("../core").EnumOption[];
+    cells?: {
+        tester: import("../core").RankedTester;
+        cell: any;
+    }[];
+    label: string;
+    description?: string;
+    required?: boolean;
+    i18nKeyPrefix?: string;
+    uischema: import("../core").ControlElement;
+    errors: string;
+    data: any;
+    rootSchema: import("../core").JsonSchema;
+    id: string;
+    config?: any;
+    schema: import("../core").JsonSchema;
+    enabled: boolean;
+    visible: boolean;
+    path: string;
+    renderers?: import("../core").JsonFormsRendererRegistryEntry[];
+};
+export declare const ctxToOneOfEnumControlProps: (ctx: JsonFormsStateContext, props: OwnPropsOfControl & OwnPropsOfEnum) => {
+    options: import("../core").EnumOption[];
+    cells?: {
+        tester: import("../core").RankedTester;
+        cell: any;
+    }[];
+    label: string;
+    description?: string;
+    required?: boolean;
+    i18nKeyPrefix?: string;
+    uischema: import("../core").ControlElement;
+    errors: string;
+    data: any;
+    rootSchema: import("../core").JsonSchema;
+    id: string;
+    config?: any;
+    schema: import("../core").JsonSchema;
+    enabled: boolean;
+    visible: boolean;
+    path: string;
+    renderers?: import("../core").JsonFormsRendererRegistryEntry[];
+};
+export declare const ctxToMultiEnumControlProps: (ctx: JsonFormsStateContext, props: OwnPropsOfControl) => {
+    options: import("../core").EnumOption[];
+    cells?: {
+        tester: import("../core").RankedTester;
+        cell: any;
+    }[];
+    label: string;
+    description?: string;
+    required?: boolean;
+    i18nKeyPrefix?: string;
+    uischema: import("../core").ControlElement;
+    errors: string;
+    data: any;
+    rootSchema: import("../core").JsonSchema;
+    id: string;
+    config?: any;
+    schema: import("../core").JsonSchema;
+    enabled: boolean;
+    visible: boolean;
+    path: string;
+    renderers?: import("../core").JsonFormsRendererRegistryEntry[];
+};
+export declare const ctxToControlWithDetailProps: (ctx: JsonFormsStateContext, props: OwnPropsOfControl) => StatePropsOfControlWithDetail;
+export declare const ctxToAllOfProps: (ctx: JsonFormsStateContext, ownProps: OwnPropsOfControl) => {
+    rootSchema: import("../core").JsonSchema;
+    path: string;
+    id: string;
+    indexOfFittingSchema: number;
+    uischemas: import("../core").JsonFormsUISchemaRegistryEntry[];
+    data: any;
+    cells?: {
+        tester: import("../core").RankedTester;
+        cell: any;
+    }[];
+    label: string;
+    description?: string;
+    required?: boolean;
+    i18nKeyPrefix?: string;
+    uischema: import("../core").ControlElement;
+    errors: string;
+    config?: any;
+    schema: import("../core").JsonSchema;
+    enabled: boolean;
+    visible: boolean;
+    renderers?: import("../core").JsonFormsRendererRegistryEntry[];
+};
+export declare const ctxDispatchToControlProps: (dispatch: Dispatch<ReducerAction<any>>) => DispatchPropsOfControl;
+export declare const ctxToAnyOfProps: (ctx: JsonFormsStateContext, ownProps: OwnPropsOfControl) => CombinatorRendererProps;
+export declare const ctxToOneOfProps: (ctx: JsonFormsStateContext, ownProps: OwnPropsOfControl) => CombinatorRendererProps;
+export declare const ctxToJsonFormsRendererProps: (ctx: JsonFormsStateContext, ownProps: OwnPropsOfJsonFormsRenderer) => import("../core").StatePropsOfJsonFormsRenderer;
+export declare const ctxDispatchToArrayControlProps: (dispatch: Dispatch<ReducerAction<any>>) => {
+    addItem(path: string, value: any): () => void;
+    removeItems?(path: string, toDelete: number[]): () => void;
+    moveUp?(path: string, toMove: number): () => void;
+    moveDown?(path: string, toMove: number): () => void;
+    handleChange(path: string, value: any): void;
+};
+export declare const ctxToMasterListItemProps: (ctx: JsonFormsStateContext, ownProps: OwnPropsOfMasterListItem) => StatePropsOfMasterItem;
+export declare const ctxToCellProps: (ctx: JsonFormsStateContext, ownProps: OwnPropsOfCell) => import("../core").StatePropsOfCell;
+export declare const ctxToEnumCellProps: (ctx: JsonFormsStateContext, ownProps: EnumCellProps) => {
+    options: import("../core").EnumOption[];
+    isValid: boolean;
+    rootSchema: import("../core").JsonSchema;
+    uischema: import("../core").ControlElement;
+    errors: string;
+    data: any;
+    id: string;
+    config?: any;
+    schema: import("../core").JsonSchema;
+    enabled: boolean;
+    visible: boolean;
+    path: string;
+    renderers?: import("../core").JsonFormsRendererRegistryEntry[];
+    cells?: import("../core").JsonFormsCellRendererRegistryEntry[];
+};
+export declare const ctxToOneOfEnumCellProps: (ctx: JsonFormsStateContext, props: OwnPropsOfEnumCell) => {
+    options: import("../core").EnumOption[];
+    isValid: boolean;
+    rootSchema: import("../core").JsonSchema;
+    uischema: import("../core").ControlElement;
+    errors: string;
+    data: any;
+    id: string;
+    config?: any;
+    schema: import("../core").JsonSchema;
+    enabled: boolean;
+    visible: boolean;
+    path: string;
+    renderers?: import("../core").JsonFormsRendererRegistryEntry[];
+    cells?: import("../core").JsonFormsCellRendererRegistryEntry[];
+};
+export declare const ctxToDispatchCellProps: (ctx: JsonFormsStateContext, ownProps: OwnPropsOfCell) => import("../core").DispatchCellStateProps;
+export declare const ctxDispatchToMultiEnumProps: (dispatch: Dispatch<ReducerAction<any>>) => {
+    addItem: (path: string, value: any) => void;
+    removeItem?: (path: string, toDelete: any) => void;
+    handleChange(path: string, value: any): void;
+};
+export declare const ctxToLabelProps: (ctx: JsonFormsStateContext, ownProps: OwnPropsOfLabel) => {
+    text: string;
+    visible: boolean;
+    config: any;
+    renderers: import("../core").JsonFormsRendererRegistryEntry[];
+    cells: import("../core").JsonFormsCellRendererRegistryEntry[];
+    uischema: import("../core").LabelElement;
+};
+interface WithContext {
+    ctx: JsonFormsStateContext;
+}
+export declare const withJsonFormsContext: (Component: ComponentType<WithContext & any>) => ComponentType<any>;
+export declare const withContextToJsonFormsRendererProps: (Component: ComponentType<JsonFormsProps>) => ComponentType<OwnPropsOfJsonFormsRenderer>;
+export declare const withJsonFormsRendererProps: (Component: ComponentType<JsonFormsProps>, memoize?: boolean) => ComponentType<OwnPropsOfJsonFormsRenderer>;
+export declare const withJsonFormsControlProps: (Component: ComponentType<ControlProps>, memoize?: boolean) => ComponentType<OwnPropsOfControl>;
+export declare const withJsonFormsLayoutProps: <T extends LayoutProps>(Component: ComponentType<T>, memoize?: boolean) => ComponentType<T & OwnPropsOfLayout>;
+export declare const withJsonFormsOneOfProps: (Component: ComponentType<CombinatorRendererProps>, memoize?: boolean) => ComponentType<OwnPropsOfControl>;
+export declare const withJsonFormsAnyOfProps: (Component: ComponentType<CombinatorRendererProps>, memoize?: boolean) => ComponentType<OwnPropsOfControl>;
+export declare const withJsonFormsAllOfProps: (Component: ComponentType<CombinatorRendererProps>, memoize?: boolean) => ComponentType<OwnPropsOfControl>;
+export declare const withJsonFormsDetailProps: (Component: ComponentType<StatePropsOfControlWithDetail>, memoize?: boolean) => ComponentType<OwnPropsOfControl>;
+export declare const withJsonFormsArrayLayoutProps: (Component: ComponentType<ArrayLayoutProps>, memoize?: boolean) => ComponentType<OwnPropsOfControl>;
+export declare const withJsonFormsArrayControlProps: (Component: ComponentType<ArrayControlProps>, memoize?: boolean) => ComponentType<OwnPropsOfControl>;
+export declare const withJsonFormsMasterListItemProps: (Component: ComponentType<StatePropsOfMasterItem>, memoize?: boolean) => ComponentType<OwnPropsOfMasterListItem>;
+export declare const withJsonFormsCellProps: (Component: ComponentType<CellProps>, memoize?: boolean) => ComponentType<OwnPropsOfCell>;
+export declare const withJsonFormsDispatchCellProps: (Component: ComponentType<DispatchCellProps>, memoize?: boolean) => ComponentType<OwnPropsOfCell>;
+export declare const withJsonFormsEnumCellProps: (Component: ComponentType<EnumCellProps>, memoize?: boolean) => ComponentType<OwnPropsOfEnumCell>;
+export declare const withJsonFormsEnumProps: (Component: ComponentType<ControlProps & OwnPropsOfEnum>, memoize?: boolean) => ComponentType<OwnPropsOfControl & OwnPropsOfEnum>;
+export declare const withJsonFormsOneOfEnumCellProps: (Component: ComponentType<EnumCellProps>, memoize?: boolean) => ComponentType<OwnPropsOfEnumCell>;
+export declare const withJsonFormsOneOfEnumProps: (Component: ComponentType<ControlProps & OwnPropsOfEnum>, memoize?: boolean) => ComponentType<OwnPropsOfControl & OwnPropsOfEnum>;
+export declare const withJsonFormsMultiEnumProps: (Component: ComponentType<ControlProps & OwnPropsOfEnum & DispatchPropsOfMultiEnumControl>, memoize?: boolean) => ComponentType<OwnPropsOfControl & OwnPropsOfEnum & DispatchPropsOfMultiEnumControl>;
+export declare const withJsonFormsLabelProps: (Component: ComponentType<LabelProps & OwnPropsOfEnum>, memoize?: boolean) => ComponentType<OwnPropsOfLabel>;
+export interface TranslateProps {
+    t: Translator;
+    locale: string;
+}
+export declare const withTranslateProps: <P extends {}>(Component: ComponentType<TranslateProps & P>) => (props: P) => React.JSX.Element;
+export declare const withArrayTranslationProps: <P extends ArrayLayoutProps>(Component: ComponentType<P & {
+    translations: ArrayTranslations;
+}>) => (props: P & TranslateProps) => React.JSX.Element;
+export {};

package/dist/.external/lib/@jsonforms/react/Renderer.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { RendererProps } from '../core';
+/**
+ * Convenience wrapper around React's Component for constraining props.
+ *
+ * @template P type of any renderer props
+ * @template S state of the Renderer
+ */
+export declare class RendererComponent<P extends RendererProps, S = {}> extends React.Component<P, S> {
+    constructor(props: P);
+}
+/**
+ * Stateless Renderer.
+ *
+ * @template P type of any renderer props
+ */
+export type StatelessRenderer<P extends RendererProps> = React.StatelessComponent<P>;
+/**
+ * Represents a Renderer, which might either be a component or a function.
+ */
+export type Renderer = RendererComponent<RendererProps & any, {}> | StatelessRenderer<RendererProps & any>;

package/dist/.external/lib/@jsonforms/react/UnknownRenderer.d.ts

@@ -0,0 +1,16 @@
+import React, { Component } from 'react';
+/**
+ * Props of an {@link UnknownRenderer}
+ */
+export interface UnknownRendererProps {
+    /**
+     * The type for which no renderer has been found.
+     */
+    type: 'renderer' | 'cell';
+}
+/**
+ * A renderer that will be used in case no other renderer is applicable.
+ */
+export declare class UnknownRenderer extends Component<UnknownRendererProps, any> {
+    render(): React.JSX.Element;
+}

package/dist/.external/lib/@jsonforms/react/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Control';
+export * from './JsonForms';
+export * from './DispatchCell';
+export * from './Renderer';
+export * from './JsonFormsContext';
+export * from './UnknownRenderer';

package/dist/.external/lib/@jsonforms/react/redux/JsonFormsReduxContext.d.ts

@@ -0,0 +1,6 @@
+import { JsonFormsSubStates } from '../../core';
+import { Reducer } from '../../../redux';
+import React from 'react';
+import { JsonFormsReduxContextProps } from '..';
+export declare const JsonFormsReduxContext: import("../../../react-redux").ConnectedComponent<({ children, dispatch, ...other }: JsonFormsReduxContextProps) => React.JSX.Element, import("../../../react-redux").Omit<JsonFormsReduxContextProps, string | number>>;
+export declare const jsonformsReducer: (additionalReducers?: {}) => Reducer<JsonFormsSubStates>;

package/dist/.external/lib/@jsonforms/react/redux/index.d.ts

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

package/dist/.external/lib/@tabler/icons-react/index.d.ts

@@ -0,0 +1 @@
+export * from './tabler-icons-react';