pragmate-ui/form/form.d.ts

An advanced, on-demand React UI library optimized for BeyondJS. Pragmate UI provides modular, responsive, and accessible components with a focus on efficient bundle sizes and a streamlined development process.

/************
Processor: ts
************/

import * as __beyond_dep_ns_0 from 'react';
import __beyond_dep_def_0 from 'react';
import * as __beyond_dep_ns_1 from 'pragmate-ui/base';
// checkbox/group.tsx
declare namespace ns_0 {
  import React = __beyond_dep_def_0;
  export function CheckboxGroup(props: any): React.JSX.Element;
}


// checkbox/index.tsx
declare namespace ns_1 {
  import IPUIProps = __beyond_dep_ns_1.IPUIProps;
  import React = __beyond_dep_def_0;
  import RefAttributes = __beyond_dep_ns_0.RefAttributes;
  export const Checkbox: React.FC<IPUIProps & RefAttributes<HTMLInputElement>>;
}


// form.tsx
declare namespace ns_2 {
  /// <reference types="react" />
  import IPUIProps = __beyond_dep_ns_1.IPUIProps;
  export function Form(props: IPUIProps): JSX.Element;
}


// input/components/date.tsx
declare namespace ns_3 {
  /// <reference types="react" />
  export function Date(): JSX.Element;
}


// input/components/error.tsx
declare namespace ns_4 {
  import React = __beyond_dep_def_0;
  export function Error({
    show,
    message,
    className,
    children
  }: {
    show: boolean;
    message?: string;
    className?: string;
    children?: React.ReactNode;
  }): React.JSX.Element;
}


// input/components/icon-container.tsx
declare namespace ns_5 {
  /// <reference types="react" />
  export function IconContainer(): JSX.Element;
}


// input/components/icon.tsx
declare namespace ns_6 {
  /// <reference types="react" />
  export function Icon(): JSX.Element;
}


// input/components/label.tsx
declare namespace ns_7 {
  import React = __beyond_dep_def_0;
  import ILabelProps = ns_12.ILabelProps;
  export function Label({
    required,
    position,
    children
  }?: ILabelProps): React.JSX.Element;
}


// input/components/password.tsx
declare namespace ns_8 {
  /// <reference types="react" />
  export function Password(): JSX.Element;
}


// input/context.ts
declare namespace ns_9 {
  import React = __beyond_dep_ns_0;
  import IInputContextValue = ns_12.IInputContextValue;
  export const InputContext: React.Context<IInputContextValue>;
  export const useInputContext: () => IInputContextValue;
}


// input/control.tsx
declare namespace ns_10 {
  /// <reference types="react" />
  export function ControlSelector(): JSX.Element;
}


// input/index.tsx
declare namespace ns_11 {
  /// <reference types="react" />
  import IProps = ns_12.IProps;
  /**
   *
   * @param props
   *
   * 1. pattern property + existing error.
   * 2. Controlled Input where the implementer defines the error.
   * 3. Automated Input with multiple validations and error management.
   *
   * @returns
   */
  export function Input(props: IProps): JSX.Element;
}


// input/interfaces/index.ts
declare namespace ns_12 {
  import InputHTMLAttributes = __beyond_dep_ns_0.InputHTMLAttributes;
  import MutableRefObject = __beyond_dep_ns_0.MutableRefObject;
  import ReactNode = __beyond_dep_ns_0.ReactNode;
  export interface IProps extends InputHTMLAttributes<HTMLInputElement> {
    ref?: any;
    variant?: string;
    icon?: string;
    errorMessage?: string;
    value?: string;
    label?: any;
    children?: ReactNode;
    hasError?: boolean;
    password?: boolean;
  }
  export interface IPropsState {
    value?: string;
    errorMessage: string;
    lengthMessage: string;
    emptyMessage: string;
    _hasError?: boolean;
    type: InputHTMLAttributes<HTMLInputElement>['type'];
  }
  export interface ILabelProps {
    position?: 'right' | 'bottom' | 'bottom-right' | 'floating';
    children?: React.ReactNode;
    required?: boolean;
  }
  export interface TState {
    value?: string | number | readonly string[];
    type?: InputHTMLAttributes<HTMLInputElement>['type'];
  }
  export interface IInputContextValue {
    state?: TState;
    id?: string;
    value?: string;
    name?: string;
    props?: IProps;
    icon?: string;
    setState?: any;
    setValue?: (value: any) => void;
    input?: MutableRefObject<HTMLInputElement>;
    isDate?: boolean;
  }
  export interface IInputContainer {
    className?: string;
  }
}


// input/internal-props.ts
declare namespace ns_13 {
  /**
   * Internal props of the input component.
   * This array is used to filter the props passed to the input component.
   */
  export const internalProps: string[];
}


// model/manager.ts
declare namespace ns_14 {
  export class SelectorManager {
    #private;
    get selector(): any;
    constructor(selector: any);
    validate(): void;
    static get(selector: any): any;
  }
}


// radio.tsx
declare namespace ns_15 {
  import IPUIProps = __beyond_dep_ns_1.IPUIProps;
  import InputHTMLAttributes = __beyond_dep_ns_0.InputHTMLAttributes;
  interface IPropsRadio extends InputHTMLAttributes<HTMLInputElement> {
    label?: string;
  }
  type CombinedProps = IPropsRadio & IPUIProps<HTMLInputElement>;
  export function Radio(props: CombinedProps): JSX.Element;
  export {};
}


// select/index.tsx
declare namespace ns_16 {
  import React = __beyond_dep_def_0;
  export function Select(props: any): React.JSX.Element;
}


// select/option.tsx
declare namespace ns_17 {
  import React = __beyond_dep_def_0;
  export function OptionSelect(props: any): React.JSX.Element;
}


// switch.tsx
declare namespace ns_18 {
  /// <reference types="react" />
  import IFormCheckableProps = ns_23.IFormCheckableProps;
  export function Switch(props: IFormCheckableProps): JSX.Element;
}


// textarea/counter.tsx
declare namespace ns_19 {
  import React = __beyond_dep_def_0;
  export function TextareaCounter({
    counter,
    length,
    maxlength
  }: {
    counter: any;
    length: any;
    maxlength: any;
  }): React.JSX.Element;
}


// textarea/error.tsx
declare namespace ns_20 {
  import React = __beyond_dep_def_0;
  export function TextareaError({
    state,
    hasError,
    errorMessage,
    value
  }: {
    state: any;
    hasError: any;
    errorMessage: any;
    value: any;
  }): React.JSX.Element;
}


// textarea/index.tsx
declare namespace ns_21 {
  /// <reference types="react" />
  import IProps = ns_22.IProps;
  export function Textarea(props: IProps): JSX.Element;
}


// textarea/types.ts
declare namespace ns_22 {
  import TextareaHTMLAttributes = __beyond_dep_ns_0.TextareaHTMLAttributes;
  import ReactNode = __beyond_dep_ns_0.ReactNode;
  export interface IProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
    ref?: any;
    errorMessage?: string;
    max?: string;
    lengthMessage?: string;
    hasError?: boolean;
    label?: string;
    value?: string;
    counter?: boolean;
    children?: ReactNode;
    variant?: string;
    floating?: boolean;
  }
  export type TValue = string | number | readonly string[];
  export interface IState {
    value?: TValue;
    errorMessage: string;
    _hasError?: boolean;
  }
}


// types/index.ts
declare namespace ns_23 {
  import IPUIProps = __beyond_dep_ns_1.IPUIProps;
  export interface IFormProps extends IPUIProps<HTMLInputElement> {
    disabled?: boolean;
    label?: string;
    name?: string;
    sizing?: 'small' | 'medium' | 'large';
  }
  export interface IFormCheckableProps extends IFormProps {
    checked?: boolean;
  }
}


export import CheckboxGroup = ns_0.CheckboxGroup;
export import Checkbox = ns_1.Checkbox;
export import Form = ns_2.Form;
export import Error = ns_4.Error;
export import Label = ns_7.Label;
export import Input = ns_11.Input;
export import Radio = ns_15.Radio;
export import Select = ns_16.Select;
export import OptionSelect = ns_17.OptionSelect;
export import Switch = ns_18.Switch;
export import Textarea = ns_21.Textarea;

export declare const hmr: {on: (event: string, listener: any) => void, off: (event: string, listener: any) => void };