@ebertjendustries/cswrapper 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,787 @@
+import React, { Dispatch, SetStateAction } from 'react';
+import { FormFieldProps } from '@cloudscape-design/components/form-field/interfaces';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { AlertProps, BoxProps, ButtonProps, DatePickerProps, MultiselectProps, SegmentedControlProps, SelectProps, TilesProps, LinkProps, HeaderProps, InputProps, StatusIndicatorProps, TextContentProps, TextareaProps, TimeInputProps, ToggleProps } from '@cloudscape-design/components';
+import { CheckboxProps } from '@cloudscape-design/components/checkbox/interfaces';
+import { OptionDefinition } from '@cloudscape-design/components/internal/components/option/interfaces';
+
+/**
+ * class for client-side Logging.
+ * Wraps console.log
+ */
+declare class Log {
+    private readonly prefix;
+    private readonly debugLogging;
+    constructor(prefix?: string);
+    static toReadableObjectString(object: any): string;
+    static toCompactReadableObjectString(object: any, dependencyCharLimit: number): string;
+    private static toObjectStr;
+    /**
+     * log at debugging level
+     */
+    debug(msg: string, ...supportingDetails: any[]): void;
+    /**
+     * log at information level
+     */
+    info(msg: string, ...supportingDetails: any[]): void;
+    /**
+     * log at warning level
+     */
+    warn(msg: string, ...supportingDetails: any[]): void;
+    /**
+     * log at error level
+     */
+    error(msg: string, ...supportingDetails: any[]): void;
+    object(prefixMsg: string, object: any): void;
+    effectStart(effectName: string, msg: string, dependencies: any[], dependencyCharLimit?: number): void;
+    effectEnd(effectName: string): void;
+    effect(effectName: string, msg: string): void;
+    /**
+     * creates a log message with some detailed information
+     * @param msgType type of message (debug, info, warn, error)
+     * @param msg the message as string
+     * @param supportingDetails details that should be logged
+     */
+    private emitLogMessage;
+}
+
+declare class FieldProperties {
+    key: string;
+    required?: boolean | undefined;
+    maxLength?: number | undefined;
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+    constructor(key: string, required?: boolean | undefined, maxLength?: number | undefined, minValue?: number | undefined, maxValue?: number | undefined);
+}
+
+declare class EnumFactory<E> {
+    enumName: string;
+    values: E[];
+    constructor(enumName: string, values: E[]);
+    getEnumIndex(instance: E): number;
+}
+
+declare enum MessageSeverity {
+    INFO = "INFO",
+    WARN = "WARN",
+    ERR = "ERR",
+    SUCCESS = "SUCCESS"
+}
+declare const MESSAGE_SEVERITY_FACTORY: EnumFactory<MessageSeverity>;
+
+declare class MessageCodeTO {
+    static readonly CONTROLLER_ID_PROPS: FieldProperties;
+    static readonly HTTP_STATUS_CODE_PROPS: FieldProperties;
+    static readonly LOCAL_CODE_PROPS: FieldProperties;
+    static readonly MESSAGE_SEVERITY_PROPS: FieldProperties;
+    static readonly UNIQUE_CODE_PROPS: FieldProperties;
+    componentId: string;
+    httpStatusCode: number;
+    localCode: string;
+    messageSeverity: MessageSeverity;
+    uniqueCode: string;
+}
+
+declare class MessageCTO {
+    static readonly TIMESTAMP_PROPS: FieldProperties;
+    static readonly DETAIL_MESSAGE_PROPS: FieldProperties;
+    static readonly CORRELATION_ID_PROPS: FieldProperties;
+    static readonly OPERATION_PROPS: FieldProperties;
+    code: MessageCodeTO;
+    timestamp: string;
+    detailMessage: string;
+    correlationId: string;
+    operation: string;
+}
+
+interface ContentWithMessagesCTO<T> {
+    content: T | undefined;
+    messages: MessageCTO[];
+}
+declare function isContentWithMessages(object: any): boolean;
+
+declare enum ControllerState {
+    UNMOUNTED = 0,
+    INITIALIZING = 1,
+    NORMAL = 2,
+    FATAL_ERROR = 3
+}
+
+interface UseMessagesHook {
+    messages: MessageWithDetailToggle[];
+    addMessages: (messages: ContentWithMessagesCTO<any>) => void;
+    clearMessages: () => void;
+    onDismissMessage: (message: MessageWithDetailToggle) => void;
+    onToggleMessageDetail: (message: MessageWithDetailToggle) => void;
+}
+type MessageWithDetailToggle = MessageCTO & {
+    showDetails: boolean;
+};
+declare function useMessages(LOGGER: Log): UseMessagesHook;
+
+interface ModalState {
+    modalId?: string;
+    confirmFunction?: () => void;
+    show: (modalId: string, confirmFunction?: () => void) => void;
+    hide: (modalId: string) => void;
+}
+type RunFunction = <T>(service: Function, execute: () => Promise<ContentWithMessagesCTO<T>>, failureIsFatal?: boolean, resultHistory?: any) => Promise<RunFunctionResult<T>>;
+declare class RunFunctionResult<T> {
+    success: boolean;
+    messages: MessageCTO[];
+    result?: T | undefined;
+    resultHistory?: any | undefined;
+    constructor(success: boolean, messages: MessageCTO[], result?: T | undefined, resultHistory?: any | undefined);
+}
+declare const fatalRunErrorFunction: (reason: any) => never;
+interface UseControllerDisplayStateHook<DM> {
+    state: ControllerState;
+    setState: Dispatch<SetStateAction<ControllerState>>;
+    run: RunFunction;
+    isLoading: (service: Function) => boolean;
+    setDirty: (dirty: boolean) => void;
+    isDirty: () => boolean;
+    displayMode: DM;
+    enterDisplayMode: (mode: DM) => void;
+    modalState: ModalState;
+}
+interface BooleanStateIndication {
+    [key: string]: boolean;
+}
+declare function useControllerDisplayState<DM>(initialDisplayMode: DM, messages: UseMessagesHook, logger: Log): UseControllerDisplayStateHook<DM>;
+
+type CommandFunction = () => void;
+type InputChangedFunction<T> = (input: T) => void;
+type PropertyChangeFunction = (propertyName: string, changedValue: any, automaticChange?: boolean) => void;
+type MultiPropertyChangeFunction = (properties: {
+    [key: string]: any;
+}, automaticChange?: boolean) => void;
+
+declare enum ElementValidityLevel {
+    VALID = "VALID",
+    REQUIRED_VALUE_IS_NOT_PRESENT = "REQUIRED_VALUE_IS_NOT_PRESENT",
+    MAX_LENGTH_EXCEEDED = "MAX_LENGTH_EXCEEDED",
+    LOWER_BOUND_ONLY_TOO_SMALL = "LOWER_BOUND_ONLY_TOO_SMALL",
+    UPPER_BOUND_ONLY_TOO_BIG = "UPPER_BOUND_ONLY_TOO_BIG",
+    BOTH_BOUNDS_OUT_OF_BOUNDS = "BOTH_BOUNDS_OUT_OF_BOUNDS"
+}
+declare const ELEMENT_VALIDITY_LEVEL_FACTORY: EnumFactory<ElementValidityLevel>;
+
+declare class LocalisationNamespace {
+    name: string;
+    constructor(name: string);
+    /**
+     *
+     * @param parts The parts. Call this with comma-separated args, e.g. createKey(arg1, arg2, arg3) or with array using following syntax:
+     *   createKey(...[arg1, arg2, arg3]). DO NOT call it directly with an array!
+     *   This is WRONG: createKey([arg1, arg2, arg3]). It will treat the array as single arg and call toString() on it.
+     */
+    createKey(...parts: (string | any)[]): string;
+}
+declare const NSK_CONTENT: string;
+
+type Indexable = {
+    [key: string]: any;
+};
+
+interface IViewElementSpec {
+    readonly key: string;
+    readonly instanceId?: string;
+    getDataTestId(): string;
+    getLocalisationKey(): string;
+    getKeyHierarchy(): string[];
+    getValueValidityLevel(value: any): ElementValidityLevel;
+}
+declare abstract class ViewElementSpec implements IViewElementSpec {
+    readonly key: string;
+    readonly instanceId?: string | undefined;
+    parent?: IViewElementSpec;
+    ns: LocalisationNamespace;
+    private dataTestId;
+    private localisationKey;
+    private keyHierarchy;
+    protected constructor(key: string, instanceId?: string | undefined);
+    getDataTestId(): string;
+    getLocalisationKey(): string;
+    getKeyHierarchy(): string[];
+    abstract getValueValidityLevel(value: any): ElementValidityLevel;
+}
+type FieldValidatorFunctionType = (fieldSpec: IFieldSpec, value: any) => ElementValidityLevel;
+interface IFieldSpec extends IViewElementSpec {
+    readonly required?: boolean;
+    readonly maxLength?: number;
+    readonly minValue?: number;
+    readonly maxValue?: number;
+    readonly customFieldValidator?: FieldValidatorFunctionType;
+}
+declare class FieldSpec extends ViewElementSpec implements IFieldSpec {
+    readonly required?: boolean | undefined;
+    readonly maxLength?: number | undefined;
+    readonly minValue?: number | undefined;
+    readonly maxValue?: number | undefined;
+    readonly customFieldValidator?: FieldValidatorFunctionType | undefined;
+    constructor(key: string, required?: boolean | undefined, maxLength?: number | undefined, minValue?: number | undefined, maxValue?: number | undefined, customFieldValidator?: FieldValidatorFunctionType | undefined, instanceId?: string);
+    static getTOValidityLevel<TO extends Indexable>(transportObject: TO, elements: IViewElementSpec[]): ElementValidityLevel;
+    static isTOValid<TO extends Indexable>(transportObject: TO, Elements: IViewElementSpec[]): boolean;
+    static debugLogElementValidityArray<TO extends Indexable>(elements: TO[], Elements: IViewElementSpec[]): void;
+    static debugLogElementValidity<TO extends Indexable>(element: TO, elementId: string, Elements: IViewElementSpec[]): void;
+    getValueValidityLevel(value: any): ElementValidityLevel;
+    private getMaxLength;
+}
+type ViewValidatorFunctionType<F extends Object> = (viewSpec: ViewSpec<F>, value: any) => ElementValidityLevel;
+declare class ViewSpec<F extends Object> extends ViewElementSpec {
+    ns: LocalisationNamespace;
+    elements: F;
+    private readonly viewValidator;
+    private constructor();
+    static create<F extends Object>(key: string, ns: LocalisationNamespace, elementDefinition: (spec: ViewSpec<F>) => F, instanceId?: string, parent?: ViewSpec<any>, customViewValidator?: ViewValidatorFunctionType<F>): ViewSpec<F>;
+    addField(fieldSpec: FieldSpec): FieldSpec;
+    addFieldFromProps(fieldProps: FieldProperties, customFieldValidator?: FieldValidatorFunctionType, instanceId?: string): FieldSpec;
+    addView<FieldType extends Object>(viewSpecProvider: (parent: ViewSpec<any>, key: string, instanceId?: string) => ViewSpec<FieldType>, key: string, instanceId?: string): ViewSpec<FieldType>;
+    getAllElements(): IViewElementSpec[];
+    getValueValidityLevel(value: any): ElementValidityLevel;
+}
+
+type LocalisedElements = {
+    [field: string]: LocalisedElements | any;
+};
+type FieldValidityLocalisationFunction = (fieldProps: FieldProperties | FieldSpec, validityLevel: ElementValidityLevel) => string | undefined;
+type LocalisationVariableType = {
+    [name: string]: string | number | undefined;
+};
+interface LocalisedEnumDetails {
+    label: string | undefined;
+    description: string | undefined;
+}
+declare abstract class Localiser {
+    translate: Function;
+    ns: LocalisationNamespace;
+    protected constructor(translate: Function, ns: LocalisationNamespace);
+    abstract getFieldValidityLocalisationFunction(): FieldValidityLocalisationFunction;
+    abstract keyExists(key: string, alternateNs?: LocalisationNamespace): boolean;
+    abstract localiseKey(key: string, variables?: LocalisationVariableType, alternateNs?: LocalisationNamespace): string;
+    abstract localiseField(key: string, variables?: LocalisationVariableType, alternateNs?: LocalisationNamespace): LocalisedElements;
+    abstract getEnumLocalisation<E extends Object>(factory: EnumFactory<E>, instance: E): LocalisedEnumDetails;
+    getEnumLabel<E extends Object>(factory: EnumFactory<E>, instance: E): string;
+    getAllEnumLabels<E extends Object>(factory: EnumFactory<E>): string[];
+    abstract language(): string;
+}
+
+declare class FromPropsHelper {
+    static getBasicProps: (props: CSReadOnlyFormProps) => {
+        localisationObject: LocalisedElements;
+        uniqueId: string;
+    };
+    static usesFormField: (props: CSReadOnlyFormProps) => boolean;
+    static getLocalisedErrorText: (props: CSReadOnlyFormProps, value: any, localiseValidity: FieldValidityLocalisationFunction) => React.ReactNode | string;
+    static sanitizeValueToString: (value: any) => string;
+}
+/**
+ * Use for read-only form elements.
+ */
+interface CSReadOnlyFormProps {
+    /** The central properties of the field, used for identification and localization, especially also in tests. */
+    fieldSpec: IFieldSpec;
+    localiser: Localiser;
+    localisationVariables?: any;
+    alternateNs?: LocalisationNamespace;
+    childrenWrapper?: (children: React.ReactNode) => React.ReactNode;
+    preventOverflow?: boolean;
+    inlineLabel?: boolean;
+    /**
+     * Only use this if you want to use any non-localised Elements from {@link FormFieldProps} or you need to create
+     * dynamic localised texts that use variables. If you only want to localise the FormField component props, you can do
+     * this with the localiser prop.
+     */
+    formField?: FormFieldProps;
+    customRef?: any;
+}
+/**
+ * Use for read-write form elements.
+ */
+interface CSFormProps extends CSReadOnlyFormProps {
+    /** Simplifies use of onChange by extracting the relevant value and allowing to listen to changes via a {@link PropertyChangeFunction}. */
+    onChangeValue: PropertyChangeFunction;
+}
+
+interface CSViewProps<ElementType extends Object> {
+    viewSpec: ViewSpec<ElementType>;
+    localiser: Localiser;
+}
+
+type CSVEnumRatingViewElements = {
+    rating: FieldSpec;
+    boxRatingName: FieldSpec;
+};
+declare const CSV_ENUM_RATING_VIEW_SPEC: (parent: ViewSpec<any>, key: string, instanceId?: string) => ViewSpec<CSVEnumRatingViewElements>;
+interface CSVEnumRatingViewProps<E extends Object> extends CSViewProps<CSVEnumRatingViewElements> {
+    onChangeValue: PropertyChangeFunction;
+    factory: EnumFactory<E>;
+    selectedEnum: E | undefined;
+    disabled?: boolean;
+    toOrderNumber?: (value: E) => number;
+}
+declare function getEnumRatingValues<E extends Object>(factory: EnumFactory<E>, toOrderNumber?: (value: E) => number): E[];
+declare function getEnumRatingLabel<E extends Object>(enumInstance: E, instanceId?: string): string;
+declare function CSVEnumRatingView<E extends Object>(props: CSVEnumRatingViewProps<E>): react_jsx_runtime.JSX.Element;
+
+type CSVNoItemsViewElements = {
+    boxHeading: FieldSpec;
+    boxBody: FieldSpec;
+};
+declare const CSV_NO_ITEMS_VIEW_SPEC: (ns: LocalisationNamespace) => ViewSpec<CSVNoItemsViewElements>;
+interface CSVNoItemsViewProps<EntityType extends Object> extends CSViewProps<CSVNoItemsViewElements> {
+    itemType: EntityType;
+    factory: EnumFactory<EntityType>;
+    headingText?: string;
+    bodyText?: string;
+    bodyNode?: React.ReactNode;
+}
+declare function CSVNoItemsView<EntityType extends Object>(props: CSVNoItemsViewProps<EntityType>): react_jsx_runtime.JSX.Element;
+
+interface IPrice<CurrencyType extends Object> {
+    priceInCents: number;
+    currency: CurrencyType;
+}
+
+type CSVPriceInputViewElements = {
+    inputPrice: FieldSpec;
+    selectCurrency: FieldSpec;
+    boxPriceDisplay: FieldSpec;
+};
+declare const CSV_PRICE_INPUT_VIEW_SPEC: (parent: ViewSpec<any>, key: string) => ViewSpec<CSVPriceInputViewElements>;
+interface CSVPriceInputViewProps<CurrencyType extends Object> extends CSViewProps<CSVPriceInputViewElements> {
+    defaultCurrency: CurrencyType;
+    currencyFactory: EnumFactory<CurrencyType>;
+    value: IPrice<CurrencyType> | undefined;
+    label?: string;
+    disabled?: boolean;
+    onChange: PropertyChangeFunction;
+    expandToViewport?: boolean;
+}
+declare function CSVPriceInputView<CurrencyType extends Object>(props: CSVPriceInputViewProps<CurrencyType>): react_jsx_runtime.JSX.Element;
+
+type CSVSearchFilterViewElements = {
+    buttonSearch: FieldSpec;
+    inputSearch: FieldSpec;
+};
+declare const CSV_SEARCH_FILTER_VIEW_SPEC: (parent: ViewSpec<any>, key: string) => ViewSpec<CSVSearchFilterViewElements>;
+interface CSVSearchFilterViewProps extends CSViewProps<CSVSearchFilterViewElements> {
+    loading: boolean;
+    searchDisabled: boolean;
+    searchString: string;
+    onChangeValue: PropertyChangeFunction;
+    onConfirmSearch: CommandFunction;
+    inputSearch?: string | React.ReactNode;
+    buttonSearch?: string | React.ReactNode;
+}
+declare function CSVSearchFilterView(props: CSVSearchFilterViewProps): react_jsx_runtime.JSX.Element;
+
+type CSVTextPromptModalViewElements = {
+    headerHeading: FieldSpec;
+    boxBodyText: FieldSpec;
+    buttonPrimary: FieldSpec;
+    buttonSecondary: FieldSpec;
+};
+declare const CSV_TEXT_PROMPT_MODAL_VIEW_SPEC: (parent: ViewSpec<any>, key: string) => ViewSpec<CSVTextPromptModalViewElements>;
+interface CSVTextPromptModalViewProps extends CSViewProps<CSVTextPromptModalViewElements> {
+    visible: boolean;
+    onDismiss: () => void;
+    onPrimaryAction: () => void;
+    onSecondaryAction?: () => void;
+    headerHeading?: string | React.ReactNode;
+    boxBodyText?: string | React.ReactNode;
+    buttonPrimary?: string | React.ReactNode;
+    buttonSecondary?: string | React.ReactNode;
+}
+/**
+ * A simple modal with header and body text as well as up to two action buttons: primary and secondary.
+ *
+ * @param props The properties
+ * @returns The component
+ */
+declare function CSVTextPromptModalView(props: CSVTextPromptModalViewProps): react_jsx_runtime.JSX.Element;
+
+declare const REST_CLIENT_LOGGER: Log;
+interface IRestClient {
+    get<T>(endpoint: string, operation?: string, header?: any): Promise<ContentWithMessagesCTO<T>>;
+    put<T>(endpoint: string, payload: object | string, operation?: string): Promise<ContentWithMessagesCTO<T>>;
+    post<T>(endpoint: string, payload: object | string | null, operation?: string): Promise<ContentWithMessagesCTO<T>>;
+    del<T>(endpoint: string, payload?: object, operation?: string): Promise<ContentWithMessagesCTO<T>>;
+}
+/**
+ * Factory function to create a new default rest client.
+ *
+ * Mostly exist to ensure we can mock creation of the rest client in tests.
+ */
+declare function createRestClient(): IRestClient;
+/**
+ * A basic REST client, based on fetch API that offers get, put, post, del.
+ */
+declare class RestClient implements IRestClient {
+    baseUrl: string;
+    prepareFetchConfig(method: string, payload: object | string | null, header?: any | null): {};
+    /**
+     * Creates a new REST client.
+     * @param baseUrl base URL, so client can be called with relative URLs.
+     */
+    constructor(baseUrl?: string);
+    /**
+     * Make a GET request on the specified endpoint
+     *
+     * @param {string} endpoint the endpoint relative to the baseUrl with a preceeding slash. e.g. '/users'.
+     * @param {string} operation the operation name for logging.
+     * @param {string} headers the HTTP headers to pass.
+     */
+    get<T>(endpoint: string, operation?: string, headers?: any): Promise<ContentWithMessagesCTO<T>>;
+    /**
+     * Make a PUT request on the specified endpoint
+     *
+     * @param {string} endpoint the endpoint relative to the baseUrl with a preceeding slash. e.g. '/users'.
+     * @param {object} payload the request payload as object.
+     * @param {string} operation the operation name for logging.
+     */
+    put<T>(endpoint: string, payload: object | string, operation?: string): Promise<ContentWithMessagesCTO<T>>;
+    /**
+     * Make a POST request on the specified endpoint
+     *
+     * @param {string} endpoint the endpoint relative to the baseUrl with a preceeding slash. e.g. '/users'.
+     * @param {object} payload the request payload as object.
+     * @param {string} operation the operation name for logging.
+     */
+    post<T>(endpoint: string, payload: object | string | null, operation?: string): Promise<ContentWithMessagesCTO<T>>;
+    /**
+     * Make a DELETE request on the specified endpoint
+     *
+     * @param {string} endpoint the endpoint relative to the baseUrl with a preceeding slash. e.g. '/users'.
+     * @param {object} payload the request payload as object.
+     * @param {string} operation the operation name for logging.
+     */
+    del<T>(endpoint: string, payload?: object, operation?: string): Promise<ContentWithMessagesCTO<T>>;
+    callApi<T>(method: string, endpoint?: string, payload?: object | string | null, operation?: string, header?: any | null): Promise<ContentWithMessagesCTO<T>>;
+}
+
+type IdType = number | string | undefined;
+declare class ObjectWithId {
+    id: IdType;
+    static idToString: (objectWithId: ObjectWithId) => string;
+    static toObjectWithId: <T>(array: T[], idExtractor: (object: T) => IdType) => (T & ObjectWithId)[];
+}
+
+declare const QUERY_START: string;
+declare const QUERY_SEP: string;
+type QueryKeyValueParams = {
+    [key: string]: string;
+};
+declare class QueryParamHelper {
+    static appendQueryParam(query: string, key: string, value: any): string;
+    static getQueryParams(queryString: string): QueryKeyValueParams;
+}
+
+interface UseAWSUIRefHook {
+    customRef: any;
+    focus: () => void;
+    scrollToView: () => void;
+    scrollToViewRef: (element: any) => void;
+}
+declare function useAWSUIRef(): UseAWSUIRefHook;
+
+interface UseTOChangeHandlerHook {
+    onPropertyChange: PropertyChangeFunction;
+    onPropertyChangeMulti: (properties: Indexable, automaticChange?: boolean) => void;
+}
+interface UseTOArrayChangeHandlerHook {
+    onChangeElement: <T>(element: T | undefined, properties: Indexable, automaticChange?: boolean) => void;
+    onRemoveElements: <T>(removedElements: T[]) => void;
+    onAddElements: <T>(newElements: T[]) => void;
+}
+type ArrayChangeHandler<T> = (changedArrayElements: T[], newArrayContent: T[]) => void;
+type ArrayNotifications<T> = {
+    onChange?: ArrayChangeHandler<T>;
+    onAdd?: ArrayChangeHandler<T>;
+    onRemove?: ArrayChangeHandler<T>;
+};
+type ChangeHandler<T> = (changedObject: T, propertyName: string, changedValue: any) => void;
+type Notifications<T> = {
+    onChange?: ChangeHandler<T>;
+};
+declare function useTOChangeHandler<T extends Indexable | undefined>(logger: Log, toName: string, setTOState: Dispatch<SetStateAction<T>>, notifications?: Notifications<T>, setDirty?: (dirty: boolean) => void): UseTOChangeHandlerHook;
+declare const singleChangeHandlerToMulti: (onPropertyChangeMulti: (properties: Indexable, automaticChange?: boolean) => void) => PropertyChangeFunction;
+declare function useTOArrayChangeHandler<T>(logger: Log, toName: string, setArrayState: Dispatch<SetStateAction<T[]>>, handlers: ArrayNotifications<T>, setDirty?: (dirty: boolean) => void): UseTOArrayChangeHandlerHook;
+
+interface CSAlertProps extends CSReadOnlyFormProps, AlertProps {
+}
+/**
+ * Represents a {@link Alert} with extra features.
+ */
+declare function CSAlert(props: CSAlertProps): react_jsx_runtime.JSX.Element;
+
+interface CSBoxProps extends CSReadOnlyFormProps, BoxProps {
+}
+/**
+ * Represents a {@link Box} with extra features.
+ */
+declare function CSBox(props: CSBoxProps): react_jsx_runtime.JSX.Element;
+
+interface CSButtonProps extends CSReadOnlyFormProps, ButtonProps {
+}
+/**
+ * Represents a {@link Button} with extra features.
+ */
+declare function CSButton(props: CSButtonProps): react_jsx_runtime.JSX.Element;
+
+interface CSCheckboxProps extends CSFormProps, CheckboxProps {
+}
+/**
+ * Represents a {@link Checkbox} with extra features.
+ */
+declare function CSCheckbox(props: CSCheckboxProps): react_jsx_runtime.JSX.Element;
+
+interface CSDatePickerProps extends CSFormProps, Omit<DatePickerProps, 'value'> {
+    value: string | undefined | null;
+}
+declare function CSDatePicker(props: CSDatePickerProps): react_jsx_runtime.JSX.Element;
+
+interface CSEnumMultiselectProps<E extends Object> extends CSFormProps, Omit<MultiselectProps, 'selectedOptions'> {
+    selectedEnums: E[];
+    factory: EnumFactory<E>;
+    enforceSelection?: boolean;
+}
+declare function CSEnumMultiselect<E extends Object>(props: CSEnumMultiselectProps<E>): react_jsx_runtime.JSX.Element;
+
+interface CSEnumSegmentedControlProps<E extends Object> extends CSFormProps, Omit<SegmentedControlProps, 'selectedId'> {
+    selectedEnum: E | undefined;
+    factory: EnumFactory<E>;
+    exclude?: E[];
+}
+declare function CSEnumSegmentedControl<E extends Object>(props: CSEnumSegmentedControlProps<E>): react_jsx_runtime.JSX.Element;
+
+interface CSEnumSelectProps<E extends Object> extends CSFormProps, Omit<SelectProps, 'selectedOption'> {
+    selectedEnum: E | undefined;
+    factory: EnumFactory<E>;
+    exclude?: E[];
+}
+declare function CSEnumSelect<E extends Object>(props: CSEnumSelectProps<E>): react_jsx_runtime.JSX.Element;
+
+interface CSEnumTilesProps<E extends Object> extends CSFormProps, Omit<TilesProps, 'value'> {
+    selectedEnum: E | undefined;
+    factory: EnumFactory<E>;
+    exclude?: E[];
+}
+declare function CSEnumTiles<E extends Object>(props: CSEnumTilesProps<E>): react_jsx_runtime.JSX.Element;
+
+interface CSLinkProps extends CSReadOnlyFormProps, LinkProps {
+}
+/**
+ * Represents a {@link Link} with extra features.
+ */
+declare function CSLink(props: CSLinkProps): react_jsx_runtime.JSX.Element;
+interface CSExternalLinkProps extends CSLinkProps {
+    link: string;
+}
+/**
+ * Represents a {@link Link} that opens a new external tab.
+ */
+declare function CSExternalLink(props: CSExternalLinkProps): react_jsx_runtime.JSX.Element;
+
+declare const FORM_FIELD_ID_SUFFIX: string;
+interface CSFormFieldProps extends CSReadOnlyFormProps {
+    /** The children embedded within the form field, typically a single form component. */
+    children: React.ReactNode;
+}
+/**
+ * Represents a {@link FormField} with extra features. First of all, if the given props do not contain any form-field
+ * props, only the child component is returned, not wrapped in a FormField.
+ *
+ * It also passes on any localization-related props and gives the form field a data-testid.
+ */
+declare function CSFormField(props: CSFormFieldProps): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+
+interface CSHeaderProps extends CSReadOnlyFormProps, HeaderProps {
+}
+/**
+ * Represents a {@link Header} with extra features.
+ */
+declare function CSHeader(props: CSHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface CSInputProps extends CSFormProps, Omit<InputProps, 'value'> {
+    value: string | undefined | null;
+}
+/**
+ * Represents an {@link Input} for generic data with extra features such as generic validation of input.
+ */
+declare function CSInput(props: CSInputProps): react_jsx_runtime.JSX.Element;
+
+interface CSMultiselectProps extends CSFormProps, MultiselectProps {
+    enforceSelection?: boolean;
+}
+/**
+ * Represents a {@link Multiselect} with extra features.
+ */
+declare function CSMultiselect(props: CSMultiselectProps): react_jsx_runtime.JSX.Element;
+
+interface CSNumericInputProps extends CSFormProps, Omit<InputProps, 'value'> {
+    value: number | undefined | null;
+}
+/**
+ * Represents an {@link Input} for numeric values with extra features such as generic validation of input.
+ */
+declare function CSNumericInput(props: CSNumericInputProps): react_jsx_runtime.JSX.Element;
+
+interface CSSegmentedControlProps extends CSFormProps, SegmentedControlProps {
+}
+declare function CSSegmentedControl(props: CSSegmentedControlProps): react_jsx_runtime.JSX.Element;
+
+interface CSSelectProps extends CSFormProps, SelectProps {
+}
+/**
+ * Represents a {@link Select} with extra features.
+ */
+declare function CSSelect(props: CSSelectProps): react_jsx_runtime.JSX.Element;
+
+interface CSStatusIndicatorProps extends CSReadOnlyFormProps, StatusIndicatorProps {
+}
+/**
+ * Represents a {@link StatusIndicator} with extra features.
+ */
+declare function CSStatusIndicator(props: CSStatusIndicatorProps): react_jsx_runtime.JSX.Element;
+
+interface CSTextContentProps extends CSReadOnlyFormProps, TextContentProps {
+}
+/**
+ * Represents an {@link TextContent} for generic data with extra features such as generic validation of input.
+ */
+declare function CSTextContent(props: CSTextContentProps): react_jsx_runtime.JSX.Element;
+
+interface CSTextareaProps extends CSFormProps, Omit<TextareaProps, 'value'> {
+    value: string | undefined | null;
+}
+/**
+ * Represents an {@link Textarea} for generic data with extra features such as generic validation of input.
+ */
+declare function CSTextarea(props: CSTextareaProps): react_jsx_runtime.JSX.Element;
+
+interface CSTimeInputProps extends CSFormProps, TimeInputProps {
+}
+/**
+ * Represents a {@link TimeInput} with extra features.
+ */
+declare function CSTimeInput(props: CSTimeInputProps): react_jsx_runtime.JSX.Element;
+
+interface CSToggleProps extends CSFormProps, ToggleProps {
+}
+/**
+ * Represents a {@link Toggle} with extra features.
+ */
+declare function CSToggle(props: CSToggleProps): react_jsx_runtime.JSX.Element;
+
+interface CSPropsType extends CSReadOnlyFormProps {
+    children?: any;
+    preventOverflow?: boolean;
+    inlineLabel?: boolean;
+}
+declare class ChildUtils {
+    static getChildren: <P extends CSPropsType>(props: P, localisationObject: LocalisedElements) => {
+        children: any;
+        formProps: any;
+    };
+}
+
+declare class DateUtils {
+    static dateAsString(date: Date): string;
+    static dateAsDateTimeString(date: Date, language: string): string;
+    static nextSundayAt(hour: number, minute: number, second: number): Date;
+    static getCurrentUserTimezone(): string;
+    static dateTimeAsUTCISO8601String(date: Date): string;
+    static currentDateTimeAsUTCISO8601String(): string;
+    static currentDateAsISO8601String(): string;
+    static toFormattedLocalizedDate(locale: string, inputInUTCISO8601: string, timezone: string): string;
+}
+
+declare function FixedWidth(props: {
+    minWidth: string;
+    maxWidth: string;
+    children: React.JSX.Element;
+}): react_jsx_runtime.JSX.Element;
+
+declare class LocalStorageService {
+    static getItemStringArrayWithDefault(key: string, defaultValue: string[]): string[];
+    static getItemEnumArrayWithDefault<T extends {
+        [key: string]: string;
+    }>(enumClass: T, key: string, defaultValue: T[]): any[];
+    static setItemEnumArray<T extends {
+        [key: number]: string;
+    }>(key: string, value: T[]): void;
+    static setItemStringArray(key: string, value: string[]): void;
+    static getItemWithDefault(key: string, defaultValue: string): string;
+    static setItem(key: string, value: string): void | null;
+    static clear(): void;
+    static setObject(key: string, value: any): void | null;
+    static getObjectWithDefault(key: string, defaultValue: any): any;
+    private static safeGetItem;
+    private static safeSetItem;
+}
+
+declare const TECHNICAL_CONTROLLER_ID: string;
+declare const NO_HTTP_CODE: number;
+declare class MessageService {
+    static getResponseTOWithMessagesFromUnknownResponse<T>(json: any, op: string, status: number): ContentWithMessagesCTO<T>;
+    static getSuccessContentWithMessagesCTO<T>(json: any, op: string): ContentWithMessagesCTO<T>;
+    static createContentWithSuccessMessage: (operation: string, message: string) => ContentWithMessagesCTO<any>;
+    static createContentWithoutMessages: (content: any) => ContentWithMessagesCTO<any>;
+    static createContentWithInfoMessage: (operation: string, message: string) => ContentWithMessagesCTO<any>;
+    static createGenericErrorMessageTO: (httpStatusCode: number, operation: string) => ContentWithMessagesCTO<any>;
+    static createCriticalErrorFrontendProcessingMessageTO: (operation: string, message: string) => MessageCTO;
+    static isAPIClientCallError: (httpStatusCode: number) => boolean;
+    static isBackendError: (httpStatusCode: number) => boolean;
+    private static createContentWithMessage;
+    private static createMessageTO;
+}
+
+declare class PriceUtils {
+    static getFormattedPrice: <CurrencyType extends Object>(locale: string, price: IPrice<CurrencyType>) => string;
+    static sumPrices: <CurrencyType extends Object>(prices: IPrice<CurrencyType>[], defaultCurrency: CurrencyType) => IPrice<CurrencyType>;
+    static getCurrenciesFromPrices: <CurrencyType extends Object>(prices: IPrice<CurrencyType>[]) => Set<CurrencyType>;
+    static getPriceValidityLevel: <CurrencyType extends Object>(spec: ViewSpec<CSVPriceInputViewElements>, value: IPrice<CurrencyType>) => ElementValidityLevel;
+    static parseFormattedPrice: <CurrencyType extends Object>(locale: string, formattedPrice: string, currency: CurrencyType) => IPrice<CurrencyType>;
+    static parseFormattedPriceWithCurrency: <CurrencyType extends Object>(locale: string, formattedPrice: string, currencySymbolMapping: {
+        [key: string]: string;
+    }) => IPrice<CurrencyType>;
+}
+
+declare class SelectHelper {
+    static singleSelectOptionWithId: <T extends ObjectWithId>(objects: T[], selectedObjectId: IdType | undefined, toOptionDefinition: (object: T) => OptionDefinition) => {
+        options: OptionDefinition[];
+        selectedOption: OptionDefinition | null;
+    };
+    static singleSelectOption: <T extends ObjectWithId>(objects: T[], selectedObject: T | undefined, toOptionDefinition: (object: T) => OptionDefinition) => {
+        options: OptionDefinition[];
+        selectedOption: OptionDefinition | null;
+    };
+    static singleSelectEnum: <E extends Object>(enumFactory: EnumFactory<E>, selectedEnum: E | undefined, localiser: Localiser, exclude?: E[]) => {
+        options: OptionDefinition[];
+        selectedOption: OptionDefinition | null;
+    };
+    static multiSelectOptions: <T extends ObjectWithId>(objects: T[], selectedObjects: T[], toOptionDefinition: (object: T) => OptionDefinition) => {
+        options: OptionDefinition[];
+        selectedOptions: OptionDefinition[];
+    };
+    static multiSelectEnums: <E extends Object>(enumFactory: EnumFactory<E>, selectedEnums: E[], localiser: Localiser) => {
+        options: OptionDefinition[];
+        selectedOptions: OptionDefinition[];
+    };
+    private static getSelectedOptions;
+    private static getSelectedEnumOptions;
+}
+
+declare const indexRangeArray: (length: number) => number[];
+declare function filterArrayByIndices<T>(items: T[], indices: number[]): T[];
+declare function sortArrayByIndices<T>(items: T[], indices: number[]): T[];
+declare const sleep: (delaySeconds: number) => Promise<unknown>;
+
+declare const openInNewTab: (link: string) => void;
+declare const warnWhenTabIsClosed: (isDirty?: () => boolean) => () => void;
+
+declare const useHotkey: (key: string, shift: boolean, ctrl: boolean, alt: boolean, callback: Function, node?: null) => void;
+
+export { type BooleanStateIndication, CSAlert, CSBox, CSButton, CSCheckbox, CSDatePicker, CSEnumMultiselect, CSEnumSegmentedControl, CSEnumSelect, CSEnumTiles, CSExternalLink, CSFormField, type CSFormProps, CSHeader, CSInput, CSLink, CSMultiselect, CSNumericInput, type CSReadOnlyFormProps, CSSegmentedControl, CSSelect, CSStatusIndicator, CSTextContent, CSTextarea, CSTimeInput, CSToggle, CSVEnumRatingView, type CSVEnumRatingViewElements, CSVNoItemsView, type CSVNoItemsViewElements, CSVPriceInputView, type CSVPriceInputViewElements, CSVSearchFilterView, type CSVSearchFilterViewElements, CSVTextPromptModalView, type CSVTextPromptModalViewElements, type CSVTextPromptModalViewProps, CSV_ENUM_RATING_VIEW_SPEC, CSV_NO_ITEMS_VIEW_SPEC, CSV_PRICE_INPUT_VIEW_SPEC, CSV_SEARCH_FILTER_VIEW_SPEC, CSV_TEXT_PROMPT_MODAL_VIEW_SPEC, type CSViewProps, ChildUtils, type CommandFunction, type ContentWithMessagesCTO, ControllerState, DateUtils, ELEMENT_VALIDITY_LEVEL_FACTORY, ElementValidityLevel, EnumFactory, FORM_FIELD_ID_SUFFIX, FieldProperties, FieldSpec, type FieldValidatorFunctionType, type FieldValidityLocalisationFunction, FixedWidth, FromPropsHelper, type IFieldSpec, type IPrice, type IRestClient, type IViewElementSpec, type IdType, type Indexable, type InputChangedFunction, LocalStorageService, LocalisationNamespace, type LocalisationVariableType, type LocalisedElements, type LocalisedEnumDetails, Localiser, Log, MESSAGE_SEVERITY_FACTORY, MessageCTO, MessageCodeTO, MessageService, MessageSeverity, type MessageWithDetailToggle, type ModalState, type MultiPropertyChangeFunction, NO_HTTP_CODE, NSK_CONTENT, ObjectWithId, PriceUtils, type PropertyChangeFunction, QUERY_SEP, QUERY_START, type QueryKeyValueParams, QueryParamHelper, REST_CLIENT_LOGGER, RestClient, type RunFunction, RunFunctionResult, SelectHelper, TECHNICAL_CONTROLLER_ID, type UseAWSUIRefHook, type UseControllerDisplayStateHook, type UseMessagesHook, type UseTOArrayChangeHandlerHook, type UseTOChangeHandlerHook, ViewSpec, type ViewValidatorFunctionType, createRestClient, fatalRunErrorFunction, filterArrayByIndices, getEnumRatingLabel, getEnumRatingValues, indexRangeArray, isContentWithMessages, openInNewTab, singleChangeHandlerToMulti, sleep, sortArrayByIndices, useAWSUIRef, useControllerDisplayState, useHotkey, useMessages, useTOArrayChangeHandler, useTOChangeHandler, warnWhenTabIsClosed };