@overmap-ai/core 1.0.27 → 1.0.28-integrate-forms.1

package/dist/forms/fields/BooleanField/BooleanField.d.ts

@@ -0,0 +1,17 @@
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { ChangeEvent, ReactNode } from "react";
+import { ComponentProps } from "../typings";
+import { CheckCircledIcon } from "@radix-ui/react-icons";
+import { ISerializedField, SerializedBooleanField } from "../../typings.ts";
+export declare class BooleanField extends BaseField<boolean, "boolean"> {
+    static readonly fieldTypeName = "Checkbox";
+    static readonly fieldTypeDescription = "Perfect for both optional and required yes/no questions.";
+    readonly onlyValidateAfterTouched = false;
+    static Icon: typeof CheckCircledIcon;
+    constructor(options: ChildFieldOptions<boolean>);
+    protected isBlank(value: boolean): boolean;
+    getValueFromChangeEvent(event: ChangeEvent<HTMLInputElement> | boolean): boolean;
+    serialize(): SerializedBooleanField;
+    static deserialize(data: ISerializedField): BooleanField;
+    getInput(props: ComponentProps<BooleanField>): ReactNode;
+}

package/dist/forms/fields/BooleanField/BooleanInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { BooleanField } from "./BooleanField";
+import { ComponentProps } from "../typings.ts";
+export declare const BooleanInput: import("react").NamedExoticComponent<ComponentProps<BooleanField>>;

package/dist/forms/fields/BooleanField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./BooleanField";
+export * from "./BooleanInput";

package/dist/forms/fields/CustomField/CustomField.d.ts

@@ -0,0 +1,18 @@
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { FC, ReactNode } from "react";
+import { GetInputProps, ISerializedOnlyField } from "../typings";
+import { FieldTypeIdentifier, FieldValue } from "../../typings.ts";
+export type CustomFieldOptions<TValue> = ChildFieldOptions<TValue>;
+export declare class CustomField<TValue extends FieldValue, 
+/** The options passed to constructor */
+TFieldOptions extends CustomFieldOptions<TValue>, 
+/** The props passed to the custom component */
+TComponentProps extends GetInputProps<CustomField<TValue, TFieldOptions, TComponentProps>>, TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> extends BaseField<TValue, TIdentifier> {
+    static readonly fieldTypeName = "Custom";
+    static readonly fieldTypeDescription = "Allows re-rendering of field already in the form";
+    readonly Component: FC<TComponentProps>;
+    readonly options: TFieldOptions;
+    constructor(options: TFieldOptions, Component: FC<TComponentProps>);
+    serialize(): ISerializedOnlyField;
+    getInput(props: TComponentProps): ReactNode;
+}

package/dist/forms/fields/CustomField/FieldInputClonerField/FieldInputCloner.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { FieldInputClonerProps } from "./typings.ts";
+/**
+ * Used to dynamically "clone" a field's input for use in conditional sections. When a field is selected for a
+ * condition, we need to render the same input in the condition section, so the user can input a value for the
+ * condition.
+ */
+export declare const FieldInputCloner: import("react").NamedExoticComponent<FieldInputClonerProps>;

package/dist/forms/fields/CustomField/FieldInputClonerField/FieldInputClonerField.d.ts

@@ -0,0 +1,18 @@
+import { CustomField, CustomFieldOptions } from "../CustomField";
+import { FieldInputClonerProps } from "./index";
+import { FieldValue, ISerializedField } from "../../../typings.ts";
+export interface FieldInputClonerFieldOptions extends CustomFieldOptions<unknown> {
+    /** Given an identifier, should return the options of the field with the
+     * corresponding identifier (the field being cloned) */
+    getFieldToClone: (identifier: string) => ISerializedField | null;
+    /** The identifier of the field to clone */
+    clonedFieldIdentifier: string;
+}
+/**
+ * The purpose of this is to display a value input field in the condition of a section. The input field will look like
+ * the input field of the condition. For example, when specifying the conditional value of a SelectField, a SelectInput
+ * will be rendered.
+ */
+export declare class FieldInputClonerField extends CustomField<FieldValue, FieldInputClonerFieldOptions, FieldInputClonerProps> {
+    constructor(options: FieldInputClonerFieldOptions);
+}

package/dist/forms/fields/CustomField/FieldInputClonerField/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FieldInputCloner";
+export * from "./FieldInputClonerField";
+export * from "./typings";

package/dist/forms/fields/CustomField/FieldInputClonerField/typings.d.ts

@@ -0,0 +1,5 @@
+import { AnyField, ComponentProps, GetInputProps } from "../../typings";
+import { CustomField } from "../CustomField";
+import { FieldInputClonerFieldOptions } from "./FieldInputClonerField";
+import { FieldValue } from "../../../typings.ts";
+export type FieldInputClonerProps = ComponentProps<CustomField<FieldValue, FieldInputClonerFieldOptions, GetInputProps<AnyField>>>;

package/dist/forms/fields/CustomField/index.d.ts

@@ -0,0 +1 @@
+export * from "./CustomField";

package/dist/forms/fields/DateField/DateField.d.ts

@@ -0,0 +1,16 @@
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { GetInputProps } from "../typings";
+import React from "react";
+import { CalendarIcon } from "@radix-ui/react-icons";
+import { ISerializedField, SerializedDateField } from "../../typings.ts";
+export declare class DateField extends BaseField<string, "date"> {
+    static readonly fieldTypeName = "Date";
+    static readonly fieldTypeDescription = "Allows specifying a date.";
+    static Icon: typeof CalendarIcon;
+    readonly onlyValidateAfterTouched = false;
+    constructor(options: ChildFieldOptions<string>);
+    serialize(): SerializedDateField;
+    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement>): string;
+    static deserialize(data: ISerializedField): DateField;
+    getInput(props: GetInputProps<this>): React.ReactNode;
+}

package/dist/forms/fields/DateField/DateInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { DateField } from "./DateField";
+import { ComponentProps } from "../typings.ts";
+export declare const DateInput: import("react").NamedExoticComponent<ComponentProps<DateField>>;

package/dist/forms/fields/DateField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./DateField";
+export * from "./DateInput";

package/dist/forms/fields/FieldSection/FieldSection.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+import { BaseSerializedObject, Form, ISerializedField, SerializedCondition, SerializedFieldSection } from "../../typings.ts";
+import { AnyField, GetInputProps } from "../typings.ts";
+import { BaseFormElement } from "../BaseField";
+interface FieldSectionOptions extends Omit<BaseSerializedObject, "type"> {
+    label?: string | null;
+    conditional?: boolean;
+    condition?: SerializedCondition | null;
+    fields: AnyField[];
+}
+export declare class FieldSection extends BaseFormElement<"section"> {
+    static readonly fieldTypeName = "Section";
+    static readonly fieldTypeDescription = "Sections can be useful for grouping fields together. They can also be conditionally shown or hidden.";
+    readonly label: string | null;
+    readonly fields: AnyField[];
+    readonly condition: SerializedCondition | null;
+    constructor(options: FieldSectionOptions);
+    static getFieldCreationSchema(options: ISerializedField[]): BaseFormElement[];
+    static deserialize(data: ISerializedField): FieldSection;
+    conditional(): this is {
+        condition: SerializedCondition;
+    };
+    serialize(): SerializedFieldSection;
+    getErrors(allValues: Form): Record<string, string>;
+    getInput(props: GetInputProps<this>): React.ReactNode;
+}
+export {};

package/dist/forms/fields/FieldSection/FieldSectionLayout.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { FieldSection } from ".";
+import { ComponentProps } from "../typings.ts";
+/**
+ * Used by FieldSection to render a section of fields.
+ */
+export declare const FieldSectionLayout: import("react").NamedExoticComponent<ComponentProps<FieldSection>>;

package/dist/forms/fields/FieldSection/index.d.ts

@@ -0,0 +1 @@
+export * from "./FieldSection";

package/dist/forms/fields/MultiStringField/MultiStringField.d.ts

@@ -0,0 +1,30 @@
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { GetInputProps, InputFieldLevelValidator } from "../typings.ts";
+import { ChangeEvent, ReactNode } from "react";
+import { ListBulletIcon } from "@radix-ui/react-icons";
+import { ISerializedField, SelectFieldOption, SerializedMultiStringField } from "../../typings.ts";
+type MultiStringFieldOptions = ChildFieldOptions<SelectFieldOption[]> & {
+    minimum_length?: number;
+    maximum_length?: number;
+};
+/**
+ * A field that lets the user input multiple strings. Each string must be unique. Useful for things like:
+ * - Specifying the options of a SelectField (used in `SelectField.getFieldCreationSchema`
+ * - Listing serial numbers and similar
+ */
+export declare class MultiStringField extends BaseField<SelectFieldOption[], "multi-string"> {
+    static readonly fieldTypeName = "Multi-string";
+    static readonly fieldTypeDescription = "Allows the user to provide multiple unique strings.";
+    readonly minLength: number;
+    readonly maxLength: number;
+    readonly onlyValidateAfterTouched = false;
+    static Icon: typeof ListBulletIcon;
+    constructor(options: MultiStringFieldOptions);
+    getValueFromChangeEvent(event: ChangeEvent<HTMLInputElement> | SelectFieldOption[]): SelectFieldOption[];
+    getInput(props: GetInputProps<this>): ReactNode;
+    serialize(): SerializedMultiStringField;
+    protected isBlank(value: SelectFieldOption[]): boolean;
+    getFieldValidators(): InputFieldLevelValidator<SelectFieldOption[]>[];
+    static deserialize(data: ISerializedField): MultiStringField;
+}
+export {};

package/dist/forms/fields/MultiStringField/MultiStringInput.d.ts

@@ -0,0 +1,8 @@
+import { ComponentProps } from "../typings.ts";
+import React from "react";
+import { MultiStringField } from "./MultiStringField.tsx";
+/**
+ * Allows the user to create an array of unique strings and customize the order.
+ * User to generate options for the Select field.
+ */
+export declare const MultiStringInput: React.NamedExoticComponent<ComponentProps<MultiStringField>>;

package/dist/forms/fields/MultiStringField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MultiStringField";
+export * from "./MultiStringInput";

package/dist/forms/fields/NumberField/NumberField.d.ts

@@ -0,0 +1,29 @@
+import { BooleanField } from "../BooleanField";
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { GetInputProps, InputFieldLevelValidator, InputValidator } from "../typings";
+import { ChangeEvent, ReactNode } from "react";
+import { FontFamilyIcon } from "@radix-ui/react-icons";
+import { ISerializedField, SerializedNumberField } from "../../typings.ts";
+export type NumberFieldValue = number | "";
+export interface NumberFieldOptions extends ChildFieldOptions<NumberFieldValue> {
+    maximum?: number;
+    minimum?: number;
+    integers?: boolean;
+}
+export declare class NumberField extends BaseField<NumberFieldValue, "number"> {
+    static readonly fieldTypeName = "Number";
+    static readonly fieldTypeDescription = "Allows specifying a number within a given range.";
+    readonly minimum: number | undefined;
+    readonly maximum: number | undefined;
+    readonly integers: boolean;
+    static Icon: typeof FontFamilyIcon;
+    constructor(options: NumberFieldOptions);
+    getValueFromChangeEvent(event: ChangeEvent<HTMLInputElement>): NumberFieldValue;
+    static _validateMin: InputValidator<NumberFieldValue>;
+    static _validateMax: InputValidator<NumberFieldValue>;
+    static getFieldCreationSchema(): (BooleanField | NumberField)[];
+    getFieldValidators(): InputFieldLevelValidator<NumberFieldValue>[];
+    serialize(): SerializedNumberField;
+    static deserialize(data: ISerializedField): NumberField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/NumberField/NumberInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { NumberField } from ".";
+import { ComponentProps } from "../typings.ts";
+export declare const NumberInput: import("react").NamedExoticComponent<ComponentProps<NumberField>>;

package/dist/forms/fields/NumberField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./NumberField";
+export * from "./NumberInput";

package/dist/forms/fields/SelectField/BaseSelectField.d.ts

@@ -0,0 +1,27 @@
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { FieldValue, SelectFieldOption } from "../../typings.ts";
+import { MultiStringField } from "../MultiStringField";
+/**
+ * The options passed to the constructor of SelectField.
+ */
+export interface BaseSelectFieldOptions<TValue, TIdentifier extends "select" | "multi-select"> extends ChildFieldOptions<TValue> {
+    /** When instantiating a SelectField, you can either pass an array of strings or an array of objects. User-created
+     * forms only support arrays of strings. For more complex internal purposes, you can provide an array of objects
+     * where the `label` is the text to display to the user and the `value` is the value handled by Formik.*/
+    options: string[] | SelectFieldOption[];
+    type: TIdentifier;
+}
+export declare abstract class BaseSelectField<TValue extends FieldValue, TIdentifier extends "select" | "multi-select"> extends BaseField<TValue, TIdentifier> {
+    readonly options: SelectFieldOption[];
+    readonly onlyValidateAfterTouched = false;
+    protected constructor(options: BaseSelectFieldOptions<TValue, TIdentifier>);
+    protected _serialize(): {
+        options: SelectFieldOption[];
+        label: string;
+        required: boolean;
+        description?: string | null | undefined;
+        identifier: string;
+        type: TIdentifier;
+    };
+    static getFieldCreationSchema(): MultiStringField[];
+}

package/dist/forms/fields/SelectField/MultiSelectField.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from "react";
+import { GetInputProps } from "../typings";
+import { BaseSelectField, BaseSelectFieldOptions } from "./BaseSelectField";
+import { CheckboxIcon } from "@radix-ui/react-icons";
+import { ISerializedField, SelectFieldOptionValue, SerializedMultiSelectField } from "../../typings.ts";
+/**
+ * The options passed to the constructor of MultiSelectField.
+ */
+export type MultiSelectFieldOptions = Omit<BaseSelectFieldOptions<SelectFieldOptionValue[], "multi-select">, "type">;
+export declare class MultiSelectField extends BaseSelectField<SelectFieldOptionValue[], "multi-select"> {
+    static readonly fieldTypeName = "Multi-select";
+    static readonly fieldTypeDescription = "Allows the user to select a multiple options from a list of options.";
+    static Icon: typeof CheckboxIcon;
+    constructor(options: MultiSelectFieldOptions);
+    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement> | string[]): string[];
+    protected isBlank(value: SelectFieldOptionValue[]): boolean;
+    serialize(): SerializedMultiSelectField;
+    static deserialize(data: ISerializedField): MultiSelectField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/SelectField/MultiSelectInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ComponentProps } from "../typings";
+import { MultiSelectField } from "./MultiSelectField";
+export declare const MultiSelectInput: import("react").NamedExoticComponent<ComponentProps<MultiSelectField>>;

package/dist/forms/fields/SelectField/SelectField.d.ts

@@ -0,0 +1,19 @@
+import { ChangeEvent, ReactNode } from "react";
+import { GetInputProps } from "../typings";
+import { BaseSelectField, BaseSelectFieldOptions } from "./BaseSelectField";
+import { DropdownMenuIcon } from "@radix-ui/react-icons";
+import { ISerializedField, SelectFieldOptionValue, SerializedSelectField } from "../../typings.ts";
+/**
+ * The options passed to the constructor of SelectField.
+ */
+export type SelectFieldOptions = Omit<BaseSelectFieldOptions<SelectFieldOptionValue, "select">, "type">;
+export declare class SelectField extends BaseSelectField<SelectFieldOptionValue, "select"> {
+    static readonly fieldTypeName = "Dropdown";
+    static readonly fieldTypeDescription = "Allows the user to select a single option from a list of options.";
+    static Icon: typeof DropdownMenuIcon;
+    constructor(options: SelectFieldOptions);
+    getValueFromChangeEvent(event: ChangeEvent<HTMLInputElement> | string): SelectFieldOptionValue;
+    serialize(): SerializedSelectField;
+    static deserialize(data: ISerializedField): SelectField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/SelectField/SelectInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ComponentProps } from "../typings";
+import { SelectField } from "./SelectField";
+export declare const SelectInput: import("react").NamedExoticComponent<ComponentProps<SelectField>>;

package/dist/forms/fields/SelectField/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./SelectField";
+export * from "./SelectInput";
+export * from "./MultiSelectInput";
+export * from "./MultiSelectField";

package/dist/forms/fields/StringOrTextFields/StringField/StringField.d.ts

@@ -0,0 +1,18 @@
+import { StringOrTextField, StringOrTextFieldOptions } from "../StringOrTextField";
+import { GetInputProps } from "../../typings";
+import React from "react";
+import { InputIcon } from "@radix-ui/react-icons";
+import { ISerializedField, SerializedStringField, StringInputType } from "../../../typings.ts";
+export interface StringFieldOptions extends Omit<StringOrTextFieldOptions, "type"> {
+    inputType?: StringInputType;
+}
+export declare class StringField extends StringOrTextField<"string"> {
+    static readonly fieldTypeName = "Short Text";
+    static readonly fieldTypeDescription = "Short text fields can hold up to 500 characters on a single line.";
+    readonly inputType: StringInputType;
+    static Icon: typeof InputIcon;
+    constructor(options: StringFieldOptions);
+    serialize(): SerializedStringField;
+    static deserialize(data: ISerializedField): StringField;
+    getInput(props: GetInputProps<this>): React.ReactNode;
+}

package/dist/forms/fields/StringOrTextFields/StringField/StringInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { StringField } from "./StringField";
+import { ComponentProps } from "../../typings.ts";
+export declare const StringInput: import("react").NamedExoticComponent<ComponentProps<StringField>>;

package/dist/forms/fields/StringOrTextFields/StringField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./StringField";
+export * from "./StringInput";

package/dist/forms/fields/StringOrTextFields/StringOrTextField.d.ts

@@ -0,0 +1,29 @@
+import { NumberField, NumberFieldValue } from "../NumberField";
+import { BaseField, FieldOptions } from "../BaseField";
+import { InputFieldLevelValidator, InputValidator } from "../typings.ts";
+import { SerializedStringField } from "../../typings.ts";
+export interface StringOrTextFieldOptions extends FieldOptions<string> {
+    minLength?: NumberFieldValue;
+    maxLength?: NumberFieldValue;
+}
+export type SerializedStringOrTextField<TIdentifier extends "string" | "text"> = Omit<SerializedStringField, "type"> & {
+    type: TIdentifier;
+};
+export declare abstract class StringOrTextField<TIdentifier extends "string" | "text"> extends BaseField<string, TIdentifier> {
+    readonly minLength?: number;
+    readonly maxLength: number;
+    protected constructor(options: StringOrTextFieldOptions);
+    /**
+     * This function validates that the value given for "minimum length" (when creating a new field) is less than or
+     * equal to the value given for "maximum length".
+     */
+    static _validateMin: InputValidator<NumberFieldValue>;
+    /**
+     * This function validates that the value given for "maximum length" (when creating a new field) is greater than or
+     * equal to the value given for "minimum length".
+     */
+    static _validateMax: InputValidator<NumberFieldValue>;
+    static getFieldCreationSchema(): NumberField[];
+    getFieldValidators(): InputFieldLevelValidator<string>[];
+    protected _serialize(): SerializedStringOrTextField<TIdentifier>;
+}

package/dist/forms/fields/StringOrTextFields/TextField/TextField.d.ts

@@ -0,0 +1,15 @@
+import { StringOrTextField, StringOrTextFieldOptions } from "../StringOrTextField";
+import { GetInputProps } from "../../typings";
+import React from "react";
+import { RowsIcon } from "@radix-ui/react-icons";
+import { ISerializedField, SerializedTextField } from "../../../typings.ts";
+export type TextFieldOptions = Omit<StringOrTextFieldOptions, "type">;
+export declare class TextField extends StringOrTextField<"text"> {
+    static readonly fieldTypeName = "Paragraph";
+    static readonly fieldTypeDescription = "Paragraph fields can hold up to 5000 characters and can have multiple lines.";
+    static Icon: typeof RowsIcon;
+    constructor(options: TextFieldOptions);
+    serialize(): SerializedTextField;
+    static deserialize(data: ISerializedField): TextField;
+    getInput(props: GetInputProps<this>): React.ReactNode;
+}

package/dist/forms/fields/StringOrTextFields/TextField/TextInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TextField } from "./TextField";
+import { ComponentProps } from "../../typings.ts";
+export declare const TextInput: import("react").NamedExoticComponent<ComponentProps<TextField>>;

package/dist/forms/fields/StringOrTextFields/TextField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./TextField";
+export * from "./TextInput";

package/dist/forms/fields/StringOrTextFields/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./StringField";
+export * from "./TextField";

package/dist/forms/fields/UploadField/UploadField.d.ts

@@ -0,0 +1,29 @@
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { GetInputProps, InputFieldLevelValidator } from "../typings";
+import { ChangeEvent, ReactNode } from "react";
+import { UploadIcon } from "@radix-ui/react-icons";
+import { NumberField } from "../NumberField";
+import { MultiSelectField } from "../SelectField";
+import { ISerializedField, SerializedUploadField } from "../../typings.ts";
+export interface UploadFieldOptions extends ChildFieldOptions<File[]> {
+    extensions?: string[];
+    maximum_size?: number | string;
+    maximum_files?: number | string;
+}
+export declare class UploadField extends BaseField<File[], "upload"> {
+    static readonly fieldTypeName = "Upload";
+    static readonly fieldTypeDescription = "Allows a file to be uploaded.";
+    readonly extensions?: string[];
+    readonly maxFileSize: number | undefined;
+    readonly maxFiles: number;
+    readonly onlyValidateAfterTouched = false;
+    static Icon: typeof UploadIcon;
+    constructor(options: UploadFieldOptions);
+    getValueFromChangeEvent(event: ChangeEvent<HTMLInputElement>): File[];
+    protected isBlank(value: File[]): boolean;
+    static getFieldCreationSchema(): (NumberField | MultiSelectField)[];
+    getFieldValidators(): InputFieldLevelValidator<File[]>[];
+    serialize(): SerializedUploadField;
+    static deserialize(data: ISerializedField): UploadField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/UploadField/UploadInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { UploadField } from "./UploadField";
+import { ComponentProps } from "../typings.ts";
+export declare const NumberInput: import("react").NamedExoticComponent<ComponentProps<UploadField>>;

package/dist/forms/fields/UploadField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UploadField";
+export * from "./UploadInput";

package/dist/forms/fields/UploadField/utils.d.ts

@@ -0,0 +1 @@
+export declare const convertKilobytesToLargestUnit: (kilobytes: number) => string;

package/dist/forms/fields/constants.d.ts

@@ -0,0 +1,20 @@
+import { StringField, TextField } from "./StringOrTextFields";
+import { BooleanField } from "./BooleanField";
+import { DateField } from "./DateField";
+import { NumberField } from "./NumberField";
+import { MultiSelectField, SelectField } from "./SelectField";
+import { CustomField } from "./CustomField";
+import { MultiStringField } from "./MultiStringField";
+import { UploadField } from "./UploadField";
+export declare const FieldTypeToClsMapping: {
+    readonly date: typeof DateField;
+    readonly number: typeof NumberField;
+    readonly boolean: typeof BooleanField;
+    readonly select: typeof SelectField;
+    readonly string: typeof StringField;
+    readonly text: typeof TextField;
+    readonly custom: typeof CustomField;
+    readonly upload: typeof UploadField;
+    readonly "multi-string": typeof MultiStringField;
+    readonly "multi-select": typeof MultiSelectField;
+};

package/dist/forms/fields/hooks.d.ts

@@ -0,0 +1,6 @@
+import { GetInputProps } from "./typings";
+import { ReactNode } from "react";
+import { BaseField, BaseFormElement } from "./BaseField";
+import { FieldValue } from "../typings.ts";
+export declare const useFieldInput: <TField extends BaseFormElement<import("../typings.ts").FieldTypeIdentifier> | null>(field: TField, props: TField extends BaseFormElement ? GetInputProps<TField> : null) => ReactNode;
+export declare const useFieldInputs: (fields: BaseFormElement[], props: GetInputProps<BaseField<FieldValue>>) => ReactNode;

package/dist/forms/fields/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./BaseField";
+export * from "./NumberField";
+export * from "./DateField";
+export * from "./StringOrTextFields";
+export * from "./BooleanField";
+export * from "./SelectField";
+export * from "./MultiStringField";
+export * from "./FieldSection";
+export * from "./utils";
+export * from "./hooks";
+export type * from "./typings";

package/dist/forms/fields/typings.d.ts

@@ -0,0 +1,23 @@
+import { HTMLProps, ReactNode } from "react";
+import { BaseField, BaseFormElement } from "./BaseField";
+import { Form, ISerializedField, SerializedFieldSection } from "../typings.ts";
+export interface SchemaMeta {
+    readonly: boolean;
+}
+export interface ISchema {
+    id?: string;
+    fields: BaseFormElement[];
+    meta: SchemaMeta;
+    title: ReactNode;
+    description?: ReactNode;
+}
+export type InputFieldLevelValidator<TValue> = (value: TValue | undefined) => string | null | undefined;
+export type InputFormLevelValidator<TValue> = (value: TValue | undefined, allValues: Form) => string | null | undefined;
+export type InputValidator<TValue> = InputFieldLevelValidator<TValue> | InputFormLevelValidator<TValue>;
+export interface ComponentProps<TField extends BaseFormElement> extends Omit<HTMLProps<HTMLElement>, "color" | "size" | "ref" | "type" | "onChange" | "onBlur" | "value" | "defaultValue" | "name" | "dir"> {
+    field: TField;
+    formId: string;
+}
+export type GetInputProps<TField extends BaseFormElement> = Omit<ComponentProps<TField>, "field">;
+export type AnyField = BaseField<any>;
+export type ISerializedOnlyField = Exclude<ISerializedField, SerializedFieldSection>;

package/dist/forms/fields/utils.d.ts

@@ -0,0 +1,14 @@
+import { AnyField, ISchema, ISerializedOnlyField, SchemaMeta } from "./typings";
+import { FieldSection } from "./FieldSection";
+import { FieldValue, ISerializedField, SerializedCondition } from "../typings.ts";
+import { UserFormRevision } from "../../typings";
+/** Deserializes anything but a FieldSection.
+ * @see `deserialize` for most use cases
+ */
+export declare const deserializeField: (serializedField: ISerializedOnlyField) => AnyField;
+/** Deserializes anything */
+export declare const deserialize: (serialized: ISerializedField) => AnyField | FieldSection;
+export type PartialFormRevision = Pick<UserFormRevision, "title" | "fields" | "description"> & Partial<UserFormRevision>;
+export declare function formRevisionToSchema(formRevision: PartialFormRevision, meta?: Partial<SchemaMeta>): ISchema;
+export declare function valueIsFile(v: FieldValue | Promise<File>[] | undefined): v is File[] | Promise<File>[];
+export declare function isConditionMet<TValue extends FieldValue | Promise<File>[]>(condition: TValue extends FieldValue ? SerializedCondition<TValue> | null : null, value: TValue): boolean;

package/dist/forms/index.d.ts

@@ -1 +1,4 @@
-export * from "./typings";
+export type * from "./typings";
+export * from "./builder";
+export * from "./fields";
+export * from "./renderer";

package/dist/forms/renderer/FormBrowser/FormBrowser.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { CachedUserForm } from "../../../typings";
+interface FormBrowserProps {
+    /** If `true`, the user can toggle the favorite state of the forms they have access to */
+    isFavoriteEditable?: boolean;
+    onSelectForm: (form: CachedUserForm) => void;
+    /** @default 20 */
+    maxResults?: number;
+}
+export declare const FormBrowser: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<FormBrowserProps & import("react").RefAttributes<HTMLDivElement>>>;
+export {};

package/dist/forms/renderer/FormRenderer/FormRenderer.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import { ISchema } from "../../fields";
+import { Form } from "../../typings.ts";
+interface FormRendererProps {
+    /** The schema of the form the render */
+    schema: ISchema;
+    /** Initial values of the form */
+    values?: Form;
+    onSubmit?: (values: Form) => Promise<void> | void;
+    /** @default "Submit" */
+    submitText?: string;
+    /** The text of the cancel button (hidden by default)
+     * @default null
+     */
+    cancelText?: string;
+    onCancel?: () => void;
+    onDirty?: () => void;
+    onDirtyChange?: (dirty: boolean) => void;
+    /** Hide the form description
+     * @default false */
+    hideDescription?: boolean;
+    /** Hide the title (and description)
+     * @default false
+     */
+    hideTitle?: boolean;
+    className?: string;
+}
+export declare const FormRenderer: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<FormRendererProps & import("react").RefAttributes<HTMLDivElement>>>;
+export {};