leds-spark-lib/dist/backend/models/model.d.ts

Biblioteca de geração de código

export type Reference<T> = {
    ref: T;
} | T;
export type Container<T> = {
    $container: T;
};
export type DATATYPE = 'boolean' | 'cnpj' | 'cpf' | 'currency' | 'date' | 'datetime' | 'decimal' | 'email' | 'file' | 'integer' | 'mobilePhoneNumber' | 'phoneNumber' | 'string' | 'uuid' | 'void' | 'zipcode';
export type FEATURE_TYPE = 'authentication';
export type LANGUAGETYPE = 'csharp-clean-architecture' | 'csharp-minimal-api' | 'java' | 'python';
export type QualifiedName = string;
export type QualifiedNameWithWildcard = string;
export interface Actor {
    $container: UseCasesModel;
    $type: 'Actor';
    comment?: string;
    fullName?: string;
    id: QualifiedName;
    superType?: Reference<Actor>;
}
export interface Attribute {
    $container: LocalEntity;
    $type: 'Attribute';
    blank: boolean;
    comment?: string;
    fullName?: string;
    max?: number;
    min?: number;
    name: string;
    type: DATATYPE;
    unique: boolean;
}
export interface AttributeEnum {
    $container: EnumX;
    $type: 'AttributeEnum';
    comment?: string;
    fullName?: string;
    name: string;
}
export interface Configuration {
    $container: Model;
    $type: 'Configuration';
    database_name?: string;
    description?: string;
    entity?: Reference<Entity>;
    feature?: FEATURE_TYPE;
    language?: LANGUAGETYPE;
    name?: string;
    package_path?: LANGUAGETYPE;
}
export interface Element {
    $container: Parameter;
    $type: 'Element';
    comment?: string;
    name: string;
    type: DATATYPE;
}
export interface EnumEntityAtribute {
    $container: LocalEntity;
    $type: 'EnumEntityAtribute';
    comment?: string;
    name: string;
    type: Reference<EnumX>;
}
export interface EnumX {
    $container: Model | Module;
    $type: 'EnumX';
    attributes: Array<AttributeEnum>;
    comment?: string;
    name: string;
}
export interface Event {
    $container: UseCase;
    $type: 'Event';
    action?: string;
    depends: Array<Reference<Event>>;
    description?: string;
    id: string;
    name_fragment?: string;
}
export interface FunctionEntity {
    $container: LocalEntity;
    $type: 'FunctionEntity';
    comment?: string;
    name: string;
    paramters: Array<Parameter>;
    response: DATATYPE;
}
export interface ImportedEntity {
    $container: ModuleImport;
    $type: 'ImportedEntity';
    name: string;
}
export interface LocalEntity {
    $container: Module;
    $type: 'LocalEntity';
    attributes: Array<Attribute>;
    comment?: string;
    enumentityatributes: Array<EnumEntityAtribute>;
    functions: Array<FunctionEntity>;
    is_abstract: boolean;
    name: string;
    relations: Array<Relation>;
    superType?: Reference<Entity>;
}
export interface ManyToMany {
    $container: LocalEntity;
    $type: 'ManyToMany';
    by?: Reference<LocalEntity>;
    comment?: string;
    fullName?: string;
    name: string;
    type: Reference<Entity>;
}
export interface ManyToOne {
    $container: LocalEntity;
    $type: 'ManyToOne';
    comment?: string;
    fullName?: string;
    name: string;
    type: Reference<Entity>;
}
export interface Model {
    $type: 'Model';
    abstractElements: Array<AbstractElement | ModuleImport | UseCasesModel>;
    configuration?: Configuration;
}
export interface Module {
    $container: Model | Module;
    $type: 'Module';
    comment?: string;
    elements: Array<AbstractElement | LocalEntity>;
    name: QualifiedName;
}
export interface ModuleImport {
    $container: Model;
    $type: 'ModuleImport';
    entities: Array<ImportedEntity>;
    library: string;
    name: string;
    package_path: string;
}
export interface OneToMany {
    $container: LocalEntity;
    $type: 'OneToMany';
    comment?: string;
    fullName?: string;
    name: string;
    type: Reference<Entity>;
}
export interface OneToOne {
    $container: LocalEntity;
    $type: 'OneToOne';
    comment?: string;
    fullName?: string;
    name: string;
    type: Reference<Entity>;
}
export interface Parameter {
    $container: FunctionEntity;
    $type: 'Parameter';
    comment?: string;
    element: Array<Element> | Element;
}
export interface UseCase {
    $container: UseCasesModel;
    $type: 'UseCase';
    actors: Array<Reference<Actor>>;
    comment?: string;
    description?: string;
    events: Array<Event>;
    id: QualifiedName;
    name_fragment: string;
    superType?: Reference<UseCase>;
}
export interface UseCasesModel {
    $container: Model;
    $type: 'UseCasesModel';
    comment?: string;
    elements: Array<UseCaseElements>;
    id: QualifiedName;
}
export type AbstractElement = EnumX | Module;
export type Entity = ImportedEntity | LocalEntity;
export type Relation = ManyToMany | ManyToOne | OneToMany | OneToOne;
export type UseCaseElements = Actor | UseCase;
export declare function isActor(item: any): item is Actor;
export declare function isLocalEntity(item: any): item is LocalEntity;
export declare function isModel(item: any): item is Model;
export declare function isModule(item: any): item is Module;
export declare function isConfiguration(item: any): item is Configuration;
export declare function isUseCasesModel(item: any): item is UseCasesModel;
export declare function isUseCase(item: any): item is UseCase;
export declare function isAttribute(item: any): item is Attribute;
export declare function isAttributeEnum(item: any): item is AttributeEnum;
export declare function isEnumX(item: any): item is EnumX;
export declare function isFunctionEntity(item: any): item is FunctionEntity;
export declare function isImportedEntity(item: any): item is ImportedEntity;
export declare function isManyToMany(item: any): item is ManyToMany;
export declare function isManyToOne(item: any): item is ManyToOne;
export declare function isOneToMany(item: any): item is OneToMany;
export declare function isOneToOne(item: any): item is OneToOne;
export declare function isParameter(item: any): item is Parameter;
export declare function isElement(item: any): item is Element;
export declare function isEnumEntityAtribute(item: any): item is EnumEntityAtribute;
export declare function isEvent(item: any): item is Event;
export declare function isModuleImport(item: any): item is ModuleImport;
export declare function getRef<T>(ref: Reference<T>): T;
/**
 * Capitaliza uma string
 *
 * @param str - String a ser capitalizada
 * @returns A string capitalizada
 */
export declare function capitalizeString(str: string): string;
export declare const ident_size = 4;
export declare const base_ident: string;
export declare function createPath(...args: string[]): string;
/**
 * Ordena topologicamente um DAG.
 *
 * @param nodes - Conjuntos de nós que denotam um grafo
 * @param fn - Função que recebe um nó `N` e retorna um iterável dos nós que PRECEDEM `N`.
 * @param reverse - Booleano que define se a ordenação deve ser feita ao contrário.
 *
 * @returns Um array, contendo os nós de `nodes` ordenados topologicamente
 *
 * @throws {Error} Se houver um ciclo em `nodes`, tornando a ordenação impossível
 */
export declare function topologicalSort<T>(nodes: Iterable<T>, fn: (a: T) => Iterable<T>, reverse?: boolean): T[];
/**
* Checa se o nó de um grafo é parte de um ciclo.
* Apenas para grafos com grau de saída 1 ou menor em cada nó
* @param start_node Nó inicial
* @param sucessor_function Função que recebe um nó e retorna o nó sucessor, ou undefined caso não haja sucessor.
* @returns Um booleano, dizendo se foi encontrado ciclo
*/
export declare function cycleFinder<T>(start_node: T, sucessor_function: (node: T) => T | undefined): boolean;
/**
* Dado um Entity que tenha nome, retorna o qualified name completo
*/
export declare function getQualifiedName(e: Entity): string;
export declare function expandToString(strings: TemplateStringsArray, ...expr: any[]): string;
export declare function expandToStringWithNL(strings: TemplateStringsArray, ...expr: any[]): string;
export declare function toString(val: any): string;
export type Generated = string;
export declare class CompositeGeneratorNode {
    private content;
    append(str: string): void;
    appendNewLine(): void;
    toString(): string;
}
export type RelationInfo = {
    tgt: LocalEntity;
    card: RelationType;
    owner: boolean;
};
type RelationType = 'OneToMany' | 'OneToOne' | 'ManyToOne' | 'ManyToMany';
export declare function processRelations(localEntities: LocalEntity[]): Map<LocalEntity, RelationInfo[]>;
export {};
//# sourceMappingURL=model.d.ts.map