.config/coc/extensions/node_modules/coc-prettier/node_modules/tslint/lib/rules/completedDocsRule.d.ts

   1 /**
   2  * @license
   3  * Copyright 2013 Palantir Technologies, Inc.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 import * as ts from "typescript";
  18 import * as Lint from "../index";
  19 import { IInputExclusionDescriptors } from "./completed-docs/exclusionDescriptors";
  20 export declare const ALL = "all";
  21 export declare const ARGUMENT_CLASSES = "classes";
  22 export declare const ARGUMENT_ENUMS = "enums";
  23 export declare const ARGUMENT_ENUM_MEMBERS = "enum-members";
  24 export declare const ARGUMENT_FUNCTIONS = "functions";
  25 export declare const ARGUMENT_INTERFACES = "interfaces";
  26 export declare const ARGUMENT_METHODS = "methods";
  27 export declare const ARGUMENT_NAMESPACES = "namespaces";
  28 export declare const ARGUMENT_PROPERTIES = "properties";
  29 export declare const ARGUMENT_TYPES = "types";
  30 export declare const ARGUMENT_VARIABLES = "variables";
  31 export declare const DESCRIPTOR_TAGS = "tags";
  32 export declare const DESCRIPTOR_LOCATIONS = "locations";
  33 export declare const DESCRIPTOR_OVERLOADS = "overloads";
  34 export declare const DESCRIPTOR_PRIVACIES = "privacies";
  35 export declare const DESCRIPTOR_VISIBILITIES = "visibilities";
  36 export declare const LOCATION_INSTANCE = "instance";
  37 export declare const LOCATION_STATIC = "static";
  38 export declare const PRIVACY_PRIVATE = "private";
  39 export declare const PRIVACY_PROTECTED = "protected";
  40 export declare const PRIVACY_PUBLIC = "public";
  41 export declare const TAGS_FOR_CONTENT = "content";
  42 export declare const TAGS_FOR_EXISTENCE = "existence";
  43 export declare const VISIBILITY_EXPORTED = "exported";
  44 export declare const VISIBILITY_INTERNAL = "internal";
  45 export declare type All = typeof ALL;
  46 export declare type DocType = All | typeof ARGUMENT_CLASSES | typeof ARGUMENT_ENUMS | typeof ARGUMENT_ENUM_MEMBERS | typeof ARGUMENT_FUNCTIONS | typeof ARGUMENT_INTERFACES | typeof ARGUMENT_METHODS | typeof ARGUMENT_NAMESPACES | typeof ARGUMENT_PROPERTIES | typeof ARGUMENT_TYPES | typeof ARGUMENT_VARIABLES;
  47 export declare type Location = All | typeof LOCATION_INSTANCE | typeof LOCATION_STATIC;
  48 export declare type Privacy = All | typeof PRIVACY_PRIVATE | typeof PRIVACY_PROTECTED | typeof PRIVACY_PUBLIC;
  49 export declare type Visibility = All | typeof VISIBILITY_EXPORTED | typeof VISIBILITY_INTERNAL;
  50 export declare class Rule extends Lint.Rules.AbstractRule {
  51     static FAILURE_STRING_EXIST: string;
  52     static defaultArguments: IInputExclusionDescriptors;
  53     static ARGUMENT_DESCRIPTOR_BLOCK: {
  54         properties: {
  55             tags: {
  56                 properties: {
  57                     content: {
  58                         items: {
  59                             type: string;
  60                         };
  61                         type: string;
  62                     };
  63                     existence: {
  64                         items: {
  65                             type: string;
  66                         };
  67                         type: string;
  68                     };
  69                 };
  70             };
  71             visibilities: {
  72                 enum: string[];
  73                 type: string;
  74             };
  75         };
  76         type: string;
  77     };
  78     static ARGUMENT_DESCRIPTOR_CLASS: {
  79         properties: {
  80             tags: {
  81                 properties: {
  82                     content: {
  83                         items: {
  84                             type: string;
  85                         };
  86                         type: string;
  87                     };
  88                     existence: {
  89                         items: {
  90                             type: string;
  91                         };
  92                         type: string;
  93                     };
  94                 };
  95             };
  96             locations: {
  97                 enum: string[];
  98                 type: string;
  99             };
 100             privacies: {
 101                 enum: string[];
 102                 type: string;
 103             };
 104         };
 105         type: string;
 106     };
 107     static ARGUMENT_DESCRIPTOR_FUNCTION: {
 108         properties: {
 109             overloads: {
 110                 type: string;
 111             };
 112             tags: {
 113                 properties: {
 114                     content: {
 115                         items: {
 116                             type: string;
 117                         };
 118                         type: string;
 119                     };
 120                     existence: {
 121                         items: {
 122                             type: string;
 123                         };
 124                         type: string;
 125                     };
 126                 };
 127             };
 128             visibilities: {
 129                 enum: string[];
 130                 type: string;
 131             };
 132         };
 133         type: string;
 134     };
 135     static ARGUMENT_DESCRIPTOR_METHOD: {
 136         properties: {
 137             overloads: {
 138                 type: string;
 139             };
 140             tags: {
 141                 properties: {
 142                     content: {
 143                         items: {
 144                             type: string;
 145                         };
 146                         type: string;
 147                     };
 148                     existence: {
 149                         items: {
 150                             type: string;
 151                         };
 152                         type: string;
 153                     };
 154                 };
 155             };
 156             locations: {
 157                 enum: string[];
 158                 type: string;
 159             };
 160             privacies: {
 161                 enum: string[];
 162                 type: string;
 163             };
 164         };
 165         type: string;
 166     };
 167     static metadata: Lint.IRuleMetadata;
 168     apply(sourceFile: ts.SourceFile): Lint.RuleFailure[];
 169     private getExclusionsMap;
 170 }