@elliemae/loan-field-renderers 26.2.2

package/dist/esm/utils/dateHelper.js

@@ -0,0 +1,35 @@
+import moment from "moment";
+const isSunday = (momentDateObj) => moment(momentDateObj).format("dddd") === "Sunday";
+const isHoliday = (momentDateObj, holidays) => holidays.includes(moment(momentDateObj).format("YYYY-MM-DD"));
+const calNextBusinessDay = (dayCound, momentDateObj, holidays) => {
+  const nextDateObj = momentDateObj.add(dayCound, "d");
+  if (isSunday(nextDateObj) || isHoliday(nextDateObj, holidays)) {
+    calNextBusinessDay(dayCound, nextDateObj, holidays);
+  }
+  return nextDateObj;
+};
+const calNextPresumedRecievedDay = (dayCount, momentDateObj, holidays) => {
+  const nextPresumedRecievedDay = isSunday(momentDateObj) || isHoliday(momentDateObj, holidays) ? calNextBusinessDay(1, momentDateObj, holidays) : momentDateObj;
+  for (let index = 0; index < dayCount; index += 1) {
+    calNextBusinessDay(1, nextPresumedRecievedDay, holidays);
+  }
+  return nextPresumedRecievedDay;
+};
+const formatISODate = (date) => moment(date).utc().format("MM/DD/YYYY");
+const formatDateForBr = (date, format) => {
+  if (!date) return date;
+  if (format === "ISO") {
+    return moment(date).format("YYYY-MM-DD");
+  }
+  return moment(date).format("MM/DD/YYYY");
+};
+const convertToLocalDateTime = (date) => date ? moment.utc(date).local().format("MM/DD/YYYY [at] hh:mm A") : date;
+export {
+  calNextBusinessDay,
+  calNextPresumedRecievedDay,
+  convertToLocalDateTime,
+  formatDateForBr,
+  formatISODate,
+  isHoliday,
+  isSunday
+};

package/dist/types/lib/bll/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const ACRONYM_FORMAT_MAP: Record<string, string>;
+export declare const FORMATTER_ACRONYMS: string[];
+export declare const FORMATTER_TYPE_MAP: Record<string, string>;
+export declare const DECIMAL_POINTS_MAP: Record<string, number>;
+/**
+ * Mapping of renderer-controlled props that should be filtered from extra props.
+ * These props are managed internally by each renderer and should not be overridden.
+ */
+export declare const RENDERER_CONTROLLED_PROPS: Readonly<Record<string, ReadonlyArray<string>>>;

package/dist/types/lib/bll/formatters/booleanFormatter.d.ts

@@ -0,0 +1,5 @@
+import { IFormatter } from '../types';
+export declare class BooleanFormatter implements IFormatter {
+    format(input: unknown): boolean;
+    parse(input: boolean): boolean | undefined;
+}

package/dist/types/lib/bll/formatters/dateFormatter.d.ts

@@ -0,0 +1,28 @@
+import { IFormatter } from '../types';
+/**
+ * DateFormatter handles conversion between storage format (YYYY-MM-DD)
+ * and display format (configurable, default MM/DD/YYYY).
+ */
+declare class DateFormatter implements IFormatter {
+    /**
+     * Format date from storage format to display format
+     * @param {unknown} input - Date value from loan (typically YYYY-MM-DD or ISO format)
+     * @param {object} [options] - Formatting options
+     * @param {string} [options.dateFormat] - Target display format (default: MM/DD/YYYY)
+     * @returns {string} Formatted date string for UI display
+     */
+    format(input: unknown, options?: {
+        dateFormat?: string;
+    }): string;
+    /**
+     * Parse date from display format to storage format
+     * @param {string} input - Date string from UI (in display format)
+     * @param {object} [options] - Parsing options
+     * @param {string} [options.dateFormat] - Source display format (default: MM/DD/YYYY)
+     * @returns {unknown} Date in storage format (YYYY-MM-DD)
+     */
+    parse(input: string, options?: {
+        dateFormat?: string;
+    }): unknown;
+}
+export { DateFormatter };

package/dist/types/lib/bll/formatters/dropdownFormatter.d.ts

@@ -0,0 +1,6 @@
+import { IFormatter } from '../types';
+declare class DropdownFormatter implements IFormatter {
+    format(input: unknown): string;
+    parse(input: string): unknown;
+}
+export { DropdownFormatter };

package/dist/types/lib/bll/formatters/factory/index.d.ts

@@ -0,0 +1,71 @@
+import { PhoneFormatter } from '../phoneFormatter';
+import { RegexFormatter } from '../regexFormatter';
+import { SSNFormatter } from '../ssnFormatter';
+import { ZipFormatter } from '../zipFormatter';
+import { BooleanFormatter } from '../booleanFormatter';
+import { TextFormatter } from '../textFormatter';
+import { NumberFormatter } from '../numberFormatter';
+import { DateFormatter } from '../dateFormatter';
+import { DropdownFormatter } from '../dropdownFormatter';
+export type FormatterAcronymMap = {
+    SS: SSNFormatter;
+    T: DateFormatter;
+    TD: DateFormatter;
+    S: TextFormatter;
+    ST: DropdownFormatter;
+    I: NumberFormatter;
+    D2: NumberFormatter;
+    D3: NumberFormatter;
+    D4: NumberFormatter;
+    D5: NumberFormatter;
+    D6: NumberFormatter;
+    RI: NumberFormatter;
+    RD2: NumberFormatter;
+    RD3: NumberFormatter;
+    RD4: NumberFormatter;
+    RD5: NumberFormatter;
+    RD6: NumberFormatter;
+    Y: BooleanFormatter;
+    P: PhoneFormatter;
+    Z: ZipFormatter;
+    RS: RegexFormatter;
+    DD: DropdownFormatter;
+    DT: DateFormatter;
+};
+type FormatterAcronym = keyof FormatterAcronymMap;
+export interface IFormatterFactory {
+    createFormatter<T extends FormatterAcronym>(acronym: T): FormatterAcronymMap[T];
+}
+declare class FormatterFactory implements IFormatterFactory {
+    /**
+     * Cache for formatter instances by acronym
+     * Since formatters are stateless, we can safely reuse instances
+     */
+    private formatterCache;
+    /**
+     * Helper to check if acronym is for number formatter
+     * @param {string} acronym - Acronym to check
+     * @returns {boolean} True if number formatter
+     */
+    private isNumberAcronym;
+    /**
+     * Helper to check if acronym is for text formatter
+     * @param {string} acronym - Acronym to check
+     * @returns {boolean} True if text formatter
+     */
+    private isTextAcronym;
+    /**
+     * Create specific formatter based on acronym
+     * @param {string} upperAcronym - Uppercase acronym
+     * @returns Specific formatter instance
+     */
+    private createSpecificFormatter;
+    /**
+     * Create formatter from acronym with type safety
+     * @param {FormatterAcronym} acronym - Acronym identifier (e.g., 'SS', 'I', 'D2')
+     * @returns {FormatterAcronymMap[T]} Specific formatter instance based on acronym
+     */
+    createFormatter<T extends FormatterAcronym>(acronym: T): FormatterAcronymMap[T];
+}
+declare const factoryInstance: FormatterFactory;
+export { factoryInstance };

package/dist/types/lib/bll/formatters/index.d.ts

@@ -0,0 +1,2 @@
+import { factoryInstance } from './factory';
+export { factoryInstance };

package/dist/types/lib/bll/formatters/numberFormatter.d.ts

@@ -0,0 +1,6 @@
+import { IFormatter, INumberFormatOptions, INumberParseOptions } from '../types';
+export declare class NumberFormatter implements IFormatter<INumberFormatOptions, INumberParseOptions> {
+    private getMaskOptions;
+    format(input: unknown, { fieldFormat, numberOptions }: INumberFormatOptions): string;
+    parse(input: string, { fieldFormat, unmaskPattern }: INumberParseOptions): number | undefined;
+}

package/dist/types/lib/bll/formatters/phoneFormatter.d.ts

@@ -0,0 +1,7 @@
+import { UsePhoneMaskT } from '@elliemae/ds-form-helpers-mask-hooks';
+import { IFormatter, IPhoneParseOptions, IPhoneFormatOptions } from '../types';
+export declare class PhoneFormatter implements IFormatter<IPhoneFormatOptions, IPhoneParseOptions> {
+    format(input: unknown, { isInternational }: IPhoneFormatOptions): string;
+    parse(input: string, { unmaskPattern }?: IPhoneParseOptions): string | undefined;
+    static getPhoneFormatOptions({ isInternational, }: Omit<UsePhoneMaskT.Props, 'valueSetter'>): Omit<UsePhoneMaskT.Props, 'valueSetter'>;
+}

package/dist/types/lib/bll/formatters/regexFormatter.d.ts

@@ -0,0 +1,5 @@
+import { IFormatter } from '../types';
+export declare class RegexFormatter implements IFormatter {
+    format(input: string, patterns?: (string | RegExp)[]): string;
+    parse(input: string, patterns?: (string | RegExp)[]): string;
+}

package/dist/types/lib/bll/formatters/ssnFormatter.d.ts

@@ -0,0 +1,5 @@
+import { IFormatter } from '../types';
+export declare class SSNFormatter implements IFormatter {
+    format(input: unknown): string;
+    parse(input: string): string | undefined;
+}

package/dist/types/lib/bll/formatters/textFormatter.d.ts

@@ -0,0 +1,6 @@
+import { IFormatter } from '../types';
+declare class TextFormatter implements IFormatter {
+    format(input: unknown): string;
+    parse(input: string): unknown;
+}
+export { TextFormatter };

package/dist/types/lib/bll/formatters/zipFormatter.d.ts

@@ -0,0 +1,5 @@
+import { IFormatter } from '../types';
+export declare class ZipFormatter implements IFormatter {
+    format(input: string): string;
+    parse(input: string): string;
+}

package/dist/types/lib/bll/index.d.ts

@@ -0,0 +1,20 @@
+import { coreInstance } from '../core';
+import { IFormatterFactory } from './formatters/factory';
+import { ValidatorFactory } from './validators/factory';
+import { SSF } from './ssf';
+import { IValidatorFactory } from './types';
+export interface IBLL {
+    get SSF(): SSF;
+    get Core(): typeof coreInstance;
+    get Formatter(): IFormatterFactory;
+    get Validator(): IValidatorFactory;
+}
+export declare class BLL implements IBLL {
+    get Core(): import("../core").Core;
+    private ssf;
+    get Formatter(): IFormatterFactory;
+    get Validator(): ValidatorFactory;
+    get SSF(): SSF;
+    set SSF(service: SSF);
+}
+export declare const bllInstance: BLL;

package/dist/types/lib/bll/ssf/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SSF Module Barrel Export
+ * Architecture follows HookBase pattern:
+ * - SSFBase: Base class with shared SSF initialization
+ * - Loan: Groups loan object operations
+ * - LoConnect: Groups loconnect host operations
+ * - SSF: Combined class with all operations via Mixins
+ *
+ * Usage:
+ * import { ssfAdapterInstance } from './ssf';
+ * await ssfAdapterInstance.getFieldValue('FR0104');
+ * await ssfAdapterInstance.getStateDropDownList();
+ */
+import { SSFBase } from './ssfBase';
+import { Loan } from './loan';
+import { LoConnect } from './loconnect';
+export { SSFBase } from './ssfBase';
+export type { FieldValueResolverFn } from './ssfBase';
+export { Loan } from './loan';
+export { LoConnect } from './loconnect';
+export interface SSF extends Loan, LoConnect {
+}
+export declare class SSF extends SSFBase {
+}
+export declare const ssfInstance: SSF;

package/dist/types/lib/bll/ssf/loan.d.ts

@@ -0,0 +1,16 @@
+import { SSFBase } from './ssfBase';
+import { ModelPathT } from './types';
+/**
+ * Loan operations - Groups loan object related SSF methods
+ * Similar to how FieldValue, FieldMeta etc. extend HookBase
+ * Reference: ssf-wrapper-base.js loan methods
+ */
+export declare class Loan extends SSFBase {
+    getFieldValue(fieldId: string): Promise<unknown>;
+    setFieldValue(fieldId: string, value: unknown): Promise<void>;
+    setFieldsValues(setFieldsValuesObject: Record<string, unknown>, doCalc?: boolean): Promise<void>;
+    getFieldContractPaths(): Promise<Record<string, ModelPathT>>;
+    isReadOnlyLoan(): Promise<boolean>;
+    resolveBaseCollectionId(fieldId: string): Promise<string>;
+    getCollectionRowIndex(fieldId: string): Promise<number>;
+}

package/dist/types/lib/bll/ssf/loconnect.d.ts

@@ -0,0 +1,15 @@
+import { SSFBase } from './ssfBase';
+import { IGoToFieldDetails, StateOptionT } from './types';
+/**
+ * LoConnect operations - Groups loconnect host related SSF methods
+ * Similar to how FieldDisabled, FieldLocked etc. extend HookBase
+ * Reference: ssf-wrapper-base.js loconnect methods
+ */
+export declare class LoConnect extends SSFBase {
+    getStateDropDownList(): Promise<StateOptionT[]>;
+    getLockStatus(fieldId: string): Promise<boolean>;
+    callCalcForLock(fieldId: string, isLocked: boolean): Promise<void>;
+    getZipCodeOptions(zip: string): Promise<Record<string, string>[] | undefined>;
+    getZipCodeOptionsWithLatLong(zip: string): Promise<Record<string, string>[] | undefined>;
+    getGTFSelectedFormDetails(): Promise<IGoToFieldDetails | null>;
+}

package/dist/types/lib/bll/ssf/ssfBase.d.ts

@@ -0,0 +1,23 @@
+import { IGoToFieldDetails, SSFLoanObjectT } from './types';
+/**
+ * Base class for SSF operations
+ * Follows the HookBase pattern - provides shared SSF initialization
+ * Reference: ssf-wrapper-base.js
+ */
+export type FieldValueResolverFn = (fieldId: string) => unknown;
+export declare class SSFBase {
+    protected ssfEnabled: boolean;
+    protected initDone: boolean;
+    protected hostInstance: unknown;
+    private gtfFormDetailsCache;
+    private fieldValueResolverFn;
+    setFieldValueResolver(resolver: FieldValueResolverFn | null): void;
+    get fieldValueResolver(): FieldValueResolverFn | null;
+    constructor();
+    protected get IsLocalhost(): boolean;
+    protected get SSFLoanObject(): Promise<SSFLoanObjectT>;
+    protected initSSF(): Promise<void>;
+    protected genericCall(funcName: string, ...rest: unknown[]): Promise<unknown>;
+    getCachedGTFFormDetails(): IGoToFieldDetails | null;
+    setCachedGTFFormDetails(formDetails: IGoToFieldDetails | null): void;
+}

package/dist/types/lib/bll/ssf/types.d.ts

@@ -0,0 +1,99 @@
+export interface IGoToFieldDetails {
+    formId: string;
+    fieldId: string;
+    formName: string;
+    fileName: string;
+    fieldOcc: number;
+}
+export type ModelPathT = [
+    string,
+    1 | 0,
+    string,
+    string?,
+    (1 | 0)?,
+    number?,
+    [
+        string,
+        string
+    ][]?,
+    (1 | 0)?
+];
+export type StateOptionT = {
+    name: string;
+    value: string;
+};
+export interface SSFLoanObjectT {
+    getField(fieldId: string): unknown;
+    setFields(fields: Record<string, unknown>): Promise<void>;
+    calculate(): Promise<void>;
+    fieldDefinitions(): Record<string, ModelPathT>;
+    isReadOnly(): Promise<boolean>;
+    resolveBaseCollectionId(fieldId: string): Promise<string>;
+    getCollectionRowIndex(fieldId: string): Promise<number>;
+}
+export interface ISSFAdapter {
+    /**
+     * Retrieves a single field value from the loan
+     * @param fieldId - The field identifier
+     * @returns Promise resolving to the field value
+     */
+    getFieldValue(fieldId: string): Promise<unknown>;
+    /**
+     * Sets a single field value in the loan
+     * @param fieldId - The field identifier
+     * @param value - The value to set
+     * @returns Promise that resolves when the operation completes
+     */
+    setFieldValue(fieldId: string, value: unknown): Promise<void>;
+    /**
+     * Sets multiple field values in the loan (batch operation)
+     * More efficient than calling setFieldValue multiple times
+     * @param setFieldsValuesObject - Map of field IDs to their values
+     * @returns Promise that resolves when the operation completes
+     */
+    setFieldsValues(setFieldsValuesObject: Record<string, unknown>): Promise<void>;
+    /**
+     * Retrieves field metadata including contract paths, formats, and options
+     * @returns Promise resolving to a map of field IDs to their metadata
+     */
+    getFieldContractPaths(): Promise<Record<string, ModelPathT>>;
+    /**
+     * Retrieves the list of US states for state dropdown fields
+     * @returns Promise resolving to an array of state options
+     */
+    getStateDropDownList(): Promise<StateOptionT[]>;
+    /**
+     * Checks if the current loan is in read-only mode
+     * @returns Promise resolving to true if loan is read-only
+     */
+    isReadOnlyLoan(): Promise<boolean>;
+    /**
+     * Retrieves the lock status of a specific field
+     * @param fieldId - The field identifier
+     * @returns Promise resolving to true if field is locked
+     */
+    getLockStatus(fieldId: string): Promise<boolean>;
+    /**
+     * Triggers calculation for a locked field
+     * @param fieldId - The field identifier
+     * @param isLocked - Whether the field is locked
+     * @returns Promise that resolves when calculation completes
+     */
+    callCalcForLock(fieldId: string, isLocked: boolean): Promise<void>;
+    /**
+     * Retrieves Go-To-Field (GTF) selected form details
+     * Used for field navigation and context
+     * @returns Promise resolving to form details or null
+     */
+    getGTFSelectedFormDetails(): Promise<IGoToFieldDetails | null>;
+    /**
+     * Gets cached GTF selected form details
+     * @returns Cached form details or null if not cached
+     */
+    getCachedGTFFormDetails(): IGoToFieldDetails | null;
+    /**
+     * Sets cached GTF selected form details
+     * @param formDetails - Form details to cache, or null to clear cache
+     */
+    setCachedGTFFormDetails(formDetails: IGoToFieldDetails | null): void;
+}

package/dist/types/lib/bll/types.d.ts

@@ -0,0 +1,47 @@
+import { UseNumberMaskT } from '@elliemae/ds-form-helpers-mask-hooks';
+export interface IFormatter<T = unknown, U = unknown> {
+    format(input: unknown, formatOptions?: T): unknown;
+    parse(input: unknown, parseOptions?: U): unknown;
+}
+export interface IValidationResult {
+    isValid: boolean;
+    message?: string;
+}
+/**
+ * Conditional type that provides specific validation options based on validator type
+ */
+export type ValidationOptionsT<T extends string> = T extends 'date' ? {
+    dateFormat: string;
+} : T extends 'maxChar' ? {
+    charsLimit: number;
+} : Record<string, unknown>;
+export interface IValidator {
+    validate(value: unknown, message?: string, options?: ValidationOptionsT<string>): IValidationResult;
+}
+export interface IValidationRule {
+    type: string;
+    message?: string;
+    options?: ValidationOptionsT<string>;
+}
+export interface IValidatePayload {
+    fieldValue: unknown;
+    validationRules: Array<IValidationRule>;
+}
+export interface IValidatorFactory {
+    createValidator(type: string): IValidator;
+    runValidators(rules: Array<IValidationRule>, value: unknown): IValidationResult;
+}
+export interface INumberFormatOptions {
+    fieldFormat: string;
+    numberOptions?: Omit<UseNumberMaskT.Props, 'valueSetter' | 'decimalPlaces' | 'decimalRequired'>;
+}
+export interface INumberParseOptions {
+    fieldFormat: string;
+    unmaskPattern?: RegExp;
+}
+export interface IPhoneFormatOptions {
+    isInternational?: boolean;
+}
+export interface IPhoneParseOptions {
+    unmaskPattern?: RegExp;
+}

package/dist/types/lib/bll/validators/dateValidator.d.ts

@@ -0,0 +1,16 @@
+import { IValidator, IValidationResult, ValidationOptionsT } from '../types';
+/**
+ * DateValidator validates date values using moment.js
+ * Supports custom date formats and provides meaningful error messages
+ */
+declare class DateValidator implements IValidator {
+    /**
+     * Validate if the given value is a valid date
+     * @param {unknown} value - The date value to validate
+     * @param {string} [message] - Custom error message
+     * @param {ValidationOptionsT<'date'>} [options] - Validation options including dateFormat for strict checking
+     * @returns {IValidationResult} Validation result with isValid flag and optional message
+     */
+    validate(value: unknown, message?: string, options?: ValidationOptionsT<'date'>): IValidationResult;
+}
+export { DateValidator };

package/dist/types/lib/bll/validators/emailValidator.d.ts

@@ -0,0 +1,4 @@
+import { IValidator, IValidationResult } from '../types';
+export declare class EmailValidator implements IValidator {
+    validate(value?: string, message?: string): IValidationResult;
+}

package/dist/types/lib/bll/validators/factory/index.d.ts

@@ -0,0 +1,15 @@
+import { IValidator, IValidatorFactory, IValidationResult, IValidationRule } from '../../types';
+declare class ValidatorFactory implements IValidatorFactory {
+    private registry;
+    /**
+     * Cache for validator instances by type
+     * Since validators are stateless, we can safely reuse instances
+     */
+    private validatorCache;
+    constructor();
+    private initBuiltInValidators;
+    createValidator(type: string): IValidator;
+    registerValidator(type: string, validatorClass: new () => IValidator): void;
+    runValidators(rules: Array<IValidationRule>, value: unknown): IValidationResult;
+}
+export { ValidatorFactory };

package/dist/types/lib/bll/validators/index.d.ts

@@ -0,0 +1,2 @@
+import { ValidatorFactory } from './factory';
+export { ValidatorFactory };

package/dist/types/lib/bll/validators/maxCharValidator.d.ts

@@ -0,0 +1,4 @@
+import { IValidator, IValidationResult, ValidationOptionsT } from '../types';
+export declare class MaxCharValidator implements IValidator {
+    validate(value: unknown, message?: string, options?: ValidationOptionsT<'maxChar'>): IValidationResult;
+}

package/dist/types/lib/bll/validators/requiredValidator.d.ts

@@ -0,0 +1,4 @@
+import { IValidator, IValidationResult } from '../types';
+export declare class RequiredValidator implements IValidator {
+    validate(value: string, message?: string): IValidationResult;
+}

package/dist/types/lib/bll/validators/zipValidator.d.ts

@@ -0,0 +1,5 @@
+import { IValidator, IValidationResult } from '../types';
+export declare const validZipCode: (zip?: string | null) => boolean;
+export declare class ZipValidator implements IValidator {
+    validate(zip?: string, message?: string): IValidationResult;
+}

package/dist/types/lib/core/index.d.ts

@@ -0,0 +1,29 @@
+import { Base } from '@elliemae/encw-core';
+declare class Core extends Base {
+    get CoreUtils(): {
+        Functions: import("@elliemae/encw-core/dist/types/lib/Utilities/Functions").Functions;
+        Objects: import("@elliemae/encw-core/dist/types/lib/Utilities/Objects").Objects;
+        Random: import("@elliemae/encw-core/dist/types/lib/Utilities/Random").Random;
+        Strings: import("@elliemae/encw-core/dist/types/lib/Utilities/Strings").Strings;
+        Validate: import("@elliemae/encw-core/dist/types/lib/Utilities/Validate").Validate;
+    };
+    get ExceptionUtils(): {
+        businessException: <T extends Record<string, unknown> | string>(message: string, cause?: T | undefined) => {
+            type: "AuthenticationException" | "AuthorizationException" | "BusinessException" | "DatabaseException" | "NetworkException" | "RuntimeException" | "ValidationException" | "CustomException";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        runtimeException: <T extends Record<string, unknown> | string>(message: string, cause?: T | undefined) => {
+            type: "AuthenticationException" | "AuthorizationException" | "BusinessException" | "DatabaseException" | "NetworkException" | "RuntimeException" | "ValidationException" | "CustomException";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+    };
+    Log<T extends object | Error>(type: 'log' | 'warn' | 'error', message: string, additionalData?: T): void | (() => void);
+}
+declare const coreInstance: Core;
+export { coreInstance, Core };

package/dist/types/lib/demo/config.d.ts

@@ -0,0 +1,11 @@
+import { NumberRendererPropsT, RendererPropsT, DateRendererPropsT } from '../renderer/types';
+export declare class Config {
+    static getTextFields(): RendererPropsT[];
+    static getNumberFields(): NumberRendererPropsT[];
+    static getCheckboxFields(): RendererPropsT[];
+    static getRadioButtonFields(): RendererPropsT[];
+    static getDateFields(): DateRendererPropsT[];
+    static getLargeTextField(): RendererPropsT[];
+    static getToggleFields(): RendererPropsT[];
+    static getRendererConfigs(): RendererPropsT[];
+}

package/dist/types/lib/demo/index.d.ts

@@ -0,0 +1 @@
+export declare const Demo: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/lib/renderer/FieldRenderer.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { RendererPropsT } from './types';
+export declare const FieldRenderer: React.FC<RendererPropsT>;
+declare const _default: React.NamedExoticComponent<RendererPropsT>;
+export default _default;

package/dist/types/lib/renderer/base/hooks/fieldDescription.d.ts

@@ -0,0 +1,5 @@
+import { HookBase } from './hookBase';
+import { AriaDescT } from '../../types';
+export declare class FieldDescription extends HookBase {
+    protected getFieldAriaDescProps(label: string, description: string): AriaDescT;
+}

package/dist/types/lib/renderer/base/hooks/fieldDisabled.d.ts

@@ -0,0 +1,10 @@
+import { FieldMetadataT } from '../../types';
+import { HookBase } from './hookBase';
+export declare class FieldDisabled extends HookBase {
+    protected isLoanReadonly(): Promise<boolean>;
+    useFieldDisabled({ fieldId, metadata, isLockedState, }: {
+        fieldId: string;
+        metadata: FieldMetadataT;
+        isLockedState?: boolean;
+    }): boolean;
+}

package/dist/types/lib/renderer/base/hooks/fieldGoTo.d.ts

@@ -0,0 +1,4 @@
+import { HookBase } from './hookBase';
+export declare class FieldGoTo extends HookBase {
+    protected isGoToField(fieldId: string): Promise<boolean>;
+}

package/dist/types/lib/renderer/base/hooks/fieldLocked.d.ts

@@ -0,0 +1,4 @@
+import { HookBase } from './hookBase';
+export declare class FieldLocked extends HookBase {
+    protected getFieldLockStatus(fieldId: string): Promise<boolean>;
+}

package/dist/types/lib/renderer/base/hooks/fieldMeta.d.ts

@@ -0,0 +1,10 @@
+import { FieldMetadataT } from '../../types';
+import { HookBase } from './hookBase';
+export declare class FieldMeta extends HookBase {
+    protected getMetadata(fieldId: string): Promise<FieldMetadataT>;
+    private lookupFieldData;
+    private transformContractPath;
+    private buildFieldMetadata;
+    private handleMetadataError;
+    private fetchStateOptions;
+}

package/dist/types/lib/renderer/base/hooks/fieldSubscribers.d.ts

@@ -0,0 +1,6 @@
+import { HookBase } from './hookBase';
+export declare class FieldSubscribers extends HookBase {
+    private useSubscribeEffect;
+    useLoanUpdatedCB(callback: (...args: unknown[]) => void): void;
+    useLoanChangeCB(callback: (...args: unknown[]) => void): void;
+}

package/dist/types/lib/renderer/base/hooks/fieldValidation.d.ts

@@ -0,0 +1,9 @@
+import { IValidationResult, IValidationRule } from '../../../bll/types';
+import { HookBase } from './hookBase';
+export declare class FieldValidation extends HookBase {
+    runValidationsOnValue(value: unknown, validationRules: Array<IValidationRule>, customValidation?: (value: unknown) => void): IValidationResult;
+    protected useFieldValidation(): {
+        validationResult: IValidationResult | null;
+        setValidationResult: import("react").Dispatch<import("react").SetStateAction<IValidationResult | null>>;
+    };
+}