TypeDoc is a sophisticated documentation generator for TypeScript projects. It parses TypeScript source code using the TypeScript compiler API, extracts JSDoc/TSDoc comments, and produces both JSON model serializations and fully-featured HTML documentation sites with search, navigation, themes, and internationalization. The system operates as a CLI tool and a programmable library, featuring a plugin architecture with converter plugins, renderer plugins, and serialization components that hook into a well-defined event lifecycle. The architecture is modular: a converter transforms the TypeScript AST into an internal reflection model, the renderer produces output via themes and routers, and a serialization layer supports JSON round-tripping for caching and merging. The codebase demonstrates advanced TypeScript patterns including a custom JSX factory for rendering, a type model hierarchy with a visitor pattern, a comprehensive options system with declarative definitions and multiple readers, and a stable event system. There are no data/research elements; this is a pure application tool.
DocFX is a .NET-based documentation generator that creates static HTML websites from Markdown, YAML metadata, .NET API comments, and REST API specifications. It features a modular architecture with a plugin system for extensibility, processing pipelines for different document types (conceptual, managed reference, REST API), and a template engine for customizable output. The system processes input files through metadata extraction, template application, and post-processing to generate documentation sites. Key components include a command-line interface (docfx.exe), build orchestration, schema-driven document validation, cross-reference resolution, and resource handling. The tool supports multiple templates (default, modern, statictoc) and output formats including HTML and PDF via Playwright rendering.
GraphQL Voyager is an interactive GraphQL schema explorer that visualizes any GraphQL API as an interactive graph. It consumes GraphQL introspection data (or SDL) and renders a navigable representation of the schema's types, fields, and relationships using Graphviz and SVG. The application is built with React and TypeScript, offering multiple consumption methods: a standalone bundle for direct browser use, an NPM package for integration with bundlers like Webpack, and middleware adapters for Express, Hapi, and Koa frameworks. The core functionality involves processing introspection JSON to extract type information, filtering out internal types (like Relay) and deprecated fields, and constructing a graph where nodes represent GraphQL types and edges represent relationships (such as field types). This graph is rendered via a Graphviz worker, with the resulting SVG enhanced for interactivity (tooltips, pan/zoom, click-to-explore). A companion documentation panel allows users to inspect details of selected types, including fields, arguments, and directives. Beyond the visualization, Voyager includes several reusable utilities that demonstrate thoughtful engineering: an LRU cache implemented in localStorage for efficient SVG rendering caching, a React hook for managing promise states (loading, error, success), and a flexible object matching utility. The project maintains a robust development workflow with TypeScript, Webpack, Playwright end-to-end testing (via Docker), and automated dependency updates via Dependabot. Recent commits indicate active maintenance, and the codebase adheres to modern React and TypeScript practices.
Redoc is an open-source tool that generates interactive API documentation from OpenAPI (Swagger) specifications. It parses OpenAPI definitions (supporting versions 2.0, 3.0, and 3.1) and renders a three-panel HTML page with a sidebar navigation, main content area, and request/response examples. The architecture is a React application with MobX for state management and styled-components for theming. Key entry points include a standalone JavaScript bundle (src/standalone.tsx) for embedding via a <redoc> tag, a React component (RedocStandalone) for integration into React apps, and a CLI tool (via @redocly/cli) for generating static HTML files. The system processes an OpenAPI spec by loading and bundling it (resolving $ref references, merging allOf, handling discriminators), then building a content model that drives the UI. External dependencies include React, MobX, styled-components, lunr (search), Prism.js (syntax highlighting), and marked (markdown rendering). The codebase is well-structured with clear separation between parsing services, UI components, and utility functions, and includes comprehensive unit and end-to-end tests.
Sphinx AutoAPI is a Sphinx extension that automatically generates API documentation by statically analyzing Python source code using the astroid library, without importing or executing the documented code. It reads Python files and .pyi stubs, builds an internal object model (modules, classes, functions, etc.), applies configurable filtering options (e.g., private members, inherited members), and renders the documentation as RST via Jinja templates. The extension also provides autodoc-style directives (e.g., autoapifunction, autoapimethod) that allow manual documentation entries backed by the same static analysis, and supports inheritance diagrams, type annotation rendering, PEP-695 type parameters, overloaded signatures, and integration with Sphinx's viewcode. Its architecture separates parsing (astroid-based), mapping (object creation and option evaluation), and output (template rendering), making the core logic reusable in other static analysis tools.
mitmproxy2swagger is a CLI tool that automatically converts HTTP traffic captures from mitmproxy or browser HAR exports into OpenAPI 3.0 specifications. It enables reverse-engineering REST APIs by analyzing recorded traffic without manual inspection. The tool uses a two-pass workflow: the first pass identifies API paths and generates a template file with parameter placeholders; after the user edits the template to select endpoints, the second pass produces full endpoint descriptions with inferred request/response schemas. Architecturally, the tool is a single-purpose Python application organized into modular components: input readers (mitmproxy_capture_reader.py for binary flow files, har_capture_reader.py for HAR JSON), a core orchestration module (mitmproxy2swagger.py) that handles argument parsing, format auto-detection, and schema merging, and utility modules (swagger_util.py for OpenAPI schema generation, console_util.py for progress display). The tool supports multiple content types (JSON, msgpack, form-urlencoded) and can optionally include example data and headers in the output. Key entry points are the `mitmproxy2swagger` command with arguments for input file, output path, API prefix, and optional flags. External dependencies include mitmproxy for reading flow files, ruamel.yaml for YAML output, json-stream for streaming HAR parsing, and msgpack for msgpack support. The codebase is well-maintained with CI/CD, tests, Docker support, and pre-commit hooks.
oq is a terminal-based OpenAPI Specification viewer that allows users to visualize and navigate OpenAPI 3.0, 3.1, and 3.2 specifications in JSON or YAML format. The application reads OpenAPI specs from files or stdin, parses them using the libopenapi library, and presents the information in an interactive terminal UI with views for endpoints, components, and webhooks. Users can navigate using keyboard shortcuts, fold/unfold sections to see details, and cycle between different views. The architecture separates OpenAPI processing logic (in oas.go) from the terminal UI (built with bubbletea), demonstrating good separation of concerns.
This repository provides the official documentation, OpenAPI specification, and client libraries for the Congress.gov API (v3), a public REST API that exposes U.S. federal legislative data including bills, amendments, members, committees, hearings, nominations, treaties, and Congressional Record content. The repo is primarily a supporting asset for the API, containing detailed endpoint documentation in Markdown, a machine-readable OpenAPI spec (openapi.yaml/json), and example client implementations in Java and Python. The Python client (cdg_client.py) demonstrates a reusable pattern with dynamic HTTP method dispatch, session management, and optional keyring-based API key storage. The Java client (CDGClient.java) uses java.net.http.HttpClient and a config file reader. The repository does not contain the actual API server implementation; it is a companion repository for developers integrating with the Congress.gov API. The codebase is well-structured, actively maintained (as evidenced by the changelog), and the documentation is comprehensive, though some minor typos exist. The duplicate client directories (java/ and api_client/java/, python/ and api_client/python/) suggest some organizational drift, but the core components are solid.
DevDocs is a web application that aggregates and serves API documentation for hundreds of programming languages, frameworks, and tools in a unified, searchable, offline-capable interface. The backend is a Ruby/Sinatra server that provides the static assets and a minimal API, while the frontend is a custom JavaScript single-page application with client-side search, keyboard navigation, and a service worker for offline access. The core data generation pipeline consists of Ruby scrapers that fetch documentation pages from official sources, apply a chain of filters (HTML cleaning, entry extraction, URL normalization, image optimization), and produce normalized JSON indexes and cached pages stored on disk. The architecture is largely monolithic with a strong separation between the scraping pipeline (lib/docs) and the frontend (assets/javascripts). While primarily an application, it contains a substantial data engineering component in its scraper/filter system, which is reusable and generalizable for other documentation aggregation projects.
Enunciate is a build-time Java framework that generates API documentation, Swagger/OpenAPI specs, WSDL/XSD, and multi-language client libraries from annotated web service source code (JAX-RS, JAX-WS, JAXB, Jackson, Spring MVC). It operates as a Maven plugin or Ant task, using a plugin architecture where each technology (JAXB, JAX-RS, etc.) and output format (HTML docs, C# client, etc.) is a separate module discovered via Java SPI. The core engine scans source files, builds an internal API model using javac annotation processing, then renders templates (FreeMarker) to produce artifacts. The codebase demonstrates solid engineering with clear separation of concerns, but shows age: it targets Java 8, uses older library versions, and has significant duplication across client generation modules. It remains functional for legacy projects but may require updates for modern Java frameworks.
Knife4j is an enhanced Swagger/OpenAPI user interface and aggregation toolkit for the Java Spring ecosystem. In production it deploys as a set of Spring Boot auto-configuration starters: openapi2 (springfox), openapi3 (springdoc), aggregation from disk/cloud/Nacos/Eureka/Polaris sources, and Spring Cloud Gateway discovery, plus an optional standalone `knife4j-insight` server and multiple frontend UIs (Vue 2, Vue 3, React/Ant Design Pro). The core data flow is: a Spring Boot service exposes OpenAPI JSON via springdoc/springfox; Knife4j customizers and plugins enrich that JSON with API ordering, markdown docs, global parameters, and enhanced metadata; the frontend consumes the OpenAPI document and renders API lists, debug consoles, OAuth2 flows, and offline export pages. Aggregation starters fetch and merge specs from remote registries or local files, cache them in memory, and proxy or route requests to upstream services.
This repository contains the official documentation for Binance Spot trading APIs. It is not a software application or data research project; it is a comprehensive reference for developers building trading clients. The documentation covers REST API, WebSocket API, WebSocket Streams, FIX API, and Simple Binary Encoding (SBE) protocols. It includes detailed specifications for endpoints, message formats, authentication, rate limits, error codes, and trading rules. The repository also provides versioned SBE XML schemas, FIX QuickFIX schemas, changelogs, and frequently asked questions. The documentation is bilingual (English and Chinese) and is actively maintained with frequent updates to reflect API changes. While the repository contains no executable code, the schema files and reference documents are essential for implementing Binance Spot integration.
This repository is a placeholder for the former Slate API documentation generator. The original code has been removed from GitHub by the author as a protest against Microsoft's contracts with ICE and the IDF. The repository now contains only a README explaining this decision and pointing to an archive. No source code is available for analysis, making it functionally dead. The project was once popular (36k stars) but is now effectively abandoned.