Brunobkr/llama.cpp_AlgMor24_github

1import ts from 'typescript';2 3/**4 * Descriptive data for a comment as yielded by {@link iterateComments}.5 */6type Comment = ts.CommentRange & {7    text: string;8    value: string;9};10/**11 * Callback type used for {@link forEachComment}.12 * @category Callbacks13 * @param fullText Full parsed text of the comment.14 * @param comment Text range of the comment in its file.15 * @example16 * ```ts17 * let onComment: ForEachCommentCallback = (fullText, comment) => {18 *    console.log(`Found comment at position ${comment.pos}: '${fullText}'.`);19 * };20 * ```21 */22type ForEachCommentCallback = (fullText: string, comment: ts.CommentRange) => void;23/**24 * Iterates over all comments owned by `node` or its children.25 * @category Nodes - Other Utilities26 * @example27 * ```ts28 * declare const node: ts.Node;29 *30 * forEachComment(node, (fullText, comment) => {31 *    console.log(`Found comment at position ${comment.pos}: '${fullText}'.`);32 * });33 * ```34 */35declare function forEachComment(node: ts.Node, callback: ForEachCommentCallback, sourceFile?: ts.SourceFile): void;36/**37 * Iterates over all comments owned by `node` or its children.38 * @category Nodes - Other Utilities39 * @example40 * ```ts41 * declare const node: ts.Node;42 *43 * for (const {pos, text} of iterateComment(node) {44 *    console.log(`Found comment at position ${pos}: '${text}'.`);45 * };46 * ```47 */48declare function iterateComments(node: ts.Node, sourceFile?: ts.SourceFile): Generator<Comment>;49 50/**51 * An option that can be tested with {@link isCompilerOptionEnabled}.52 * @category Compiler Options53 */54type BooleanCompilerOptions = keyof {55    [K in keyof ts.CompilerOptions as NonNullable<ts.CompilerOptions[K]> extends boolean ? K : never]: unknown;56};57/**58 * An option that can be tested with {@link isStrictCompilerOptionEnabled}.59 * @category Compiler Options60 */61type StrictCompilerOption = "alwaysStrict" | "noImplicitAny" | "noImplicitThis" | "strictBindCallApply" | "strictFunctionTypes" | "strictNullChecks" | "strictPropertyInitialization";62/**63 * Checks if a given compiler option is enabled.64 * It handles dependencies of options, e.g. `declaration` is implicitly enabled by `composite` or `strictNullChecks` is enabled by `strict`.65 * However, it does not check dependencies that are already checked and reported as errors, e.g. `checkJs` without `allowJs`.66 * This function only handles boolean flags.67 * @category Compiler Options68 * @example69 * ```ts70 * const options = {71 * 	allowJs: true,72 * };73 *74 * isCompilerOptionEnabled(options, "allowJs"); // true75 * isCompilerOptionEnabled(options, "allowSyntheticDefaultImports"); // false76 * ```77 */78declare function isCompilerOptionEnabled(options: ts.CompilerOptions, option: BooleanCompilerOptions): boolean;79/**80 * Checks if a given compiler option is enabled, accounting for whether all flags81 * (except `strictPropertyInitialization`) have been enabled by `strict: true`.82 * @category Compiler Options83 * @example84 * ```ts85 * const optionsLenient = {86 * 	noImplicitAny: true,87 * };88 *89 * isStrictCompilerOptionEnabled(optionsLenient, "noImplicitAny"); // true90 * isStrictCompilerOptionEnabled(optionsLenient, "noImplicitThis"); // false91 * ```92 * @example93 * ```ts94 * const optionsStrict = {95 * 	noImplicitThis: false,96 * 	strict: true,97 * };98 *99 * isStrictCompilerOptionEnabled(optionsStrict, "noImplicitAny"); // true100 * isStrictCompilerOptionEnabled(optionsStrict, "noImplicitThis"); // false101 * ```102 */103declare function isStrictCompilerOptionEnabled(options: ts.CompilerOptions, option: StrictCompilerOption): boolean;104 105/**106 * Test if the given node has the given `ModifierFlags` set.107 * @category Nodes - Flag Utilities108 * @example109 * ```ts110 * declare const node: ts.Node;111 *112 * if (isModifierFlagSet(node, ts.ModifierFlags.Abstract)) {113 *   // ...114 * }115 * ```116 */117declare function isModifierFlagSet(node: ts.Declaration, flag: ts.ModifierFlags): boolean;118/**119 * Test if the given node has the given `NodeFlags` set.120 * @category Nodes - Flag Utilities121 * @example122 * ```ts123 * declare const node: ts.Node;124 *125 * if (isNodeFlagSet(node, ts.NodeFlags.AwaitContext)) {126 *   // ...127 * }128 * ```129 */130declare const isNodeFlagSet: (node: ts.Node, flag: ts.NodeFlags) => boolean;131/**132 * Test if the given node has the given `ObjectFlags` set.133 * @category Nodes - Flag Utilities134 * @example135 * ```ts136 * declare const node: ts.Node;137 *138 * if (isObjectFlagSet(node, ts.ObjectFlags.Anonymous)) {139 *   // ...140 * }141 * ```142 */143declare function isObjectFlagSet(objectType: ts.ObjectType, flag: ts.ObjectFlags): boolean;144/**145 * Test if the given node has the given `SymbolFlags` set.146 * @category Nodes - Flag Utilities147 * @example148 * ```ts149 * declare const symbol: ts.Symbol;150 *151 * if (isSymbolFlagSet(symbol, ts.SymbolFlags.Accessor)) {152 *   // ...153 * }154 * ```155 */156declare const isSymbolFlagSet: (symbol: ts.Symbol, flag: ts.SymbolFlags) => boolean;157/**158 * Test if the given node has the given `TypeFlags` set.159 * @category Nodes - Flag Utilities160 * @example161 * ```ts162 * declare const type: ts.Type;163 *164 * if (isTypeFlagSet(type, ts.TypeFlags.Any)) {165 *   // ...166 * }167 * ```168 */169declare const isTypeFlagSet: (type: ts.Type, flag: ts.TypeFlags) => boolean;170 171/**172 * Test if the given iterable includes a modifier of any of the given kinds.173 * @category Modifier Utilities174 * @example175 * ```ts176 * declare const modifiers: ts.Modifier[];177 *178 * includesModifier(modifiers, ts.SyntaxKind.AbstractKeyword);179 * ```180 */181declare function includesModifier(modifiers: Iterable<ts.ModifierLike> | undefined, ...kinds: ts.ModifierSyntaxKind[]): boolean;182 183/**184 * What operations(s), if any, an expression applies.185 */186declare enum AccessKind {187    None = 0,188    Read = 1,189    Write = 2,190    Delete = 4,191    ReadWrite = 3192}193/**194 * Determines which operation(s), if any, an expression applies.195 * @example196 * ```ts197 * declare const node: ts.Expression;198 *199 * if (getAccessKind(node).Write & AccessKind.Write) !== 0) {200 *   // this is a reassignment (write)201 * }202 * ```203 */204declare function getAccessKind(node: ts.Expression): AccessKind;205 206/**207 * An `AssertionExpression` that is declared as const.208 * @category Node Types209 */210type ConstAssertionExpression = ts.AssertionExpression & {211    type: ts.TypeReferenceNode;212    typeName: ConstAssertionIdentifier;213};214/**215 * An `Identifier` with an `escapedText` value of `"const"`.216 * @category Node Types217 */218type ConstAssertionIdentifier = ts.Identifier & {219    escapedText: "const" & ts.__String;220};221/**222 * a `NamedDeclaration` that definitely has a name.223 * @category Node Types224 */225interface NamedDeclarationWithName extends ts.NamedDeclaration {226    name: ts.DeclarationName;227}228/**229 * A number or string-like literal.230 * @category Node Types231 */232type NumericOrStringLikeLiteral = ts.NumericLiteral | ts.StringLiteralLike;233/**234 * Test if a node is a {@link ConstAssertionExpression}.235 * @category Nodes - Type Guards236 * @example237 * ```ts238 * declare const node: ts.Node;239 *240 * if (isConstAssertionExpression(node)) {241 *   // ...242 * }243 * ```244 * @returns Whether the given node appears to be a {@link ConstAssertionExpression}.245 */246declare function isConstAssertionExpression(node: ts.AssertionExpression): node is ConstAssertionExpression;247/**248 * Test if a node is an `IterationStatement`.249 * @category Nodes - Type Guards250 * @example251 * ```ts252 * declare const node: ts.Node;253 *254 * if (isIterationStatement(node)) {255 *   // ...256 * }257 * ```258 * @returns Whether the given node appears to be an `IterationStatement`.259 */260declare function isIterationStatement(node: ts.Node): node is ts.IterationStatement;261/**262 * Test if a node is a `JSDocNamespaceDeclaration`.263 * @category Nodes - Type Guards264 * @example265 * ```ts266 * declare const node: ts.Node;267 *268 * if (isJSDocNamespaceDeclaration(node)) {269 *   // ...270 * }271 * ```272 * @returns Whether the given node appears to be a `JSDocNamespaceDeclaration`.273 */274declare function isJSDocNamespaceDeclaration(node: ts.Node): node is ts.JSDocNamespaceDeclaration;275/**276 * Test if a node is a `JsxTagNamePropertyAccess`.277 * @category Nodes - Type Guards278 * @example279 * ```ts280 * declare const node: ts.Node;281 *282 * if (isJsxTagNamePropertyAccess(node)) {283 *   // ...284 * }285 * ```286 * @returns Whether the given node appears to be a `JsxTagNamePropertyAccess`.287 */288declare function isJsxTagNamePropertyAccess(node: ts.Node): node is ts.JsxTagNamePropertyAccess;289/**290 * Test if a node is a {@link NamedDeclarationWithName}.291 * @category Nodes - Type Guards292 * @example293 * ```ts294 * declare const node: ts.Node;295 *296 * if (isNamedDeclarationWithName(node)) {297 *   // ...298 * }299 * ```300 * @returns Whether the given node appears to be a {@link NamedDeclarationWithName}.301 */302declare function isNamedDeclarationWithName(node: ts.Declaration): node is NamedDeclarationWithName;303/**304 * Test if a node is a `NamespaceDeclaration`.305 * @category Nodes - Type Guards306 * @example307 * ```ts308 * declare const node: ts.Node;309 *310 * if (isNamespaceDeclaration(node)) {311 *   // ...312 * }313 * ```314 * @returns Whether the given node appears to be a `NamespaceDeclaration`.315 */316declare function isNamespaceDeclaration(node: ts.Node): node is ts.NamespaceDeclaration;317/**318 * Test if a node is a {@link NumericOrStringLikeLiteral}.319 * @category Nodes - Type Guards320 * @example321 * ```ts322 * declare const node: ts.Node;323 *324 * if (isNumericOrStringLikeLiteral(node)) {325 *   // ...326 * }327 * ```328 * @returns Whether the given node appears to be a {@link NumericOrStringLikeLiteral}.329 */330declare function isNumericOrStringLikeLiteral(node: ts.Node): node is NumericOrStringLikeLiteral;331/**332 * Test if a node is a `PropertyAccessEntityNameExpression`.333 * @category Nodes - Type Guards334 * @example335 * ```ts336 * declare const node: ts.Node;337 *338 * if (isPropertyAccessEntityNameExpression(node)) {339 *   // ...340 * }341 * ```342 * @returns Whether the given node appears to be a `PropertyAccessEntityNameExpression`.343 */344declare function isPropertyAccessEntityNameExpression(node: ts.Node): node is ts.PropertyAccessEntityNameExpression;345/**346 * Test if a node is a `SuperElementAccessExpression`.347 * @category Nodes - Type Guards348 * @example349 * ```ts350 * declare const node: ts.Node;351 *352 * if (isSuperElementAccessExpression(node)) {353 *   // ...354 * }355 * ```356 * @returns Whether the given node appears to be a `SuperElementAccessExpression`.357 */358declare function isSuperElementAccessExpression(node: ts.Node): node is ts.SuperElementAccessExpression;359/**360 * Test if a node is a `SuperPropertyAccessExpression`.361 * @category Nodes - Type Guards362 * @example363 * ```ts364 * declare const node: ts.Node;365 *366 * if (isSuperPropertyAccessExpression(node)) {367 *   // ...368 * }369 * ```370 * @returns Whether the given node appears to be a `SuperPropertyAccessExpression`.371 */372declare function isSuperPropertyAccessExpression(node: ts.Node): node is ts.SuperPropertyAccessExpression;373 374/**375 * A node that represents the any keyword.376 * @category Node Types377 */378type AnyKeyword = ts.KeywordToken<ts.SyntaxKind.AnyKeyword>;379/**380 * A node that represents the bigint keyword.381 * @category Node Types382 */383type BigIntKeyword = ts.KeywordToken<ts.SyntaxKind.BigIntKeyword>;384/**385 * A node that represents the boolean keyword.386 * @category Node Types387 */388type BooleanKeyword = ts.KeywordToken<ts.SyntaxKind.BooleanKeyword>;389/**390 * A node that represents the false keyword.391 * @category Node Types392 */393type FalseKeyword = ts.KeywordToken<ts.SyntaxKind.FalseKeyword>;394/**395 * A node that represents the import keyword.396 * @category Node Types397 */398type ImportKeyword = ts.KeywordToken<ts.SyntaxKind.ImportKeyword>;399/**400 * A node that represents the never keyword.401 * @category Node Types402 */403type NeverKeyword = ts.KeywordToken<ts.SyntaxKind.NeverKeyword>;404/**405 * A node that represents the null keyword.406 * @category Node Types407 */408type NullKeyword = ts.KeywordToken<ts.SyntaxKind.NullKeyword>;409/**410 * A node that represents the number keyword.411 * @category Node Types412 */413type NumberKeyword = ts.KeywordToken<ts.SyntaxKind.NumberKeyword>;414/**415 * A node that represents the object keyword.416 * @category Node Types417 */418type ObjectKeyword = ts.KeywordToken<ts.SyntaxKind.ObjectKeyword>;419/**420 * A node that represents the string keyword.421 * @category Node Types422 */423type StringKeyword = ts.KeywordToken<ts.SyntaxKind.StringKeyword>;424/**425 * A node that represents the super keyword.426 * @category Node Types427 */428type SuperKeyword = ts.KeywordToken<ts.SyntaxKind.SuperKeyword>;429/**430 * A node that represents the symbol keyword.431 * @category Node Types432 */433type SymbolKeyword = ts.KeywordToken<ts.SyntaxKind.SymbolKeyword>;434/**435 * A node that represents the this keyword.436 * @category Node Types437 */438type ThisKeyword = ts.KeywordToken<ts.SyntaxKind.ThisKeyword>;439/**440 * A node that represents the true keyword.441 * @category Node Types442 */443type TrueKeyword = ts.KeywordToken<ts.SyntaxKind.TrueKeyword>;444/**445 * A node that represents the undefined keyword.446 * @category Node Types447 */448type UndefinedKeyword = ts.KeywordToken<ts.SyntaxKind.UndefinedKeyword>;449/**450 * A node that represents the unknown keyword.451 * @category Node Types452 */453type UnknownKeyword = ts.KeywordToken<ts.SyntaxKind.UnknownKeyword>;454/**455 * A node that represents the void keyword.456 * @category Node Types457 */458type VoidKeyword = ts.KeywordToken<ts.SyntaxKind.VoidKeyword>;459/**460 * Test if a node is an `AbstractKeyword`.461 * @category Nodes - Type Guards462 * @example463 * ```ts464 * declare const node: ts.Node;465 *466 * if (isAbstractKeyword(node)) {467 *   // ...468 * }469 * ```470 * @returns Whether the given node appears to be an `AbstractKeyword`.471 */472declare function isAbstractKeyword(node: ts.Node): node is ts.AbstractKeyword;473/**474 * Test if a node is an `AccessorKeyword`.475 * @category Nodes - Type Guards476 * @example477 * ```ts478 * declare const node: ts.Node;479 *480 * if (isAccessorKeyword(node)) {481 *   // ...482 * }483 * ```484 * @returns Whether the given node appears to be an `AccessorKeyword`.485 */486declare function isAccessorKeyword(node: ts.Node): node is ts.AccessorKeyword;487/**488 * Test if a node is an {@link AnyKeyword}.489 * @category Nodes - Type Guards490 * @example491 * ```ts492 * declare const node: ts.Node;493 *494 * if (isAnyKeyword(node)) {495 *   // ...496 * }497 * ```498 * @returns Whether the given node appears to be an {@link AnyKeyword}.499 */500declare function isAnyKeyword(node: ts.Node): node is AnyKeyword;501/**502 * Test if a node is an `AssertKeyword`.503 * @category Nodes - Type Guards504 * @example505 * ```ts506 * declare const node: ts.Node;507 *508 * if (isAssertKeyword(node)) {509 *   // ...510 * }511 * ```512 * @returns Whether the given node appears to be an `AssertKeyword`.513 */514declare function isAssertKeyword(node: ts.Node): node is ts.AssertKeyword;515/**516 * Test if a node is an `AssertsKeyword`.517 * @deprecated With TypeScript v5, in favor of typescript's `isAssertsKeyword`.518 * @category Nodes - Type Guards519 * @example520 * ```ts521 * declare const node: ts.Node;522 *523 * if (isAssertsKeyword(node)) {524 *   // ...525 * }526 * ```527 * @returns Whether the given node appears to be an `AssertsKeyword`.528 */529declare function isAssertsKeyword(node: ts.Node): node is ts.AssertsKeyword;530/**531 * Test if a node is an `AsyncKeyword`.532 * @category Nodes - Type Guards533 * @example534 * ```ts535 * declare const node: ts.Node;536 *537 * if (isAsyncKeyword(node)) {538 *   // ...539 * }540 * ```541 * @returns Whether the given node appears to be an `AsyncKeyword`.542 */543declare function isAsyncKeyword(node: ts.Node): node is ts.AsyncKeyword;544/**545 * Test if a node is an `AwaitKeyword`.546 * @deprecated With TypeScript v5, in favor of typescript's `isAwaitKeyword`.547 * @category Nodes - Type Guards548 * @example549 * ```ts550 * declare const node: ts.Node;551 *552 * if (isAwaitKeyword(node)) {553 *   // ...554 * }555 * ```556 * @returns Whether the given node appears to be an `AwaitKeyword`.557 */558declare function isAwaitKeyword(node: ts.Node): node is ts.AwaitKeyword;559/**560 * Test if a node is a {@link BigIntKeyword}.561 * @deprecated With TypeScript v5, in favor of typescript's `isBigIntKeyword`.562 * @category Nodes - Type Guards563 * @example564 * ```ts565 * declare const node: ts.Node;566 *567 * if (isBigIntKeyword(node)) {568 *   // ...569 * }570 * ```571 * @returns Whether the given node appears to be a {@link BigIntKeyword}.572 */573declare function isBigIntKeyword(node: ts.Node): node is BigIntKeyword;574/**575 * Test if a node is a {@link BooleanKeyword}.576 * @deprecated With TypeScript v5, in favor of typescript's `isBooleanKeyword`.577 * @category Nodes - Type Guards578 * @example579 * ```ts580 * declare const node: ts.Node;581 *582 * if (isBooleanKeyword(node)) {583 *   // ...584 * }585 * ```586 * @returns Whether the given node appears to be a {@link BooleanKeyword}.587 */588declare function isBooleanKeyword(node: ts.Node): node is BooleanKeyword;589/**590 * Test if a node is a `ColonToken`.591 * @deprecated With TypeScript v5, in favor of typescript's `isColonToken`.592 * @category Nodes - Type Guards593 * @example594 * ```ts595 * declare const node: ts.Node;596 *597 * if (isColonToken(node)) {598 *   // ...599 * }600 * ```601 * @returns Whether the given node appears to be a `ColonToken`.602 */603declare function isColonToken(node: ts.Node): node is ts.ColonToken;604/**605 * Test if a node is a `ConstKeyword`.606 * @category Nodes - Type Guards607 * @example608 * ```ts609 * declare const node: ts.Node;610 *611 * if (isConstKeyword(node)) {612 *   // ...613 * }614 * ```615 * @returns Whether the given node appears to be a `ConstKeyword`.616 */617declare function isConstKeyword(node: ts.Node): node is ts.ConstKeyword;618/**619 * Test if a node is a `DeclareKeyword`.620 * @category Nodes - Type Guards621 * @example622 * ```ts623 * declare const node: ts.Node;624 *625 * if (isDeclareKeyword(node)) {626 *   // ...627 * }628 * ```629 * @returns Whether the given node appears to be a `DeclareKeyword`.630 */631declare function isDeclareKeyword(node: ts.Node): node is ts.DeclareKeyword;632/**633 * Test if a node is a `DefaultKeyword`.634 * @category Nodes - Type Guards635 * @example636 * ```ts637 * declare const node: ts.Node;638 *639 * if (isDefaultKeyword(node)) {640 *   // ...641 * }642 * ```643 * @returns Whether the given node appears to be a `DefaultKeyword`.644 */645declare function isDefaultKeyword(node: ts.Node): node is ts.DefaultKeyword;646/**647 * Test if a node is a `DotToken`.648 * @category Nodes - Type Guards649 * @example650 * ```ts651 * declare const node: ts.Node;652 *653 * if (isDotToken(node)) {654 *   // ...655 * }656 * ```657 * @returns Whether the given node appears to be a `DotToken`.658 */659declare function isDotToken(node: ts.Node): node is ts.DotToken;660/**661 * Test if a node is an `EndOfFileToken`.662 * @category Nodes - Type Guards663 * @example664 * ```ts665 * declare const node: ts.Node;666 *667 * if (isEndOfFileToken(node)) {668 *   // ...669 * }670 * ```671 * @returns Whether the given node appears to be an `EndOfFileToken`.672 */673declare function isEndOfFileToken(node: ts.Node): node is ts.EndOfFileToken;674/**675 * Test if a node is an `EqualsGreaterThanToken`.676 * @deprecated With TypeScript v5, in favor of typescript's `isEqualsGreaterThanToken`.677 * @category Nodes - Type Guards678 * @example679 * ```ts680 * declare const node: ts.Node;681 *682 * if (isEqualsGreaterThanToken(node)) {683 *   // ...684 * }685 * ```686 * @returns Whether the given node appears to be an `EqualsGreaterThanToken`.687 */688declare function isEqualsGreaterThanToken(node: ts.Node): node is ts.EqualsGreaterThanToken;689/**690 * Test if a node is an `EqualsToken`.691 * @category Nodes - Type Guards692 * @example693 * ```ts694 * declare const node: ts.Node;695 *696 * if (isEqualsToken(node)) {697 *   // ...698 * }699 * ```700 * @returns Whether the given node appears to be an `EqualsToken`.701 */702declare function isEqualsToken(node: ts.Node): node is ts.EqualsToken;703/**704 * Test if a node is an `ExclamationToken`.705 * @deprecated With TypeScript v5, in favor of typescript's `isExclamationToken`.706 * @category Nodes - Type Guards707 * @example708 * ```ts709 * declare const node: ts.Node;710 *711 * if (isExclamationToken(node)) {712 *   // ...713 * }714 * ```715 * @returns Whether the given node appears to be an `ExclamationToken`.716 */717declare function isExclamationToken(node: ts.Node): node is ts.ExclamationToken;718/**719 * Test if a node is an `ExportKeyword`.720 * @category Nodes - Type Guards721 * @example722 * ```ts723 * declare const node: ts.Node;724 *725 * if (isExportKeyword(node)) {726 *   // ...727 * }728 * ```729 * @returns Whether the given node appears to be an `ExportKeyword`.730 */731declare function isExportKeyword(node: ts.Node): node is ts.ExportKeyword;732/**733 * Test if a node is a {@link FalseKeyword}.734 * @category Nodes - Type Guards735 * @example736 * ```ts737 * declare const node: ts.Node;738 *739 * if (isFalseKeyword(node)) {740 *   // ...741 * }742 * ```743 * @returns Whether the given node appears to be a {@link FalseKeyword}.744 */745declare function isFalseKeyword(node: ts.Node): node is FalseKeyword;746/**747 * Test if a node is a `FalseLiteral`.748 * @category Nodes - Type Guards749 * @example750 * ```ts751 * declare const node: ts.Node;752 *753 * if (isFalseLiteral(node)) {754 *   // ...755 * }756 * ```757 * @returns Whether the given node appears to be a `FalseLiteral`.758 */759declare function isFalseLiteral(node: ts.Node): node is ts.FalseLiteral;760/**761 * Test if a node is an `ImportExpression`.762 * @category Nodes - Type Guards763 * @example764 * ```ts765 * declare const node: ts.Node;766 *767 * if (isImportExpression(node)) {768 *   // ...769 * }770 * ```771 * @returns Whether the given node appears to be an `ImportExpression`.772 */773declare function isImportExpression(node: ts.Node): node is ts.ImportExpression;774/**775 * Test if a node is an {@link ImportKeyword}.776 * @category Nodes - Type Guards777 * @example778 * ```ts779 * declare const node: ts.Node;780 *781 * if (isImportKeyword(node)) {782 *   // ...783 * }784 * ```785 * @returns Whether the given node appears to be an {@link ImportKeyword}.786 */787declare function isImportKeyword(node: ts.Node): node is ImportKeyword;788/**789 * Test if a node is an `InKeyword`.790 * @category Nodes - Type Guards791 * @example792 * ```ts793 * declare const node: ts.Node;794 *795 * if (isInKeyword(node)) {796 *   // ...797 * }798 * ```799 * @returns Whether the given node appears to be an `InKeyword`.800 */801declare function isInKeyword(node: ts.Node): node is ts.InKeyword;802/**803 * Test if a node is a `JSDocText`.804 * @category Nodes - Type Guards805 * @example806 * ```ts807 * declare const node: ts.Node;808 *809 * if (isJSDocText(node)) {810 *   // ...811 * }812 * ```813 * @returns Whether the given node appears to be a `JSDocText`.814 */815declare function isJSDocText(node: ts.Node): node is ts.JSDocText;816/**817 * Test if a node is a `JsonMinusNumericLiteral`.818 * @category Nodes - Type Guards819 * @example820 * ```ts821 * declare const node: ts.Node;822 *823 * if (isJsonMinusNumericLiteral(node)) {824 *   // ...825 * }826 * ```827 * @returns Whether the given node appears to be a `JsonMinusNumericLiteral`.828 */829declare function isJsonMinusNumericLiteral(node: ts.Node): node is ts.JsonMinusNumericLiteral;830/**831 * Test if a node is a {@link NeverKeyword}.832 * @category Nodes - Type Guards833 * @example834 * ```ts835 * declare const node: ts.Node;836 *837 * if (isNeverKeyword(node)) {838 *   // ...839 * }840 * ```841 * @returns Whether the given node appears to be a {@link NeverKeyword}.842 */843declare function isNeverKeyword(node: ts.Node): node is NeverKeyword;844/**845 * Test if a node is a {@link NullKeyword}.846 * @category Nodes - Type Guards847 * @example848 * ```ts849 * declare const node: ts.Node;850 *851 * if (isNullKeyword(node)) {852 *   // ...853 * }854 * ```855 * @returns Whether the given node appears to be a {@link NullKeyword}.856 */857declare function isNullKeyword(node: ts.Node): node is NullKeyword;858/**859 * Test if a node is a `NullLiteral`.860 * @category Nodes - Type Guards861 * @example862 * ```ts863 * declare const node: ts.Node;864 *865 * if (isNullLiteral(node)) {866 *   // ...867 * }868 * ```869 * @returns Whether the given node appears to be a `NullLiteral`.870 */871declare function isNullLiteral(node: ts.Node): node is ts.NullLiteral;872/**873 * Test if a node is a {@link NumberKeyword}.874 * @category Nodes - Type Guards875 * @example876 * ```ts877 * declare const node: ts.Node;878 *879 * if (isNumberKeyword(node)) {880 *   // ...881 * }882 * ```883 * @returns Whether the given node appears to be a {@link NumberKeyword}.884 */885declare function isNumberKeyword(node: ts.Node): node is NumberKeyword;886/**887 * Test if a node is an {@link ObjectKeyword}.888 * @category Nodes - Type Guards889 * @example890 * ```ts891 * declare const node: ts.Node;892 *893 * if (isObjectKeyword(node)) {894 *   // ...895 * }896 * ```897 * @returns Whether the given node appears to be an {@link ObjectKeyword}.898 */899declare function isObjectKeyword(node: ts.Node): node is ObjectKeyword;900/**901 * Test if a node is an `OutKeyword`.902 * @category Nodes - Type Guards903 * @example904 * ```ts905 * declare const node: ts.Node;906 *907 * if (isOutKeyword(node)) {908 *   // ...909 * }910 * ```911 * @returns Whether the given node appears to be an `OutKeyword`.912 */913declare function isOutKeyword(node: ts.Node): node is ts.OutKeyword;914/**915 * Test if a node is an `OverrideKeyword`.916 * @category Nodes - Type Guards917 * @example918 * ```ts919 * declare const node: ts.Node;920 *921 * if (isOverrideKeyword(node)) {922 *   // ...923 * }924 * ```925 * @returns Whether the given node appears to be an `OverrideKeyword`.926 */927declare function isOverrideKeyword(node: ts.Node): node is ts.OverrideKeyword;928/**929 * Test if a node is a `PrivateKeyword`.930 * @category Nodes - Type Guards931 * @example932 * ```ts933 * declare const node: ts.Node;934 *935 * if (isPrivateKeyword(node)) {936 *   // ...937 * }938 * ```939 * @returns Whether the given node appears to be a `PrivateKeyword`.940 */941declare function isPrivateKeyword(node: ts.Node): node is ts.PrivateKeyword;942/**943 * Test if a node is a `ProtectedKeyword`.944 * @category Nodes - Type Guards945 * @example946 * ```ts947 * declare const node: ts.Node;948 *949 * if (isProtectedKeyword(node)) {950 *   // ...951 * }952 * ```953 * @returns Whether the given node appears to be a `ProtectedKeyword`.954 */955declare function isProtectedKeyword(node: ts.Node): node is ts.ProtectedKeyword;956/**957 * Test if a node is a `PublicKeyword`.958 * @category Nodes - Type Guards959 * @example960 * ```ts961 * declare const node: ts.Node;962 *963 * if (isPublicKeyword(node)) {964 *   // ...965 * }966 * ```967 * @returns Whether the given node appears to be a `PublicKeyword`.968 */969declare function isPublicKeyword(node: ts.Node): node is ts.PublicKeyword;970/**971 * Test if a node is a `QuestionDotToken`.972 * @deprecated With TypeScript v5, in favor of typescript's `isQuestionDotToken`.973 * @category Nodes - Type Guards974 * @example975 * ```ts976 * declare const node: ts.Node;977 *978 * if (isQuestionDotToken(node)) {979 *   // ...980 * }981 * ```982 * @returns Whether the given node appears to be a `QuestionDotToken`.983 */984declare function isQuestionDotToken(node: ts.Node): node is ts.QuestionDotToken;985/**986 * Test if a node is a `QuestionToken`.987 * @deprecated With TypeScript v5, in favor of typescript's `isQuestionToken`.988 * @category Nodes - Type Guards989 * @example990 * ```ts991 * declare const node: ts.Node;992 *993 * if (isQuestionToken(node)) {994 *   // ...995 * }996 * ```997 * @returns Whether the given node appears to be a `QuestionToken`.998 */999declare function isQuestionToken(node: ts.Node): node is ts.QuestionToken;1000/**1001 * Test if a node is a `ReadonlyKeyword`.1002 * @category Nodes - Type Guards1003 * @example1004 * ```ts1005 * declare const node: ts.Node;1006 *1007 * if (isReadonlyKeyword(node)) {1008 *   // ...1009 * }1010 * ```1011 * @returns Whether the given node appears to be a `ReadonlyKeyword`.1012 */1013declare function isReadonlyKeyword(node: ts.Node): node is ts.ReadonlyKeyword;1014/**1015 * Test if a node is a `StaticKeyword`.1016 * @category Nodes - Type Guards1017 * @example1018 * ```ts1019 * declare const node: ts.Node;1020 *1021 * if (isStaticKeyword(node)) {1022 *   // ...1023 * }1024 * ```1025 * @returns Whether the given node appears to be a `StaticKeyword`.1026 */1027declare function isStaticKeyword(node: ts.Node): node is ts.StaticKeyword;1028/**1029 * Test if a node is a {@link StringKeyword}.1030 * @category Nodes - Type Guards1031 * @example1032 * ```ts1033 * declare const node: ts.Node;1034 *1035 * if (isStringKeyword(node)) {1036 *   // ...1037 * }1038 * ```1039 * @returns Whether the given node appears to be a {@link StringKeyword}.1040 */1041declare function isStringKeyword(node: ts.Node): node is StringKeyword;1042/**1043 * Test if a node is a `SuperExpression`.1044 * @category Nodes - Type Guards1045 * @example1046 * ```ts1047 * declare const node: ts.Node;1048 *1049 * if (isSuperExpression(node)) {1050 *   // ...1051 * }1052 * ```1053 * @returns Whether the given node appears to be a `SuperExpression`.1054 */1055declare function isSuperExpression(node: ts.Node): node is ts.SuperExpression;1056/**1057 * Test if a node is a {@link SuperKeyword}.1058 * @category Nodes - Type Guards1059 * @example1060 * ```ts1061 * declare const node: ts.Node;1062 *1063 * if (isSuperKeyword(node)) {1064 *   // ...1065 * }1066 * ```1067 * @returns Whether the given node appears to be a {@link SuperKeyword}.1068 */1069declare function isSuperKeyword(node: ts.Node): node is SuperKeyword;1070/**1071 * Test if a node is a {@link SymbolKeyword}.1072 * @category Nodes - Type Guards1073 * @example1074 * ```ts1075 * declare const node: ts.Node;1076 *1077 * if (isSymbolKeyword(node)) {1078 *   // ...1079 * }1080 * ```1081 * @returns Whether the given node appears to be a {@link SymbolKeyword}.1082 */1083declare function isSymbolKeyword(node: ts.Node): node is SymbolKeyword;1084/**1085 * Test if a node is a `SyntaxList`.1086 * @category Nodes - Type Guards1087 * @example1088 * ```ts1089 * declare const node: ts.Node;1090 *1091 * if (isSyntaxList(node)) {1092 *   // ...1093 * }1094 * ```1095 * @returns Whether the given node appears to be a `SyntaxList`.1096 */1097declare function isSyntaxList(node: ts.Node): node is ts.SyntaxList;1098/**1099 * Test if a node is a `ThisExpression`.1100 * @category Nodes - Type Guards1101 * @example1102 * ```ts1103 * declare const node: ts.Node;1104 *1105 * if (isThisExpression(node)) {1106 *   // ...1107 * }1108 * ```1109 * @returns Whether the given node appears to be a `ThisExpression`.1110 */1111declare function isThisExpression(node: ts.Node): node is ts.ThisExpression;1112/**1113 * Test if a node is a {@link ThisKeyword}.1114 * @category Nodes - Type Guards1115 * @example1116 * ```ts1117 * declare const node: ts.Node;1118 *1119 * if (isThisKeyword(node)) {1120 *   // ...1121 * }1122 * ```1123 * @returns Whether the given node appears to be a {@link ThisKeyword}.1124 */1125declare function isThisKeyword(node: ts.Node): node is ThisKeyword;1126/**1127 * Test if a node is a {@link TrueKeyword}.1128 * @category Nodes - Type Guards1129 * @example1130 * ```ts1131 * declare const node: ts.Node;1132 *1133 * if (isTrueKeyword(node)) {1134 *   // ...1135 * }1136 * ```1137 * @returns Whether the given node appears to be a {@link TrueKeyword}.1138 */1139declare function isTrueKeyword(node: ts.Node): node is TrueKeyword;1140/**1141 * Test if a node is a `TrueLiteral`.1142 * @category Nodes - Type Guards1143 * @example1144 * ```ts1145 * declare const node: ts.Node;1146 *1147 * if (isTrueLiteral(node)) {1148 *   // ...1149 * }1150 * ```1151 * @returns Whether the given node appears to be a `TrueLiteral`.1152 */1153declare function isTrueLiteral(node: ts.Node): node is ts.TrueLiteral;1154/**1155 * Test if a node is an {@link UndefinedKeyword}.1156 * @category Nodes - Type Guards1157 * @example1158 * ```ts1159 * declare const node: ts.Node;1160 *1161 * if (isUndefinedKeyword(node)) {1162 *   // ...1163 * }1164 * ```1165 * @returns Whether the given node appears to be an {@link UndefinedKeyword}.1166 */1167declare function isUndefinedKeyword(node: ts.Node): node is UndefinedKeyword;1168/**1169 * Test if a node is an {@link UnknownKeyword}.1170 * @category Nodes - Type Guards1171 * @example1172 * ```ts1173 * declare const node: ts.Node;1174 *1175 * if (isUnknownKeyword(node)) {1176 *   // ...1177 * }1178 * ```1179 * @returns Whether the given node appears to be an {@link UnknownKeyword}.1180 */1181declare function isUnknownKeyword(node: ts.Node): node is UnknownKeyword;1182/**1183 * Test if a node is a {@link VoidKeyword}.1184 * @category Nodes - Type Guards1185 * @example1186 * ```ts1187 * declare const node: ts.Node;1188 *1189 * if (isVoidKeyword(node)) {1190 *   // ...1191 * }1192 * ```1193 * @returns Whether the given node appears to be a {@link VoidKeyword}.1194 */1195declare function isVoidKeyword(node: ts.Node): node is VoidKeyword;1196 1197/**1198 * Test if a node is a `HasDecorators`.1199 * @category Nodes - Type Guards1200 * @example

Showing the first 1,200 of 3054 lines. Download the file for the rest.