@codeplex-sac/ui 0.0.6 → 0.0.8

package/lib/alerta/alerta.d.ts

@@ -1,7 +1,7 @@
 import { default as React } from 'react';
 import { AlertProps } from '@mui/material/Alert';
-export type CodeplexAlertaVariante = 'info' | 'success' | 'warning' | 'danger';
-export type CodeplexAlertaDiseno = 'standard' | 'filled' | 'outlined';
+export type CodeplexAlertaVariante = 'info' | 'exito' | 'advertencia' | 'peligro';
+export type CodeplexAlertaDiseno = 'estandar' | 'lleno' | 'contorno' | 'suave';
 export interface CodeplexAlertaProps extends Omit<AlertProps, 'variant' | 'severity' | 'onClose'> {
     variante?: CodeplexAlertaVariante;
     diseno?: CodeplexAlertaDiseno;
@@ -10,8 +10,12 @@ export interface CodeplexAlertaProps extends Omit<AlertProps, 'variant' | 'sever
     cerrable?: boolean;
     abierto?: boolean;
     alCerrar?: () => void;
+    tiempoAutoCierre?: number;
     accion?: React.ReactNode;
-    color?: AlertProps['color'];
+    icono?: React.ReactNode;
+    className?: string;
+    sx?: any;
+    children?: React.ReactNode;
 }
-export declare const CodeplexAlerta: ({ variante, diseno, titulo, descripcion, cerrable, abierto, alCerrar, accion, className, children, sx, icon, ...props }: CodeplexAlertaProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexAlert: ({ variante, diseno, titulo, descripcion, cerrable, abierto, alCerrar, accion, className, children, sx, icon, ...props }: CodeplexAlertaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexAlerta: ({ variante, diseno, titulo, descripcion, cerrable, abierto, alCerrar, tiempoAutoCierre, accion, icono, className, children, sx, ...props }: CodeplexAlertaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexAlert: ({ variante, diseno, titulo, descripcion, cerrable, abierto, alCerrar, tiempoAutoCierre, accion, icono, className, children, sx, ...props }: CodeplexAlertaProps) => import("react/jsx-runtime").JSX.Element;

package/lib/autocompletado/autocompletado.d.ts

@@ -1,15 +1,23 @@
 import { default as React } from 'react';
 import { AutocompleteProps, AutocompleteRenderInputParams } from '@mui/material/Autocomplete';
 import { TextFieldProps } from '@mui/material/TextField';
-export interface CodeplexAutocompletadoProps<T, Multiple extends boolean | undefined = undefined, DisableClearable extends boolean | undefined = undefined, FreeSolo extends boolean | undefined = undefined> extends Omit<AutocompleteProps<T, Multiple, DisableClearable, FreeSolo>, 'renderInput' | 'options'> {
+export interface CodeplexAutocompletadoProps<T, Multiple extends boolean | undefined = undefined, DisableClearable extends boolean | undefined = undefined, FreeSolo extends boolean | undefined = undefined> extends Omit<AutocompleteProps<T, Multiple, DisableClearable, FreeSolo>, 'renderInput' | 'options' | 'value' | 'onChange' | 'loading' | 'disabled' | 'readOnly'> {
+    opciones: ReadonlyArray<T>;
+    valor?: any;
+    alCambiar?: (event: React.SyntheticEvent, value: any, reason: string, details?: any) => void;
     etiqueta?: string;
     textoAyuda?: string;
-    requerido?: boolean;
-    propsEntrada?: TextFieldProps;
-    renderizarEntrada?: (params: AutocompleteRenderInputParams) => React.ReactNode;
-    opciones?: ReadonlyArray<T>;
     marcador?: string;
     error?: boolean;
+    mensajeError?: string;
+    requerido?: boolean;
+    cargando?: boolean;
+    deshabilitado?: boolean;
+    soloLectura?: boolean;
+    limpiable?: boolean;
+    multiple?: Multiple;
+    renderizarEntrada?: (params: AutocompleteRenderInputParams) => React.ReactNode;
+    propsEntrada?: TextFieldProps;
 }
-export declare function CodeplexAutocompletado<T, Multiple extends boolean | undefined = undefined, DisableClearable extends boolean | undefined = undefined, FreeSolo extends boolean | undefined = undefined>({ etiqueta, textoAyuda, requerido, propsEntrada, renderizarEntrada, opciones, marcador, error, ...props }: CodeplexAutocompletadoProps<T, Multiple, DisableClearable, FreeSolo>): import("react/jsx-runtime").JSX.Element;
+export declare function CodeplexAutocompletado<T, Multiple extends boolean | undefined = undefined, DisableClearable extends boolean | undefined = undefined, FreeSolo extends boolean | undefined = undefined>({ opciones, valor, alCambiar, etiqueta, textoAyuda, marcador, error, mensajeError, requerido, cargando, deshabilitado, soloLectura, limpiable, multiple, propsEntrada, renderizarEntrada, ...props }: CodeplexAutocompletadoProps<T, Multiple, DisableClearable, FreeSolo>): import("react/jsx-runtime").JSX.Element;
 export declare const CodeplexAutocomplete: typeof CodeplexAutocompletado;

package/lib/avatar-usuario/avatar-usuario.d.ts

@@ -1,11 +1,22 @@
+import { default as React } from 'react';
 import { AvatarProps } from '@mui/material/Avatar';
 import { AvatarGroupProps } from '@mui/material/AvatarGroup';
 export type CodeplexAvatarTamano = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
-export interface CodeplexAvatarUsuarioProps extends Omit<AvatarProps, 'variant'> {
+export type CodeplexAvatarVariante = 'circular' | 'redondeado' | 'cuadrado';
+export type CodeplexAvatarEstado = 'conectado' | 'desconectado' | 'ocupado' | 'ausente' | 'invisible';
+export type CodeplexAvatarColorInsignia = 'primario' | 'secundario' | 'error' | 'info' | 'advertencia' | 'exito';
+export interface CodeplexAvatarUsuarioProps extends Omit<AvatarProps, 'variant' | 'src' | 'alt' | 'children'> {
     tamano?: CodeplexAvatarTamano | number;
-    variante?: AvatarProps['variant'];
+    variante?: CodeplexAvatarVariante;
+    estado?: CodeplexAvatarEstado;
+    imagen?: string;
+    texto?: string;
+    cargando?: boolean;
+    insignia?: React.ReactNode;
+    colorInsignia?: CodeplexAvatarColorInsignia;
+    children?: React.ReactNode;
 }
-export declare const CodeplexAvatarUsuario: ({ tamano, variante, sx, children, ...props }: CodeplexAvatarUsuarioProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexAvatarUsuario: ({ tamano, variante, estado, imagen, texto, cargando, insignia, colorInsignia, sx, children, ...props }: CodeplexAvatarUsuarioProps) => import("react/jsx-runtime").JSX.Element;
 export interface CodeplexGrupoAvataresProps extends Omit<AvatarGroupProps, 'max'> {
     maximo?: number;
     total?: number;
@@ -24,4 +35,4 @@ export declare const stringAvatar: (nombre: string) => {
     children: string;
 };
 export declare const CodeplexAvatarGroup: ({ children, spacing, maximo, ...props }: CodeplexGrupoAvataresProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexAvatar: ({ tamano, variante, sx, children, ...props }: CodeplexAvatarUsuarioProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexAvatar: ({ tamano, variante, estado, imagen, texto, cargando, insignia, colorInsignia, sx, children, ...props }: CodeplexAvatarUsuarioProps) => import("react/jsx-runtime").JSX.Element;

package/lib/boton/boton.d.ts

@@ -1,19 +1,29 @@
 import { default as React } from 'react';
 import { ButtonProps } from '@mui/material/Button';
-export type CodeplexBotonVariante = 'primary' | 'secondary' | 'outline' | 'ghost' | 'danger' | 'success' | 'contenido' | 'texto' | 'borde';
-export type CodeplexBotonTamano = 'xs' | 'sm' | 'md' | 'lg';
+export type CodeplexBotonVariante = 'primario' | 'secundario' | 'contorno' | 'fantasma' | 'peligro' | 'exito' | 'advertencia' | 'info' | 'oscuro' | 'claro' | 'suave' | 'enlace';
+export type CodeplexBotonTamano = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type CodeplexBotonForma = 'cuadrado' | 'circulo' | 'pildora';
+export type CodeplexBotonColor = ButtonProps['color'] | 'primario' | 'secundario' | 'exito' | 'error' | 'info' | 'advertencia' | 'oscuro' | 'claro';
+export type CodeplexBotonEstado = 'inactivo' | 'cargando' | 'exito' | 'error';
 export interface CodeplexBotonProps extends Omit<ButtonProps, 'variant' | 'size' | 'onClick' | 'color'> {
     variante?: CodeplexBotonVariante;
     tamano?: CodeplexBotonTamano;
+    forma?: CodeplexBotonForma;
+    estado?: CodeplexBotonEstado;
     cargando?: boolean;
     alHacerClick?: ButtonProps['onClick'];
-    color?: ButtonProps['color'] | 'primario' | 'secundario' | 'exito' | 'error' | 'info' | 'advertencia';
+    color?: CodeplexBotonColor;
     iconoIzquierda?: React.ReactNode;
     iconoDerecha?: React.ReactNode;
+    soloIcono?: boolean;
     texto?: React.ReactNode;
+    textoCargando?: React.ReactNode;
+    textoExito?: React.ReactNode;
+    textoError?: React.ReactNode;
     component?: React.ElementType;
     to?: string;
     href?: string;
+    target?: string;
     fullWidth?: boolean;
 }
 export declare const EntradaOcultaVisualmente: React.ComponentType<React.ComponentProps<"input">>;

package/lib/campo-numero/campo-numero.d.ts

@@ -1,11 +1,21 @@
 import { TextFieldProps } from '@mui/material/TextField';
-export interface CodeplexCampoNumeroProps extends Omit<TextFieldProps, 'onChange'> {
+export type CodeplexCampoNumeroAlineacion = 'izquierda' | 'centro' | 'derecha';
+export interface CodeplexCampoNumeroProps extends Omit<TextFieldProps, 'onChange' | 'error' | 'helperText'> {
+    etiqueta?: string;
+    textoAyuda?: string;
     minimo?: number;
     maximo?: number;
     paso?: number;
-    valor?: number;
+    valor?: number | null;
     valorPorDefecto?: number;
+    alineacion?: CodeplexCampoNumeroAlineacion;
+    mostrarControles?: boolean;
+    error?: boolean;
+    mensajeError?: string;
+    deshabilitado?: boolean;
+    soloLectura?: boolean;
+    anchoCompleto?: boolean;
     alCambiar?: (value: number | null) => void;
 }
-export declare const CodeplexCampoNumero: ({ InputProps, disabled, minimo, maximo, paso, valor, valorPorDefecto, alCambiar, ...props }: CodeplexCampoNumeroProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexNumberField: ({ InputProps, disabled, minimo, maximo, paso, valor, valorPorDefecto, alCambiar, ...props }: CodeplexCampoNumeroProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexCampoNumero: ({ etiqueta, textoAyuda, minimo, maximo, paso, valor, valorPorDefecto, alineacion, mostrarControles, error, mensajeError, deshabilitado, soloLectura, anchoCompleto, alCambiar, InputProps, ...props }: CodeplexCampoNumeroProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexNumberField: ({ etiqueta, textoAyuda, minimo, maximo, paso, valor, valorPorDefecto, alineacion, mostrarControles, error, mensajeError, deshabilitado, soloLectura, anchoCompleto, alCambiar, InputProps, ...props }: CodeplexCampoNumeroProps) => import("react/jsx-runtime").JSX.Element;

package/lib/campo-texto/campo-texto.d.ts

@@ -1,9 +1,26 @@
 import { default as React } from 'react';
 import { TextFieldProps } from '@mui/material/TextField';
-export interface CodeplexCampoTextoProps extends Omit<TextFieldProps, 'label' | 'helperText'> {
+export interface CodeplexCampoTextoProps extends Omit<TextFieldProps, 'label' | 'helperText' | 'disabled' | 'readOnly' | 'value' | 'onChange' | 'error' | 'multiline' | 'rows' | 'minRows' | 'maxRows' | 'placeholder' | 'fullWidth' | 'type' | 'onFocus' | 'onBlur'> {
     etiqueta?: React.ReactNode;
     textoAyuda?: React.ReactNode;
+    valor?: unknown;
+    alCambiar?: TextFieldProps['onChange'];
+    deshabilitado?: boolean;
+    soloLectura?: boolean;
+    error?: boolean;
+    mensajeError?: React.ReactNode;
+    multilinea?: boolean;
+    filas?: number | string;
+    filasMinimas?: number | string;
+    filasMaximas?: number | string;
+    marcador?: string;
+    anchoCompleto?: boolean;
+    tipo?: React.InputHTMLAttributes<unknown>['type'];
+    iconoInicio?: React.ReactNode;
+    iconoFin?: React.ReactNode;
+    alEnfocar?: TextFieldProps['onFocus'];
+    alDesenfocar?: TextFieldProps['onBlur'];
     contenedorProps?: any;
 }
-export declare const CodeplexCampoTexto: ({ etiqueta, textoAyuda, ...props }: CodeplexCampoTextoProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexTextField: ({ etiqueta, textoAyuda, ...props }: CodeplexCampoTextoProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexCampoTexto: ({ etiqueta, textoAyuda, valor, alCambiar, deshabilitado, soloLectura, error, mensajeError, multilinea, filas, filasMinimas, filasMaximas, marcador, anchoCompleto, tipo, iconoInicio, iconoFin, alEnfocar, alDesenfocar, InputProps, sx, ...props }: CodeplexCampoTextoProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexTextField: ({ etiqueta, textoAyuda, valor, alCambiar, deshabilitado, soloLectura, error, mensajeError, multilinea, filas, filasMinimas, filasMaximas, marcador, anchoCompleto, tipo, iconoInicio, iconoFin, alEnfocar, alDesenfocar, InputProps, sx, ...props }: CodeplexCampoTextoProps) => import("react/jsx-runtime").JSX.Element;

package/lib/cargando/cargando.d.ts

@@ -1,13 +1,13 @@
 import { CircularProgressProps } from '@mui/material/CircularProgress';
 export type CodeplexCargandoTamano = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-export type CodeplexCargandoColor = 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning' | 'white' | 'gray';
-export type CodeplexCargandoTipo = 'border' | 'dots' | 'ping';
+export type CodeplexCargandoColor = 'primario' | 'secundario' | 'error' | 'info' | 'exito' | 'advertencia' | 'blanco' | 'gris';
+export type CodeplexCargandoTipo = 'borde' | 'anillo' | 'puntos' | 'pulso' | 'segmentos' | 'lineas' | 'puntos-circulo' | 'cuadricula';
 export interface CodeplexCargandoProps extends Omit<CircularProgressProps, 'size' | 'color'> {
     tamano?: CodeplexCargandoTamano | number;
     color?: CodeplexCargandoColor;
     tipo?: CodeplexCargandoTipo;
     etiqueta?: string;
-    posicionEtiqueta?: 'right' | 'bottom';
+    posicionEtiqueta?: 'derecha' | 'abajo';
     pantallaCompleta?: boolean;
 }
 export declare const CodeplexCargando: ({ tamano, color, tipo, etiqueta, posicionEtiqueta, pantallaCompleta, className, sx, ...props }: CodeplexCargandoProps) => import("react/jsx-runtime").JSX.Element;

package/lib/casilla/casilla.d.ts

@@ -1,9 +1,22 @@
 import { default as React } from 'react';
 import { CheckboxProps } from '@mui/material/Checkbox';
 import { default as FormGroup } from '@mui/material/FormGroup';
-export interface CodeplexCasillaProps extends CheckboxProps {
-    etiqueta?: string;
-    posicionEtiqueta?: 'end' | 'start' | 'top' | 'bottom';
+export type CodeplexCasillaTamano = 'p' | 'm' | 'g';
+export type CodeplexCasillaColor = 'primario' | 'secundario' | 'exito' | 'error' | 'info' | 'advertencia';
+export type CodeplexCasillaVariante = 'estandar' | 'suave' | 'borde';
+export interface CodeplexCasillaProps extends Omit<CheckboxProps, 'size' | 'color' | 'checked'> {
+    etiqueta?: React.ReactNode;
+    posicionEtiqueta?: 'derecha' | 'izquierda' | 'arriba' | 'abajo';
+    seleccionado?: boolean;
+    indeterminado?: boolean;
+    deshabilitado?: boolean;
+    soloLectura?: boolean;
+    requerido?: boolean;
+    error?: boolean;
+    tamano?: CodeplexCasillaTamano;
+    color?: CodeplexCasillaColor;
+    variante?: CodeplexCasillaVariante;
+    alCambiar?: (evento: React.ChangeEvent<HTMLInputElement>, seleccionado: boolean) => void;
 }
 export declare const CodeplexCasilla: React.ForwardRefExoticComponent<Omit<CodeplexCasillaProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 export { FormGroup as CodeplexGrupoFormulario };

package/lib/deslizador/deslizador.d.ts

@@ -1,15 +1,23 @@
+import { default as React } from 'react';
 import { SliderProps } from '@mui/material/Slider';
-export interface CodeplexDeslizadorProps extends Omit<SliderProps, 'value' | 'min' | 'max' | 'step' | 'marks' | 'valueLabelDisplay'> {
+export type CodeplexDeslizadorColor = 'primario' | 'secundario' | 'exito' | 'error' | 'info' | 'advertencia';
+export type CodeplexDeslizadorMostrarEtiqueta = 'auto' | 'siempre' | 'nunca';
+export interface CodeplexDeslizadorProps extends Omit<SliderProps, 'value' | 'min' | 'max' | 'step' | 'marks' | 'valueLabelDisplay' | 'color'> {
     etiqueta?: string;
     textoAyuda?: string;
-    valor?: SliderProps['value'];
+    valor?: number | number[];
     minimo?: number;
     maximo?: number;
     paso?: number | null;
-    marcas?: boolean | any[];
-    mostrarEtiquetaValor?: 'auto' | 'on' | 'off';
-    alCambiar?: SliderProps['onChange'];
+    marcas?: boolean | Array<{
+        value: number;
+        label?: React.ReactNode;
+    }>;
+    mostrarEtiquetaValor?: CodeplexDeslizadorMostrarEtiqueta;
+    orientacion?: 'horizontal' | 'vertical';
+    color?: CodeplexDeslizadorColor;
+    alCambiar?: (event: Event, value: number | number[], activeThumb: number) => void;
     tamano?: SliderProps['size'];
 }
-export declare const CodeplexDeslizador: ({ etiqueta, textoAyuda, valor, minimo, maximo, paso, marcas, mostrarEtiquetaValor, alCambiar, tamano, className, sx, ...props }: CodeplexDeslizadorProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexSlider: ({ etiqueta, textoAyuda, valor, minimo, maximo, paso, marcas, mostrarEtiquetaValor, alCambiar, tamano, className, sx, ...props }: CodeplexDeslizadorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexDeslizador: ({ etiqueta, textoAyuda, valor, minimo, maximo, paso, marcas, mostrarEtiquetaValor, orientacion, color, alCambiar, tamano, className, sx, ...props }: CodeplexDeslizadorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexSlider: ({ etiqueta, textoAyuda, valor, minimo, maximo, paso, marcas, mostrarEtiquetaValor, orientacion, color, alCambiar, tamano, className, sx, ...props }: CodeplexDeslizadorProps) => import("react/jsx-runtime").JSX.Element;

package/lib/esqueleto/esqueleto.d.ts

@@ -1,9 +1,10 @@
 import { SkeletonProps } from '@mui/material/Skeleton';
-export interface CodeplexEsqueletoProps extends SkeletonProps {
-    variante?: 'text' | 'rectangular' | 'rounded' | 'circular';
+export interface CodeplexEsqueletoProps extends Omit<SkeletonProps, 'variant' | 'animation' | 'width' | 'height'> {
+    variante?: 'texto' | 'rectangular' | 'redondeado' | 'circular';
     ancho?: number | string;
     alto?: number | string;
-    animacion?: 'pulse' | 'wave' | false;
+    animacion?: 'pulso' | 'ola' | false;
+    colorBase?: string;
 }
-export declare const CodeplexEsqueleto: ({ variante, ancho, alto, animacion, ...props }: CodeplexEsqueletoProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexSkeleton: ({ variante, ancho, alto, animacion, ...props }: CodeplexEsqueletoProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexEsqueleto: ({ variante, ancho, alto, animacion, colorBase, className, ...props }: CodeplexEsqueletoProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexSkeleton: ({ variante, ancho, alto, animacion, colorBase, className, ...props }: CodeplexEsqueletoProps) => import("react/jsx-runtime").JSX.Element;

package/lib/grupo-botones/grupo-botones.d.ts

@@ -1,8 +1,14 @@
 import { ButtonGroupProps } from '@mui/material/ButtonGroup';
-export interface CodeplexGrupoBotonesProps extends Omit<ButtonGroupProps, 'variant' | 'color'> {
-    variante?: ButtonGroupProps['variant'] | 'contenido' | 'texto' | 'borde';
-    tamano?: ButtonGroupProps['size'];
-    color?: ButtonGroupProps['color'] | 'primario' | 'secundario' | 'exito' | 'error' | 'info' | 'advertencia';
+export type CodeplexGrupoBotonesVariante = 'contenido' | 'contorno' | 'texto' | 'cristal';
+export type CodeplexGrupoBotonesOrientacion = 'horizontal' | 'vertical';
+export type CodeplexGrupoBotonesTamano = 'p' | 'm' | 'g';
+export type CodeplexGrupoBotonesColor = 'primario' | 'secundario' | 'exito' | 'error' | 'info' | 'advertencia' | 'oscuro' | 'claro';
+export interface CodeplexGrupoBotonesProps extends Omit<ButtonGroupProps, 'variant' | 'color' | 'orientation' | 'size'> {
+    variante?: CodeplexGrupoBotonesVariante;
+    orientacion?: CodeplexGrupoBotonesOrientacion;
+    tamano?: CodeplexGrupoBotonesTamano;
+    color?: CodeplexGrupoBotonesColor;
+    separado?: boolean;
+    radio?: number;
 }
-export declare const CodeplexGrupoBotones: ({ children, tamano, variante, color, ...props }: CodeplexGrupoBotonesProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexButtonGroup: ({ children, tamano, variante, color, ...props }: CodeplexGrupoBotonesProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexGrupoBotones: ({ children, tamano, variante, color, orientacion, separado, radio, ...props }: CodeplexGrupoBotonesProps) => import("react/jsx-runtime").JSX.Element;

package/lib/grupo-radio/grupo-radio.d.ts

@@ -6,13 +6,21 @@ export interface CodeplexRadioProps extends RadioProps {
     posicionEtiqueta?: 'end' | 'start' | 'top' | 'bottom';
 }
 export declare const CodeplexRadio: React.ForwardRefExoticComponent<Omit<CodeplexRadioProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-export interface CodeplexGrupoRadioProps extends RadioGroupProps {
+export type CodeplexGrupoRadioOrientacion = 'horizontal' | 'vertical';
+export type CodeplexGrupoRadioColor = 'primario' | 'secundario' | 'exito' | 'error' | 'info' | 'advertencia';
+export interface CodeplexGrupoRadioProps extends Omit<RadioGroupProps, 'row' | 'onChange'> {
     etiqueta?: string;
     opciones?: Array<{
         valor: string;
         etiqueta: string;
         deshabilitado?: boolean;
     }>;
+    orientacion?: CodeplexGrupoRadioOrientacion;
+    valor?: string;
+    alCambiar?: (event: React.ChangeEvent<HTMLInputElement>, value: string) => void;
+    color?: CodeplexGrupoRadioColor;
+    error?: boolean;
+    mensajeError?: string;
 }
-export declare const CodeplexGrupoRadio: ({ etiqueta, opciones, children, ...props }: CodeplexGrupoRadioProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexRadioGroup: ({ etiqueta, opciones, children, ...props }: CodeplexGrupoRadioProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexGrupoRadio: ({ etiqueta, opciones, orientacion, valor, alCambiar, color, error, mensajeError, children, ...props }: CodeplexGrupoRadioProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexRadioGroup: ({ etiqueta, opciones, orientacion, valor, alCambiar, color, error, mensajeError, children, ...props }: CodeplexGrupoRadioProps) => import("react/jsx-runtime").JSX.Element;

package/lib/insignia/insignia.d.ts

@@ -1,13 +1,22 @@
 import { default as React } from 'react';
 import { BadgeProps } from '@mui/material/Badge';
-export interface CodeplexInsigniaProps extends Omit<BadgeProps, 'variant' | 'overlap'> {
+export type CodeplexInsigniaColor = 'primario' | 'secundario' | 'error' | 'info' | 'advertencia' | 'exito';
+export type CodeplexInsigniaVariante = 'estandar' | 'punto';
+export type CodeplexInsigniaSuperposicion = 'rectangular' | 'circular';
+export type CodeplexInsigniaPosicionVertical = 'arriba' | 'abajo';
+export type CodeplexInsigniaPosicionHorizontal = 'derecha' | 'izquierda';
+export interface CodeplexInsigniaProps extends Omit<BadgeProps, 'variant' | 'overlap' | 'color' | 'anchorOrigin' | 'badgeContent' | 'max' | 'showZero' | 'invisible'> {
     contenido?: React.ReactNode;
-    variante?: 'standard' | 'dot';
+    color?: CodeplexInsigniaColor;
+    variante?: CodeplexInsigniaVariante;
+    superposicion?: CodeplexInsigniaSuperposicion;
     maximo?: number;
     mostrarCero?: boolean;
-    superposicion?: 'rectangular' | 'circular';
-    color?: BadgeProps['color'];
     invisible?: boolean;
+    posicionVertical?: CodeplexInsigniaPosicionVertical;
+    posicionHorizontal?: CodeplexInsigniaPosicionHorizontal;
+    animado?: boolean;
+    borde?: boolean;
 }
-export declare const CodeplexInsignia: ({ children, color, contenido, variante, maximo, mostrarCero, superposicion, ...props }: CodeplexInsigniaProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexBadge: ({ children, color, contenido, variante, maximo, mostrarCero, superposicion, ...props }: CodeplexInsigniaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexInsignia: ({ children, color, contenido, variante, maximo, mostrarCero, superposicion, invisible, posicionVertical, posicionHorizontal, animado, borde, ...props }: CodeplexInsigniaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexBadge: ({ children, color, contenido, variante, maximo, mostrarCero, superposicion, invisible, posicionVertical, posicionHorizontal, animado, borde, ...props }: CodeplexInsigniaProps) => import("react/jsx-runtime").JSX.Element;

package/lib/interruptor/interruptor.d.ts

@@ -1,8 +1,19 @@
+import { default as React } from 'react';
 import { SwitchProps } from '@mui/material/Switch';
-export interface CodeplexInterruptorProps extends Omit<SwitchProps, 'size'> {
-    etiqueta?: string;
-    posicionEtiqueta?: 'end' | 'start' | 'top' | 'bottom';
-    tamano?: 'small' | 'medium';
+export type CodeplexInterruptorColor = 'primario' | 'secundario' | 'exito' | 'error' | 'advertencia' | 'info';
+export type CodeplexInterruptorTamano = 'pequeno' | 'mediano';
+export type CodeplexInterruptorPosicionEtiqueta = 'inicio' | 'fin' | 'arriba' | 'abajo';
+export interface CodeplexInterruptorProps extends Omit<SwitchProps, 'size' | 'color' | 'checked' | 'defaultChecked' | 'onChange' | 'disabled'> {
+    etiqueta?: React.ReactNode;
+    posicionEtiqueta?: CodeplexInterruptorPosicionEtiqueta;
+    tamano?: CodeplexInterruptorTamano;
+    seleccionado?: boolean;
+    porDefectoSeleccionado?: boolean;
+    alCambiar?: (event: React.ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+    color?: CodeplexInterruptorColor;
+    deshabilitado?: boolean;
+    error?: boolean;
+    mensajeError?: string;
 }
-export declare const CodeplexInterruptor: ({ etiqueta, posicionEtiqueta, tamano, sx, ...props }: CodeplexInterruptorProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexSwitch: ({ etiqueta, posicionEtiqueta, tamano, sx, ...props }: CodeplexInterruptorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexInterruptor: ({ etiqueta, posicionEtiqueta, tamano, seleccionado, porDefectoSeleccionado, alCambiar, color, deshabilitado, error, mensajeError, sx, className, ...props }: CodeplexInterruptorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexSwitch: ({ etiqueta, posicionEtiqueta, tamano, seleccionado, porDefectoSeleccionado, alCambiar, color, deshabilitado, error, mensajeError, sx, className, ...props }: CodeplexInterruptorProps) => import("react/jsx-runtime").JSX.Element;

package/lib/lista-transferencia/lista-transferencia.d.ts

@@ -10,6 +10,8 @@ export interface CodeplexListaTransferenciaProps {
     tituloIzquierda?: string;
     tituloDerecha?: string;
     alto?: number | string;
+    buscable?: boolean;
+    deshabilitado?: boolean;
 }
-export declare const CodeplexListaTransferencia: ({ izquierda, derecha, alCambiar, tituloIzquierda, tituloDerecha, alto }: CodeplexListaTransferenciaProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexTransferList: ({ izquierda, derecha, alCambiar, tituloIzquierda, tituloDerecha, alto }: CodeplexListaTransferenciaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexListaTransferencia: ({ izquierda, derecha, alCambiar, tituloIzquierda, tituloDerecha, alto, buscable, deshabilitado }: CodeplexListaTransferenciaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexTransferList: ({ izquierda, derecha, alCambiar, tituloIzquierda, tituloDerecha, alto, buscable, deshabilitado }: CodeplexListaTransferenciaProps) => import("react/jsx-runtime").JSX.Element;

package/lib/mensaje-emergente/mensaje-emergente.d.ts

@@ -1,15 +1,16 @@
 import { default as React } from 'react';
+import { TooltipProps } from '@mui/material/Tooltip';
 export type CodeplexTooltipLado = 'arriba' | 'abajo' | 'izquierda' | 'derecha';
-export type CodeplexTooltipSide = 'top' | 'bottom' | 'left' | 'right';
-export interface CodeplexMensajeEmergenteProps {
-    contenido?: React.ReactNode;
+export type CodeplexTooltipColor = 'oscuro' | 'claro' | 'primario' | 'azul';
+export type CodeplexTooltipAnimacion = 'zoom' | 'fade';
+export interface CodeplexMensajeEmergenteProps extends Omit<TooltipProps, 'title' | 'placement' | 'arrow' | 'children'> {
+    contenido: React.ReactNode;
+    children: React.ReactElement;
     lado?: CodeplexTooltipLado;
-    retrasoMs?: number;
     flecha?: boolean;
-    deshabilitado?: boolean;
-    alCambiarEstado?: (abierto: boolean) => void;
-    className?: string;
-    children: React.ReactNode;
+    color?: CodeplexTooltipColor;
+    animacion?: CodeplexTooltipAnimacion;
+    retraso?: number;
 }
-export declare const CodeplexMensajeEmergente: ({ contenido, lado, retrasoMs, flecha, deshabilitado, alCambiarEstado, className, children, }: CodeplexMensajeEmergenteProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexTooltip: ({ contenido, lado, retrasoMs, flecha, deshabilitado, alCambiarEstado, className, children, }: CodeplexMensajeEmergenteProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexMensajeEmergente: ({ contenido, children, lado, flecha, color, animacion, retraso, className, sx, ...props }: CodeplexMensajeEmergenteProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexTooltip: ({ contenido, children, lado, flecha, color, animacion, retraso, className, sx, ...props }: CodeplexMensajeEmergenteProps) => import("react/jsx-runtime").JSX.Element;

package/lib/notificacion/notificacion.d.ts

@@ -1,20 +1,24 @@
 import { default as React } from 'react';
 import { SnackbarProps } from '@mui/material/Snackbar';
-import { AlertProps } from '@mui/material/Alert';
-export type CodeplexNotificacionVariante = 'info' | 'success' | 'warning' | 'error';
-export type CodeplexNotificacionPosicion = 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
+export type CodeplexNotificacionVariante = 'info' | 'exito' | 'advertencia' | 'error';
+export type CodeplexNotificacionEstilo = 'solido' | 'suave' | 'cristal' | 'contorno';
+export type CodeplexNotificacionAnimacion = 'slide' | 'grow' | 'fade';
+export type CodeplexNotificacionPosicion = 'arriba-izquierda' | 'arriba-centro' | 'arriba-derecha' | 'abajo-izquierda' | 'abajo-centro' | 'abajo-derecha';
 export interface CodeplexNotificacionProps extends Omit<SnackbarProps, 'open' | 'onClose' | 'anchorOrigin'> {
-    open: boolean;
+    abierto: boolean;
+    alCerrar?: () => void;
     variante?: CodeplexNotificacionVariante;
+    estilo?: CodeplexNotificacionEstilo;
     titulo?: string;
-    subtitulo?: string;
+    mensaje: string | React.ReactNode;
     posicion?: CodeplexNotificacionPosicion;
+    animacion?: CodeplexNotificacionAnimacion;
+    duracion?: number | null;
     mostrarIcono?: boolean;
+    mostrarProgreso?: boolean;
     cerrable?: boolean;
-    duracion?: number | null;
-    onClose?: (event?: React.SyntheticEvent | Event, reason?: string) => void;
-    alertProps?: AlertProps;
+    accion?: React.ReactNode;
 }
-export declare const CodeplexNotificacion: ({ open, variante, titulo, subtitulo, posicion, mostrarIcono, cerrable, duracion, onClose, alertProps, children, ...props }: CodeplexNotificacionProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexTostada: ({ open, variante, titulo, subtitulo, posicion, mostrarIcono, cerrable, duracion, onClose, alertProps, children, ...props }: CodeplexNotificacionProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexToast: ({ open, variante, titulo, subtitulo, posicion, mostrarIcono, cerrable, duracion, onClose, alertProps, children, ...props }: CodeplexNotificacionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexNotificacion: ({ abierto, alCerrar, variante, estilo, titulo, mensaje, posicion, animacion, duracion, mostrarIcono, mostrarProgreso, cerrable, accion, className, sx, ...props }: CodeplexNotificacionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexTostada: ({ abierto, alCerrar, variante, estilo, titulo, mensaje, posicion, animacion, duracion, mostrarIcono, mostrarProgreso, cerrable, accion, className, sx, ...props }: CodeplexNotificacionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexToast: ({ abierto, alCerrar, variante, estilo, titulo, mensaje, posicion, animacion, duracion, mostrarIcono, mostrarProgreso, cerrable, accion, className, sx, ...props }: CodeplexNotificacionProps) => import("react/jsx-runtime").JSX.Element;

package/lib/progreso/progreso.d.ts

@@ -1,5 +1,5 @@
 import { LinearProgressProps } from '@mui/material/LinearProgress';
-export type CodeplexProgresoVariante = 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning';
+export type CodeplexProgresoVariante = 'primario' | 'secundario' | 'error' | 'info' | 'exito' | 'advertencia';
 export type CodeplexProgresoTamano = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export interface CodeplexProgresoProps extends Omit<LinearProgressProps, 'variant' | 'color'> {
     valor?: number;
@@ -10,9 +10,9 @@ export interface CodeplexProgresoProps extends Omit<LinearProgressProps, 'varian
     indeterminado?: boolean;
     tamano?: CodeplexProgresoTamano;
     variante?: CodeplexProgresoVariante;
-    color?: LinearProgressProps['color'];
     rayado?: boolean;
     animado?: boolean;
+    colorPersonalizado?: string;
 }
-export declare const CodeplexProgreso: ({ valor, maximo, etiqueta, mostrarPorcentaje, etiquetaInterna, indeterminado, tamano, variante, color, rayado, animado, className, sx, ...props }: CodeplexProgresoProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexProgress: ({ valor, maximo, etiqueta, mostrarPorcentaje, etiquetaInterna, indeterminado, tamano, variante, color, rayado, animado, className, sx, ...props }: CodeplexProgresoProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexProgreso: ({ valor, maximo, etiqueta, mostrarPorcentaje, etiquetaInterna, indeterminado, tamano, variante, rayado, animado, colorPersonalizado, className, sx, ...props }: CodeplexProgresoProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexProgress: ({ valor, maximo, etiqueta, mostrarPorcentaje, etiquetaInterna, indeterminado, tamano, variante, rayado, animado, colorPersonalizado, className, sx, ...props }: CodeplexProgresoProps) => import("react/jsx-runtime").JSX.Element;

package/lib/selector/selector.d.ts

@@ -14,8 +14,12 @@ export interface CodeplexSelectorProps extends Omit<SelectProps, 'renderValue'>
     renderizarValor?: (value: any) => ReactNode;
     alCambiar?: SelectProps['onChange'];
     tamano?: SelectProps['size'];
+    alCrearNuevo?: () => void;
+    textoCrearNuevo?: string;
+    mensajeError?: string;
+    buscable?: boolean;
 }
-export declare const CodeplexSelector: ({ value, onChange, size, multiple, error, disabled, required, variant, displayEmpty, etiqueta, opciones, textoAyuda, marcador, renderizarValor, alCambiar, tamano, children, sx, ...props }: CodeplexSelectorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexSelector: ({ value, onChange, size, multiple, error, disabled, required, variant, displayEmpty, etiqueta, opciones, textoAyuda, marcador, renderizarValor, alCambiar, tamano, alCrearNuevo, textoCrearNuevo, mensajeError, buscable, children, sx, ...props }: CodeplexSelectorProps) => import("react/jsx-runtime").JSX.Element;
 export { MenuItem as CodeplexElementoMenu };
 export { default as CodeplexSubcabeceraLista } from '@mui/material/ListSubheader';
-export declare const CodeplexSelect: ({ value, onChange, size, multiple, error, disabled, required, variant, displayEmpty, etiqueta, opciones, textoAyuda, marcador, renderizarValor, alCambiar, tamano, children, sx, ...props }: CodeplexSelectorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexSelect: ({ value, onChange, size, multiple, error, disabled, required, variant, displayEmpty, etiqueta, opciones, textoAyuda, marcador, renderizarValor, alCambiar, tamano, alCrearNuevo, textoCrearNuevo, mensajeError, buscable, children, sx, ...props }: CodeplexSelectorProps) => import("react/jsx-runtime").JSX.Element;

package/lib/tarjeta/tarjeta.d.ts

@@ -1,15 +1,19 @@
 import { default as React } from 'react';
 import { CardProps } from '@mui/material/Card';
-export type CodeplexTarjetaVariante = 'default' | 'outline' | 'soft';
-export type CodeplexTarjetaRelleno = 'none' | 'sm' | 'md' | 'lg';
+export type CodeplexTarjetaVariante = 'estandar' | 'contorno' | 'suave';
+export type CodeplexTarjetaRelleno = 'ninguno' | 'p' | 'm' | 'g';
 export interface CodeplexTarjetaProps extends Omit<CardProps, 'variant'> {
     variante?: CodeplexTarjetaVariante;
     relleno?: CodeplexTarjetaRelleno;
     efectoHover?: boolean;
     clicable?: boolean;
+    titulo?: React.ReactNode;
+    subtitulo?: React.ReactNode;
+    accionCabecera?: React.ReactNode;
     multimedia?: React.ReactNode;
     cabecera?: React.ReactNode;
     pie?: React.ReactNode;
+    alHacerClick?: () => void;
 }
-export declare const CodeplexTarjeta: ({ variante, relleno, efectoHover, clicable, multimedia, cabecera, pie, className, children, ...props }: CodeplexTarjetaProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexCard: ({ variante, relleno, efectoHover, clicable, multimedia, cabecera, pie, className, children, ...props }: CodeplexTarjetaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexTarjeta: ({ variante, relleno, efectoHover, clicable, titulo, subtitulo, accionCabecera, multimedia, cabecera, pie, alHacerClick, className, children, sx, ...props }: CodeplexTarjetaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexCard: ({ variante, relleno, efectoHover, clicable, titulo, subtitulo, accionCabecera, multimedia, cabecera, pie, alHacerClick, className, children, sx, ...props }: CodeplexTarjetaProps) => import("react/jsx-runtime").JSX.Element;

package/lib/valoracion/valoracion.d.ts

@@ -1,15 +1,24 @@
+import { default as React } from 'react';
 import { RatingProps } from '@mui/material/Rating';
-export type CodeplexValoracionTamano = 'small' | 'medium' | 'large';
-export type CodeplexValoracionVariante = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
-export interface CodeplexValoracionProps extends Omit<RatingProps, 'onChange'> {
-    valor?: number;
-    mostrarValor?: boolean;
-    textosAyuda?: string[];
-    variante?: CodeplexValoracionVariante;
-    alCambiar?: (value: number | null) => void;
+export type CodeplexValoracionTamano = 'p' | 'm' | 'g' | 'xg';
+export type CodeplexValoracionColor = 'primario' | 'secundario' | 'exito' | 'advertencia' | 'error' | 'info';
+export interface CodeplexValoracionProps extends Omit<RatingProps, 'onChange' | 'size' | 'max' | 'readOnly' | 'precision'> {
+    valor?: number | null;
     maximo?: number;
+    precision?: 0.5 | 1;
     soloLectura?: boolean;
+    deshabilitado?: boolean;
     tamano?: CodeplexValoracionTamano;
+    color?: CodeplexValoracionColor;
+    etiquetas?: {
+        [index: number]: string;
+    };
+    mostrarEtiqueta?: boolean;
+    animado?: boolean;
+    brillo?: boolean;
+    alCambiar?: (nuevoValor: number | null) => void;
+    iconoPersonalizado?: React.ReactNode;
+    iconoVacioPersonalizado?: React.ReactNode;
 }
-export declare const CodeplexValoracion: ({ valor, maximo, soloLectura, tamano, variante, mostrarValor, textosAyuda, alCambiar, className, ...props }: CodeplexValoracionProps) => import("react/jsx-runtime").JSX.Element;
-export declare const CodeplexRating: ({ valor, maximo, soloLectura, tamano, variante, mostrarValor, textosAyuda, alCambiar, className, ...props }: CodeplexValoracionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexValoracion: ({ valor, maximo, precision, soloLectura, deshabilitado, tamano, color, etiquetas, mostrarEtiqueta, alCambiar, iconoPersonalizado, iconoVacioPersonalizado, animado, brillo, className, sx, ...props }: CodeplexValoracionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CodeplexRating: ({ valor, maximo, precision, soloLectura, deshabilitado, tamano, color, etiquetas, mostrarEtiqueta, alCambiar, iconoPersonalizado, iconoVacioPersonalizado, animado, brillo, className, sx, ...props }: CodeplexValoracionProps) => import("react/jsx-runtime").JSX.Element;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeplex-sac/ui",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "main": "./index.js",
   "types": "./index.d.ts",
   "exports": {