@horizon-backend/domain-data-core/dist/index.d.mts

Core domain data utilities for Horizon Platform - Schema generators, data enrichers, converters and specifications

/**
 * JsonToZodGenerator - Converte schemas Horizon Fields Metadata Pattern v2.2.0 para Zod
 *
 * Suporta o novo formato com:
 * - categories (ao invés de tags)
 * - validation.precision para decimais
 * - enum como object
 * - mask para validações automáticas
 * - conditions para campos condicionais
 * - parent para hierarquias
 * - db metadata (ignorado na geração Zod)
 * - Inferência inteligente
 */
interface HorizonFieldDefinition {
    key: string;
    type: "String" | "String[]" | "Number" | "Boolean" | "Json" | "Json[]" | "Array";
    label: string;
    categories?: string[];
    validation?: {
        required?: boolean;
        min?: number;
        max?: number;
        minLength?: number;
        maxLength?: number;
        precision?: number;
    };
    format?: "currency" | "area" | "distance" | "count" | "percent" | "date" | "datetime" | "time";
    unit?: string;
    mask?: "cpf" | "cnpj" | "cep" | "phone" | "email" | "url";
    enum?: Record<string, string>;
    conditions?: string[];
    parent?: string;
    searchable?: boolean;
    filterable?: boolean;
    sortable?: boolean;
    db?: {
        type?: string;
        unique?: boolean;
        index?: boolean | string;
        default?: any;
    };
    origin?: string;
    modifiedBy?: string[];
}
interface JsonToZodOptions {
    schemaName: string;
    addDescriptions?: boolean;
    addValidationMessages?: boolean;
    exportType?: boolean;
    sortFields?: boolean;
    enablePrecisionValidation?: boolean;
    logInference?: boolean;
}
declare class JsonToZodGenerator {
    private static inferenceLog;
    /**
     * Aplica inferência inteligente em um campo
     */
    private static applyInference;
    private static log;
    /**
     * Converte um campo para Zod
     */
    private static fieldToZod;
    /**
     * Gera o schema Zod completo
     */
    static generate(fields: HorizonFieldDefinition[], options: JsonToZodOptions): string;
    /**
     * Gera schema a partir de arquivo JSON v2.2.0
     */
    static generateFromFile(jsonPath: string, options: JsonToZodOptions): Promise<string>;
    /**
     * Salva o schema gerado
     */
    static saveToFile(fields: HorizonFieldDefinition[], options: JsonToZodOptions, outputPath: string): Promise<void>;
    /**
     * Analisa um schema e retorna estatísticas
     */
    static analyzeSchema(fields: HorizonFieldDefinition[]): {
        totalFields: number;
        fieldTypes: Record<string, number>;
        fieldFormats: Record<string, number>;
        fieldCategories: Record<string, number>;
        requiredFields: number;
        fieldsWithValidation: number;
        fieldsWithMask: number;
        fieldsWithEnum: number;
        fieldsWithConditions: number;
        fieldsWithParent: number;
    };
}

type index$1_HorizonFieldDefinition = HorizonFieldDefinition;
type index$1_JsonToZodGenerator = JsonToZodGenerator;
declare const index$1_JsonToZodGenerator: typeof JsonToZodGenerator;
type index$1_JsonToZodOptions = JsonToZodOptions;
declare namespace index$1 {
  export { type JsonToZodOptions as GeneratorOptions, type index$1_HorizonFieldDefinition as HorizonFieldDefinition, index$1_JsonToZodGenerator as JsonToZodGenerator, type index$1_JsonToZodOptions as JsonToZodOptions };
}

/**
 * 🎨 Horizon Domain Data Display Enricher
 *
 * Enriquecedor genérico de dados de domínios para display
 * Transforma dados brutos de entidades em objetos enriquecidos para UI
 *
 * @module horizon-domain-data-display-enricher
 * @version 1.0.0
 */
interface FieldMetadata {
    key: string;
    label?: string;
    type?: string;
    format?: string;
    unit?: string;
    categories?: string[];
    composedLabel?: string;
    icon?: string;
    iconName?: string;
    validation?: any;
    [key: string]: any;
}
interface EnrichmentOptions {
    data: Record<string, any>;
    metadata: FieldMetadata[];
    locale?: string;
    currency?: string;
    getIcon?: (iconName: string) => any;
}
interface EnrichedField extends FieldMetadata {
    value: any;
    valueLabel?: string;
    composedLabel?: string;
    icon?: any;
}
/**
 * Formata valor monetário
 */
declare function formatCurrency(value: number | string | null, currency?: string, locale?: string): string;
/**
 * Formata data
 */
declare function formatDateTime(value: string | Date, locale?: string): string;
/**
 * Formata área com unidade
 */
declare function formatArea(value: number | string, unit?: string): string;
/**
 * Formata distância com unidade
 */
declare function formatDistance(value: number | string, unit?: string): string;
/**
 * Formata porcentagem
 */
declare function formatPercent(value: number | string): string;
/**
 * Formata contagem (números inteiros)
 */
declare function formatCount(value: number | string): string;
/**
 * Formata ano
 */
declare function formatYear(value: number | string): string;
/**
 * Processa template com pluralização e substituições
 */
declare function processTemplate(template: string | undefined, value: any, valueLabel: string): string | undefined;
/**
 * Função principal de enriquecimento de dados
 *
 * @param options - Opções de enriquecimento
 * @returns Dados enriquecidos com metadados
 */
declare function enrichDomainDataForDisplay(options: EnrichmentOptions): Record<string, any>;
declare const formatters: {
    currency: typeof formatCurrency;
    date: typeof formatDateTime;
    area: typeof formatArea;
    distance: typeof formatDistance;
    percent: typeof formatPercent;
    count: typeof formatCount;
    year: typeof formatYear;
};
declare const templateProcessor: typeof processTemplate;
/**
 * Função de compatibilidade com a API antiga
 * @deprecated Use enrichDomainDataForDisplay instead
 */
declare function EnrichFieldsWithMetadata({ data, metadata }: {
    data: any;
    metadata: any[];
}): any;

declare const index_EnrichFieldsWithMetadata: typeof EnrichFieldsWithMetadata;
type index_EnrichedField = EnrichedField;
type index_EnrichmentOptions = EnrichmentOptions;
type index_FieldMetadata = FieldMetadata;
declare const index_enrichDomainDataForDisplay: typeof enrichDomainDataForDisplay;
declare const index_formatters: typeof formatters;
declare const index_templateProcessor: typeof templateProcessor;
declare namespace index {
  export { index_EnrichFieldsWithMetadata as EnrichFieldsWithMetadata, type index_EnrichedField as EnrichedField, type index_EnrichmentOptions as EnrichmentOptions, type index_FieldMetadata as FieldMetadata, enrichDomainDataForDisplay as default, index_enrichDomainDataForDisplay as enrichDomainDataForDisplay, index_formatters as formatters, index_templateProcessor as templateProcessor };
}

export { index as domainDataDisplayEnricher, index$1 as jsonSchemaToZodGenerator };