publico/vue-componentes
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

migrado para typescript 7

Browse source
This commit is contained in:
Luiz Silva 2026-08-04 09:44:15 -03:00
parent 1ee3b2d207
commit a9bac68e1b
47 changed files with 3386 additions and 31528 deletions
Download patch file Download diff file Expand all files Collapse all files

4674
dist/eli-vue.es.js vendored
View file

File diff suppressed because one or more lines are too long

160
dist/eli-vue.umd.js vendored
View file

File diff suppressed because one or more lines are too long

1361
dist/types/componentes/EliEntrada/EliEntradaConfirmacao.vue.d.ts vendored
View file

File diff suppressed because it is too large Load diff

72
dist/types/componentes/EliEntrada/EliEntradaCoordenadas.vue.d.ts vendored
View file

@ -1,72 +0,0 @@
import "leaflet/dist/leaflet.css";
import { type PropType } from "vue";
import "./EliEntradaCoordenadas.css";
import type { PadroesEntradas } from "./tiposEntradas";
type EntradaCoordenadas = PadroesEntradas["coordenadas"];
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
value: {
type: PropType<EntradaCoordenadas["value"]>;
default: null;
};
opcoes: {
type: PropType<EntradaCoordenadas["opcoes"]>;
required: true;
};
}>, {
alturaEfetiva: import("vue").ComputedRef<number>;
geolocalizando: import("vue").Ref<boolean, boolean>;
possuiValor: import("vue").ComputedRef<boolean>;
latDisplay: import("vue").ComputedRef<string>;
lngDisplay: import("vue").ComputedRef<string>;
onLatChange: (v: string | number) => void;
onLngChange: (v: string | number) => void;
usarMinhaLocalizacao: () => Promise<void>;
limpar: () => void;
attrs: import("vue").Attrs;
mapaRef: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"update:value": (_v: EntradaCoordenadas["value"]) => true;
input: (_v: EntradaCoordenadas["value"]) => true;
change: (_v: EntradaCoordenadas["value"]) => true;
focus: () => true;
blur: () => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
value: {
type: PropType<EntradaCoordenadas["value"]>;
default: null;
};
opcoes: {
type: PropType<EntradaCoordenadas["opcoes"]>;
required: true;
};
}>> & Readonly<{
onInput?: ((_v: {
formato: "decimal";
datum: "EPSG:4326";
latitude: number;
longitude: number;
} | null | undefined) => any) | undefined;
onBlur?: (() => any) | undefined;
"onUpdate:value"?: ((_v: {
formato: "decimal";
datum: "EPSG:4326";
latitude: number;
longitude: number;
} | null | undefined) => any) | undefined;
onChange?: ((_v: {
formato: "decimal";
datum: "EPSG:4326";
latitude: number;
longitude: number;
} | null | undefined) => any) | undefined;
onFocus?: (() => any) | undefined;
}>, {
value: {
formato: "decimal";
datum: "EPSG:4326";
latitude: number;
longitude: number;
} | null | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

144
dist/types/componentes/EliEntrada/EliEntradaDataHora/Calendario.vue.d.ts vendored
View file

@ -1,144 +0,0 @@
import type dayjs from "dayjs";
import { type PropType } from "vue";
import type { CelulaCalendario } from "./useDataHora";
import "./Calendario.css";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
uid: {
type: NumberConstructor;
required: true;
};
aberto: {
type: BooleanConstructor;
required: true;
};
estiloPopover: {
type: PropType<Record<string, string>>;
required: true;
};
rotulo: {
type: StringConstructor;
required: true;
};
modo: {
type: PropType<"data" | "dataHora">;
required: true;
};
nomeMesAtual: {
type: StringConstructor;
required: true;
};
anoAtual: {
type: NumberConstructor;
required: true;
};
mesAtual: {
type: NumberConstructor;
required: true;
};
listaAnos: {
type: PropType<number[]>;
required: true;
};
celulas: {
type: PropType<CelulaCalendario[]>;
required: true;
};
diaSelecionado: {
type: PropType<dayjs.Dayjs | null>;
default: null;
};
horaTemp: {
type: StringConstructor;
required: true;
};
minutoTemp: {
type: StringConstructor;
required: true;
};
}>, {
diasSemana: string[];
MESES: string[];
onMesSelectChange: (e: Event) => void;
onAnoSelectChange: (e: Event) => void;
onHoraInput: (e: Event) => void;
onHoraBlur: () => void;
onHoraKeydown: (e: KeyboardEvent) => void;
onMinutoInput: (e: Event) => void;
onMinutoBlur: () => void;
onMinutoKeydown: (e: KeyboardEvent) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
fechar: () => true;
confirmar: () => true;
navegarMes: (_delta: number) => true;
selecionarDia: (_cell: CelulaCalendario) => true;
mudarMes: (_mes: number) => true;
mudarAno: (_ano: number) => true;
"update:horaTemp": (_v: string) => true;
"update:minutoTemp": (_v: string) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
uid: {
type: NumberConstructor;
required: true;
};
aberto: {
type: BooleanConstructor;
required: true;
};
estiloPopover: {
type: PropType<Record<string, string>>;
required: true;
};
rotulo: {
type: StringConstructor;
required: true;
};
modo: {
type: PropType<"data" | "dataHora">;
required: true;
};
nomeMesAtual: {
type: StringConstructor;
required: true;
};
anoAtual: {
type: NumberConstructor;
required: true;
};
mesAtual: {
type: NumberConstructor;
required: true;
};
listaAnos: {
type: PropType<number[]>;
required: true;
};
celulas: {
type: PropType<CelulaCalendario[]>;
required: true;
};
diaSelecionado: {
type: PropType<dayjs.Dayjs | null>;
default: null;
};
horaTemp: {
type: StringConstructor;
required: true;
};
minutoTemp: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{
onFechar?: (() => any) | undefined;
onConfirmar?: (() => any) | undefined;
onNavegarMes?: ((_delta: number) => any) | undefined;
onSelecionarDia?: ((_cell: CelulaCalendario) => any) | undefined;
onMudarMes?: ((_mes: number) => any) | undefined;
onMudarAno?: ((_ano: number) => any) | undefined;
"onUpdate:horaTemp"?: ((_v: string) => any) | undefined;
"onUpdate:minutoTemp"?: ((_v: string) => any) | undefined;
}>, {
diaSelecionado: dayjs.Dayjs | null;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

700
dist/types/componentes/EliEntrada/EliEntradaDataHora/index.vue.d.ts vendored
View file

@ -1,700 +0,0 @@
import { type PropType } from "vue";
import type { CampoDensidade, CampoVariante } from "../../../tipos";
import "./EliEntradaDataHora.css";
import type { EntradaDataHora } from "./useDataHora";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
value: {
type: PropType<EntradaDataHora["value"]>;
default: undefined;
};
opcoes: {
type: PropType<EntradaDataHora["opcoes"]>;
required: false;
default: undefined;
};
modelValue: {
type: PropType<string | null>;
default: null;
};
modo: {
type: PropType<"data" | "dataHora">;
default: undefined;
};
rotulo: {
type: StringConstructor;
default: undefined;
};
placeholder: {
type: StringConstructor;
default: undefined;
};
desabilitado: {
type: BooleanConstructor;
default: undefined;
};
limpavel: {
type: BooleanConstructor;
default: undefined;
};
erro: {
type: BooleanConstructor;
default: undefined;
};
mensagensErro: {
type: PropType<string | string[]>;
default: undefined;
};
dica: {
type: StringConstructor;
default: undefined;
};
dicaPersistente: {
type: BooleanConstructor;
default: undefined;
};
densidade: {
type: PropType<CampoDensidade>;
default: undefined;
};
variante: {
type: PropType<CampoVariante>;
default: undefined;
};
min: {
type: PropType<string | undefined>;
default: undefined;
};
max: {
type: PropType<string | undefined>;
default: undefined;
};
}>, {
uid: number;
aberto: import("vue").Ref<boolean, boolean>;
estiloPopover: import("vue").Ref<Record<string, string>, Record<string, string>>;
referencia: import("vue").Ref<{
clone: () => import("dayjs").Dayjs;
isValid: () => boolean;
year: {
(): number;
(value: number): import("dayjs").Dayjs;
};
month: {
(): number;
(value: number): import("dayjs").Dayjs;
};
date: {
(): number;
(value: number): import("dayjs").Dayjs;
};
day: {
(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
(value: number): import("dayjs").Dayjs;
};
hour: {
(): number;
(value: number): import("dayjs").Dayjs;
};
minute: {
(): number;
(value: number): import("dayjs").Dayjs;
};
second: {
(): number;
(value: number): import("dayjs").Dayjs;
};
millisecond: {
(): number;
(value: number): import("dayjs").Dayjs;
};
set: (unit: import("dayjs").UnitType, value: number) => import("dayjs").Dayjs;
get: (unit: import("dayjs").UnitType) => number;
add: {
(value: number, unit?: import("dayjs").ManipulateType): import("dayjs").Dayjs;
(duration: plugin.Duration): import("dayjs").Dayjs;
};
subtract: {
(value: number, unit?: import("dayjs").ManipulateType): import("dayjs").Dayjs;
(duration: plugin.Duration): import("dayjs").Dayjs;
};
startOf: (unit: import("dayjs").OpUnitType) => import("dayjs").Dayjs;
endOf: (unit: import("dayjs").OpUnitType) => import("dayjs").Dayjs;
format: (template?: string) => string;
diff: (date?: import("dayjs").ConfigType, unit?: import("dayjs").QUnitType | import("dayjs").OpUnitType, float?: boolean) => number;
valueOf: () => number;
unix: () => number;
daysInMonth: () => number;
toDate: () => Date;
toJSON: () => string;
toISOString: () => string;
toString: () => string;
utcOffset: {
(): number;
(offset: number | string, keepLocalTime?: boolean): import("dayjs").Dayjs;
};
isBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSame: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
locale: {
(): string;
(preset: string | ILocale, object?: Partial<ILocale>): import("dayjs").Dayjs;
};
isSameOrAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSameOrBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
fromNow: (withoutSuffix?: boolean) => string;
from: (compared: import("dayjs").ConfigType, withoutSuffix?: boolean) => string;
toNow: (withoutSuffix?: boolean) => string;
to: (compared: import("dayjs").ConfigType, withoutSuffix?: boolean) => string;
tz: (timezone?: string, keepLocalTime?: boolean) => import("dayjs").Dayjs;
offsetName: (type?: "short" | "long") => string | undefined;
utc: (keepLocalTime?: boolean) => import("dayjs").Dayjs;
local: () => import("dayjs").Dayjs;
isUTC: () => boolean;
week: {
(): number;
(value: number): import("dayjs").Dayjs;
};
}, import("dayjs").Dayjs | {
clone: () => import("dayjs").Dayjs;
isValid: () => boolean;
year: {
(): number;
(value: number): import("dayjs").Dayjs;
};
month: {
(): number;
(value: number): import("dayjs").Dayjs;
};
date: {
(): number;
(value: number): import("dayjs").Dayjs;
};
day: {
(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
(value: number): import("dayjs").Dayjs;
};
hour: {
(): number;
(value: number): import("dayjs").Dayjs;
};
minute: {
(): number;
(value: number): import("dayjs").Dayjs;
};
second: {
(): number;
(value: number): import("dayjs").Dayjs;
};
millisecond: {
(): number;
(value: number): import("dayjs").Dayjs;
};
set: (unit: import("dayjs").UnitType, value: number) => import("dayjs").Dayjs;
get: (unit: import("dayjs").UnitType) => number;
add: {
(value: number, unit?: import("dayjs").ManipulateType): import("dayjs").Dayjs;
(duration: plugin.Duration): import("dayjs").Dayjs;
};
subtract: {
(value: number, unit?: import("dayjs").ManipulateType): import("dayjs").Dayjs;
(duration: plugin.Duration): import("dayjs").Dayjs;
};
startOf: (unit: import("dayjs").OpUnitType) => import("dayjs").Dayjs;
endOf: (unit: import("dayjs").OpUnitType) => import("dayjs").Dayjs;
format: (template?: string) => string;
diff: (date?: import("dayjs").ConfigType, unit?: import("dayjs").QUnitType | import("dayjs").OpUnitType, float?: boolean) => number;
valueOf: () => number;
unix: () => number;
daysInMonth: () => number;
toDate: () => Date;
toJSON: () => string;
toISOString: () => string;
toString: () => string;
utcOffset: {
(): number;
(offset: number | string, keepLocalTime?: boolean): import("dayjs").Dayjs;
};
isBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSame: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
locale: {
(): string;
(preset: string | ILocale, object?: Partial<ILocale>): import("dayjs").Dayjs;
};
isSameOrAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSameOrBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
fromNow: (withoutSuffix?: boolean) => string;
from: (compared: import("dayjs").ConfigType, withoutSuffix?: boolean) => string;
toNow: (withoutSuffix?: boolean) => string;
to: (compared: import("dayjs").ConfigType, withoutSuffix?: boolean) => string;
tz: (timezone?: string, keepLocalTime?: boolean) => import("dayjs").Dayjs;
offsetName: (type?: "short" | "long") => string | undefined;
utc: (keepLocalTime?: boolean) => import("dayjs").Dayjs;
local: () => import("dayjs").Dayjs;
isUTC: () => boolean;
week: {
(): number;
(value: number): import("dayjs").Dayjs;
};
}>;
diaSelecionado: import("vue").Ref<{
clone: () => import("dayjs").Dayjs;
isValid: () => boolean;
year: {
(): number;
(value: number): import("dayjs").Dayjs;
};
month: {
(): number;
(value: number): import("dayjs").Dayjs;
};
date: {
(): number;
(value: number): import("dayjs").Dayjs;
};
day: {
(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
(value: number): import("dayjs").Dayjs;
};
hour: {
(): number;
(value: number): import("dayjs").Dayjs;
};
minute: {
(): number;
(value: number): import("dayjs").Dayjs;
};
second: {
(): number;
(value: number): import("dayjs").Dayjs;
};
millisecond: {
(): number;
(value: number): import("dayjs").Dayjs;
};
set: (unit: import("dayjs").UnitType, value: number) => import("dayjs").Dayjs;
get: (unit: import("dayjs").UnitType) => number;
add: {
(value: number, unit?: import("dayjs").ManipulateType): import("dayjs").Dayjs;
(duration: plugin.Duration): import("dayjs").Dayjs;
};
subtract: {
(value: number, unit?: import("dayjs").ManipulateType): import("dayjs").Dayjs;
(duration: plugin.Duration): import("dayjs").Dayjs;
};
startOf: (unit: import("dayjs").OpUnitType) => import("dayjs").Dayjs;
endOf: (unit: import("dayjs").OpUnitType) => import("dayjs").Dayjs;
format: (template?: string) => string;
diff: (date?: import("dayjs").ConfigType, unit?: import("dayjs").QUnitType | import("dayjs").OpUnitType, float?: boolean) => number;
valueOf: () => number;
unix: () => number;
daysInMonth: () => number;
toDate: () => Date;
toJSON: () => string;
toISOString: () => string;
toString: () => string;
utcOffset: {
(): number;
(offset: number | string, keepLocalTime?: boolean): import("dayjs").Dayjs;
};
isBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSame: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
locale: {
(): string;
(preset: string | ILocale, object?: Partial<ILocale>): import("dayjs").Dayjs;
};
isSameOrAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSameOrBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
fromNow: (withoutSuffix?: boolean) => string;
from: (compared: import("dayjs").ConfigType, withoutSuffix?: boolean) => string;
toNow: (withoutSuffix?: boolean) => string;
to: (compared: import("dayjs").ConfigType, withoutSuffix?: boolean) => string;
tz: (timezone?: string, keepLocalTime?: boolean) => import("dayjs").Dayjs;
offsetName: (type?: "short" | "long") => string | undefined;
utc: (keepLocalTime?: boolean) => import("dayjs").Dayjs;
local: () => import("dayjs").Dayjs;
isUTC: () => boolean;
week: {
(): number;
(value: number): import("dayjs").Dayjs;
};
} | null, import("dayjs").Dayjs | {
clone: () => import("dayjs").Dayjs;
isValid: () => boolean;
year: {
(): number;
(value: number): import("dayjs").Dayjs;
};
month: {
(): number;
(value: number): import("dayjs").Dayjs;
};
date: {
(): number;
(value: number): import("dayjs").Dayjs;
};
day: {
(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
(value: number): import("dayjs").Dayjs;
};
hour: {
(): number;
(value: number): import("dayjs").Dayjs;
};
minute: {
(): number;
(value: number): import("dayjs").Dayjs;
};
second: {
(): number;
(value: number): import("dayjs").Dayjs;
};
millisecond: {
(): number;
(value: number): import("dayjs").Dayjs;
};
set: (unit: import("dayjs").UnitType, value: number) => import("dayjs").Dayjs;
get: (unit: import("dayjs").UnitType) => number;
add: {
(value: number, unit?: import("dayjs").ManipulateType): import("dayjs").Dayjs;
(duration: plugin.Duration): import("dayjs").Dayjs;
};
subtract: {
(value: number, unit?: import("dayjs").ManipulateType): import("dayjs").Dayjs;
(duration: plugin.Duration): import("dayjs").Dayjs;
};
startOf: (unit: import("dayjs").OpUnitType) => import("dayjs").Dayjs;
endOf: (unit: import("dayjs").OpUnitType) => import("dayjs").Dayjs;
format: (template?: string) => string;
diff: (date?: import("dayjs").ConfigType, unit?: import("dayjs").QUnitType | import("dayjs").OpUnitType, float?: boolean) => number;
valueOf: () => number;
unix: () => number;
daysInMonth: () => number;
toDate: () => Date;
toJSON: () => string;
toISOString: () => string;
toString: () => string;
utcOffset: {
(): number;
(offset: number | string, keepLocalTime?: boolean): import("dayjs").Dayjs;
};
isBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSame: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
locale: {
(): string;
(preset: string | ILocale, object?: Partial<ILocale>): import("dayjs").Dayjs;
};
isSameOrAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSameOrBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
fromNow: (withoutSuffix?: boolean) => string;
from: (compared: import("dayjs").ConfigType, withoutSuffix?: boolean) => string;
toNow: (withoutSuffix?: boolean) => string;
to: (compared: import("dayjs").ConfigType, withoutSuffix?: boolean) => string;
tz: (timezone?: string, keepLocalTime?: boolean) => import("dayjs").Dayjs;
offsetName: (type?: "short" | "long") => string | undefined;
utc: (keepLocalTime?: boolean) => import("dayjs").Dayjs;
local: () => import("dayjs").Dayjs;
isUTC: () => boolean;
week: {
(): number;
(value: number): import("dayjs").Dayjs;
};
} | null>;
horaTemp: import("vue").Ref<string, string>;
minutoTemp: import("vue").Ref<string, string>;
opcoesEfetivas: import("vue").ComputedRef<{
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
} & {
modo?: "data" | "dataHora";
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
min?: string;
max?: string;
densidade?: import("../../../tipos").CampoDensidade;
variante?: import("../../../tipos").CampoVariante;
}>;
modoEfetivo: import("vue").ComputedRef<"data" | "dataHora">;
desabilitadoEfetivo: import("vue").ComputedRef<boolean>;
valor: import("vue").ComputedRef<string | null>;
valorFormatado: import("vue").ComputedRef<string>;
mensagensVisiveis: import("vue").ComputedRef<string[]>;
nomeMesAtual: import("vue").ComputedRef<string>;
anoAtual: import("vue").ComputedRef<number>;
mesAtual: import("vue").ComputedRef<number>;
listaAnos: import("vue").ComputedRef<number[]>;
mudarMes: (mes: number) => void;
mudarAno: (ano: number) => void;
celulas: import("vue").ComputedRef<import("./useDataHora").CelulaCalendario[]>;
abrirSeHabilitado: () => void;
fechar: () => void;
navegarMes: (delta: number) => void;
selecionarDia: (cell: import("./useDataHora").CelulaCalendario) => void;
confirmar: () => void;
limpar: () => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"update:value": (_v: string | null) => true;
input: (_v: string | null) => true;
change: (_v: string | null) => true;
"update:modelValue": (_v: string | null) => true;
alterar: (_v: string | null) => true;
foco: () => true;
desfoco: () => true;
focus: () => true;
blur: () => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
value: {
type: PropType<EntradaDataHora["value"]>;
default: undefined;
};
opcoes: {
type: PropType<EntradaDataHora["opcoes"]>;
required: false;
default: undefined;
};
modelValue: {
type: PropType<string | null>;
default: null;
};
modo: {
type: PropType<"data" | "dataHora">;
default: undefined;
};
rotulo: {
type: StringConstructor;
default: undefined;
};
placeholder: {
type: StringConstructor;
default: undefined;
};
desabilitado: {
type: BooleanConstructor;
default: undefined;
};
limpavel: {
type: BooleanConstructor;
default: undefined;
};
erro: {
type: BooleanConstructor;
default: undefined;
};
mensagensErro: {
type: PropType<string | string[]>;
default: undefined;
};
dica: {
type: StringConstructor;
default: undefined;
};
dicaPersistente: {
type: BooleanConstructor;
default: undefined;
};
densidade: {
type: PropType<CampoDensidade>;
default: undefined;
};
variante: {
type: PropType<CampoVariante>;
default: undefined;
};
min: {
type: PropType<string | undefined>;
default: undefined;
};
max: {
type: PropType<string | undefined>;
default: undefined;
};
}>> & Readonly<{
onInput?: ((_v: string | null) => any) | undefined;
"onUpdate:modelValue"?: ((_v: string | null) => any) | undefined;
onBlur?: (() => any) | undefined;
"onUpdate:value"?: ((_v: string | null) => any) | undefined;
onChange?: ((_v: string | null) => any) | undefined;
onFocus?: (() => any) | undefined;
onFoco?: (() => any) | undefined;
onDesfoco?: (() => any) | undefined;
onAlterar?: ((_v: string | null) => any) | undefined;
}>, {
modo: "data" | "dataHora";
limpavel: boolean;
erro: boolean;
mensagensErro: string | string[];
dica: string;
dicaPersistente: boolean;
min: string | undefined;
max: string | undefined;
densidade: CampoDensidade;
variante: CampoVariante;
desabilitado: boolean;
opcoes: {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
} & {
modo?: "data" | "dataHora";
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
min?: string;
max?: string;
densidade?: import("../../../tipos").CampoDensidade;
variante?: import("../../../tipos").CampoVariante;
};
value: string | null | undefined;
modelValue: string | null;
rotulo: string;
placeholder: string;
}, {}, {
Calendario: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
uid: {
type: NumberConstructor;
required: true;
};
aberto: {
type: BooleanConstructor;
required: true;
};
estiloPopover: {
type: PropType<Record<string, string>>;
required: true;
};
rotulo: {
type: StringConstructor;
required: true;
};
modo: {
type: PropType<"data" | "dataHora">;
required: true;
};
nomeMesAtual: {
type: StringConstructor;
required: true;
};
anoAtual: {
type: NumberConstructor;
required: true;
};
mesAtual: {
type: NumberConstructor;
required: true;
};
listaAnos: {
type: PropType<number[]>;
required: true;
};
celulas: {
type: PropType<import("./useDataHora").CelulaCalendario[]>;
required: true;
};
diaSelecionado: {
type: PropType<import("dayjs").Dayjs | null>;
default: null;
};
horaTemp: {
type: StringConstructor;
required: true;
};
minutoTemp: {
type: StringConstructor;
required: true;
};
}>, {
diasSemana: string[];
MESES: string[];
onMesSelectChange: (e: Event) => void;
onAnoSelectChange: (e: Event) => void;
onHoraInput: (e: Event) => void;
onHoraBlur: () => void;
onHoraKeydown: (e: KeyboardEvent) => void;
onMinutoInput: (e: Event) => void;
onMinutoBlur: () => void;
onMinutoKeydown: (e: KeyboardEvent) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
fechar: () => true;
confirmar: () => true;
navegarMes: (_delta: number) => true;
selecionarDia: (_cell: import("./useDataHora").CelulaCalendario) => true;
mudarMes: (_mes: number) => true;
mudarAno: (_ano: number) => true;
"update:horaTemp": (_v: string) => true;
"update:minutoTemp": (_v: string) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
uid: {
type: NumberConstructor;
required: true;
};
aberto: {
type: BooleanConstructor;
required: true;
};
estiloPopover: {
type: PropType<Record<string, string>>;
required: true;
};
rotulo: {
type: StringConstructor;
required: true;
};
modo: {
type: PropType<"data" | "dataHora">;
required: true;
};
nomeMesAtual: {
type: StringConstructor;
required: true;
};
anoAtual: {
type: NumberConstructor;
required: true;
};
mesAtual: {
type: NumberConstructor;
required: true;
};
listaAnos: {
type: PropType<number[]>;
required: true;
};
celulas: {
type: PropType<import("./useDataHora").CelulaCalendario[]>;
required: true;
};
diaSelecionado: {
type: PropType<import("dayjs").Dayjs | null>;
default: null;
};
horaTemp: {
type: StringConstructor;
required: true;
};
minutoTemp: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{
onFechar?: (() => any) | undefined;
onConfirmar?: (() => any) | undefined;
onNavegarMes?: ((_delta: number) => any) | undefined;
onSelecionarDia?: ((_cell: import("./useDataHora").CelulaCalendario) => any) | undefined;
onMudarMes?: ((_mes: number) => any) | undefined;
onMudarAno?: ((_ano: number) => any) | undefined;
"onUpdate:horaTemp"?: ((_v: string) => any) | undefined;
"onUpdate:minutoTemp"?: ((_v: string) => any) | undefined;
}>, {
diaSelecionado: import("dayjs").Dayjs | null;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

8
dist/types/componentes/EliEntrada/EliEntradaDataHora/useDataHora.d.ts vendored
View file

@ -112,7 +112,7 @@ export declare function useDataHora(props: Props, emit: EmitFn): {
toNow: (withoutSuffix?: boolean) => string; toNow: (withoutSuffix?: boolean) => string;
to: (compared: dayjs.ConfigType, withoutSuffix?: boolean) => string; to: (compared: dayjs.ConfigType, withoutSuffix?: boolean) => string;
tz: (timezone?: string, keepLocalTime?: boolean) => dayjs.Dayjs; tz: (timezone?: string, keepLocalTime?: boolean) => dayjs.Dayjs;
offsetName: (type?: "short" | "long") => string | undefined; offsetName: (type?: 'short' | 'long') => string | undefined;
utc: (keepLocalTime?: boolean) => dayjs.Dayjs; utc: (keepLocalTime?: boolean) => dayjs.Dayjs;
local: () => dayjs.Dayjs; local: () => dayjs.Dayjs;
isUTC: () => boolean; isUTC: () => boolean;
@ -194,7 +194,7 @@ export declare function useDataHora(props: Props, emit: EmitFn): {
toNow: (withoutSuffix?: boolean) => string; toNow: (withoutSuffix?: boolean) => string;
to: (compared: dayjs.ConfigType, withoutSuffix?: boolean) => string; to: (compared: dayjs.ConfigType, withoutSuffix?: boolean) => string;
tz: (timezone?: string, keepLocalTime?: boolean) => dayjs.Dayjs; tz: (timezone?: string, keepLocalTime?: boolean) => dayjs.Dayjs;
offsetName: (type?: "short" | "long") => string | undefined; offsetName: (type?: 'short' | 'long') => string | undefined;
utc: (keepLocalTime?: boolean) => dayjs.Dayjs; utc: (keepLocalTime?: boolean) => dayjs.Dayjs;
local: () => dayjs.Dayjs; local: () => dayjs.Dayjs;
isUTC: () => boolean; isUTC: () => boolean;
@ -277,7 +277,7 @@ export declare function useDataHora(props: Props, emit: EmitFn): {
toNow: (withoutSuffix?: boolean) => string; toNow: (withoutSuffix?: boolean) => string;
to: (compared: dayjs.ConfigType, withoutSuffix?: boolean) => string; to: (compared: dayjs.ConfigType, withoutSuffix?: boolean) => string;
tz: (timezone?: string, keepLocalTime?: boolean) => dayjs.Dayjs; tz: (timezone?: string, keepLocalTime?: boolean) => dayjs.Dayjs;
offsetName: (type?: "short" | "long") => string | undefined; offsetName: (type?: 'short' | 'long') => string | undefined;
utc: (keepLocalTime?: boolean) => dayjs.Dayjs; utc: (keepLocalTime?: boolean) => dayjs.Dayjs;
local: () => dayjs.Dayjs; local: () => dayjs.Dayjs;
isUTC: () => boolean; isUTC: () => boolean;
@ -359,7 +359,7 @@ export declare function useDataHora(props: Props, emit: EmitFn): {
toNow: (withoutSuffix?: boolean) => string; toNow: (withoutSuffix?: boolean) => string;
to: (compared: dayjs.ConfigType, withoutSuffix?: boolean) => string; to: (compared: dayjs.ConfigType, withoutSuffix?: boolean) => string;
tz: (timezone?: string, keepLocalTime?: boolean) => dayjs.Dayjs; tz: (timezone?: string, keepLocalTime?: boolean) => dayjs.Dayjs;
offsetName: (type?: "short" | "long") => string | undefined; offsetName: (type?: 'short' | 'long') => string | undefined;
utc: (keepLocalTime?: boolean) => dayjs.Dayjs; utc: (keepLocalTime?: boolean) => dayjs.Dayjs;
local: () => dayjs.Dayjs; local: () => dayjs.Dayjs;
isUTC: () => boolean; isUTC: () => boolean;

48
dist/types/componentes/EliEntrada/EliEntradaNumero.vue.d.ts vendored
View file

@ -1,48 +0,0 @@
import { type PropType } from "vue";
import type { PadroesEntradas } from "./tiposEntradas";
import "./EliEntradaNumero.css";
type EntradaNumero = PadroesEntradas["numero"];
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
/** Interface padrão (EliEntrada): value + opcoes. */
value: {
type: PropType<EntradaNumero["value"]>;
default: undefined;
};
opcoes: {
type: PropType<EntradaNumero["opcoes"]>;
required: true;
};
}>, {
attrs: import("vue").Attrs;
emit: ((event: "input", _v: number | null | undefined) => void) & ((event: "blur") => void) & ((event: "update:value", _v: number | null | undefined) => void) & ((event: "change", _v: number | null | undefined) => void) & ((event: "focus") => void);
displayValue: import("vue").Ref<string, string>;
isInteiro: import("vue").ComputedRef<boolean>;
onUpdateModelValue: (texto: string) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"update:value": (_v: EntradaNumero["value"]) => true;
/** Compat Vue2 (v-model padrão: value + input) */
input: (_v: EntradaNumero["value"]) => true;
change: (_v: EntradaNumero["value"]) => true;
focus: () => true;
blur: () => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
/** Interface padrão (EliEntrada): value + opcoes. */
value: {
type: PropType<EntradaNumero["value"]>;
default: undefined;
};
opcoes: {
type: PropType<EntradaNumero["opcoes"]>;
required: true;
};
}>> & Readonly<{
onInput?: ((_v: number | null | undefined) => any) | undefined;
onBlur?: (() => any) | undefined;
"onUpdate:value"?: ((_v: number | null | undefined) => any) | undefined;
onChange?: ((_v: number | null | undefined) => any) | undefined;
onFocus?: (() => any) | undefined;
}>, {
value: number | null | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

1610
dist/types/componentes/EliEntrada/EliEntradaParagrafo.vue.d.ts vendored
View file

File diff suppressed because it is too large Load diff

9998
dist/types/componentes/EliEntrada/EliEntradaSelecao.vue.d.ts vendored
View file

File diff suppressed because one or more lines are too long

9998
dist/types/componentes/EliEntrada/EliEntradaSelecaoMultipla.vue.d.ts vendored
View file

File diff suppressed because one or more lines are too long

48
dist/types/componentes/EliEntrada/EliEntradaTexto.vue.d.ts vendored
View file

@ -1,48 +0,0 @@
import { type PropType } from "vue";
import type { PadroesEntradas } from "./tiposEntradas";
type EntradaTexto = PadroesEntradas["texto"];
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
/** Interface padrão (EliEntrada): value + opcoes. */
value: {
type: PropType<EntradaTexto["value"]>;
default: undefined;
};
opcoes: {
type: PropType<EntradaTexto["opcoes"]>;
required: true;
};
}>, {
attrs: import("vue").Attrs;
emit: ((event: "input", _v: string | null | undefined) => void) & ((event: "blur") => void) & ((event: "update:value", _v: string | null | undefined) => void) & ((event: "change", _v: string | null | undefined) => void) & ((event: "focus") => void);
localValue: import("vue").WritableComputedRef<string | null | undefined, string | null | undefined>;
inputHtmlType: import("vue").ComputedRef<"text" | "email" | "url">;
inputMode: import("vue").ComputedRef<string | undefined>;
onInput: (e: Event) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"update:value": (_v: EntradaTexto["value"]) => true;
/** Compat Vue2 (v-model padrão: value + input) */
input: (_v: EntradaTexto["value"]) => true;
change: (_v: EntradaTexto["value"]) => true;
focus: () => true;
blur: () => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
/** Interface padrão (EliEntrada): value + opcoes. */
value: {
type: PropType<EntradaTexto["value"]>;
default: undefined;
};
opcoes: {
type: PropType<EntradaTexto["opcoes"]>;
required: true;
};
}>> & Readonly<{
onInput?: ((_v: string | null | undefined) => any) | undefined;
onBlur?: (() => any) | undefined;
"onUpdate:value"?: ((_v: string | null | undefined) => any) | undefined;
onChange?: ((_v: string | null | undefined) => any) | undefined;
onFocus?: (() => any) | undefined;
}>, {
value: string | null | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

1222
dist/types/componentes/EliTabela/EliTabela.vue.d.ts vendored
View file

File diff suppressed because it is too large Load diff

218
dist/types/componentes/EliTabela/EliTabelaBody.vue.d.ts vendored
View file

@ -1,218 +0,0 @@
import { type PropType } from "vue";
import type { tipoEliColuna } from "./types-eli-tabela";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
colunas: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
colunasInvisiveis: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
temColunasInvisiveis: {
type: BooleanConstructor;
required: true;
};
linhasExpandidas: {
type: PropType<Record<number, boolean>>;
required: true;
};
linhas: {
type: PropType<unknown[]>;
required: true;
};
temAcoes: {
type: BooleanConstructor;
required: true;
};
menuAberto: {
type: PropType<number | null>;
required: true;
};
possuiAcoes: {
type: PropType<(i: number) => boolean>;
required: true;
};
toggleMenu: {
type: PropType<(indice: number, evento: MouseEvent) => void>;
required: true;
};
alternarLinhaExpandida: {
type: PropType<(indice: number) => void>;
required: true;
};
mostrarSelecao: {
type: BooleanConstructor;
default: boolean;
};
isSelecionado: {
type: PropType<(linha: unknown) => boolean>;
required: true;
};
alternarSelecao: {
type: PropType<(linha: unknown) => void>;
required: true;
};
}>, {
ChevronRight: import("@lucide/vue").LucideIcon;
ChevronDown: import("@lucide/vue").LucideIcon;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
colunas: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
colunasInvisiveis: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
temColunasInvisiveis: {
type: BooleanConstructor;
required: true;
};
linhasExpandidas: {
type: PropType<Record<number, boolean>>;
required: true;
};
linhas: {
type: PropType<unknown[]>;
required: true;
};
temAcoes: {
type: BooleanConstructor;
required: true;
};
menuAberto: {
type: PropType<number | null>;
required: true;
};
possuiAcoes: {
type: PropType<(i: number) => boolean>;
required: true;
};
toggleMenu: {
type: PropType<(indice: number, evento: MouseEvent) => void>;
required: true;
};
alternarLinhaExpandida: {
type: PropType<(indice: number) => void>;
required: true;
};
mostrarSelecao: {
type: BooleanConstructor;
default: boolean;
};
isSelecionado: {
type: PropType<(linha: unknown) => boolean>;
required: true;
};
alternarSelecao: {
type: PropType<(linha: unknown) => void>;
required: true;
};
}>> & Readonly<{}>, {
mostrarSelecao: boolean;
}, {}, {
EliTabelaCelula: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
celula: {
type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
required: true;
};
}>, {
Componente: import("vue").ComputedRef<import("vue").Component>;
dadosParaComponente: import("vue").ComputedRef<{
texto: string;
acao?: () => void;
} | {
texto: string;
acao?: () => void;
} | {
numero: number;
prefixo?: string;
sufixo?: string;
acao?: () => void;
} | {
opcoes: {
rotulo: string;
cor?: string;
icone?: import("@lucide/vue").LucideIcon;
acao?: () => void;
}[];
} | {
valor: string;
formato: "data" | "data_hora" | "relativo";
acao?: () => void;
} | {
componente: import("vue").Component;
props?: () => Promise<Record<string, unknown>> | Record<string, unknown>;
}>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
celula: {
type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
EliTabelaDetalhesLinha: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
linha: {
type: PropType<unknown>;
required: true;
};
colunasInvisiveis: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
linha: {
type: PropType<unknown>;
required: true;
};
colunasInvisiveis: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
EliTabelaCelula: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
celula: {
type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
required: true;
};
}>, {
Componente: import("vue").ComputedRef<import("vue").Component>;
dadosParaComponente: import("vue").ComputedRef<{
texto: string;
acao?: () => void;
} | {
texto: string;
acao?: () => void;
} | {
numero: number;
prefixo?: string;
sufixo?: string;
acao?: () => void;
} | {
opcoes: {
rotulo: string;
cor?: string;
icone?: import("@lucide/vue").LucideIcon;
acao?: () => void;
}[];
} | {
valor: string;
formato: "data" | "data_hora" | "relativo";
acao?: () => void;
} | {
componente: import("vue").Component;
props?: () => Promise<Record<string, unknown>> | Record<string, unknown>;
}>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
celula: {
type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
MoreVertical: import("@lucide/vue").LucideIcon;
ChevronRight: import("@lucide/vue").LucideIcon;
ChevronDown: import("@lucide/vue").LucideIcon;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

138
dist/types/componentes/EliTabela/EliTabelaCabecalho.vue.d.ts vendored
View file

@ -1,138 +0,0 @@
import { type PropType } from "vue";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
exibirBusca: {
type: BooleanConstructor;
required: true;
};
exibirBotaoColunas: {
type: BooleanConstructor;
required: false;
default: boolean;
};
exibirBotaoFiltroAvancado: {
type: BooleanConstructor;
required: false;
default: boolean;
};
filtrosAtivosResumo: {
type: PropType<{
quantidade: number;
rotulos: string[];
}>;
required: false;
default: () => {
quantidade: number;
rotulos: never[];
};
};
valorBusca: {
type: StringConstructor;
required: true;
};
parametrosConsulta: {
type: PropType<any>;
required: false;
};
acoesCabecalho: {
type: PropType<Array<{
icone?: any;
cor?: string;
rotulo: string;
acao: (params?: any) => void;
}>>;
required: true;
};
}>, {
temAcoesCabecalho: import("vue").ComputedRef<boolean>;
tooltipFiltro: import("vue").ComputedRef<string>;
emitBuscar: (texto: string) => void;
emitColunas: () => void;
emitFiltroAvancado: () => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
buscar(valor: string): boolean;
colunas(): true;
filtroAvancado(): true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
exibirBusca: {
type: BooleanConstructor;
required: true;
};
exibirBotaoColunas: {
type: BooleanConstructor;
required: false;
default: boolean;
};
exibirBotaoFiltroAvancado: {
type: BooleanConstructor;
required: false;
default: boolean;
};
filtrosAtivosResumo: {
type: PropType<{
quantidade: number;
rotulos: string[];
}>;
required: false;
default: () => {
quantidade: number;
rotulos: never[];
};
};
valorBusca: {
type: StringConstructor;
required: true;
};
parametrosConsulta: {
type: PropType<any>;
required: false;
};
acoesCabecalho: {
type: PropType<Array<{
icone?: any;
cor?: string;
rotulo: string;
acao: (params?: any) => void;
}>>;
required: true;
};
}>> & Readonly<{
onColunas?: (() => any) | undefined;
onBuscar?: ((valor: string) => any) | undefined;
onFiltroAvancado?: (() => any) | undefined;
}>, {
exibirBotaoColunas: boolean;
exibirBotaoFiltroAvancado: boolean;
filtrosAtivosResumo: {
quantidade: number;
rotulos: string[];
};
}, {}, {
Columns3: import("@lucide/vue").LucideIcon;
EliTabelaCaixaDeBusca: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
modelo: {
type: StringConstructor;
required: false;
default: string;
};
}>, {
texto: import("vue").Ref<string, string>;
emitirBusca: () => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
buscar(valor: string): boolean;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
modelo: {
type: StringConstructor;
required: false;
default: string;
};
}>> & Readonly<{
onBuscar?: ((valor: string) => any) | undefined;
}>, {
modelo: string;
}, {}, {
Search: import("@lucide/vue").LucideIcon;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
Filter: import("@lucide/vue").LucideIcon;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

26
dist/types/componentes/EliTabela/EliTabelaCaixaDeBusca.vue.d.ts vendored
View file

@ -1,26 +0,0 @@
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
modelo: {
type: StringConstructor;
required: false;
default: string;
};
}>, {
texto: import("vue").Ref<string, string>;
emitirBusca: () => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
buscar(valor: string): boolean;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
modelo: {
type: StringConstructor;
required: false;
default: string;
};
}>> & Readonly<{
onBuscar?: ((valor: string) => any) | undefined;
}>, {
modelo: string;
}, {}, {
Search: import("@lucide/vue").LucideIcon;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

38
dist/types/componentes/EliTabela/EliTabelaDebug.vue.d.ts vendored
View file

@ -1,38 +0,0 @@
import { type PropType } from "vue";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
isDev: {
type: BooleanConstructor;
required: true;
};
menuAberto: {
type: PropType<number | null>;
default: null;
};
menuPopupPos: {
type: PropType<{
top: number;
left: number;
}>;
required: true;
};
}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
isDev: {
type: BooleanConstructor;
required: true;
};
menuAberto: {
type: PropType<number | null>;
default: null;
};
menuPopupPos: {
type: PropType<{
top: number;
left: number;
}>;
required: true;
};
}>> & Readonly<{}>, {
menuAberto: number | null;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

63
dist/types/componentes/EliTabela/EliTabelaDetalhesLinha.vue.d.ts vendored
View file

@ -1,63 +0,0 @@
import { type PropType } from "vue";
import type { tipoEliColuna } from "./types-eli-tabela";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
linha: {
type: PropType<unknown>;
required: true;
};
colunasInvisiveis: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
linha: {
type: PropType<unknown>;
required: true;
};
colunasInvisiveis: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {
EliTabelaCelula: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
celula: {
type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
required: true;
};
}>, {
Componente: import("vue").ComputedRef<import("vue").Component>;
dadosParaComponente: import("vue").ComputedRef<{
texto: string;
acao?: () => void;
} | {
texto: string;
acao?: () => void;
} | {
numero: number;
prefixo?: string;
sufixo?: string;
acao?: () => void;
} | {
opcoes: {
rotulo: string;
cor?: string;
icone?: import("@lucide/vue").LucideIcon;
acao?: () => void;
}[];
} | {
valor: string;
formato: "data" | "data_hora" | "relativo";
acao?: () => void;
} | {
componente: import("vue").Component;
props?: () => Promise<Record<string, unknown>> | Record<string, unknown>;
}>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
celula: {
type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

39
dist/types/componentes/EliTabela/EliTabelaEstados.vue.d.ts vendored
View file

@ -1,39 +0,0 @@
import { type PropType } from "vue";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
carregando: {
type: BooleanConstructor;
required: true;
};
erro: {
type: PropType<string | null>;
default: null;
};
mensagemVazio: {
type: PropType<string | undefined>;
required: false;
default: undefined;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
carregando: {
type: BooleanConstructor;
required: true;
};
erro: {
type: PropType<string | null>;
default: null;
};
mensagemVazio: {
type: PropType<string | undefined>;
required: false;
default: undefined;
};
}>> & Readonly<{}>, {
erro: string | null;
mensagemVazio: string | undefined;
}, {}, {
AlertCircle: import("@lucide/vue").LucideIcon;
Inbox: import("@lucide/vue").LucideIcon;
LoaderCircle: import("@lucide/vue").LucideIcon;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

90
dist/types/componentes/EliTabela/EliTabelaHead.vue.d.ts vendored
View file

@ -1,90 +0,0 @@
import { type PropType } from "vue";
import type { tipoEliColuna } from "./types-eli-tabela";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
colunas: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
temAcoes: {
type: BooleanConstructor;
required: true;
};
temColunasInvisiveis: {
type: BooleanConstructor;
required: true;
};
colunaOrdenacao: {
type: PropType<string | null>;
default: null;
};
direcaoOrdenacao: {
type: PropType<"asc" | "desc">;
required: true;
};
mostrarSelecao: {
type: BooleanConstructor;
default: boolean;
};
todosSelecionados: {
type: BooleanConstructor;
default: boolean;
};
algunsSelecionados: {
type: BooleanConstructor;
default: boolean;
};
}>, {
ArrowUp: import("@lucide/vue").LucideIcon;
ArrowDown: import("@lucide/vue").LucideIcon;
isOrdenavel: (coluna: tipoEliColuna<unknown>) => boolean;
emitAlternarOrdenacao: (chave: string) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
alternarOrdenacao(chave: string): boolean;
"alternar-selecao-todos": () => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
colunas: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
temAcoes: {
type: BooleanConstructor;
required: true;
};
temColunasInvisiveis: {
type: BooleanConstructor;
required: true;
};
colunaOrdenacao: {
type: PropType<string | null>;
default: null;
};
direcaoOrdenacao: {
type: PropType<"asc" | "desc">;
required: true;
};
mostrarSelecao: {
type: BooleanConstructor;
default: boolean;
};
todosSelecionados: {
type: BooleanConstructor;
default: boolean;
};
algunsSelecionados: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
"onAlternar-selecao-todos"?: (() => any) | undefined;
onAlternarOrdenacao?: ((chave: string) => any) | undefined;
}>, {
mostrarSelecao: boolean;
colunaOrdenacao: string | null;
todosSelecionados: boolean;
algunsSelecionados: boolean;
}, {}, {
ArrowUp: import("@lucide/vue").LucideIcon;
ArrowDown: import("@lucide/vue").LucideIcon;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

69
dist/types/componentes/EliTabela/EliTabelaMenuAcoes.vue.d.ts vendored
View file

@ -1,69 +0,0 @@
import { type PropType } from "vue";
import type { tipoEliTabelaAcao } from "./types-eli-tabela";
type ItemAcao<T> = {
acao: tipoEliTabelaAcao<T>;
indice: number;
visivel: boolean;
};
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
menuAberto: {
type: PropType<number | null>;
default: null;
};
posicao: {
type: PropType<{
top: number;
left: number;
}>;
required: true;
};
acoes: {
type: PropType<ItemAcao<any>[]>;
required: true;
};
linha: {
type: PropType<unknown>;
default: unknown;
};
}>, {
menuEl: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
possuiAcoes: import("vue").ComputedRef<boolean>;
emitExecutar: (item: {
acao: tipoEliTabelaAcao<any>;
}) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
executar(payload: {
acao: tipoEliTabelaAcao<any>;
linha: unknown;
}): boolean;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
menuAberto: {
type: PropType<number | null>;
default: null;
};
posicao: {
type: PropType<{
top: number;
left: number;
}>;
required: true;
};
acoes: {
type: PropType<ItemAcao<any>[]>;
required: true;
};
linha: {
type: PropType<unknown>;
default: unknown;
};
}>> & Readonly<{
onExecutar?: ((payload: {
acao: tipoEliTabelaAcao<any>;
linha: unknown;
}) => any) | undefined;
}>, {
linha: unknown;
menuAberto: number | null;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

64
dist/types/componentes/EliTabela/EliTabelaModalColunas.vue.d.ts vendored
View file

@ -1,64 +0,0 @@
import { type PropType } from "vue";
import "./EliTabelaModalColunas.css";
import type { EliTabelaColunasConfig } from "./colunasStorage";
import type { tipoEliColuna } from "./types-eli-tabela";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
aberto: {
type: BooleanConstructor;
required: true;
};
rotulosColunas: {
type: PropType<string[]>;
required: true;
};
configInicial: {
type: PropType<EliTabelaColunasConfig>;
required: true;
};
colunas: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
}>, {
emitFechar: () => void;
emitSalvar: () => void;
visiveisLocal: import("vue").Ref<string[], string[]>;
invisiveisLocal: import("vue").Ref<string[], string[]>;
itemSendoArrastado: import("vue").Ref<string | null, string | null>;
onDragStart: (e: DragEvent, rotulo: string) => void;
onDragEnd: () => void;
onDragOverItem: (alvoRotulo: string, destino: "visiveis" | "invisiveis") => void;
onDragOverLista: (destino: "visiveis" | "invisiveis") => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
fechar(): true;
salvar(_config: EliTabelaColunasConfig): true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
aberto: {
type: BooleanConstructor;
required: true;
};
rotulosColunas: {
type: PropType<string[]>;
required: true;
};
configInicial: {
type: PropType<EliTabelaColunasConfig>;
required: true;
};
colunas: {
type: PropType<tipoEliColuna<any>[]>;
required: true;
};
}>> & Readonly<{
onFechar?: (() => any) | undefined;
onSalvar?: ((_config: EliTabelaColunasConfig) => any) | undefined;
}>, {}, {}, {
Columns2: import("@lucide/vue").LucideIcon;
Eye: import("@lucide/vue").LucideIcon;
EyeOff: import("@lucide/vue").LucideIcon;
GripVertical: import("@lucide/vue").LucideIcon;
X: import("@lucide/vue").LucideIcon;
Check: import("@lucide/vue").LucideIcon;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

272
dist/types/componentes/EliTabela/EliTabelaModalFiltroAvancado.vue.d.ts vendored
View file

@ -1,272 +0,0 @@
import { type PropType } from "vue";
import type { FiltroBase } from "./useFiltroAvancado";
import { rotuloDoFiltro } from "./useFiltroAvancado";
import "./EliTabelaModalFiltroAvancado.css";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
aberto: {
type: BooleanConstructor;
required: true;
};
filtrosBase: {
type: PropType<FiltroBase<string>[]>;
required: true;
};
modelo: {
/** Linhas persistidas do pai — normalizadas internamente via normalizarModelo() */
type: PropType<Array<{
chave: string;
valor: unknown;
}>>;
required: true;
};
modeloFormula: {
type: StringConstructor;
default: string;
};
}>, {
linhas: import("vue").Ref<{
chave: string;
entrada: readonly ["texto", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
limiteCaracteres?: number | undefined;
formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep" | undefined;
}] | readonly ["dataHora", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
modo?: "data" | "dataHora" | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
min?: string | undefined;
max?: string | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["numero", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
sufixo?: string | undefined;
prefixo?: string | undefined;
precisao?: number | undefined;
}] | readonly ["paragrafo", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
linhas?: number | undefined;
limiteCaracteres?: number | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["selecao", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[] | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["selecaoMultipla", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[] | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["confirmacao", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
cor?: string | undefined;
desabilitado?: boolean | undefined;
rotuloAtivo?: string | undefined;
rotuloInativo?: string | undefined;
densidade?: import("../..").CampoDensidade | undefined;
}] | readonly ["coordenadas", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
zoom?: number | undefined;
alturaMapa?: number | undefined;
camadas?: {
estados?: boolean | undefined;
municipios?: boolean | undefined;
} | undefined;
}];
valor: unknown;
}[], import("./useFiltroAvancado").LinhaFiltro[] | {
chave: string;
entrada: readonly ["texto", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
limiteCaracteres?: number | undefined;
formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep" | undefined;
}] | readonly ["dataHora", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
modo?: "data" | "dataHora" | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
min?: string | undefined;
max?: string | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["numero", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
sufixo?: string | undefined;
prefixo?: string | undefined;
precisao?: number | undefined;
}] | readonly ["paragrafo", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
linhas?: number | undefined;
limiteCaracteres?: number | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["selecao", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[] | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["selecaoMultipla", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[] | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["confirmacao", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
cor?: string | undefined;
desabilitado?: boolean | undefined;
rotuloAtivo?: string | undefined;
rotuloInativo?: string | undefined;
densidade?: import("../..").CampoDensidade | undefined;
}] | readonly ["coordenadas", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
zoom?: number | undefined;
alturaMapa?: number | undefined;
camadas?: {
estados?: boolean | undefined;
municipios?: boolean | undefined;
} | undefined;
}];
valor: unknown;
}[]>;
opcoesParaAdicionar: import("vue").ComputedRef<{
chave: string;
rotulo: string;
filtro: (valor: unknown) => Pick<import("p-comuns").tipoCondicaoFiltroDeltaTipado<"small" | "length" | "concat" | "slice" | "indexOf" | "lastIndexOf" | "includes" | "toString" | "charAt" | "charCodeAt" | "localeCompare" | "match" | "replace" | "search" | "split" | "substring" | "toLowerCase" | "toLocaleLowerCase" | "toUpperCase" | "toLocaleUpperCase" | "trim" | "substr" | "codePointAt" | "endsWith" | "normalize" | "repeat" | "startsWith" | "anchor" | "big" | "blink" | "bold" | "fixed" | "fontcolor" | "fontsize" | "italics" | "link" | "strike" | "sub" | "sup" | "padStart" | "padEnd" | "trimEnd" | "trimStart" | "trimLeft" | "trimRight" | "matchAll" | "valueOf">, "valor" | "coluna" | "operador"> | undefined;
entrada: import("../EliEntrada/tiposEntradas").ComponenteEntrada;
}[]>;
chaveParaAdicionar: import("vue").Ref<string, string>;
formulaCustomizada: import("vue").Ref<string, string>;
formulaGerada: import("vue").ComputedRef<string>;
componenteEntrada: (entrada: import("../EliEntrada/tiposEntradas").ComponenteEntrada) => import("vue").Component;
opcoesEntrada: (entrada: import("../EliEntrada/tiposEntradas").ComponenteEntrada) => {
rotulo: string;
};
adicionar: () => void;
remover: (idx: number) => void;
emitFechar: () => void;
emitSalvar: () => void;
emitLimpar: () => void;
rotuloDoFiltro: typeof rotuloDoFiltro;
rotuloDoFiltroAtivo: (chave: string) => string;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
fechar: () => true;
limpar: () => true;
/** Dado serializável emitido pelo botão Aplicar */
salvar: (_linhas: Array<{
chave: string;
valor: unknown;
}>, _formula?: string) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
aberto: {
type: BooleanConstructor;
required: true;
};
filtrosBase: {
type: PropType<FiltroBase<string>[]>;
required: true;
};
modelo: {
/** Linhas persistidas do pai — normalizadas internamente via normalizarModelo() */
type: PropType<Array<{
chave: string;
valor: unknown;
}>>;
required: true;
};
modeloFormula: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onLimpar?: (() => any) | undefined;
onFechar?: (() => any) | undefined;
onSalvar?: ((_linhas: {
chave: string;
valor: unknown;
}[], _formula?: string | undefined) => any) | undefined;
}>, {
modeloFormula: string;
}, {}, {
CircleHelp: import("@lucide/vue").LucideIcon;
Filter: import("@lucide/vue").LucideIcon;
Plus: import("@lucide/vue").LucideIcon;
Trash2: import("@lucide/vue").LucideIcon;
X: import("@lucide/vue").LucideIcon;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

82
dist/types/componentes/EliTabela/EliTabelaPaginacao.vue.d.ts vendored
View file

@ -1,82 +0,0 @@
import { type PropType } from "vue";
import "./EliTabelaPaginacao.css";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
pagina: {
type: NumberConstructor;
required: true;
};
totalPaginas: {
type: NumberConstructor;
required: true;
};
maximoBotoes: {
type: NumberConstructor;
required: false;
};
acoes: {
type: PropType<Array<{
icone?: any;
cor?: string;
rotulo: string;
acao: (params?: any) => void;
}>>;
required: false;
default: () => never[];
};
parametrosConsulta: {
type: PropType<any>;
required: false;
};
}>, {
botoes: import("vue").ComputedRef<{
label: string;
pagina?: number;
ativo?: boolean;
ehEllipsis?: boolean;
}[]>;
irParaPagina: (pagina: number | undefined) => void;
anteriorDesabilitado: import("vue").ComputedRef<boolean>;
proximaDesabilitada: import("vue").ComputedRef<boolean>;
paginaAtual: import("vue").ComputedRef<number>;
totalPaginasExibidas: import("vue").ComputedRef<number>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
alterar(pagina: number): boolean;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
pagina: {
type: NumberConstructor;
required: true;
};
totalPaginas: {
type: NumberConstructor;
required: true;
};
maximoBotoes: {
type: NumberConstructor;
required: false;
};
acoes: {
type: PropType<Array<{
icone?: any;
cor?: string;
rotulo: string;
acao: (params?: any) => void;
}>>;
required: false;
default: () => never[];
};
parametrosConsulta: {
type: PropType<any>;
required: false;
};
}>> & Readonly<{
onAlterar?: ((pagina: number) => any) | undefined;
}>, {
acoes: {
icone?: any;
cor?: string;
rotulo: string;
acao: (params?: any) => void;
}[];
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

44
dist/types/componentes/EliTabela/celulas/EliTabelaCelula.vue.d.ts vendored
View file

@ -1,44 +0,0 @@
import type { Component } from "vue";
import { type PropType } from "vue";
import type { tipoComponenteCelula } from "../types-eli-tabela";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
celula: {
type: PropType<tipoComponenteCelula>;
required: true;
};
}>, {
Componente: import("vue").ComputedRef<Component>;
dadosParaComponente: import("vue").ComputedRef<{
texto: string;
acao?: () => void;
} | {
texto: string;
acao?: () => void;
} | {
numero: number;
prefixo?: string;
sufixo?: string;
acao?: () => void;
} | {
opcoes: {
rotulo: string;
cor?: string;
icone?: import("@lucide/vue").LucideIcon;
acao?: () => void;
}[];
} | {
valor: string;
formato: "data" | "data_hora" | "relativo";
acao?: () => void;
} | {
componente: Component;
props?: () => Promise<Record<string, unknown>> | Record<string, unknown>;
}>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
celula: {
type: PropType<tipoComponenteCelula>;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

15
dist/types/componentes/EliTabela/celulas/EliTabelaCelulaComponente.vue.d.ts vendored
View file

@ -1,15 +0,0 @@
import { type PropType } from "vue";
import type { tiposTabelaCelulas } from "./tiposTabelaCelulas";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["componente"]>;
};
}>, {
propsResolvidas: import("vue").Ref<Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["componente"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

18
dist/types/componentes/EliTabela/celulas/EliTabelaCelulaData.vue.d.ts vendored
View file

@ -1,18 +0,0 @@
import "dayjs/locale/pt-br";
import { type PropType } from "vue";
import type { tiposTabelaCelulas } from "./tiposTabelaCelulas";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["data"]>;
required: false;
};
}>, {
textoData: import("vue").ComputedRef<string>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["data"]>;
required: false;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

15
dist/types/componentes/EliTabela/celulas/EliTabelaCelulaNumero.vue.d.ts vendored
View file

@ -1,15 +0,0 @@
import { type PropType } from "vue";
import type { tiposTabelaCelulas } from "./tiposTabelaCelulas";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["numero"]>;
};
}>, {
textoNumero: import("vue").ComputedRef<string>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["numero"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

674
dist/types/componentes/EliTabela/celulas/EliTabelaCelulaTags.vue.d.ts vendored
View file

@ -1,674 +0,0 @@
import { type PropType } from "vue";
import type { tiposTabelaCelulas } from "./tiposTabelaCelulas";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["tags"]>;
required: false;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["tags"]>;
required: false;
};
}>> & Readonly<{}>, {}, {}, {
VChip: {
new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<{
style: string | false | import("vue").StyleValue[] | import("vue").CSSProperties | null;
density: import("vuetify/lib/composables/density.mjs").Density;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
};
modelValue: boolean;
} & {
theme?: string | undefined;
class?: any;
border?: string | number | boolean | undefined;
elevation?: string | number | undefined;
rounded?: string | number | boolean | undefined;
color?: string | undefined;
value?: any;
selectedClass?: string | undefined;
href?: string | undefined;
to?: string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric | undefined;
activeClass?: string | undefined;
appendAvatar?: string | undefined;
appendIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
baseColor?: string | undefined;
link?: boolean | undefined;
prependAvatar?: string | undefined;
prependIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
text?: string | number | boolean | undefined;
onClick?: ((args_0: MouseEvent) => void) | undefined;
onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
} & {
$children?: {
default?: ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: (() => import("vue").VNodeChild) | undefined;
prepend?: (() => import("vue").VNodeChild) | undefined;
append?: (() => import("vue").VNodeChild) | undefined;
close?: (() => import("vue").VNodeChild) | undefined;
filter?: (() => import("vue").VNodeChild) | undefined;
} | {
$stable?: boolean | undefined;
} | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | import("vue").VNodeChild;
"v-slots"?: {
default?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: false | (() => import("vue").VNodeChild) | undefined;
prepend?: false | (() => import("vue").VNodeChild) | undefined;
append?: false | (() => import("vue").VNodeChild) | undefined;
close?: false | (() => import("vue").VNodeChild) | undefined;
filter?: false | (() => import("vue").VNodeChild) | undefined;
} | undefined;
} & {
"v-slot:append"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:close"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:default"?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
"v-slot:filter"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:label"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:prepend"?: false | (() => import("vue").VNodeChild) | undefined;
} & {
onClick?: ((e: KeyboardEvent | MouseEvent) => any) | undefined;
"onClick:close"?: ((e: MouseEvent) => any) | undefined;
"onGroup:selected"?: ((val: {
value: boolean;
}) => any) | undefined;
"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
}, () => false | JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"click:close": (e: MouseEvent) => true;
"update:modelValue": (value: boolean) => true;
"group:selected": (val: {
value: boolean;
}) => true;
click: (e: KeyboardEvent | MouseEvent) => true;
}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
style: import("vue").StyleValue;
density: import("vuetify/lib/composables/density.mjs").Density;
rounded: string | number | boolean;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
link: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined;
text: string | number | boolean;
modelValue: boolean;
}, true, {}, import("vue").SlotsType<Partial<{
default: (arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
label: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
prepend: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
append: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
close: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
filter: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
}>>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, {
style: string | false | import("vue").StyleValue[] | import("vue").CSSProperties | null;
density: import("vuetify/lib/composables/density.mjs").Density;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
};
modelValue: boolean;
} & {
theme?: string | undefined;
class?: any;
border?: string | number | boolean | undefined;
elevation?: string | number | undefined;
rounded?: string | number | boolean | undefined;
color?: string | undefined;
value?: any;
selectedClass?: string | undefined;
href?: string | undefined;
to?: string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric | undefined;
activeClass?: string | undefined;
appendAvatar?: string | undefined;
appendIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
baseColor?: string | undefined;
link?: boolean | undefined;
prependAvatar?: string | undefined;
prependIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
text?: string | number | boolean | undefined;
onClick?: ((args_0: MouseEvent) => void) | undefined;
onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
} & {
$children?: {
default?: ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: (() => import("vue").VNodeChild) | undefined;
prepend?: (() => import("vue").VNodeChild) | undefined;
append?: (() => import("vue").VNodeChild) | undefined;
close?: (() => import("vue").VNodeChild) | undefined;
filter?: (() => import("vue").VNodeChild) | undefined;
} | {
$stable?: boolean | undefined;
} | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | import("vue").VNodeChild;
"v-slots"?: {
default?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: false | (() => import("vue").VNodeChild) | undefined;
prepend?: false | (() => import("vue").VNodeChild) | undefined;
append?: false | (() => import("vue").VNodeChild) | undefined;
close?: false | (() => import("vue").VNodeChild) | undefined;
filter?: false | (() => import("vue").VNodeChild) | undefined;
} | undefined;
} & {
"v-slot:append"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:close"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:default"?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
"v-slot:filter"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:label"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:prepend"?: false | (() => import("vue").VNodeChild) | undefined;
} & {
onClick?: ((e: KeyboardEvent | MouseEvent) => any) | undefined;
"onClick:close"?: ((e: MouseEvent) => any) | undefined;
"onGroup:selected"?: ((val: {
value: boolean;
}) => any) | undefined;
"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
}, () => false | JSX.Element, {}, {}, {}, {
style: import("vue").StyleValue;
density: import("vuetify/lib/composables/density.mjs").Density;
rounded: string | number | boolean;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
link: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined;
text: string | number | boolean;
modelValue: boolean;
}>;
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<{
style: string | false | import("vue").StyleValue[] | import("vue").CSSProperties | null;
density: import("vuetify/lib/composables/density.mjs").Density;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
};
modelValue: boolean;
} & {
theme?: string | undefined;
class?: any;
border?: string | number | boolean | undefined;
elevation?: string | number | undefined;
rounded?: string | number | boolean | undefined;
color?: string | undefined;
value?: any;
selectedClass?: string | undefined;
href?: string | undefined;
to?: string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric | undefined;
activeClass?: string | undefined;
appendAvatar?: string | undefined;
appendIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
baseColor?: string | undefined;
link?: boolean | undefined;
prependAvatar?: string | undefined;
prependIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
text?: string | number | boolean | undefined;
onClick?: ((args_0: MouseEvent) => void) | undefined;
onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
} & {
$children?: {
default?: ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: (() => import("vue").VNodeChild) | undefined;
prepend?: (() => import("vue").VNodeChild) | undefined;
append?: (() => import("vue").VNodeChild) | undefined;
close?: (() => import("vue").VNodeChild) | undefined;
filter?: (() => import("vue").VNodeChild) | undefined;
} | {
$stable?: boolean | undefined;
} | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | import("vue").VNodeChild;
"v-slots"?: {
default?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: false | (() => import("vue").VNodeChild) | undefined;
prepend?: false | (() => import("vue").VNodeChild) | undefined;
append?: false | (() => import("vue").VNodeChild) | undefined;
close?: false | (() => import("vue").VNodeChild) | undefined;
filter?: false | (() => import("vue").VNodeChild) | undefined;
} | undefined;
} & {
"v-slot:append"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:close"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:default"?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
"v-slot:filter"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:label"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:prepend"?: false | (() => import("vue").VNodeChild) | undefined;
} & {
onClick?: ((e: KeyboardEvent | MouseEvent) => any) | undefined;
"onClick:close"?: ((e: MouseEvent) => any) | undefined;
"onGroup:selected"?: ((val: {
value: boolean;
}) => any) | undefined;
"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
}, () => false | JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"click:close": (e: MouseEvent) => true;
"update:modelValue": (value: boolean) => true;
"group:selected": (val: {
value: boolean;
}) => true;
click: (e: KeyboardEvent | MouseEvent) => true;
}, string, {
style: import("vue").StyleValue;
density: import("vuetify/lib/composables/density.mjs").Density;
rounded: string | number | boolean;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
link: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined;
text: string | number | boolean;
modelValue: boolean;
}, {}, string, import("vue").SlotsType<Partial<{
default: (arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
label: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
prepend: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
append: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
close: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
filter: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
}>>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vuetify/lib/util/defineComponent.mjs").FilterPropsOptions<{
theme: StringConstructor;
class: PropType<any>;
style: {
type: PropType<import("vue").StyleValue>;
default: null;
};
border: (BooleanConstructor | NumberConstructor | StringConstructor)[];
density: {
type: PropType<import("vuetify/lib/composables/density.mjs").Density>;
default: string;
validator: (v: any) => boolean;
};
elevation: {
type: (NumberConstructor | StringConstructor)[];
validator(v: any): boolean;
};
rounded: {
type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
default: undefined;
};
tile: BooleanConstructor;
tag: Omit<{
type: PropType<string | import("vuetify/lib/types.mjs").JSXComponent>;
default: string;
}, "default" | "type"> & {
type: PropType<string | import("vuetify/lib/types.mjs").JSXComponent>;
default: NonNullable<string | import("vuetify/lib/types.mjs").JSXComponent>;
};
color: StringConstructor;
variant: Omit<{
type: PropType<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
default: string;
validator: (v: any) => boolean;
}, "default" | "type"> & {
type: PropType<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
default: NonNullable<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
};
value: null;
disabled: BooleanConstructor;
selectedClass: StringConstructor;
size: {
type: (NumberConstructor | StringConstructor)[];
default: string;
};
href: StringConstructor;
replace: BooleanConstructor;
to: PropType<string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric>;
exact: BooleanConstructor;
activeClass: StringConstructor;
appendAvatar: StringConstructor;
appendIcon: PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
baseColor: StringConstructor;
closable: BooleanConstructor;
closeIcon: {
type: PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
default: string;
};
closeLabel: {
type: StringConstructor;
default: string;
};
draggable: BooleanConstructor;
filter: BooleanConstructor;
filterIcon: {
type: PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
default: string;
};
label: BooleanConstructor;
link: {
type: BooleanConstructor;
default: undefined;
};
pill: BooleanConstructor;
prependAvatar: StringConstructor;
prependIcon: PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
ripple: {
type: PropType<boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined>;
default: boolean;
};
text: {
type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
default: undefined;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
onClick: PropType<(args_0: MouseEvent) => void>;
onClickOnce: PropType<(args_0: MouseEvent) => void>;
}, import("vue").ExtractPropTypes<{
theme: StringConstructor;
class: PropType<any>;
style: {
type: PropType<import("vue").StyleValue>;
default: null;
};
border: (BooleanConstructor | NumberConstructor | StringConstructor)[];
density: {
type: PropType<import("vuetify/lib/composables/density.mjs").Density>;
default: string;
validator: (v: any) => boolean;
};
elevation: {
type: (NumberConstructor | StringConstructor)[];
validator(v: any): boolean;
};
rounded: {
type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
default: undefined;
};
tile: BooleanConstructor;
tag: Omit<{
type: PropType<string | import("vuetify/lib/types.mjs").JSXComponent>;
default: string;
}, "default" | "type"> & {
type: PropType<string | import("vuetify/lib/types.mjs").JSXComponent>;
default: NonNullable<string | import("vuetify/lib/types.mjs").JSXComponent>;
};
color: StringConstructor;
variant: Omit<{
type: PropType<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
default: string;
validator: (v: any) => boolean;
}, "default" | "type"> & {
type: PropType<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
default: NonNullable<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
};
value: null;
disabled: BooleanConstructor;
selectedClass: StringConstructor;
size: {
type: (NumberConstructor | StringConstructor)[];
default: string;
};
href: StringConstructor;
replace: BooleanConstructor;
to: PropType<string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric>;
exact: BooleanConstructor;
activeClass: StringConstructor;
appendAvatar: StringConstructor;
appendIcon: PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
baseColor: StringConstructor;
closable: BooleanConstructor;
closeIcon: {
type: PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
default: string;
};
closeLabel: {
type: StringConstructor;
default: string;
};
draggable: BooleanConstructor;
filter: BooleanConstructor;
filterIcon: {
type: PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
default: string;
};
label: BooleanConstructor;
link: {
type: BooleanConstructor;
default: undefined;
};
pill: BooleanConstructor;
prependAvatar: StringConstructor;
prependIcon: PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
ripple: {
type: PropType<boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined>;
default: boolean;
};
text: {
type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
default: undefined;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
onClick: PropType<(args_0: MouseEvent) => void>;
onClickOnce: PropType<(args_0: MouseEvent) => void>;
}>>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

13
dist/types/componentes/EliTabela/celulas/EliTabelaCelulaTextoSimples.vue.d.ts vendored
View file

@ -1,13 +0,0 @@
import { type PropType } from "vue";
import type { tiposTabelaCelulas } from "./tiposTabelaCelulas";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["textoSimples"]>;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["textoSimples"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

13
dist/types/componentes/EliTabela/celulas/EliTabelaCelulaTextoTruncado.vue.d.ts vendored
View file

@ -1,13 +0,0 @@
import { type PropType } from "vue";
import type { tiposTabelaCelulas } from "./tiposTabelaCelulas";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["textoTruncado"]>;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: PropType<tiposTabelaCelulas["textoTruncado"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

729
dist/types/componentes/EliTabela/celulas/registryTabelaCelulas.d.ts vendored
View file

@ -9,727 +9,10 @@
* 3. Registrar aqui no mapa * 3. Registrar aqui no mapa
*/ */
export declare const registryTabelaCelulas: { export declare const registryTabelaCelulas: {
readonly textoSimples: import("vue").DefineComponent<import("vue").ExtractPropTypes<{ readonly textoSimples: import("vue").DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>;
dados: { readonly textoTruncado: import("vue").DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>;
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["textoSimples"]>; readonly numero: import("vue").DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>;
}; readonly tags: import("vue").DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>;
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{ readonly data: import("vue").DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>;
dados: { readonly componente: import("vue").DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>;
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["textoSimples"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
readonly textoTruncado: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["textoTruncado"]>;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["textoTruncado"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
readonly numero: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["numero"]>;
};
}>, {
textoNumero: import("vue").ComputedRef<string>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["numero"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
readonly tags: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["tags"]>;
required: false;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["tags"]>;
required: false;
};
}>> & Readonly<{}>, {}, {}, {
VChip: {
new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<{
style: string | false | import("vue").StyleValue[] | import("vue").CSSProperties | null;
density: import("vuetify/lib/composables/density.mjs").Density;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
};
modelValue: boolean;
} & {
theme?: string | undefined;
class?: any;
border?: string | number | boolean | undefined;
elevation?: string | number | undefined;
rounded?: string | number | boolean | undefined;
color?: string | undefined;
value?: any;
selectedClass?: string | undefined;
href?: string | undefined;
to?: string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric | undefined;
activeClass?: string | undefined;
appendAvatar?: string | undefined;
appendIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
baseColor?: string | undefined;
link?: boolean | undefined;
prependAvatar?: string | undefined;
prependIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
text?: string | number | boolean | undefined;
onClick?: ((args_0: MouseEvent) => void) | undefined;
onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
} & {
$children?: {
default?: ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: (() => import("vue").VNodeChild) | undefined;
prepend?: (() => import("vue").VNodeChild) | undefined;
append?: (() => import("vue").VNodeChild) | undefined;
close?: (() => import("vue").VNodeChild) | undefined;
filter?: (() => import("vue").VNodeChild) | undefined;
} | {
$stable?: boolean | undefined;
} | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | import("vue").VNodeChild;
"v-slots"?: {
default?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: false | (() => import("vue").VNodeChild) | undefined;
prepend?: false | (() => import("vue").VNodeChild) | undefined;
append?: false | (() => import("vue").VNodeChild) | undefined;
close?: false | (() => import("vue").VNodeChild) | undefined;
filter?: false | (() => import("vue").VNodeChild) | undefined;
} | undefined;
} & {
"v-slot:append"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:close"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:default"?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
"v-slot:filter"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:label"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:prepend"?: false | (() => import("vue").VNodeChild) | undefined;
} & {
onClick?: ((e: KeyboardEvent | MouseEvent) => any) | undefined;
"onClick:close"?: ((e: MouseEvent) => any) | undefined;
"onGroup:selected"?: ((val: {
value: boolean;
}) => any) | undefined;
"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
}, () => false | JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"click:close": (e: MouseEvent) => true;
"update:modelValue": (value: boolean) => true;
"group:selected": (val: {
value: boolean;
}) => true;
click: (e: KeyboardEvent | MouseEvent) => true;
}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
style: import("vue").StyleValue;
density: import("vuetify/lib/composables/density.mjs").Density;
rounded: string | number | boolean;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
link: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined;
text: string | number | boolean;
modelValue: boolean;
}, true, {}, import("vue").SlotsType<Partial<{
default: (arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
label: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
prepend: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
append: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
close: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
filter: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
}>>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, {
style: string | false | import("vue").StyleValue[] | import("vue").CSSProperties | null;
density: import("vuetify/lib/composables/density.mjs").Density;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
};
modelValue: boolean;
} & {
theme?: string | undefined;
class?: any;
border?: string | number | boolean | undefined;
elevation?: string | number | undefined;
rounded?: string | number | boolean | undefined;
color?: string | undefined;
value?: any;
selectedClass?: string | undefined;
href?: string | undefined;
to?: string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric | undefined;
activeClass?: string | undefined;
appendAvatar?: string | undefined;
appendIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
baseColor?: string | undefined;
link?: boolean | undefined;
prependAvatar?: string | undefined;
prependIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
text?: string | number | boolean | undefined;
onClick?: ((args_0: MouseEvent) => void) | undefined;
onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
} & {
$children?: {
default?: ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: (() => import("vue").VNodeChild) | undefined;
prepend?: (() => import("vue").VNodeChild) | undefined;
append?: (() => import("vue").VNodeChild) | undefined;
close?: (() => import("vue").VNodeChild) | undefined;
filter?: (() => import("vue").VNodeChild) | undefined;
} | {
$stable?: boolean | undefined;
} | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | import("vue").VNodeChild;
"v-slots"?: {
default?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: false | (() => import("vue").VNodeChild) | undefined;
prepend?: false | (() => import("vue").VNodeChild) | undefined;
append?: false | (() => import("vue").VNodeChild) | undefined;
close?: false | (() => import("vue").VNodeChild) | undefined;
filter?: false | (() => import("vue").VNodeChild) | undefined;
} | undefined;
} & {
"v-slot:append"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:close"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:default"?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
"v-slot:filter"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:label"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:prepend"?: false | (() => import("vue").VNodeChild) | undefined;
} & {
onClick?: ((e: KeyboardEvent | MouseEvent) => any) | undefined;
"onClick:close"?: ((e: MouseEvent) => any) | undefined;
"onGroup:selected"?: ((val: {
value: boolean;
}) => any) | undefined;
"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
}, () => false | JSX.Element, {}, {}, {}, {
style: import("vue").StyleValue;
density: import("vuetify/lib/composables/density.mjs").Density;
rounded: string | number | boolean;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
link: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined;
text: string | number | boolean;
modelValue: boolean;
}>;
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<{
style: string | false | import("vue").StyleValue[] | import("vue").CSSProperties | null;
density: import("vuetify/lib/composables/density.mjs").Density;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
};
modelValue: boolean;
} & {
theme?: string | undefined;
class?: any;
border?: string | number | boolean | undefined;
elevation?: string | number | undefined;
rounded?: string | number | boolean | undefined;
color?: string | undefined;
value?: any;
selectedClass?: string | undefined;
href?: string | undefined;
to?: string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric | undefined;
activeClass?: string | undefined;
appendAvatar?: string | undefined;
appendIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
baseColor?: string | undefined;
link?: boolean | undefined;
prependAvatar?: string | undefined;
prependIcon?: import("vuetify/lib/composables/icons.mjs").IconValue | undefined;
text?: string | number | boolean | undefined;
onClick?: ((args_0: MouseEvent) => void) | undefined;
onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
} & {
$children?: {
default?: ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: (() => import("vue").VNodeChild) | undefined;
prepend?: (() => import("vue").VNodeChild) | undefined;
append?: (() => import("vue").VNodeChild) | undefined;
close?: (() => import("vue").VNodeChild) | undefined;
filter?: (() => import("vue").VNodeChild) | undefined;
} | {
$stable?: boolean | undefined;
} | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | import("vue").VNodeChild;
"v-slots"?: {
default?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
label?: false | (() => import("vue").VNodeChild) | undefined;
prepend?: false | (() => import("vue").VNodeChild) | undefined;
append?: false | (() => import("vue").VNodeChild) | undefined;
close?: false | (() => import("vue").VNodeChild) | undefined;
filter?: false | (() => import("vue").VNodeChild) | undefined;
} | undefined;
} & {
"v-slot:append"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:close"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:default"?: false | ((arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNodeChild) | undefined;
"v-slot:filter"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:label"?: false | (() => import("vue").VNodeChild) | undefined;
"v-slot:prepend"?: false | (() => import("vue").VNodeChild) | undefined;
} & {
onClick?: ((e: KeyboardEvent | MouseEvent) => any) | undefined;
"onClick:close"?: ((e: MouseEvent) => any) | undefined;
"onGroup:selected"?: ((val: {
value: boolean;
}) => any) | undefined;
"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
}, () => false | JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"click:close": (e: MouseEvent) => true;
"update:modelValue": (value: boolean) => true;
"group:selected": (val: {
value: boolean;
}) => true;
click: (e: KeyboardEvent | MouseEvent) => true;
}, string, {
style: import("vue").StyleValue;
density: import("vuetify/lib/composables/density.mjs").Density;
rounded: string | number | boolean;
tile: boolean;
tag: string | import("vuetify/lib/types.mjs").JSXComponent;
variant: "elevated" | "flat" | "outlined" | "plain" | "text" | "tonal";
disabled: boolean;
size: string | number;
replace: boolean;
exact: boolean;
closable: boolean;
closeIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
closeLabel: string;
draggable: boolean;
filter: boolean;
filterIcon: import("vuetify/lib/composables/icons.mjs").IconValue;
label: boolean;
link: boolean;
pill: boolean;
ripple: boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined;
text: string | number | boolean;
modelValue: boolean;
}, {}, string, import("vue").SlotsType<Partial<{
default: (arg: {
isSelected: boolean | undefined;
selectedClass: boolean | (string | undefined)[] | undefined;
select: ((value: boolean) => void) | undefined;
toggle: (() => void) | undefined;
value: unknown;
disabled: boolean;
}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
label: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
prepend: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
append: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
close: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
filter: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>[];
}>>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vuetify/lib/util/defineComponent.mjs").FilterPropsOptions<{
theme: StringConstructor;
class: import("vue").PropType<any>;
style: {
type: import("vue").PropType<import("vue").StyleValue>;
default: null;
};
border: (BooleanConstructor | NumberConstructor | StringConstructor)[];
density: {
type: import("vue").PropType<import("vuetify/lib/composables/density.mjs").Density>;
default: string;
validator: (v: any) => boolean;
};
elevation: {
type: (NumberConstructor | StringConstructor)[];
validator(v: any): boolean;
};
rounded: {
type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
default: undefined;
};
tile: BooleanConstructor;
tag: Omit<{
type: import("vue").PropType<string | import("vuetify/lib/types.mjs").JSXComponent>;
default: string;
}, "default" | "type"> & {
type: import("vue").PropType<string | import("vuetify/lib/types.mjs").JSXComponent>;
default: NonNullable<string | import("vuetify/lib/types.mjs").JSXComponent>;
};
color: StringConstructor;
variant: Omit<{
type: import("vue").PropType<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
default: string;
validator: (v: any) => boolean;
}, "default" | "type"> & {
type: import("vue").PropType<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
default: NonNullable<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
};
value: null;
disabled: BooleanConstructor;
selectedClass: StringConstructor;
size: {
type: (NumberConstructor | StringConstructor)[];
default: string;
};
href: StringConstructor;
replace: BooleanConstructor;
to: import("vue").PropType<string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric>;
exact: BooleanConstructor;
activeClass: StringConstructor;
appendAvatar: StringConstructor;
appendIcon: import("vue").PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
baseColor: StringConstructor;
closable: BooleanConstructor;
closeIcon: {
type: import("vue").PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
default: string;
};
closeLabel: {
type: StringConstructor;
default: string;
};
draggable: BooleanConstructor;
filter: BooleanConstructor;
filterIcon: {
type: import("vue").PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
default: string;
};
label: BooleanConstructor;
link: {
type: BooleanConstructor;
default: undefined;
};
pill: BooleanConstructor;
prependAvatar: StringConstructor;
prependIcon: import("vue").PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
ripple: {
type: import("vue").PropType<boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined>;
default: boolean;
};
text: {
type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
default: undefined;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
onClick: import("vue").PropType<(args_0: MouseEvent) => void>;
onClickOnce: import("vue").PropType<(args_0: MouseEvent) => void>;
}, import("vue").ExtractPropTypes<{
theme: StringConstructor;
class: import("vue").PropType<any>;
style: {
type: import("vue").PropType<import("vue").StyleValue>;
default: null;
};
border: (BooleanConstructor | NumberConstructor | StringConstructor)[];
density: {
type: import("vue").PropType<import("vuetify/lib/composables/density.mjs").Density>;
default: string;
validator: (v: any) => boolean;
};
elevation: {
type: (NumberConstructor | StringConstructor)[];
validator(v: any): boolean;
};
rounded: {
type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
default: undefined;
};
tile: BooleanConstructor;
tag: Omit<{
type: import("vue").PropType<string | import("vuetify/lib/types.mjs").JSXComponent>;
default: string;
}, "default" | "type"> & {
type: import("vue").PropType<string | import("vuetify/lib/types.mjs").JSXComponent>;
default: NonNullable<string | import("vuetify/lib/types.mjs").JSXComponent>;
};
color: StringConstructor;
variant: Omit<{
type: import("vue").PropType<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
default: string;
validator: (v: any) => boolean;
}, "default" | "type"> & {
type: import("vue").PropType<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
default: NonNullable<"elevated" | "flat" | "outlined" | "plain" | "text" | "tonal">;
};
value: null;
disabled: BooleanConstructor;
selectedClass: StringConstructor;
size: {
type: (NumberConstructor | StringConstructor)[];
default: string;
};
href: StringConstructor;
replace: BooleanConstructor;
to: import("vue").PropType<string | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").RouteLocationAsRelativeGeneric>;
exact: BooleanConstructor;
activeClass: StringConstructor;
appendAvatar: StringConstructor;
appendIcon: import("vue").PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
baseColor: StringConstructor;
closable: BooleanConstructor;
closeIcon: {
type: import("vue").PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
default: string;
};
closeLabel: {
type: StringConstructor;
default: string;
};
draggable: BooleanConstructor;
filter: BooleanConstructor;
filterIcon: {
type: import("vue").PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
default: string;
};
label: BooleanConstructor;
link: {
type: BooleanConstructor;
default: undefined;
};
pill: BooleanConstructor;
prependAvatar: StringConstructor;
prependIcon: import("vue").PropType<import("vuetify/lib/composables/icons.mjs").IconValue>;
ripple: {
type: import("vue").PropType<boolean | {
class?: string | undefined;
keys?: string[] | undefined;
} | undefined>;
default: boolean;
};
text: {
type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
default: undefined;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
onClick: import("vue").PropType<(args_0: MouseEvent) => void>;
onClickOnce: import("vue").PropType<(args_0: MouseEvent) => void>;
}>>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
readonly data: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["data"]>;
required: false;
};
}>, {
textoData: import("vue").ComputedRef<string>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["data"]>;
required: false;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
readonly componente: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["componente"]>;
};
}>, {
propsResolvidas: import("vue").Ref<Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
dados: {
type: import("vue").PropType<import("./tiposTabelaCelulas").tiposTabelaCelulas["componente"]>;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}; };

122
dist/types/componentes/EliTabela/useEliTabela.d.ts vendored
View file

@ -5,33 +5,6 @@ export declare function useEliTabela(props: {
selecionados: unknown[]; selecionados: unknown[];
esconderDebug: boolean; esconderDebug: boolean;
}, emit: (event: "update:selecionados", value: unknown[]) => void): { }, emit: (event: "update:selecionados", value: unknown[]) => void): {
menuAberto: import("vue").Ref<number | null, number | null>;
menuPopup: import("vue").Ref<{
menuEl: HTMLElement | null;
} | null, {
menuEl: HTMLElement | null;
} | {
menuEl: HTMLElement | null;
} | null>;
menuPopupPos: import("vue").Ref<{
top: number;
left: number;
}, {
top: number;
left: number;
} | {
top: number;
left: number;
}>;
possuiAcoes: (i: number) => boolean;
toggleMenu: (i: number, evento?: MouseEvent) => void;
acoesDisponiveisPorLinha: (i: number) => {
acao: import("./types-eli-tabela").tipoEliTabelaAcao<any>;
indice: number;
visivel: boolean;
}[];
paginaAtual: import("vue").Ref<number, number>;
valorBusca: import("vue").Ref<string, string>;
modalColunasAberto: import("vue").Ref<boolean, boolean>; modalColunasAberto: import("vue").Ref<boolean, boolean>;
configColunas: import("vue").Ref<{ configColunas: import("vue").Ref<{
visiveis: string[]; visiveis: string[];
@ -50,37 +23,6 @@ export declare function useEliTabela(props: {
fecharModalColunas: () => void; fecharModalColunas: () => void;
salvarModalColunas: (cfg: import("./colunasStorage").EliTabelaColunasConfig) => void; salvarModalColunas: (cfg: import("./colunasStorage").EliTabelaColunasConfig) => void;
alternarLinhaExpandida: (indice: number) => void; alternarLinhaExpandida: (indice: number) => void;
mostrarSelecao: import("vue").ComputedRef<boolean>;
isSelecionado: (linha: unknown) => boolean;
alternarSelecao: (linha: unknown) => void;
todosSelecionados: import("vue").ComputedRef<boolean>;
algunsSelecionados: import("vue").ComputedRef<boolean>;
alternarSelecaoTodos: (forcarMarcar?: boolean) => void;
filtrosUi: import("vue").Ref<{
chave: string;
valor: unknown;
}[], {
chave: string;
valor: unknown;
}[] | {
chave: string;
valor: unknown;
}[]>;
filtrosFormula: import("vue").Ref<string, string>;
modalFiltroAberto: import("vue").Ref<boolean, boolean>;
exibirFiltroAvancado: import("vue").ComputedRef<boolean>;
filtrosAvancadosAtivos: import("vue").ComputedRef<import("p-comuns").tipoFiltroDeltaColunaTipada<any>[]>;
filtrosAtivosResumo: import("vue").ComputedRef<{
quantidade: number;
rotulos: string[];
}>;
abrirModalFiltro: () => void;
fecharModalFiltro: () => void;
limparFiltrosAvancados: () => void;
salvarFiltrosAvancados: (novoLinhas: {
chave: string;
valor: unknown;
}[], novaFormula?: string) => void;
isDev: boolean; isDev: boolean;
tabela: import("vue").ComputedRef<tipoEliTabelaConsulta<any>>; tabela: import("vue").ComputedRef<tipoEliTabelaConsulta<any>>;
carregando: import("vue").Ref<boolean, boolean>; carregando: import("vue").Ref<boolean, boolean>;
@ -91,7 +33,7 @@ export declare function useEliTabela(props: {
quantidadeFiltrada: import("vue").ComputedRef<number>; quantidadeFiltrada: import("vue").ComputedRef<number>;
acoesVisiveis: import("vue").Ref<boolean[][], boolean[][]>; acoesVisiveis: import("vue").Ref<boolean[][], boolean[][]>;
colunaOrdenacao: import("vue").Ref<string | null, string | null>; colunaOrdenacao: import("vue").Ref<string | null, string | null>;
direcaoOrdenacao: import("vue").Ref<"desc" | "asc", "desc" | "asc">; direcaoOrdenacao: import("vue").Ref<"asc" | "desc", "asc" | "desc">;
registrosPorConsulta: import("vue").ComputedRef<number>; registrosPorConsulta: import("vue").ComputedRef<number>;
totalPaginas: import("vue").ComputedRef<number>; totalPaginas: import("vue").ComputedRef<number>;
temAcoes: import("vue").ComputedRef<boolean>; temAcoes: import("vue").ComputedRef<boolean>;
@ -119,18 +61,76 @@ export declare function useEliTabela(props: {
temAcoesSuperiores: import("vue").ComputedRef<boolean>; temAcoesSuperiores: import("vue").ComputedRef<boolean>;
temAcoesInferiores: import("vue").ComputedRef<boolean>; temAcoesInferiores: import("vue").ComputedRef<boolean>;
parametrosConsultaAtuais: import("vue").ComputedRef<{ parametrosConsultaAtuais: import("vue").ComputedRef<{
atualizarConsulta: () => Promise<void>;
editarLista: (novaLista: any[]) => Promise<any[]>;
filtros?: import("p-comuns").tipoFiltroDeltaColunaTipada<string>[] | undefined; filtros?: import("p-comuns").tipoFiltroDeltaColunaTipada<string>[] | undefined;
coluna_ordem?: string | number | symbol | undefined; coluna_ordem?: string | number | symbol | undefined;
direcao_ordem?: "asc" | "desc"; direcao_ordem?: "asc" | "desc";
offSet?: number; offSet?: number;
limit?: number; limit?: number;
texto_busca?: string; texto_busca?: string;
atualizarConsulta: () => Promise<void>;
editarLista: (novaLista: any[]) => Promise<any[]>;
}>; }>;
carregar: () => Promise<void>; carregar: () => Promise<void>;
alternarOrdenacao: (chave?: string) => void; alternarOrdenacao: (chave?: string) => void;
atualizarBusca: (texto: string) => void; atualizarBusca: (texto: string) => void;
irParaPagina: (pagina: number) => void; irParaPagina: (pagina: number) => void;
filtrosUi: import("vue").Ref<{
chave: string;
valor: unknown;
}[], {
chave: string;
valor: unknown;
}[] | {
chave: string;
valor: unknown;
}[]>;
filtrosFormula: import("vue").Ref<string, string>;
modalFiltroAberto: import("vue").Ref<boolean, boolean>;
exibirFiltroAvancado: import("vue").ComputedRef<boolean>;
filtrosAvancadosAtivos: import("vue").ComputedRef<import("p-comuns").tipoFiltroDeltaColunaTipada<any>[]>;
filtrosAtivosResumo: import("vue").ComputedRef<{
quantidade: number;
rotulos: string[];
}>;
abrirModalFiltro: () => void;
fecharModalFiltro: () => void;
limparFiltrosAvancados: () => void;
salvarFiltrosAvancados: (novoLinhas: {
chave: string;
valor: unknown;
}[], novaFormula?: string) => void;
mostrarSelecao: import("vue").ComputedRef<boolean>;
isSelecionado: (linha: unknown) => boolean;
alternarSelecao: (linha: unknown) => void;
todosSelecionados: import("vue").ComputedRef<boolean>;
algunsSelecionados: import("vue").ComputedRef<boolean>;
alternarSelecaoTodos: (forcarMarcar?: boolean) => void;
menuAberto: import("vue").Ref<number | null, number | null>;
menuPopup: import("vue").Ref<{
menuEl: HTMLElement | null;
} | null, {
menuEl: HTMLElement | null;
} | {
menuEl: HTMLElement | null;
} | null>;
menuPopupPos: import("vue").Ref<{
top: number;
left: number;
}, {
top: number;
left: number;
} | {
top: number;
left: number;
}>;
possuiAcoes: (i: number) => boolean;
toggleMenu: (i: number, evento?: MouseEvent) => void;
acoesDisponiveisPorLinha: (i: number) => {
acao: import("./types-eli-tabela").tipoEliTabelaAcao<any>;
indice: number;
visivel: boolean;
}[];
paginaAtual: import("vue").Ref<number, number>;
valorBusca: import("vue").Ref<string, string>;
}; };
export {}; export {};

6
dist/types/componentes/EliTabela/useEliTabelaConsulta.d.ts vendored
View file

@ -27,7 +27,7 @@ export declare function useEliTabelaConsulta(props: PropsConsulta, filtrosAvanca
quantidadeFiltrada: import("vue").ComputedRef<number>; quantidadeFiltrada: import("vue").ComputedRef<number>;
acoesVisiveis: Ref<boolean[][], boolean[][]>; acoesVisiveis: Ref<boolean[][], boolean[][]>;
colunaOrdenacao: Ref<string | null, string | null>; colunaOrdenacao: Ref<string | null, string | null>;
direcaoOrdenacao: Ref<"desc" | "asc", "desc" | "asc">; direcaoOrdenacao: Ref<"asc" | "desc", "asc" | "desc">;
registrosPorConsulta: import("vue").ComputedRef<number>; registrosPorConsulta: import("vue").ComputedRef<number>;
totalPaginas: import("vue").ComputedRef<number>; totalPaginas: import("vue").ComputedRef<number>;
temAcoes: import("vue").ComputedRef<boolean>; temAcoes: import("vue").ComputedRef<boolean>;
@ -55,14 +55,14 @@ export declare function useEliTabelaConsulta(props: PropsConsulta, filtrosAvanca
temAcoesSuperiores: import("vue").ComputedRef<boolean>; temAcoesSuperiores: import("vue").ComputedRef<boolean>;
temAcoesInferiores: import("vue").ComputedRef<boolean>; temAcoesInferiores: import("vue").ComputedRef<boolean>;
parametrosConsultaAtuais: import("vue").ComputedRef<{ parametrosConsultaAtuais: import("vue").ComputedRef<{
atualizarConsulta: () => Promise<void>;
editarLista: (novaLista: any[]) => Promise<any[]>;
filtros?: tipoFiltroDeltaColunaTipada<string>[] | undefined; filtros?: tipoFiltroDeltaColunaTipada<string>[] | undefined;
coluna_ordem?: string | number | symbol | undefined; coluna_ordem?: string | number | symbol | undefined;
direcao_ordem?: "asc" | "desc"; direcao_ordem?: "asc" | "desc";
offSet?: number; offSet?: number;
limit?: number; limit?: number;
texto_busca?: string; texto_busca?: string;
atualizarConsulta: () => Promise<void>;
editarLista: (novaLista: any[]) => Promise<any[]>;
}>; }>;
carregar: () => Promise<void>; carregar: () => Promise<void>;
alternarOrdenacao: (chave?: string) => void; alternarOrdenacao: (chave?: string) => void;

322
dist/types/componentes/EliTabela/useFiltroAvancado.d.ts vendored
View file

@ -59,187 +59,187 @@ interface UseFiltroAvancadoOptions {
export declare function useFiltroAvancado({ aberto, filtrosBase, modelo, modeloFormula, emit, }: UseFiltroAvancadoOptions): { export declare function useFiltroAvancado({ aberto, filtrosBase, modelo, modeloFormula, emit, }: UseFiltroAvancadoOptions): {
linhas: Ref<{ linhas: Ref<{
chave: string; chave: string;
entrada: readonly ["texto", { entrada: readonly ["confirmacao", {
rotulo: string; rotulo: string;
placeholder?: string | undefined; placeholder?: string;
apenasLeitura?: boolean | undefined; apenasLeitura?: boolean;
limiteCaracteres?: number | undefined; cor?: string;
formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep" | undefined; desabilitado?: boolean;
}] | readonly ["dataHora", { rotuloAtivo?: string;
rotulo: string; rotuloInativo?: string;
placeholder?: string | undefined; densidade?: import("../..").CampoDensidade;
apenasLeitura?: boolean | undefined;
modo?: "data" | "dataHora" | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
min?: string | undefined;
max?: string | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["numero", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
sufixo?: string | undefined;
prefixo?: string | undefined;
precisao?: number | undefined;
}] | readonly ["paragrafo", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
linhas?: number | undefined;
limiteCaracteres?: number | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["selecao", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[] | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["selecaoMultipla", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[] | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["confirmacao", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
cor?: string | undefined;
desabilitado?: boolean | undefined;
rotuloAtivo?: string | undefined;
rotuloInativo?: string | undefined;
densidade?: import("../..").CampoDensidade | undefined;
}] | readonly ["coordenadas", { }] | readonly ["coordenadas", {
rotulo: string; rotulo: string;
placeholder?: string | undefined; placeholder?: string;
apenasLeitura?: boolean | undefined; apenasLeitura?: boolean;
zoom?: number | undefined; zoom?: number;
alturaMapa?: number | undefined; alturaMapa?: number;
camadas?: { camadas?: {
estados?: boolean | undefined; estados?: boolean;
municipios?: boolean | undefined; municipios?: boolean;
} | undefined; } | undefined;
}] | readonly ["dataHora", {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
modo?: "data" | "dataHora";
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
min?: string;
max?: string;
densidade?: import("../..").CampoDensidade;
variante?: import("../..").CampoVariante;
}] | readonly ["numero", {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
sufixo?: string;
prefixo?: string;
precisao?: number;
}] | readonly ["paragrafo", {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
linhas?: number;
limiteCaracteres?: number;
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
densidade?: import("../..").CampoDensidade;
variante?: import("../..").CampoVariante;
}] | readonly ["selecao", {
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[];
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
densidade?: import("../..").CampoDensidade;
variante?: import("../..").CampoVariante;
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
}] | readonly ["selecaoMultipla", {
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[];
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
densidade?: import("../..").CampoDensidade;
variante?: import("../..").CampoVariante;
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
}] | readonly ["texto", {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
limiteCaracteres?: number;
formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep";
}]; }];
valor: unknown; valor: unknown;
}[], LinhaFiltro[] | { }[], LinhaFiltro[] | {
chave: string; chave: string;
entrada: readonly ["texto", { entrada: readonly ["confirmacao", {
rotulo: string; rotulo: string;
placeholder?: string | undefined; placeholder?: string;
apenasLeitura?: boolean | undefined; apenasLeitura?: boolean;
limiteCaracteres?: number | undefined; cor?: string;
formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep" | undefined; desabilitado?: boolean;
}] | readonly ["dataHora", { rotuloAtivo?: string;
rotulo: string; rotuloInativo?: string;
placeholder?: string | undefined; densidade?: import("../..").CampoDensidade;
apenasLeitura?: boolean | undefined;
modo?: "data" | "dataHora" | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
min?: string | undefined;
max?: string | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["numero", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
sufixo?: string | undefined;
prefixo?: string | undefined;
precisao?: number | undefined;
}] | readonly ["paragrafo", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
linhas?: number | undefined;
limiteCaracteres?: number | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["selecao", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[] | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["selecaoMultipla", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[] | undefined;
limpavel?: boolean | undefined;
erro?: boolean | undefined;
mensagensErro?: string | string[] | undefined;
dica?: string | undefined;
dicaPersistente?: boolean | undefined;
densidade?: import("../..").CampoDensidade | undefined;
variante?: import("../..").CampoVariante | undefined;
}] | readonly ["confirmacao", {
rotulo: string;
placeholder?: string | undefined;
apenasLeitura?: boolean | undefined;
cor?: string | undefined;
desabilitado?: boolean | undefined;
rotuloAtivo?: string | undefined;
rotuloInativo?: string | undefined;
densidade?: import("../..").CampoDensidade | undefined;
}] | readonly ["coordenadas", { }] | readonly ["coordenadas", {
rotulo: string; rotulo: string;
placeholder?: string | undefined; placeholder?: string;
apenasLeitura?: boolean | undefined; apenasLeitura?: boolean;
zoom?: number | undefined; zoom?: number;
alturaMapa?: number | undefined; alturaMapa?: number;
camadas?: { camadas?: {
estados?: boolean | undefined; estados?: boolean;
municipios?: boolean | undefined; municipios?: boolean;
} | undefined; } | undefined;
}] | readonly ["dataHora", {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
modo?: "data" | "dataHora";
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
min?: string;
max?: string;
densidade?: import("../..").CampoDensidade;
variante?: import("../..").CampoVariante;
}] | readonly ["numero", {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
sufixo?: string;
prefixo?: string;
precisao?: number;
}] | readonly ["paragrafo", {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
linhas?: number;
limiteCaracteres?: number;
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
densidade?: import("../..").CampoDensidade;
variante?: import("../..").CampoVariante;
}] | readonly ["selecao", {
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[];
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
densidade?: import("../..").CampoDensidade;
variante?: import("../..").CampoVariante;
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
}] | readonly ["selecaoMultipla", {
itens: import("../EliEntrada/tiposSelecao").CarregadorItens;
desativado?: string[];
limpavel?: boolean;
erro?: boolean;
mensagensErro?: string | string[];
dica?: string;
dicaPersistente?: boolean;
densidade?: import("../..").CampoDensidade;
variante?: import("../..").CampoVariante;
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
}] | readonly ["texto", {
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
limiteCaracteres?: number;
formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep";
}]; }];
valor: unknown; valor: unknown;
}[]>; }[]>;
opcoesParaAdicionar: import("vue").ComputedRef<{ opcoesParaAdicionar: import("vue").ComputedRef<{
chave: string; chave: string;
rotulo: string; rotulo: string;
filtro: (valor: unknown) => Pick<import("p-comuns").tipoCondicaoFiltroDeltaTipado<"small" | "length" | "concat" | "slice" | "indexOf" | "lastIndexOf" | "includes" | "toString" | "charAt" | "charCodeAt" | "localeCompare" | "match" | "replace" | "search" | "split" | "substring" | "toLowerCase" | "toLocaleLowerCase" | "toUpperCase" | "toLocaleUpperCase" | "trim" | "substr" | "codePointAt" | "endsWith" | "normalize" | "repeat" | "startsWith" | "anchor" | "big" | "blink" | "bold" | "fixed" | "fontcolor" | "fontsize" | "italics" | "link" | "strike" | "sub" | "sup" | "padStart" | "padEnd" | "trimEnd" | "trimStart" | "trimLeft" | "trimRight" | "matchAll" | "valueOf">, "valor" | "coluna" | "operador"> | undefined; filtro: (valor: unknown) => Pick<import("p-comuns").tipoCondicaoFiltroDeltaTipado<"anchor" | "big" | "blink" | "bold" | "charAt" | "charCodeAt" | "codePointAt" | "concat" | "endsWith" | "fixed" | "fontcolor" | "fontsize" | "includes" | "indexOf" | "italics" | "lastIndexOf" | "length" | "link" | "localeCompare" | "match" | "matchAll" | "normalize" | "padEnd" | "padStart" | "repeat" | "replace" | "search" | "slice" | "small" | "split" | "startsWith" | "strike" | "sub" | "substr" | "substring" | "sup" | "toLocaleLowerCase" | "toLocaleUpperCase" | "toLowerCase" | "toString" | "toUpperCase" | "trim" | "trimEnd" | "trimLeft" | "trimRight" | "trimStart" | "valueOf">, "coluna" | "operador" | "valor"> | undefined;
entrada: ComponenteEntrada; entrada: ComponenteEntrada;
}[]>; }[]>;
chaveParaAdicionar: Ref<string, string>; chaveParaAdicionar: Ref<string, string>;

65
dist/types/componentes/FeedbackWidget/EliFeedbackWidget.vue.d.ts vendored
View file

@ -1,65 +0,0 @@
import "./EliFeedbackPainel.css";
import "./EliFeedbackWidget.css";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<{}, {
textareaRef: import("vue").Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
expandido: import("vue").Ref<boolean, boolean>;
modo: import("vue").Ref<import("./tiposFeedback").ModoSelecao, import("./tiposFeedback").ModoSelecao>;
elementoSelecionado: import("vue").Ref<{
seletor: string;
id: string | null;
classes: string[];
tag: string;
textoVisivel: string;
dataAtributos: Record<string, string>;
caminhoDom: string;
} | null, import("./tiposFeedback").ElementoCapturado | {
seletor: string;
id: string | null;
classes: string[];
tag: string;
textoVisivel: string;
dataAtributos: Record<string, string>;
caminhoDom: string;
} | null>;
comentario: import("vue").Ref<string, string>;
copiouElemento: import("vue").Ref<boolean, boolean>;
itens: import("vue").Ref<{
id: string;
criadoEm: string;
elemento: {
seletor: string;
id: string | null;
classes: string[];
tag: string;
textoVisivel: string;
dataAtributos: Record<string, string>;
caminhoDom: string;
};
comentario: string;
urlPagina: string;
}[], import("./tiposFeedback").ItemFeedback[] | {
id: string;
criadoEm: string;
elemento: {
seletor: string;
id: string | null;
classes: string[];
tag: string;
textoVisivel: string;
dataAtributos: Record<string, string>;
caminhoDom: string;
};
comentario: string;
urlPagina: string;
}[]>;
totalItens: import("vue").ComputedRef<number>;
aoClicarFab: () => void;
aoIniciarFeedback: () => void;
aoIniciarCopia: () => void;
cancelarSelecao: () => void;
salvarFeedback: () => void;
exportarMarkdown: () => void;
confirmarLimpeza: () => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

53
dist/types/componentes/botao/EliBotao.vue.d.ts vendored
View file

@ -1,53 +0,0 @@
import { type PropType } from "vue";
import type { BotaoTamanho, BotaoVariante } from "../../tipos";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
variant: {
type: PropType<BotaoVariante>;
default: string;
};
size: {
type: PropType<BotaoTamanho>;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
loading: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
variant: {
type: PropType<BotaoVariante>;
default: string;
};
size: {
type: PropType<BotaoTamanho>;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
loading: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
color: string;
variant: BotaoVariante;
size: BotaoTamanho;
disabled: boolean;
loading: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

148
dist/types/componentes/cartao/EliCartao.vue.d.ts vendored
View file

@ -1,148 +0,0 @@
import { type PropType } from "vue";
import type { CartaoStatus } from "../../tipos";
type CartaoVariante = "outlined" | "flat" | "elevated" | "tonal";
/**
* EliCartao
*
* Um cartão de domínio para listas/pipelines (ex.: oportunidades/propostas) com:
* - título
* - status padronizado (novo/rascunho/vendido/cancelado)
* - slot padrão para conteúdo
* - slot opcional para ações
*/
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
/** Título de fallback caso o slot `titulo` não seja usado. */
titulo: {
type: StringConstructor;
default: string;
};
/**
* Status semântico do cartão.
* Usado para cor/label e para permitir filtros por status.
*/
status: {
type: PropType<CartaoStatus>;
required: true;
};
/** Variante visual do v-card (Vuetify). */
variant: {
type: PropType<CartaoVariante>;
default: string;
};
}>, {
rotuloStatus: import("vue").ComputedRef<CartaoStatus>;
corStatus: import("vue").ComputedRef<"primary" | "secondary" | "success" | "error">;
classeStatus: import("vue").ComputedRef<string>;
onClick: () => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
/** Emit opcional para padronizar clique no cartão. */
clicar: (_status: CartaoStatus) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
/** Título de fallback caso o slot `titulo` não seja usado. */
titulo: {
type: StringConstructor;
default: string;
};
/**
* Status semântico do cartão.
* Usado para cor/label e para permitir filtros por status.
*/
status: {
type: PropType<CartaoStatus>;
required: true;
};
/** Variante visual do v-card (Vuetify). */
variant: {
type: PropType<CartaoVariante>;
default: string;
};
}>> & Readonly<{
onClicar?: ((_status: CartaoStatus) => any) | undefined;
}>, {
variant: CartaoVariante;
titulo: string;
}, {}, {
EliBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
location: {
type: PropType<import("../..").IndicadorLocalizacao>;
default: string;
};
offsetX: {
type: PropType<import("../..").IndicadorOffset>;
default: string;
};
offsetY: {
type: PropType<import("../..").IndicadorOffset>;
default: string;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: BooleanConstructor;
default: boolean;
};
badge: {
type: PropType<string | number | undefined>;
default: undefined;
};
radius: {
type: PropType<import("../..").IndicadorPresetRaio | import("../..").CssLength>;
default: string;
};
}>, {
showBadge: import("vue").ComputedRef<boolean>;
badgeStyle: import("vue").ComputedRef<{
"--eli-badge-radius": string;
}>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
location: {
type: PropType<import("../..").IndicadorLocalizacao>;
default: string;
};
offsetX: {
type: PropType<import("../..").IndicadorOffset>;
default: string;
};
offsetY: {
type: PropType<import("../..").IndicadorOffset>;
default: string;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: BooleanConstructor;
default: boolean;
};
badge: {
type: PropType<string | number | undefined>;
default: undefined;
};
radius: {
type: PropType<import("../..").IndicadorPresetRaio | import("../..").CssLength>;
default: string;
};
}>> & Readonly<{}>, {
color: string;
location: import("../..").IndicadorLocalizacao;
offsetX: import("../..").IndicadorOffset;
offsetY: import("../..").IndicadorOffset;
dot: boolean;
visible: boolean;
badge: string | number | undefined;
radius: import("../..").IndicadorPresetRaio | import("../..").CssLength;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

87
dist/types/componentes/indicador/EliBadge.vue.d.ts vendored
View file

@ -1,87 +0,0 @@
import { type PropType } from "vue";
import type { CssLength, IndicadorLocalizacao, IndicadorOffset, IndicadorPresetRaio } from "../../tipos";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
location: {
type: PropType<IndicadorLocalizacao>;
default: string;
};
offsetX: {
type: PropType<IndicadorOffset>;
default: string;
};
offsetY: {
type: PropType<IndicadorOffset>;
default: string;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: BooleanConstructor;
default: boolean;
};
badge: {
type: PropType<string | number | undefined>;
default: undefined;
};
/** 🔥 NOVO: controla só o radius */
radius: {
type: PropType<IndicadorPresetRaio | CssLength>;
default: string;
};
}>, {
showBadge: import("vue").ComputedRef<boolean>;
badgeStyle: import("vue").ComputedRef<{
"--eli-badge-radius": string;
}>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
location: {
type: PropType<IndicadorLocalizacao>;
default: string;
};
offsetX: {
type: PropType<IndicadorOffset>;
default: string;
};
offsetY: {
type: PropType<IndicadorOffset>;
default: string;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: BooleanConstructor;
default: boolean;
};
badge: {
type: PropType<string | number | undefined>;
default: undefined;
};
/** 🔥 NOVO: controla só o radius */
radius: {
type: PropType<IndicadorPresetRaio | CssLength>;
default: string;
};
}>> & Readonly<{}>, {
color: string;
location: IndicadorLocalizacao;
offsetX: IndicadorOffset;
offsetY: IndicadorOffset;
dot: boolean;
visible: boolean;
badge: string | number | undefined;
radius: IndicadorPresetRaio | CssLength;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

194
dist/types/componentes/ola_mundo/EliOlaMundo.vue.d.ts vendored
View file

@ -1,194 +0,0 @@
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<{}, {
nome: import("vue").Ref<string, string>;
email: import("vue").Ref<string, string>;
documento: import("vue").Ref<string, string>;
telefone: import("vue").Ref<string, string>;
cep: import("vue").Ref<string, string>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
EliBotao: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
variant: {
type: import("vue").PropType<import("../../index.js").BotaoVariante>;
default: string;
};
size: {
type: import("vue").PropType<import("../../index.js").BotaoTamanho>;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
loading: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
variant: {
type: import("vue").PropType<import("../../index.js").BotaoVariante>;
default: string;
};
size: {
type: import("vue").PropType<import("../../index.js").BotaoTamanho>;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
loading: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
color: string;
variant: import("../../index.js").BotaoVariante;
size: import("../../index.js").BotaoTamanho;
disabled: boolean;
loading: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
EliBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
location: {
type: import("vue").PropType<import("../../index.js").IndicadorLocalizacao>;
default: string;
};
offsetX: {
type: import("vue").PropType<import("../../index.js").IndicadorOffset>;
default: string;
};
offsetY: {
type: import("vue").PropType<import("../../index.js").IndicadorOffset>;
default: string;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: BooleanConstructor;
default: boolean;
};
badge: {
type: import("vue").PropType<string | number | undefined>;
default: undefined;
};
radius: {
type: import("vue").PropType<import("../../index.js").IndicadorPresetRaio | import("../../index.js").CssLength>;
default: string;
};
}>, {
showBadge: import("vue").ComputedRef<boolean>;
badgeStyle: import("vue").ComputedRef<{
"--eli-badge-radius": string;
}>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
color: {
type: StringConstructor;
default: string;
};
location: {
type: import("vue").PropType<import("../../index.js").IndicadorLocalizacao>;
default: string;
};
offsetX: {
type: import("vue").PropType<import("../../index.js").IndicadorOffset>;
default: string;
};
offsetY: {
type: import("vue").PropType<import("../../index.js").IndicadorOffset>;
default: string;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: BooleanConstructor;
default: boolean;
};
badge: {
type: import("vue").PropType<string | number | undefined>;
default: undefined;
};
radius: {
type: import("vue").PropType<import("../../index.js").IndicadorPresetRaio | import("../../index.js").CssLength>;
default: string;
};
}>> & Readonly<{}>, {
color: string;
location: import("../../index.js").IndicadorLocalizacao;
offsetX: import("../../index.js").IndicadorOffset;
offsetY: import("../../index.js").IndicadorOffset;
dot: boolean;
visible: boolean;
badge: string | number | undefined;
radius: import("../../index.js").IndicadorPresetRaio | import("../../index.js").CssLength;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
EliEntradaTexto: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
value: {
type: import("vue").PropType<string | null | undefined>;
default: undefined;
};
opcoes: {
type: import("vue").PropType<{
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
} & {
limiteCaracteres?: number;
formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep";
}>;
required: true;
};
}>, {
attrs: import("vue").Attrs;
emit: ((event: "input", _v: string | null | undefined) => void) & ((event: "blur") => void) & ((event: "update:value", _v: string | null | undefined) => void) & ((event: "change", _v: string | null | undefined) => void) & ((event: "focus") => void);
localValue: import("vue").WritableComputedRef<string | null | undefined, string | null | undefined>;
inputHtmlType: import("vue").ComputedRef<"text" | "email" | "url">;
inputMode: import("vue").ComputedRef<string | undefined>;
onInput: (e: Event) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"update:value": (_v: string | null | undefined) => true;
input: (_v: string | null | undefined) => true;
change: (_v: string | null | undefined) => true;
focus: () => true;
blur: () => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
value: {
type: import("vue").PropType<string | null | undefined>;
default: undefined;
};
opcoes: {
type: import("vue").PropType<{
rotulo: string;
placeholder?: string;
apenasLeitura?: boolean;
} & {
limiteCaracteres?: number;
formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep";
}>;
required: true;
};
}>> & Readonly<{
onInput?: ((_v: string | null | undefined) => any) | undefined;
onBlur?: (() => any) | undefined;
"onUpdate:value"?: ((_v: string | null | undefined) => any) | undefined;
onChange?: ((_v: string | null | undefined) => any) | undefined;
onFocus?: (() => any) | undefined;
}>, {
value: string | null | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

6
package.json
View file

@ -1,6 +1,6 @@
{ {
"name": "eli-vue", "name": "eli-vue",
"version": "0.1.222", "version": "0.1.227",
"private": false, "private": false,
"main": "./dist/eli-vue.umd.js", "main": "./dist/eli-vue.umd.js",
"module": "./dist/eli-vue.es.js", "module": "./dist/eli-vue.es.js",
@ -16,7 +16,7 @@
"biome": "pnpm exec biome check --write", "biome": "pnpm exec biome check --write",
"check": "pnpm run biome && npx tsc --noEmit", "check": "pnpm run biome && npx tsc --noEmit",
"prebuild": "npm version patch --no-git-tag-version", "prebuild": "npm version patch --no-git-tag-version",
"build:types": "vue-tsc -p tsconfig.build.json --declaration --emitDeclarationOnly", "build:types": "tsc -p tsconfig.build.json --declaration --emitDeclarationOnly",
"build": "sh ./.agent/verificar-linhas.sh || exit 1 && pnpm run biome && vite build && npm run build:types", "build": "sh ./.agent/verificar-linhas.sh || exit 1 && pnpm run biome && vite build && npm run build:types",
"dev": "sh ./.agent/verificar-linhas.sh || exit 1 && pnpm run biome && pnpm run fechar && vite", "dev": "sh ./.agent/verificar-linhas.sh || exit 1 && pnpm run biome && pnpm run fechar && vite",
"preview": "vite preview", "preview": "vite preview",
@ -34,7 +34,7 @@
"@vitejs/plugin-vue": "^5.0.0", "@vitejs/plugin-vue": "^5.0.0",
"leaflet": "^1.9.4", "leaflet": "^1.9.4",
"sass": "^1.94.2", "sass": "^1.94.2",
"typescript": "^6", "typescript": "^7.0.2",
"vite": "^6.0.0", "vite": "^6.0.0",
"vite-plugin-css-injected-by-js": "^3.5.2", "vite-plugin-css-injected-by-js": "^3.5.2",
"vite-plugin-vuetify": "^2.1.2", "vite-plugin-vuetify": "^2.1.2",

1215
pnpm-lock.yaml generated
View file

File diff suppressed because it is too large Load diff

7
src/env.d.ts vendored Normal file
View file

@ -0,0 +1,7 @@
/// <reference types="vite/client" />
declare module "*.vue" {
import type { DefineComponent } from "vue"
const component: DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>
export default component
}

12
src/playground/App.vue
View file

@ -72,8 +72,6 @@
.playground-console-scroll::-webkit-scrollbar-thumb:hover { .playground-console-scroll::-webkit-scrollbar-thumb:hover {
background: #52525b; background: #52525b;
} }
</style>
<script lang="ts"> <script lang="ts">
import { defineComponent, provide, ref } from "vue" import { defineComponent, provide, ref } from "vue"
import { EliFeedbackWidget } from "../componentes/FeedbackWidget" import { EliFeedbackWidget } from "../componentes/FeedbackWidget"
@ -83,6 +81,7 @@ import DataHoraPlayground from "./data_hora.playground.vue"
import EntradasPlayground from "./entradas.playground.vue" import EntradasPlayground from "./entradas.playground.vue"
import IndicadorPlayground from "./indicador.playground.vue" import IndicadorPlayground from "./indicador.playground.vue"
import OlaMundoPlayground from "./ola_mundo.playground.vue" import OlaMundoPlayground from "./ola_mundo.playground.vue"
import { PLAYGROUND_CONSOLE_KEY, type PlaygroundConsole } from "./playgroundConsole"
import TabelaPlayground from "./tabela.playground.vue" import TabelaPlayground from "./tabela.playground.vue"
type AbaPlayground = type AbaPlayground =
@ -114,15 +113,6 @@ const mapaAbaParaHash: Record<AbaPlayground, string> = {
ola_mundo: "demo", ola_mundo: "demo",
} }
/** Chave de injeção para o console do playground */
export const PLAYGROUND_CONSOLE_KEY = "playgroundConsole"
/** Tipagem do console injetado */
export interface PlaygroundConsole {
adicionarLog: (acao: string, req: unknown, res: unknown) => void
logMensagem: (mensagem: string) => void
}
export default defineComponent({ export default defineComponent({
name: "App", name: "App",
components: { components: {

8
src/playground/playgroundConsole.ts Normal file
View file

@ -0,0 +1,8 @@
/** Chave de injeção para o console do playground */
export const PLAYGROUND_CONSOLE_KEY = "playgroundConsole"
/** Tipagem do console injetado */
export interface PlaygroundConsole {
adicionarLog: (acao: string, req: unknown, res: unknown) => void
logMensagem: (mensagem: string) => void
}

2
src/playground/useTabelaPlayground.ts
View file

@ -12,9 +12,9 @@ import { Plus } from "@lucide/vue"
import { codigosResposta } from "p-respostas" import { codigosResposta } from "p-respostas"
import { inject, ref } from "vue" import { inject, ref } from "vue"
import type { tipoEliTabelaConsulta } from "@/componentes/EliTabela" import type { tipoEliTabelaConsulta } from "@/componentes/EliTabela"
import { PLAYGROUND_CONSOLE_KEY, type PlaygroundConsole } from "./App.vue"
import { ApiSimulacao } from "./api_simulador" import { ApiSimulacao } from "./api_simulador"
import type { tipoEmpreendedores } from "./api_simulador/dados" import type { tipoEmpreendedores } from "./api_simulador/dados"
import { PLAYGROUND_CONSOLE_KEY, type PlaygroundConsole } from "./playgroundConsole"
import { colunasTabela, criarAcoesLinha, filtrosAvancados } from "./useTabelaPlaygroundConfig" import { colunasTabela, criarAcoesLinha, filtrosAvancados } from "./useTabelaPlaygroundConfig"
import { consultar } from "./useTabelaPlaygroundConsultar" import { consultar } from "./useTabelaPlaygroundConsultar"

4
tsconfig.json
View file

@ -18,11 +18,9 @@
"noFallthroughCasesInSwitch": true, "noFallthroughCasesInSwitch": true,
/* Importações */ /* Importações */
"baseUrl": ".",
"paths": { "paths": {
"@/*": ["src/*"] "@/*": ["./src/*"]
}, },
"ignoreDeprecations": "6.0",
/* Vue */ /* Vue */
"types": ["vite/client"] "types": ["vite/client"]