Standard Tags Registry

/**
 * Registry of all standard TSDoc tag definitions
 */
class StandardTags {
  /** All standard tag definitions (75+ tags) */
  static readonly allDefinitions: ReadonlyArray<TSDocTagDefinition>;
  
  // Core Tags (universally supported)
  static readonly param: TSDocTagDefinition;
  static readonly returns: TSDocTagDefinition;
  static readonly typeParam: TSDocTagDefinition;
  static readonly remarks: TSDocTagDefinition;
  static readonly example: TSDocTagDefinition;
  static readonly public: TSDocTagDefinition;
  static readonly private: TSDocTagDefinition;
  static readonly protected: TSDocTagDefinition;
  static readonly internal: TSDocTagDefinition;
  static readonly readonly: TSDocTagDefinition;
  static readonly override: TSDocTagDefinition;
  static readonly virtual: TSDocTagDefinition;
  static readonly sealed: TSDocTagDefinition;
  static readonly static: TSDocTagDefinition;
  
  // Extended Tags (recommended)
  static readonly alpha: TSDocTagDefinition;
  static readonly beta: TSDocTagDefinition;
  static readonly deprecated: TSDocTagDefinition;
  static readonly experimental: TSDocTagDefinition;
  static readonly throws: TSDocTagDefinition;
  static readonly see: TSDocTagDefinition;
  static readonly since: TSDocTagDefinition;
  static readonly defaultValue: TSDocTagDefinition;
  
  // Discretionary Tags (tool-specific)
  static readonly author: TSDocTagDefinition;
  static readonly version: TSDocTagDefinition;
  static readonly packageDocumentation: TSDocTagDefinition;
  static readonly fileoverview: TSDocTagDefinition;
  static readonly license: TSDocTagDefinition;
  static readonly copyright: TSDocTagDefinition;
}

import { StandardTags, TSDocConfiguration } from "@microsoft/tsdoc";

// Get all standard tags
console.log(`Total standard tags: ${StandardTags.allDefinitions.length}`);

// Check tag properties
console.log(`@param allows multiple: ${StandardTags.param.allowMultiple}`);
console.log(`@returns syntax kind: ${StandardTags.returns.syntaxKind}`);

// Add all standard tags to configuration
const config = new TSDocConfiguration();
config.addTagDefinitions(StandardTags.allDefinitions);

// Enable only core tags
const coreTags = [
  StandardTags.param,
  StandardTags.returns,
  StandardTags.remarks,
  StandardTags.example
];
config.setSupportForTags(coreTags, true);

/**
 * Standardization levels for TSDoc tags
 */
enum Standardization {
  /** No standardization level assigned */
  None = "None",
  
  /** Core tags that all tools should support */
  Core = "Core",
  
  /** Extended tags that are recommended but optional */
  Extended = "Extended",
  
  /** Discretionary tags that are tool-specific */
  Discretionary = "Discretionary"
}

/**
 * Collection of standard modifier tags like @public, @beta, @alpha
 */
class StandardModifierTagSet extends ModifierTagSet {
  // Release state modifiers
  readonly isPublic: boolean;
  readonly isProtected: boolean;
  readonly isPrivate: boolean;
  readonly isInternal: boolean;
  
  // API stability modifiers
  readonly isAlpha: boolean;
  readonly isBeta: boolean;
  readonly isExperimental: boolean;
  
  // Code modifiers
  readonly isReadonly: boolean;
  readonly isStatic: boolean;
  readonly isVirtual: boolean;
  readonly isOverride: boolean;
  readonly isSealed: boolean;
}

/**
 * Base class for collections of modifier tags
 */
class ModifierTagSet {
  /** Check if a specific tag definition is present */
  hasTag(tagDefinition: TSDocTagDefinition): boolean;
  
  /** Check if a tag with the given name is present */
  hasTagName(tagName: string): boolean;
  
  /** Add a tag definition to the set */
  addTag(tagDefinition: TSDocTagDefinition): void;
}

import { TSDocParser } from "@microsoft/tsdoc";

const parser = new TSDocParser();
const context = parser.parseString(`
  /**
   * This is a beta API that might change.
   * @beta
   * @readonly
   * @static
   */
`);

const modifiers = context.docComment.modifierTagSet;

// Check for specific modifiers
if (modifiers.isBeta) {
  console.log("This is a beta API");
}

if (modifiers.isReadonly && modifiers.isStatic) {
  console.log("This is a static readonly member");
}

// Check visibility
const visibility = modifiers.isPublic ? "public" :
                  modifiers.isProtected ? "protected" :
                  modifiers.isPrivate ? "private" : "default";
console.log(`Visibility: ${visibility}`);

// Block tags for structured documentation
static readonly param: TSDocTagDefinition;        // @param name - description
static readonly returns: TSDocTagDefinition;      // @returns description
static readonly typeParam: TSDocTagDefinition;    // @typeParam T - description
static readonly remarks: TSDocTagDefinition;      // @remarks additional info
static readonly example: TSDocTagDefinition;      // @example code sample
static readonly throws: TSDocTagDefinition;       // @throws ErrorType - when thrown
static readonly see: TSDocTagDefinition;          // @see related item
static readonly since: TSDocTagDefinition;        // @since version
static readonly deprecated: TSDocTagDefinition;   // @deprecated use instead
static readonly defaultValue: TSDocTagDefinition; // @defaultValue description

// Access level modifiers
static readonly public: TSDocTagDefinition;       // @public - externally visible
static readonly protected: TSDocTagDefinition;    // @protected - subclass visible
static readonly private: TSDocTagDefinition;      // @private - internal only
static readonly internal: TSDocTagDefinition;     // @internal - package internal

// Code behavior modifiers
static readonly readonly: TSDocTagDefinition;     // @readonly - immutable
static readonly static: TSDocTagDefinition;       // @static - class-level
static readonly virtual: TSDocTagDefinition;      // @virtual - can be overridden
static readonly override: TSDocTagDefinition;     // @override - overrides parent
static readonly sealed: TSDocTagDefinition;       // @sealed - cannot be extended

// API stability indicators
static readonly alpha: TSDocTagDefinition;        // @alpha - early experimental
static readonly beta: TSDocTagDefinition;         // @beta - preview release
static readonly experimental: TSDocTagDefinition; // @experimental - may change

// Package/file level documentation
static readonly packageDocumentation: TSDocTagDefinition; // @packageDocumentation
static readonly fileoverview: TSDocTagDefinition;         // @fileoverview
static readonly license: TSDocTagDefinition;              // @license
static readonly copyright: TSDocTagDefinition;            // @copyright
static readonly author: TSDocTagDefinition;               // @author
static readonly version: TSDocTagDefinition;              // @version

/**
 * Processes user data with validation.
 * @param userData - The user information to process
 * @param options - Optional processing configuration
 * @param callback - Function called when processing completes
 * @typeParam T - The type of user data
 * @returns Promise that resolves to processed data
 * @throws ValidationError When user data is invalid
 */
function processUser<T>(
  userData: T, 
  options?: ProcessOptions,
  callback?: (result: T) => void
): Promise<T>;

/**
 * Legacy authentication method.
 * @deprecated Use `authenticateWithToken()` instead
 * @since 1.0.0
 * @see {@link authenticateWithToken} for the new approach
 * @internal
 */
function authenticateWithPassword(username: string, password: string): boolean;

/**
 * New token-based authentication.
 * @beta
 * @since 2.0.0
 * @example
 * ```typescript
 * const success = authenticateWithToken("abc123");
 * ```
 */
function authenticateWithToken(token: string): boolean;

/**
 * Base class for data processors.
 * @public
 */
class DataProcessor {
  /**
   * Configuration options.
   * @readonly
   * @protected
   */
  protected readonly config: ProcessConfig;
  
  /**
   * Default processor instance.
   * @static
   * @public
   */
  static readonly defaultProcessor: DataProcessor;
  
  /**
   * Process data (can be overridden).
   * @virtual
   * @param data - Input data
   */
  process(data: any): any {
    // implementation
  }
}

/**
 * Specialized processor.
 * @sealed
 */
class SpecializedProcessor extends DataProcessor {
  /**
   * Enhanced processing method.
   * @override
   */
  process(data: any): any {
    // specialized implementation
  }
}