codelyzer

  • Version 6.0.2
  • Published
  • 571 kB
  • 14 dependencies
  • MIT license

Install

npm i codelyzer
yarn add codelyzer
pnpm add codelyzer

Overview

Linting for Angular applications, following angular.io/styleguide.

Index

Variables

Classes

Interfaces

Variables

variable Config

const Config: Config;

    variable LogLevel

    const LogLevel: { Debug: number; Error: number; Info: number; None: number };

      variable rulesDirectory

      const rulesDirectory: string;

        Classes

        class AngularWhitespaceRule

        class Rule extends Lint.Rules.AbstractRule {}

          property metadata

          static readonly metadata: Lint.IRuleMetadata;

            method apply

            apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

              method isEnabled

              isEnabled: () => boolean;

                class BasicCssAstVisitor

                class BasicCssAstVisitor extends SourceMappingVisitor implements ast.CssAstVisitor {}

                  constructor

                  constructor(
                  sourceFile: ts.SourceFile,
                  _originalOptions: Lint.IOptions,
                  context: ComponentMetadata,
                  style: StyleMetadata,
                  templateStart: number
                  );

                    property context

                    protected context: ComponentMetadata;

                      property templateStart

                      protected templateStart: number;

                        method visitCssAtRulePredicate

                        visitCssAtRulePredicate: (ast: ast.CssAtRulePredicateAst, context?: any) => any;

                          method visitCssBlock

                          visitCssBlock: (ast: ast.CssBlockAst, context?: any) => any;

                            method visitCssDefinition

                            visitCssDefinition: (ast: ast.CssDefinitionAst, context?: any) => any;

                              method visitCssInlineRule

                              visitCssInlineRule: (ast: ast.CssInlineRuleAst, context?: any) => any;

                                method visitCssKeyframeDefinition

                                visitCssKeyframeDefinition: (
                                ast: ast.CssKeyframeDefinitionAst,
                                context?: any
                                ) => any;

                                  method visitCssKeyframeRule

                                  visitCssKeyframeRule: (ast: ast.CssKeyframeRuleAst, context?: any) => any;

                                    method visitCssMediaQueryRule

                                    visitCssMediaQueryRule: (ast: ast.CssMediaQueryRuleAst, context?: any) => any;

                                      method visitCssPseudoSelector

                                      visitCssPseudoSelector: (ast: ast.CssPseudoSelectorAst, context?: any) => any;

                                        method visitCssSelector

                                        visitCssSelector: (ast: ast.CssSelectorAst, context?: any) => any;

                                          method visitCssSelectorRule

                                          visitCssSelectorRule: (ast: ast.CssSelectorRuleAst, context?: any) => any;

                                            method visitCssSimpleSelector

                                            visitCssSimpleSelector: (ast: ast.CssSimpleSelectorAst, context?: any) => any;

                                              method visitCssStylesBlock

                                              visitCssStylesBlock: (ast: ast.CssStylesBlockAst, context?: any) => any;

                                                method visitCssStyleSheet

                                                visitCssStyleSheet: (ast: ast.CssStyleSheetAst, context?: any) => any;

                                                  method visitCssUnknownRule

                                                  visitCssUnknownRule: (ast: ast.CssUnknownRuleAst, context?: any) => any;

                                                    method visitCssUnknownTokenList

                                                    visitCssUnknownTokenList: (
                                                    ast: ast.CssUnknownTokenListAst,
                                                    context?: any
                                                    ) => any;

                                                      method visitCssValue

                                                      visitCssValue: (ast: ast.CssStyleValueAst, context?: any) => any;

                                                        class BasicTemplateAstVisitor

                                                        class BasicTemplateAstVisitor
                                                        extends SourceMappingVisitor
                                                        implements ast.TemplateAstVisitor {}

                                                          constructor

                                                          constructor(
                                                          sourceFile: ts.SourceFile,
                                                          _originalOptions: Lint.IOptions,
                                                          context: ComponentMetadata,
                                                          templateStart: number,
                                                          expressionVisitorCtrl?: RecursiveAngularExpressionVisitorCtr
                                                          );

                                                            property context

                                                            protected context: ComponentMetadata;

                                                              property templateStart

                                                              protected templateStart: number;

                                                                method visit

                                                                visit: (node: ast.TemplateAst, context: any) => any;

                                                                  method visitAttr

                                                                  visitAttr: (ast: ast.AttrAst, context: any) => any;

                                                                    method visitBoundText

                                                                    visitBoundText: (text: ast.BoundTextAst, context: any) => any;

                                                                      method visitDirective

                                                                      visitDirective: (ast: ast.DirectiveAst, context: any) => any;

                                                                        method visitDirectiveProperty

                                                                        visitDirectiveProperty: (
                                                                        prop: ast.BoundDirectivePropertyAst,
                                                                        context: any
                                                                        ) => any;

                                                                          method visitElement

                                                                          visitElement: (element: ast.ElementAst, context: any) => any;

                                                                            method visitElementProperty

                                                                            visitElementProperty: (prop: ast.BoundElementPropertyAst, context: any) => any;

                                                                              method visitEmbeddedTemplate

                                                                              visitEmbeddedTemplate: (ast: ast.EmbeddedTemplateAst, context: any) => any;

                                                                                method visitEvent

                                                                                visitEvent: (ast: ast.BoundEventAst, context: any) => any;

                                                                                  method visitNgContent

                                                                                  visitNgContent: (ast: ast.NgContentAst, context: any) => any;

                                                                                    method visitNgTemplateAST

                                                                                    protected visitNgTemplateAST: (
                                                                                    ast: e.AST,
                                                                                    templateStart: number,
                                                                                    prop?: any
                                                                                    ) => void;

                                                                                      method visitReference

                                                                                      visitReference: (ast: ast.ReferenceAst, context: any) => any;

                                                                                        method visitText

                                                                                        visitText: (text: ast.TextAst, context: any) => any;

                                                                                          method visitVariable

                                                                                          visitVariable: (ast: ast.VariableAst, context: any) => any;

                                                                                            class ComponentClassSuffixRule

                                                                                            class Rule extends Lint.Rules.AbstractRule {}

                                                                                              property FAILURE_STRING

                                                                                              static readonly FAILURE_STRING: string;

                                                                                                property metadata

                                                                                                static readonly metadata: Lint.IRuleMetadata;

                                                                                                  property walkerBuilder

                                                                                                  static walkerBuilder: F2<ts.SourceFile, Lint.IOptions, NgWalker>;

                                                                                                    method apply

                                                                                                    apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

                                                                                                      method validate

                                                                                                      static validate: (className: string, suffixList: string[]) => boolean;

                                                                                                        class ComponentMaxInlineDeclarationsRule

                                                                                                        class Rule extends AbstractRule {}

                                                                                                          property FAILURE_STRING

                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                            property metadata

                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                              method apply

                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                method isEnabled

                                                                                                                isEnabled: () => boolean;

                                                                                                                  class ComponentMetadata

                                                                                                                  class ComponentMetadata extends DirectiveMetadata {}

                                                                                                                    constructor

                                                                                                                    constructor(
                                                                                                                    controller: ts.ClassDeclaration,
                                                                                                                    decorator: ts.Decorator,
                                                                                                                    selector?: string,
                                                                                                                    animations?: AnimationMetadata[],
                                                                                                                    styles?: StyleMetadata[],
                                                                                                                    template?: TemplateMetadata
                                                                                                                    );

                                                                                                                      property animations

                                                                                                                      readonly animations?: AnimationMetadata[];

                                                                                                                        property controller

                                                                                                                        readonly controller: ts.ClassDeclaration;

                                                                                                                          property decorator

                                                                                                                          readonly decorator: ts.Decorator;

                                                                                                                            property selector

                                                                                                                            readonly selector?: string;

                                                                                                                              property styles

                                                                                                                              readonly styles?: StyleMetadata[];

                                                                                                                                property template

                                                                                                                                readonly template?: TemplateMetadata;

                                                                                                                                  class ComponentSelectorRule

                                                                                                                                  class Rule extends SelectorPropertyBase {}

                                                                                                                                    property handleType

                                                                                                                                    handleType: string;

                                                                                                                                      property metadata

                                                                                                                                      static readonly metadata: IRuleMetadata;

                                                                                                                                        method getPrefixFailure

                                                                                                                                        getPrefixFailure: (prefixes: ReadonlyArray<string>) => string;

                                                                                                                                          method getStyleFailure

                                                                                                                                          getStyleFailure: (style: SelectorStyle) => string;

                                                                                                                                            method getTypeFailure

                                                                                                                                            getTypeFailure: (types: ReadonlyArray<SelectorType>) => string;

                                                                                                                                              method isEnabled

                                                                                                                                              isEnabled: () => boolean;

                                                                                                                                                class ContextualDecoratorRule

                                                                                                                                                class Rule extends AbstractRule {}

                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                    property metadata

                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                      method apply

                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                        class ContextualLifecycleRule

                                                                                                                                                        class Rule extends AbstractRule {}

                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                            property metadata

                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                              method apply

                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                class DirectiveClassSuffixRule

                                                                                                                                                                class Rule extends Lint.Rules.AbstractRule {}

                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                    property metadata

                                                                                                                                                                    static readonly metadata: Lint.IRuleMetadata;

                                                                                                                                                                      method apply

                                                                                                                                                                      apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

                                                                                                                                                                        method validate

                                                                                                                                                                        static validate: (className: string, suffixes: string[]) => boolean;

                                                                                                                                                                          class DirectiveMetadata

                                                                                                                                                                          class DirectiveMetadata {}

                                                                                                                                                                            constructor

                                                                                                                                                                            constructor(
                                                                                                                                                                            controller: ts.ClassDeclaration,
                                                                                                                                                                            decorator: ts.Decorator,
                                                                                                                                                                            selector?: string
                                                                                                                                                                            );

                                                                                                                                                                              property controller

                                                                                                                                                                              readonly controller: ts.ClassDeclaration;

                                                                                                                                                                                property decorator

                                                                                                                                                                                readonly decorator: ts.Decorator;

                                                                                                                                                                                  property selector

                                                                                                                                                                                  readonly selector?: string;

                                                                                                                                                                                    class DirectiveSelectorRule

                                                                                                                                                                                    class Rule extends SelectorPropertyBase {}

                                                                                                                                                                                      property handleType

                                                                                                                                                                                      handleType: string;

                                                                                                                                                                                        property metadata

                                                                                                                                                                                        static readonly metadata: IRuleMetadata;

                                                                                                                                                                                          method getPrefixFailure

                                                                                                                                                                                          getPrefixFailure: (prefixes: ReadonlyArray<string>) => string;

                                                                                                                                                                                            method getStyleFailure

                                                                                                                                                                                            getStyleFailure: (style: SelectorStyle) => string;

                                                                                                                                                                                              method getTypeFailure

                                                                                                                                                                                              getTypeFailure: (types: ReadonlyArray<SelectorType>) => string;

                                                                                                                                                                                                method isEnabled

                                                                                                                                                                                                isEnabled: () => boolean;

                                                                                                                                                                                                  class ImportDestructuringSpacingRule

                                                                                                                                                                                                  class Rule extends AbstractRule {}

                                                                                                                                                                                                    property FAILURE_STRING

                                                                                                                                                                                                    static readonly FAILURE_STRING: string;

                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                      static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                        method apply

                                                                                                                                                                                                        apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                          class InjectableMetadata

                                                                                                                                                                                                          class InjectableMetadata {}

                                                                                                                                                                                                            constructor

                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                            controller: ts.ClassDeclaration,
                                                                                                                                                                                                            decorator: ts.Decorator,
                                                                                                                                                                                                            providedIn?: any
                                                                                                                                                                                                            );

                                                                                                                                                                                                              property controller

                                                                                                                                                                                                              readonly controller: ts.ClassDeclaration;

                                                                                                                                                                                                                property decorator

                                                                                                                                                                                                                readonly decorator: ts.Decorator;

                                                                                                                                                                                                                  property providedIn

                                                                                                                                                                                                                  readonly providedIn?: any;

                                                                                                                                                                                                                    class ModuleMetadata

                                                                                                                                                                                                                    class ModuleMetadata {}

                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                      constructor(controller: ts.ClassDeclaration, decorator: ts.Decorator);

                                                                                                                                                                                                                        property controller

                                                                                                                                                                                                                        readonly controller: ts.ClassDeclaration;

                                                                                                                                                                                                                          property decorator

                                                                                                                                                                                                                          readonly decorator: ts.Decorator;

                                                                                                                                                                                                                            class NgWalker

                                                                                                                                                                                                                            class NgWalker extends Lint.RuleWalker {}

                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                              sourceFile: ts.SourceFile,
                                                                                                                                                                                                                              _originalOptions: Lint.IOptions,
                                                                                                                                                                                                                              _config?: NgWalkerConfig,
                                                                                                                                                                                                                              _metadataReader?: MetadataReader
                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                method getContextSourceFile

                                                                                                                                                                                                                                protected getContextSourceFile: (path: string, content: string) => ts.SourceFile;

                                                                                                                                                                                                                                  method visitClassDeclaration

                                                                                                                                                                                                                                  visitClassDeclaration: (declaration: ts.ClassDeclaration) => void;

                                                                                                                                                                                                                                    method visitClassDecorator

                                                                                                                                                                                                                                    protected visitClassDecorator: (decorator: ts.Decorator) => void;

                                                                                                                                                                                                                                      method visitMethodDeclaration

                                                                                                                                                                                                                                      visitMethodDeclaration: (method: ts.MethodDeclaration) => void;

                                                                                                                                                                                                                                        method visitMethodDecorator

                                                                                                                                                                                                                                        protected visitMethodDecorator: (decorator: ts.Decorator) => void;

                                                                                                                                                                                                                                          method visitNgComponent

                                                                                                                                                                                                                                          protected visitNgComponent: (metadata: ComponentMetadata) => void;

                                                                                                                                                                                                                                            method visitNgContentChild

                                                                                                                                                                                                                                            protected visitNgContentChild: (
                                                                                                                                                                                                                                            property: ts.PropertyDeclaration,
                                                                                                                                                                                                                                            input: ts.Decorator,
                                                                                                                                                                                                                                            args: string[]
                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                              method visitNgContentChildren

                                                                                                                                                                                                                                              protected visitNgContentChildren: (
                                                                                                                                                                                                                                              property: ts.PropertyDeclaration,
                                                                                                                                                                                                                                              input: ts.Decorator,
                                                                                                                                                                                                                                              args: string[]
                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                method visitNgDirective

                                                                                                                                                                                                                                                protected visitNgDirective: (metadata: DirectiveMetadata) => void;

                                                                                                                                                                                                                                                  method visitNgHostBinding

                                                                                                                                                                                                                                                  protected visitNgHostBinding: (
                                                                                                                                                                                                                                                  property: ts.PropertyDeclaration,
                                                                                                                                                                                                                                                  decorator: ts.Decorator,
                                                                                                                                                                                                                                                  args: string[]
                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                    method visitNgHostListener

                                                                                                                                                                                                                                                    protected visitNgHostListener: (
                                                                                                                                                                                                                                                    method: ts.MethodDeclaration,
                                                                                                                                                                                                                                                    decorator: ts.Decorator,
                                                                                                                                                                                                                                                    args: string[]
                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                      method visitNgInjectable

                                                                                                                                                                                                                                                      protected visitNgInjectable: (metadata: InjectableMetadata) => void;

                                                                                                                                                                                                                                                        method visitNgInput

                                                                                                                                                                                                                                                        protected visitNgInput: (
                                                                                                                                                                                                                                                        property: ts.PropertyDeclaration,
                                                                                                                                                                                                                                                        input: ts.Decorator,
                                                                                                                                                                                                                                                        args: string[]
                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                          method visitNgModule

                                                                                                                                                                                                                                                          protected visitNgModule: (metadata: ModuleMetadata) => void;

                                                                                                                                                                                                                                                            method visitNgOutput

                                                                                                                                                                                                                                                            protected visitNgOutput: (
                                                                                                                                                                                                                                                            property: ts.PropertyDeclaration,
                                                                                                                                                                                                                                                            output: ts.Decorator,
                                                                                                                                                                                                                                                            args: string[]
                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                              method visitNgPipe

                                                                                                                                                                                                                                                              protected visitNgPipe: (metadata: PipeMetadata) => void;

                                                                                                                                                                                                                                                                method visitNgStyleHelper

                                                                                                                                                                                                                                                                protected visitNgStyleHelper: (
                                                                                                                                                                                                                                                                style: CssAst,
                                                                                                                                                                                                                                                                context: ComponentMetadata,
                                                                                                                                                                                                                                                                styleMetadata: StyleMetadata,
                                                                                                                                                                                                                                                                baseStart: number
                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                  method visitNgTemplateHelper

                                                                                                                                                                                                                                                                  protected visitNgTemplateHelper: (
                                                                                                                                                                                                                                                                  roots: compiler.TemplateAst[],
                                                                                                                                                                                                                                                                  context: ComponentMetadata,
                                                                                                                                                                                                                                                                  baseStart: number
                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                    method visitNgViewChild

                                                                                                                                                                                                                                                                    protected visitNgViewChild: (
                                                                                                                                                                                                                                                                    property: ts.PropertyDeclaration,
                                                                                                                                                                                                                                                                    input: ts.Decorator,
                                                                                                                                                                                                                                                                    args: string[]
                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                      method visitNgViewChildren

                                                                                                                                                                                                                                                                      protected visitNgViewChildren: (
                                                                                                                                                                                                                                                                      property: ts.PropertyDeclaration,
                                                                                                                                                                                                                                                                      input: ts.Decorator,
                                                                                                                                                                                                                                                                      args: string[]
                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                        method visitPropertyDeclaration

                                                                                                                                                                                                                                                                        visitPropertyDeclaration: (prop: ts.PropertyDeclaration) => void;

                                                                                                                                                                                                                                                                          method visitPropertyDecorator

                                                                                                                                                                                                                                                                          protected visitPropertyDecorator: (decorator: ts.Decorator) => void;

                                                                                                                                                                                                                                                                            class NoAttributeDecoratorRule

                                                                                                                                                                                                                                                                            class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                              property FAILURE_STRING

                                                                                                                                                                                                                                                                              static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                property metadata

                                                                                                                                                                                                                                                                                static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                  method apply

                                                                                                                                                                                                                                                                                  apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                    class NoConflictingLifecycleRule

                                                                                                                                                                                                                                                                                    class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                      property FAILURE_STRING_INTERFACE_HOOK

                                                                                                                                                                                                                                                                                      static readonly FAILURE_STRING_INTERFACE_HOOK: string;

                                                                                                                                                                                                                                                                                        property FAILURE_STRING_METHOD_HOOK

                                                                                                                                                                                                                                                                                        static readonly FAILURE_STRING_METHOD_HOOK: string;

                                                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                                                          static metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                                                            apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                              class NoForwardRefRule

                                                                                                                                                                                                                                                                                              class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                property FAILURE_STRING

                                                                                                                                                                                                                                                                                                static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                  property metadata

                                                                                                                                                                                                                                                                                                  static metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                                                                    apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                      class NoHostMetadataPropertyRule

                                                                                                                                                                                                                                                                                                      class Rule extends MetadataPropertyBase {}

                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                        constructor(options: IOptions);

                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                              class NoInputPrefixRule

                                                                                                                                                                                                                                                                                                              class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                  property metadata

                                                                                                                                                                                                                                                                                                                  static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                                                                                    apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                      method isEnabled

                                                                                                                                                                                                                                                                                                                      isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                        class NoInputRenameRule

                                                                                                                                                                                                                                                                                                                        class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                class NoInputsMetadataPropertyRule

                                                                                                                                                                                                                                                                                                                                class Rule extends MetadataPropertyBase {}

                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                  constructor(options: IOptions);

                                                                                                                                                                                                                                                                                                                                    property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                    static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                                                                      static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                        class NoLifecycleCallRule

                                                                                                                                                                                                                                                                                                                                        class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                class NoOutputNativeRule

                                                                                                                                                                                                                                                                                                                                                class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                        class NoOutputOnPrefixRule

                                                                                                                                                                                                                                                                                                                                                        class Rule extends Lint.Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                            static readonly metadata: Lint.IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                class NoOutputRenameRule

                                                                                                                                                                                                                                                                                                                                                                class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                        class NoOutputsMetadataPropertyRule

                                                                                                                                                                                                                                                                                                                                                                        class Rule extends MetadataPropertyBase {}

                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                          constructor(options: IOptions);

                                                                                                                                                                                                                                                                                                                                                                            property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                            static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                              property metadata

                                                                                                                                                                                                                                                                                                                                                                              static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                class NoPipeImpureRule

                                                                                                                                                                                                                                                                                                                                                                                class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                        class NoQueriesMetadataPropertyRule

                                                                                                                                                                                                                                                                                                                                                                                        class Rule extends MetadataPropertyBase {}

                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                          constructor(options: IOptions);

                                                                                                                                                                                                                                                                                                                                                                                            property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                            static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                              property metadata

                                                                                                                                                                                                                                                                                                                                                                                              static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                class NoUnusedCssRule

                                                                                                                                                                                                                                                                                                                                                                                                class Rule extends Lint.Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                  property metadata

                                                                                                                                                                                                                                                                                                                                                                                                  static readonly metadata: Lint.IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                                                                                                                                                                    apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                      class PipeMetadata

                                                                                                                                                                                                                                                                                                                                                                                                      class PipeMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                                        controller: ts.ClassDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                        decorator: ts.Decorator,
                                                                                                                                                                                                                                                                                                                                                                                                        name?: string,
                                                                                                                                                                                                                                                                                                                                                                                                        pure?: ts.BooleanLiteral
                                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                                          property controller

                                                                                                                                                                                                                                                                                                                                                                                                          readonly controller: ts.ClassDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                            property decorator

                                                                                                                                                                                                                                                                                                                                                                                                            readonly decorator: ts.Decorator;

                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                              readonly name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property pure

                                                                                                                                                                                                                                                                                                                                                                                                                readonly pure?: ts.BooleanLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                  class PipePrefixRule

                                                                                                                                                                                                                                                                                                                                                                                                                  class Rule extends Lint.Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(options: Lint.IOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                      property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                      static FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                        static readonly metadata: Lint.IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                          property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                          prefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                                                                                                                                                                                            apply: (sourceFile: ts.SourceFile) => Lint.RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                              method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                              isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                method validatePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                validatePrefix: (prefix: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                  class PreferInlineDecoratorRule

                                                                                                                                                                                                                                                                                                                                                                                                                                  class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                        apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                          isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            class PreferOnPushComponentChangeDetectionRule

                                                                                                                                                                                                                                                                                                                                                                                                                                            class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                  apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                    class PreferOutputReadonlyRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                        static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                          apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class RelativeUrlPrefixRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class TemplateAccessibilityAltTextRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property DEFAULT_ELEMENTS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly DEFAULT_ELEMENTS: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TemplateAccessibilityElementsContentRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ELEMENTS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly ELEMENTS: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class TemplateAccessibilityLabelForVisitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class TemplateAccessibilityTabindexNoPositiveRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property FAILURE_MESSAGE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly FAILURE_MESSAGE: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TemplateAccessibilityTableScopeRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property FAILURE_MESSAGE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly FAILURE_MESSAGE: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class TemplateAccessibilityValidAriaRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class TemplateBananaInBoxRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TemplateClickEventsHaveKeyEventsRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class TemplateConditionalComplexityRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property DEFAULT_MAX_COMPLEXITY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly DEFAULT_MAX_COMPLEXITY: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class TemplateCyclomaticComplexityRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property DEFAULT_MAX_COMPLEXITY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly DEFAULT_MAX_COMPLEXITY: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TemplateI18nRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING_ATTR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING_ATTR: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property FAILURE_STRING_TEXT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly FAILURE_STRING_TEXT: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class TemplateMouseEventsHaveKeyEventsRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property FAILURE_STRING_MOUSE_OUT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly FAILURE_STRING_MOUSE_OUT: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property FAILURE_STRING_MOUSE_OVER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly FAILURE_STRING_MOUSE_OVER: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class TemplateNoAnyRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TemplateNoAutofocusRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class TemplateNoCallExpressionRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TemplateNoDistractingElementsRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Rule extends Rules.AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class TemplateNoNegatedAsyncRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property FAILURE_STRING_NEGATED_PIPE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static readonly FAILURE_STRING_NEGATED_PIPE: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING_UNSTRICT_EQUALITY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING_UNSTRICT_EQUALITY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TemplateUseTrackByFunctionRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class UseComponentSelectorRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UseComponentViewEncapsulationRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class UseInjectableProvidedInRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UseLifecycleInterfaceRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class UsePipeDecoratorRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UsePipeTransformInterfaceRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Rule extends AbstractRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property FAILURE_STRING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly FAILURE_STRING: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly metadata: IRuleMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: (sourceFile: SourceFile) => RuleFailure[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface AnimationMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface AnimationMetadata extends PropertyMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animation: CodeWithSourceMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CodeWithSourceMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CodeWithSourceMap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              code: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                map?: RawSourceMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Config {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property interpolation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interpolation: [string, string];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property logLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        logLevel: ValueOf<typeof LogLevel>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property predefinedDirectives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          predefinedDirectives: DirectiveDeclaration[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property resolveUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolveUrl: UrlResolver;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property transformStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              transformStyle: StyleTransformer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property transformTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transformTemplate: TemplateTransformer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CssAstVisitorCtrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CssAstVisitorCtrl {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceFile: ts.SourceFile,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: Lint.IOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context: ComponentMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    style: StyleMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    templateStart: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DirectiveDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DirectiveDeclaration {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property exportAs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        exportAs?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property hostAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hostAttributes?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hostListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hostListeners?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hostProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hostProperties?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property inputs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                inputs?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property outputs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  outputs?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selector: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NgWalkerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NgWalkerConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssVisitorCtrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssVisitorCtrl?: CssAstVisitorCtrl;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property expressionVisitorCtrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          expressionVisitorCtrl?: RecursiveAngularExpressionVisitorCtr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property templateVisitorCtrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            templateVisitorCtrl?: TemplateAstVisitorCtr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PropertyMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PropertyMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node?: ts.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  url?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RecursiveAngularExpressionVisitorCtr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RecursiveAngularExpressionVisitorCtr {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      new (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceFile: ts.SourceFile,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: Lint.IOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      context: ComponentMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      basePosition: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface StyleMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface StyleMetadata extends PropertyMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          style: CodeWithSourceMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StyleTransformer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StyleTransformer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (code: string, url?: string): CodeWithSourceMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TemplateAstVisitorCtr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TemplateAstVisitorCtr {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  new (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceFile: ts.SourceFile,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: Lint.IOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  context: ComponentMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  templateStart: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expressionVisitorCtrl: RecursiveAngularExpressionVisitorCtr
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TemplateMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TemplateMetadata extends PropertyMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      template: CodeWithSourceMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TemplateTransformer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TemplateTransformer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (code: string, url?: string): CodeWithSourceMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UrlResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UrlResolver {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (url: string | null): string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (59)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (14)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/codelyzer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/codelyzer)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/codelyzer"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>