@flyanra/vue-core 0.3.0 → 1.0.0

package/dist/types/components/basic/fly-button/FlyButton.types.d.ts

@@ -1,5 +1,5 @@
 import type { ButtonType, ElButton, UseTooltipProps } from 'element-plus';
-import type { T_FlyIconTypes } from '../../general/fly-icon/FlyIcon.types';
+import type { T_FlyIconV2Props } from '../../general';
 export type FlyButtonIconPosition = 'left' | 'right';
 export type FlyButtonSizes = InstanceType<typeof ElButton>['$props']['size'];
 export type FlyButtonTypes = ButtonType;
@@ -12,9 +12,8 @@ export type FlyButtonProps = {
      */
     clipRound?: boolean;
     full?: boolean;
-    icon?: string | object;
+    icon?: T_FlyIconV2Props['icon'];
     iconPosition?: FlyButtonIconPosition;
-    iconType?: T_FlyIconTypes;
     imageUrl?: string;
     label?: string;
     size?: FlyButtonSizes;

package/dist/types/components/basic/typography/FlyCollapseTitleRenderer.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    title: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/feedback/tooltip/FlyInfoTooltip.vue.d.ts

@@ -0,0 +1,36 @@
+declare var __VLS_7: {}, __VLS_15: {};
+type __VLS_Slots = {} & {
+    trigger?: (props: typeof __VLS_7) => any;
+} & {
+    default?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    content: {
+        type: StringConstructor;
+        default: string;
+    };
+    html: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    content: {
+        type: StringConstructor;
+        default: string;
+    };
+    html: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    html: boolean;
+    content: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/feedback/tooltip/FlyTooltip.vue.d.ts

@@ -1,3 +1,4 @@
+import './FlyTooltip.element.scss';
 import type { T_FlyTooltipProps } from './FlyTooltip.types';
 declare var __VLS_8: {}, __VLS_11: {};
 type __VLS_Slots = {} & {

package/dist/types/components/form/form.utils.d.ts

@@ -0,0 +1,11 @@
+import type { FormInstance } from 'element-plus';
+export type ValidateFieldsError = {
+    [K: string]: {
+        message?: string;
+    }[];
+};
+/**
+ * @returns Translated error message based on active locale
+ */
+export declare function formFieldErrorMessageFormatter(errors: ValidateFieldsError): string;
+export declare function genericFormValidator(formRef: FormInstance): Promise<true>;

package/dist/types/components/form/index.d.ts

@@ -0,0 +1,5 @@
+export * from './input-renderers/form-item-renderer';
+export * from './input-renderers/input-renderer';
+export type { T_InputRendererBase } from './input-renderers/input-renderer.types';
+export * from './input-validators';
+export * from './form.utils';

package/dist/types/components/form/input-renderers/boolean/FlyBoolean.types.d.ts

@@ -0,0 +1,14 @@
+export type T_InputBooleanValues = string | number | boolean | undefined;
+export type T_InputBooleanBase = T_InputBoolean & {
+    type: 'boolean';
+    placeholder?: string;
+};
+export type T_InputBoolean = {
+    /**
+     * Attrs are passed directly to the input element as props
+     */
+    attrs?: {
+        activeText?: string;
+        inactiveText?: string;
+    };
+};

package/dist/types/components/form/input-renderers/boolean/FlyBoolean.vue.d.ts

@@ -0,0 +1,15 @@
+import './FlyBoolean.scss';
+import type { T_InputBoolean, T_InputBooleanValues } from './FlyBoolean.types';
+type __VLS_Props = {
+    modelValue?: T_InputBooleanValues;
+    input?: T_InputBoolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (v: T_InputBooleanValues) => any;
+    change: (v: T_InputBooleanValues) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((v: T_InputBooleanValues) => any) | undefined;
+    onChange?: ((v: T_InputBooleanValues) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-renderers/date-time/FlyDateTime.types.d.ts

@@ -0,0 +1,20 @@
+export type T_DateTimeRawValue = Date | [Date, Date] | undefined;
+export type T_DateTimeValues = string | string[] | undefined;
+export type T_DateInputTypes = 'date' | 'dateTime' | 'dateRange' | 'dateTimeRange';
+export type T_InputDateTimeBase = T_InputDateTime & {
+    type: 'dateTime';
+};
+export type T_InputDateTime = {
+    placeholder?: string;
+    startPlaceholder?: string;
+    endPlaceholder?: string;
+    /**
+     * Attrs are passed directly to the input element as props
+     */
+    attrs?: {
+        [K: string]: unknown;
+    };
+    config?: {
+        inputType?: T_DateInputTypes;
+    };
+};

package/dist/types/components/form/input-renderers/date-time/FlyDateTime.vue.d.ts

@@ -0,0 +1,19 @@
+import './FlyDateTime.scss';
+import type { T_DateTimeValues, T_InputDateTime } from './FlyDateTime.types';
+type __VLS_Props = {
+    modelValue?: T_DateTimeValues;
+    input?: T_InputDateTime;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+    "update:modelValue": (v: T_DateTimeValues) => any;
+    change: (v: T_DateTimeValues) => any;
+    blur: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((v: T_DateTimeValues) => any) | undefined;
+    onChange?: ((v: T_DateTimeValues) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-renderers/form-item-renderer/FlyFormItemRenderer.vue.d.ts

@@ -0,0 +1,19 @@
+import type { T_InputRendererBase } from '../input-renderer.types';
+import './FlyFormItemRenderer.scss';
+type __VLS_Props = {
+    modelValue: unknown;
+    input: T_InputRendererBase;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+    "update:modelValue": (value: unknown) => any;
+    change: (value: unknown) => any;
+    blur: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
+    onChange?: ((value: unknown) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-renderers/form-item-renderer/index.d.ts

@@ -0,0 +1,3 @@
+import FlyFormItemRenderer from './FlyFormItemRenderer.vue';
+export default FlyFormItemRenderer;
+export { FlyFormItemRenderer };

package/dist/types/components/form/input-renderers/form-schema-renderer/FlyFormSchemaRenderer.types.d.ts

@@ -0,0 +1,2 @@
+import type FlyFormSchemaRenderer from './FlyFormSchemaRenderer.vue';
+export type T_FlyFormSchemaRendererInstance = InstanceType<typeof FlyFormSchemaRenderer> | null;

package/dist/types/components/form/input-renderers/form-schema-renderer/FlyFormSchemaRenderer.utils.d.ts

@@ -0,0 +1,21 @@
+import type { FormItemRule } from 'element-plus';
+import type { T_FormSchemaLookupData, T_InputSchema, T_InputSchemaSelect, T_InputSchemaValueUnit } from '../form-schema.types';
+import type { T_InputRendererBase } from '../input-renderer.types';
+import type { T_InputSelectOption } from '../select/FlySelect.types';
+export declare function getValidatorsFromInputFields(fields: T_InputRendererBase[]): Record<string, FormItemRule[]>;
+export declare function generateInputFromFormSchema(field: T_InputSchema, lookupData?: T_FormSchemaLookupData): (import("../input-renderer.types").T_DynamicInputPropsBase & import("../boolean/FlyBoolean.types").T_InputBoolean & {
+    type: "boolean";
+    placeholder?: string;
+}) | (import("../input-renderer.types").T_DynamicInputPropsBase & import("../date-time/FlyDateTime.types").T_InputDateTime & {
+    type: "dateTime";
+}) | (import("../input-renderer.types").T_DynamicInputPropsBase & import("../number/FlyNumber.types").T_InputNumber & {
+    type: "number";
+}) | (import("../input-renderer.types").T_DynamicInputPropsBase & import("../select/FlySelect.types").T_InputSelect & {
+    type: "select";
+}) | (import("../input-renderer.types").T_DynamicInputPropsBase & import("../text/FlyText.types").T_InputText & {
+    type: "text" | "textarea";
+}) | (import("../input-renderer.types").T_DynamicInputPropsBase & import("../value-unit/FlyValueUnit.types").T_InputValueUnit & {
+    type: "valueUnit";
+}) | undefined;
+export declare function generateFormRule(field: T_InputSchema): FormItemRule[];
+export declare function generateSelectOptionsFromSchema(field: T_InputSchemaSelect | T_InputSchemaValueUnit, lookupData?: T_FormSchemaLookupData): T_InputSelectOption[];

package/dist/types/components/form/input-renderers/form-schema-renderer/FlyFormSchemaRenderer.vue.d.ts

@@ -0,0 +1,17 @@
+import '../../../../styles/element/overrides/form.scss';
+import { type T_FormSchemaRendererProps } from './UseFormSchemaRenderer';
+type __VLS_Props = T_FormSchemaRendererProps & {
+    /**
+     * Column span within a 12 column grid
+     */
+    columnSpan?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    validateForm: () => Promise<true | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: Record<string, unknown> | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: Record<string, unknown> | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-renderers/form-schema-renderer/UseFormSchemaRenderer.d.ts

@@ -0,0 +1,25 @@
+import { type Ref } from 'vue';
+import type { FormInstance } from 'element-plus';
+import type { T_FormSchemaLookupData, T_InputSchema } from '../form-schema.types';
+import type { T_FormSchemaRendererConfig } from '../input-renderer.types';
+export type T_FormSchemaRendererProps = {
+    formConfig: T_InputSchema[];
+    lookupData?: T_FormSchemaLookupData;
+    modelValue?: Record<string, unknown>;
+    disabled?: boolean;
+};
+export type T_FormSchemaRendererEmits = {
+    (e: 'update:modelValue', value: T_FormSchemaRendererProps['modelValue']): void;
+};
+type ConfigFormCompArgs = {
+    formRef: Ref<FormInstance | undefined>;
+    props: T_FormSchemaRendererProps;
+    emit: T_FormSchemaRendererEmits;
+};
+export declare function UseFormSchemaRenderer(args: ConfigFormCompArgs): {
+    dynamicValidators: import("vue").ComputedRef<Record<string, import("element-plus").FormItemRule[]>>;
+    formProxy: import("vue").WritableComputedRef<Record<string, unknown>, Record<string, unknown>>;
+    generatedForm: Ref<T_FormSchemaRendererConfig | undefined, T_FormSchemaRendererConfig | undefined>;
+    validateForm: () => Promise<true | undefined>;
+};
+export {};

package/dist/types/components/form/input-renderers/form-schema.types.d.ts

@@ -0,0 +1,77 @@
+import type { T_DateInputTypes } from './date-time/FlyDateTime.types';
+import type { T_InputSelectOption } from './select/FlySelect.types';
+import type { T_ValueUnitValue } from './value-unit/FlyValueUnit.types';
+export type T_FormSchemaLookupData = Record<string, Array<unknown>>;
+export type T_InputSchema = T_InputSchemaText | T_InputSchemaNumber | T_InputSchemaBoolean | T_InputSchemaSelect | T_InputSchemaValueUnit | T_InputSchemaDateTime;
+type T_FieldValidationBase = {
+    required?: boolean;
+};
+type T_InputSchemaBase<ValidationRules = object> = {
+    unique_key: string;
+    label: string;
+    tooltip?: string;
+    placeholder?: string;
+    validation?: T_FieldValidationBase & ValidationRules;
+};
+export type T_InputSchemaText = T_InputSchemaBase<{
+    minLength?: number;
+    maxLength?: number;
+}> & {
+    type: 'text';
+    default_value?: string;
+    config?: {
+        maxLength?: number;
+        minLength?: number;
+        type?: string;
+        rows?: number;
+    };
+};
+export type T_InputSchemaNumber = T_InputSchemaBase<{
+    minLength?: number;
+    maxLength?: number;
+}> & {
+    type: 'number';
+    default_value?: number;
+    config?: {
+        minLength?: number;
+        maxLength?: number;
+    };
+};
+export type T_InputSchemaBoolean = T_InputSchemaBase & {
+    type: 'boolean';
+    default_value?: boolean;
+    config?: {
+        activeText?: string;
+        inactiveText?: string;
+    };
+};
+type T_SelectOptions = {
+    options_config_Lookup_id: string;
+    options?: never;
+} | {
+    options?: T_InputSelectOption[];
+    options_config_Lookup_id?: never;
+};
+type T_SelectBase<M extends boolean | undefined> = T_InputSchemaBase & {
+    type: 'select';
+    config: T_SelectOptions & {
+        multiple?: M;
+    };
+    default_value?: M extends true ? (string | number)[] : string | number;
+};
+export type T_InputSchemaSelect = T_SelectBase<true> | T_SelectBase<false | undefined>;
+export type T_InputSchemaValueUnit = T_InputSchemaBase & {
+    type: 'valueUnit';
+    config: T_SelectOptions & {
+        valueType?: 'text' | 'number';
+    };
+    default_value?: T_ValueUnitValue;
+};
+export type T_InputSchemaDateTime = T_InputSchemaBase & {
+    type: 'dateTime';
+    default_value?: string | [string | string];
+    config?: {
+        inputType: T_DateInputTypes;
+    };
+};
+export {};

package/dist/types/components/form/input-renderers/input-renderer/FlyInputRenderer.vue.d.ts

@@ -0,0 +1,18 @@
+import type { T_InputRendererBase } from '../input-renderer.types';
+type __VLS_Props = {
+    modelValue?: unknown;
+    input: T_InputRendererBase;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+    "update:modelValue": (v: unknown) => any;
+    change: (v: unknown) => any;
+    blur: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((v: unknown) => any) | undefined;
+    onChange?: ((v: unknown) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-renderers/input-renderer/index.d.ts

@@ -0,0 +1,3 @@
+import FlyInputRenderer from './FlyInputRenderer.vue';
+export default FlyInputRenderer;
+export { FlyInputRenderer };

package/dist/types/components/form/input-renderers/input-renderer.types.d.ts

@@ -0,0 +1,30 @@
+import type { Component } from 'vue';
+import type { FormItemRule } from 'element-plus';
+import type { T_InputBoolean, T_InputBooleanBase } from './boolean/FlyBoolean.types';
+import type { T_InputDateTime, T_InputDateTimeBase } from './date-time/FlyDateTime.types';
+import type { T_InputNumber, T_InputNumberBase } from './number/FlyNumber.types';
+import type { T_InputSelect, T_InputSelectBase } from './select/FlySelect.types';
+import type { T_InputText, T_InputTextBase } from './text/FlyText.types';
+import type { T_InputValueUnit, T_InputValueUnitBase } from './value-unit/FlyValueUnit.types';
+export type T_DynamicInputPropsBase = {
+    key: string;
+    prop?: string;
+    label: string;
+    tooltip?: string;
+    columnSpan?: number;
+    validations?: FormItemRule[];
+};
+export type T_InputRendererBase = T_DynamicInputPropsBase & T_SupportedInputTypeBase;
+export type T_SupportedInputTypeBase = T_InputTextBase | T_InputBooleanBase | T_InputDateTimeBase | T_InputNumberBase | T_InputSelectBase | T_InputValueUnitBase;
+export type T_SupportedInputType = T_InputText | T_InputNumber | T_InputValueUnit | T_InputSelect | T_InputBoolean | T_InputDateTime;
+export type T_InputTypes = T_SupportedInputTypeBase['type'];
+export type T_DynamicInputComponent = Component<{
+    modelValue?: unknown;
+    input?: T_SupportedInputType;
+}>;
+export type T_FormSchemaRendererConfig = {
+    inputs: T_InputRendererBase[];
+    baseForm: {
+        [K: string]: unknown;
+    };
+};

package/dist/types/components/form/input-renderers/input-renderer.utils.d.ts

@@ -0,0 +1,2 @@
+import type { T_InputTypes } from './input-renderer.types';
+export declare function getInputDisplayValue(v: unknown, inputType: T_InputTypes): string | number;

package/dist/types/components/form/input-renderers/number/FlyNumber.types.d.ts

@@ -0,0 +1,13 @@
+export type T_InputTextValues = string | number | undefined;
+export type T_InputNumberBase = T_InputNumber & {
+    type: 'number';
+};
+export type T_InputNumber = {
+    placeholder?: string;
+    /**
+     * Attrs are passed directly to the input element as props
+     */
+    attrs?: {
+        [K: string]: unknown;
+    };
+};

package/dist/types/components/form/input-renderers/number/FlyNumber.utils.d.ts

@@ -0,0 +1 @@
+export declare function displayToNumber(v: unknown): number | undefined;

package/dist/types/components/form/input-renderers/number/FlyNumber.vue.d.ts

@@ -0,0 +1,19 @@
+import './FlyNumber.scss';
+import type { T_InputNumber, T_InputTextValues } from './FlyNumber.types';
+type __VLS_Props = {
+    modelValue?: unknown;
+    input?: T_InputNumber;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+    "update:modelValue": (v: T_InputTextValues) => any;
+    change: (v: T_InputTextValues) => any;
+    blur: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((v: T_InputTextValues) => any) | undefined;
+    onChange?: ((v: T_InputTextValues) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-renderers/regional-tenant-form-renderer/FlyRegionalTenantFormRenderer.types.d.ts

@@ -0,0 +1,13 @@
+import type { T_FormSchemaLookupData, T_InputSchema } from '../form-schema.types';
+export type T_TenantRegionalFormSection = {
+    key: string;
+    fields: T_InputSchema[];
+    title: string;
+    description?: string;
+    lookupData?: T_FormSchemaLookupData;
+    modelValue?: Record<string, unknown>;
+};
+export type T_TenantRegionalFormProps = {
+    mainFormTitle: string;
+    sections?: T_TenantRegionalFormSection[];
+};

package/dist/types/components/form/input-renderers/regional-tenant-form-renderer/FlyRegionalTenantFormRenderer.vue.d.ts

@@ -0,0 +1,20 @@
+import '../../../../styles/element/overrides/collapse.scss';
+import type { T_TenantRegionalFormProps } from './FlyRegionalTenantFormRenderer.types';
+declare function validateForms(): Promise<true | undefined>;
+declare var __VLS_19: {}, __VLS_38: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_19) => any;
+} & {
+    default?: (props: typeof __VLS_38) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<T_TenantRegionalFormProps, {
+    validateForms: typeof validateForms;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<T_TenantRegionalFormProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/form/input-renderers/select/FlySelect.types.d.ts

@@ -0,0 +1,22 @@
+export type T_InputSelectValue = string | number | (string | number)[] | undefined;
+export type T_InputLabelValue = {
+    label: string;
+    value: string | number;
+};
+export type T_InputSelectOption = T_InputLabelValue | (number | string);
+export type T_InputSelectOptionList = T_InputSelectOption[] | Record<string, T_InputLabelValue>;
+export type T_InputSelectBase = T_InputSelect & {
+    type: 'select';
+};
+export type T_InputSelect = {
+    placeholder?: string;
+    /**
+     * Attrs are passed directly to the input element as props
+     */
+    attrs?: {
+        multiple?: boolean;
+    };
+    config?: {
+        options: T_InputSelectOptionList;
+    };
+};

package/dist/types/components/form/input-renderers/select/FlySelect.utils.d.ts

@@ -0,0 +1,2 @@
+import type { T_InputLabelValue, T_InputSelectOptionList } from './FlySelect.types';
+export declare function normalizeSelectOptionsToDict(options: T_InputSelectOptionList): Record<string, T_InputLabelValue>;

package/dist/types/components/form/input-renderers/select/FlySelect.vue.d.ts

@@ -0,0 +1,19 @@
+import './FlySelect.scss';
+import type { T_InputSelect, T_InputSelectValue } from './FlySelect.types';
+type __VLS_Props = {
+    modelValue?: T_InputSelectValue;
+    input?: T_InputSelect;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+    "update:modelValue": (v: T_InputSelectValue) => any;
+    change: (v: T_InputSelectValue) => any;
+    blur: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((v: T_InputSelectValue) => any) | undefined;
+    onChange?: ((v: T_InputSelectValue) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-renderers/text/FlyText.types.d.ts

@@ -0,0 +1,18 @@
+export type T_InputTextValues = string | number | undefined;
+export type T_InputTextBase = T_InputText & {
+    type: 'text' | 'textarea';
+};
+export type T_InputText = {
+    placeholder?: string;
+    /**
+     * Attrs are passed directly to the input element as props
+     */
+    attrs?: {
+        minlength?: number;
+        maxlength?: number;
+        showWordLimit?: boolean;
+        type?: string;
+        rows?: number;
+    };
+    mask?: string;
+};

package/dist/types/components/form/input-renderers/text/FlyText.vue.d.ts

@@ -0,0 +1,19 @@
+import './FlyText.scss';
+import type { T_InputText, T_InputTextValues } from './FlyText.types';
+type __VLS_Props = {
+    modelValue?: T_InputTextValues;
+    input?: T_InputText;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+    "update:modelValue": (v: T_InputTextValues) => any;
+    change: (v: T_InputTextValues) => any;
+    blur: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((v: T_InputTextValues) => any) | undefined;
+    onChange?: ((v: T_InputTextValues) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-renderers/value-unit/FlyValueUnit.types.d.ts

@@ -0,0 +1,23 @@
+import type { T_InputNumber } from '../number/FlyNumber.types';
+import type { T_InputSelect, T_InputSelectOptionList } from '../select/FlySelect.types';
+import type { T_InputText } from '../text/FlyText.types';
+export type T_ValueUnitValue = {
+    unit: string | number | undefined;
+    value: string | number | undefined;
+} | undefined;
+export type T_InputValueUnitBase = T_InputValueUnit & {
+    type: 'valueUnit';
+};
+export type T_InputValueUnit = {
+    placeholder?: string;
+    unitPlaceholder?: string;
+    /**
+     * Attrs are passed directly to the input element as props
+     */
+    attrs?: T_InputText['attrs'] | T_InputNumber['attrs'];
+    unitsAttr?: T_InputSelect['attrs'];
+    config?: {
+        valueType?: 'text' | 'number';
+        options: T_InputSelectOptionList;
+    };
+};

package/dist/types/components/form/input-renderers/value-unit/FlyValueUnit.vue.d.ts

@@ -0,0 +1,19 @@
+import './FlyValueUnit.scss';
+import type { T_InputValueUnit, T_ValueUnitValue } from './FlyValueUnit.types';
+type __VLS_Props = {
+    modelValue?: T_ValueUnitValue;
+    input?: T_InputValueUnit;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+    "update:modelValue": (v: T_ValueUnitValue) => any;
+    change: (v: T_ValueUnitValue) => any;
+    blur: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((v: T_ValueUnitValue) => any) | undefined;
+    onChange?: ((v: T_ValueUnitValue) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/form/input-validators.d.ts

@@ -0,0 +1,12 @@
+import type { FormItemRule } from 'element-plus';
+import { type checkInputRange } from '../../utils/validators';
+type InputTriggers = 'blur' | 'change';
+export declare const requiredField: (fieldLabel?: string, trigger?: InputTriggers, useRequiredMessage?: boolean) => FormItemRule;
+export declare const checkInputRangeValidator: (validator: ReturnType<typeof checkInputRange>, trigger?: InputTriggers) => FormItemRule;
+export declare const requiredFieldNumber: (languageKey?: string, trigger?: InputTriggers) => FormItemRule;
+export declare const requiredFieldNumberSelect: (label?: string, trigger?: InputTriggers, useRequiredMessage?: boolean) => FormItemRule;
+export declare const requiredFieldValueUnit: (label: string | undefined, trigger: InputTriggers | undefined, useRequiredMessage: boolean | undefined, required: boolean | undefined, options: {
+    valueType?: "text" | "number";
+}) => FormItemRule;
+export declare const requiredFieldArray: (label?: string, trigger?: InputTriggers, useRequiredMessage?: boolean) => FormItemRule;
+export {};

package/dist/types/components/general/fly-icon-v2/FlyIconV2.types.d.ts

@@ -0,0 +1,5 @@
+import { type Component } from 'vue';
+export type T_FlyIconV2Props = {
+    icon: Component;
+    size?: string | number;
+};

package/dist/types/components/general/fly-icon-v2/FlyIconV2.vue.d.ts

@@ -0,0 +1,4 @@
+import type { T_FlyIconV2Props } from './FlyIconV2.types';
+declare const __VLS_export: import("vue").DefineComponent<T_FlyIconV2Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<T_FlyIconV2Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;