arch-unit-ts/dist/arch-unit/library/Architectures.d.ts

arch-unit-ts

import { DescribedPredicate } from '../base/DescribedPredicate';
import { Dependency, TypeScriptClasses } from '../core/domain/TypeScriptClass';
import { ArchRule } from '../lang/ArchRule';
import { EvaluationResult } from '../lang/EvaluationResult';
export declare abstract class Architectures {
    static layeredArchitecture(): DependencySettings;
}
declare class DependencySettings {
    private readonly description;
    readonly ignoreExcludedDependencies: ((predicate: DescribedPredicate<Dependency>) => DescribedPredicate<Dependency>) | undefined;
    private constructor();
    static default(): DependencySettings;
    consideringOnlyDependenciesInAnyPackage(...packageIdentifiers: string[]): LayeredArchitecture;
    getDescription(): string;
    private setToConsideringOnlyDependenciesInAnyPackage;
    private originOrTargetIs;
}
declare class LayeredArchitecture implements ArchRule {
    private readonly layerDefinitions;
    private readonly dependencySpecifications;
    private readonly dependencySettings;
    private overriddenDescription;
    private readonly optionalLayers;
    private constructor();
    static fromDependencySettings(dependencySettings: DependencySettings): LayeredArchitecture;
    withOptionalLayers(optionalLayers: boolean): LayeredArchitecture;
    because(reason: string): ArchRule;
    check(classes: TypeScriptClasses): void;
    evaluate(classes: TypeScriptClasses): EvaluationResult;
    private checkEmptyLayers;
    private evaluateLayersShouldNotBeEmpty;
    private notBeEmptyFor;
    private evaluateDependenciesShouldBeSatisfied;
    private originMatchesIfDependencyIsRelevant;
    getDescription(): string;
    layer(name: string, ...packageIdentifiers: string[]): LayeredArchitecture;
    optionalLayer(name: string, ...packageIdentifiers: string[]): LayeredArchitecture;
    whereLayer(name: string): LayerDependencySpecification;
    private checkLayerNamesExist;
    addDependencySpecification(dependencySpecification: LayerDependencySpecification): this;
}
declare class LayerDependencySpecification {
    readonly layerName: string;
    readonly allowedLayers: Set<string>;
    private readonly layeredArchitecture;
    private descriptionSuffix;
    constructor(layerName: string, layeredArchitecture: LayeredArchitecture);
    toString(): string;
    mayOnlyBeAccessedByLayers(...layerNames: string[]): LayeredArchitecture;
    private restrictLayers;
    mayNotBeAccessedByAnyLayer(): LayeredArchitecture;
    private denyLayerAccess;
}
export {};