diff --git a/README.md b/README.md index 3d0c32c84..434139f5f 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,8 @@ It does two things: | `object-reference///` | The published, committed documentation builds (the archive). | | `iron-products.json` | Product catalog — package type, package name / Maven coordinates, domain, and URL path per product. | | `scaffolds/` | DocFX templates, `docfx..json` configs, homepages, and the `tools/` toolchain (DocFX, JDK — Git LFS). | -| `docs/` | Internal operator notes (e.g. the Windows/DocFX limitation). | +| `docs/` | Internal operator notes (e.g. the Windows/DocFX limitation) and generated API diffs under `docs/api-diffs/`. | +| `apidiff/` | Modules behind `diff-apidocs`, in both ports. | | `*.py` / `*.mjs` | The tooling, in two interchangeable ports (see below). | ## Tooling @@ -33,6 +34,7 @@ Both versions read from the same `iron-products.json` and write to the same `obj | --- | --- | --- | | Inspect a product's version / build status | `check-apidocs.py` | `check-apidocs.mjs` | | Generate any missing documentation | `update-apidocs.py` | `update-apidocs.mjs` | +| Diff the API surface between two versions | `diff-apidocs.py` | `diff-apidocs.mjs` | | Shared version/path helpers | `apidocs.py` | `apidocs.mjs` | | Colorized status output | `statuslogger.py` | `statuslogger.mjs` | @@ -88,6 +90,46 @@ node update-apidocs.mjs > [`docs/running-generation-in-wsl.md`](docs/running-generation-in-wsl.md). > The version-inspection tooling (`check-apidocs`) runs fine on any platform. +### `diff-apidocs` — compare two archived versions + +Reports what changed in a product's public API between two builds already in `object-reference/`, +classified as breaking, additive, or cosmetic. + +```bash +# Python — newest vs previous archived version +python diff-apidocs.py -p ironzip +# Node — an explicit pair, written out as JSON + Markdown +node diff-apidocs.mjs -p ironzip --from 2024.1.1 --to 2026.6.2 --json --markdown +``` + +| Flag | Meaning | +| --- | --- | +| `-p, --product-code` | Product code (e.g. `ironzip`). | +| `-n, --product-name` | Product display name (alternative to the code). | +| `--from` / `--to` | The versions to compare. Omit both for newest-vs-previous; omit one and the newest is used for that end. | +| `--namespace GLOB` | Only report types matching the glob; repeatable. | +| `--exclude GLOB` | Skip types matching the glob; repeatable. | +| `--include-internal` | Include vendored/internal namespaces (`.Internal`, `Interop`, `grpc`, `Pdfium`, `BouncyCastle`, `GrpcLayer`), which are excluded by default. | +| `--all-visibility` | Include non-public declarations (public/protected only by default). | +| `--json [PATH]` / `--markdown [PATH]` | Write an artifact; defaults to `docs/api-diffs//...{json,md}`. | +| `--quiet` / `--no-warnings` | Suppress the terminal report / parser warnings. | +| `--fail-on-breaking` | Exit `2` when breaking changes are found (for release gating). | +| `--list-versions` | List the product's archived versions and exit. | + +Exit codes: `0` success, `1` tool error (unknown product, missing version), `2` breaking changes +found with `--fail-on-breaking`. + +This tool is **entirely offline** — it reads only the committed archive, never a package registry, so +it needs no network and triggers no build. Two sources are combined per version: `xrefmap.yml` for +member identity (uid, kind, parameter types) and the DocFX `api/*.html` pages for the signature +detail xrefmap lacks (modifiers, return types, base types, default parameter values, and property +accessors). Each declaration is located by the `data-uid` DocFX writes on its heading, which is +byte-identical to the xrefmap uid. + +Because a uid encodes parameter *types*, a parameter-type change or a new overload appears as a +removal plus an addition rather than a modification; the report notes the pairing. Only DocFX (.NET) +products are supported — `ironpdfjava` is JavaDoc output with no xrefmap and exits with a message. + ### Archetype-N API-overview enhancement After DocFX generates a .NET product's `…/object-reference/api/` pages, `update-apidocs` injects a short, task-led SEO overview into each class-reference page (prose + three meta-title/description variants + `TechArticle`/`FAQPage` JSON-LD), placed below the class summary and above the member tables, wrapped in `` / `` sentinels (idempotent). This is on by default; pass `--no-enhancement` to skip it. @@ -106,7 +148,7 @@ The per-product cache (committed, with a `_manifest.json`) makes steady-state re ## Dependencies -- **Python**: `requests`, `colorama` (`pip install requests colorama`). -- **Node.js**: `adm-zip` (`npm install`) — only needed by `update-apidocs.mjs` for nupkg extraction; `check-apidocs.mjs` and `apidocs.mjs` are dependency-free. +- **Python**: `requests`, `colorama` (`pip install requests colorama`). `diff-apidocs.py` is stdlib-only apart from `colorama` (via `statuslogger.py`) — it does not use `requests`. +- **Node.js**: `adm-zip` (`npm install`) — only needed by `update-apidocs.mjs` for nupkg extraction; `check-apidocs.mjs`, `diff-apidocs.mjs`, and `apidocs.mjs` are dependency-free. - **Generation only**: the DocFX + JDK toolchain under `scaffolds/tools/` (Git LFS), plus `mono` on Linux to run DocFX. - **Archetype-N enhancement**: stdlib-only (Python) / native (Node `>=18`, global `fetch`); no extra packages. An LLM API key is only needed to author pages not already in the cache. diff --git a/_config.yml b/_config.yml index 1e3f270d1..57ff203e7 100644 --- a/_config.yml +++ b/_config.yml @@ -17,6 +17,9 @@ exclude: - package-lock.json - node_modules - __pycache__ + # The `*.py`/`*.mjs` globs above already cover its files; excluding the directory outright means + # nothing added under it can ever be published by accident. + - apidiff - scaffolds - docs - .vscode diff --git a/apidiff/__init__.py b/apidiff/__init__.py new file mode 100644 index 000000000..8a458456e --- /dev/null +++ b/apidiff/__init__.py @@ -0,0 +1,13 @@ +"""apidiff — API surface diffing for the object-reference archive. + +Reads two built version directories under ``object-reference//`` and reports what changed in +the public API surface between them, classified as breaking, additive, or cosmetic. + +Two committed sources are combined: + +* ``xrefmap.yml`` supplies member *identity* (uid + kind + parameter types) for the whole product. +* ``api/.html`` supplies the *signature* detail xrefmap lacks — modifiers, return types, + base types, default parameter values, and property accessors. + +Nothing is downloaded; the archive is the only input. See ``docs/api-surface-diff-plan.md``. +""" diff --git a/apidiff/archive.mjs b/apidiff/archive.mjs new file mode 100644 index 000000000..75be59607 --- /dev/null +++ b/apidiff/archive.mjs @@ -0,0 +1,147 @@ +/** + * archive.mjs — resolve a product and a pair of archived versions, entirely offline + * (Node port of archive.py). + * + * Directory existence under `object-reference//` is the whole version index — there is no + * manifest — so every lookup here is a filesystem read. Nothing contacts a package registry, which + * is what lets the tool run on a machine with no network and no credentials. + */ + +import { existsSync, readFileSync, statSync } from "node:fs"; +import { join } from "node:path"; + +import { PRODUCTS_CATALOG, getApidocPath, listArchivedVersions, compareVersions, versionSortKey } from "../apidocs.mjs"; + +/** Only DocFX-generated (.NET) products carry the xrefmap.yml + api/*.html pair this tool reads. */ +export const SUPPORTED_PACKAGE_TYPES = new Set(["nuget"]); + +/** A resolution failure with a message already written for the operator. */ +export class ArchiveError extends Error {} + +function loadCatalog() { + return JSON.parse(readFileSync(PRODUCTS_CATALOG, "utf-8")); +} + +/** Return a product's catalog entry from iron-products.json. */ +export function loadProduct(productCode = null, productName = null) { + if (!productCode && !productName) { + throw new ArchiveError("Please specify product code or product name (-p, --product-code | -n, --product-name)"); + } + const catalog = loadCatalog(); + for (const product of catalog.libraries) { + if ((productCode && product.code === productCode) || (productName && product.name === productName)) return product; + } + const known = catalog.libraries.map((product) => product.code).sort().join(", "); + throw new ArchiveError(`Specified product does not exist. Known product codes: ${known}`); +} + +/** Product codes this tool can diff, in catalog order. */ +export function supportedProductCodes() { + return loadCatalog().libraries + .filter((product) => SUPPORTED_PACKAGE_TYPES.has(product.packageType) && listArchivedVersions(product.code).length) + .map((product) => product.code); +} + +/** Reject products whose docs are not DocFX output (JavaDoc, pip, npm). */ +export function requireSupported(product) { + const packageType = product.packageType; + if (!SUPPORTED_PACKAGE_TYPES.has(packageType)) { + throw new ArchiveError( + `${product.code} is a ${packageType === "maven" ? "JavaDoc" : packageType} product ` + + `(packageType: ${packageType}).\n` + + `Signature diffing is not yet supported. Supported: ${supportedProductCodes().join(", ")}`, + ); + } +} + +/** Distance stand-in for a component that cannot be compared numerically, so it always ranks last. */ +const INCOMPARABLE = 10 ** 9; + +/** + * Archived versions closest to the requested one, nearest first. + * + * Candidates are ranked first by *how deep* the first differing component is — sharing a major + * version matters more than a small difference in it, so 2026.5.9 suggests 2026.5.2 ahead of + * 2025.1.1 — and only then by the size of that difference. + */ +function nearest(version, available, limit = 5) { + const target = versionSortKey(version); + + const distance = (candidate) => { + const key = versionSortKey(candidate); + const shared = Math.min(target.length, key.length); + for (let index = 0; index < shared; index++) { + const [leftKind, leftValue, leftText] = target[index]; + const [rightKind, rightValue, rightText] = key[index]; + if (leftKind !== rightKind || leftValue !== rightValue || leftText !== rightText) { + const magnitude = leftKind === 0 && rightKind === 0 ? Math.abs(leftValue - rightValue) : INCOMPARABLE; + // Negated so a difference appearing later (a longer shared prefix) sorts first. + return [-index, magnitude, candidate]; + } + } + return [-target.length, 0, candidate]; + }; + + return [...available] + .map((candidate) => [distance(candidate), candidate]) + .sort(([a], [b]) => a[0] - b[0] || a[1] - b[1] || (a[2] < b[2] ? -1 : a[2] > b[2] ? 1 : 0)) + .slice(0, limit) + .map(([, candidate]) => candidate); +} + +/** Throw unless the version has a built directory in the archive. */ +export function requireVersion(product, version, available) { + if (available.includes(version)) return; + const suggestions = available.length ? nearest(version, available).join(", ") : "(none archived)"; + throw new ArchiveError( + `${product.code} ${version} is not in the archive.\n` + + `Nearest archived: ${suggestions}\n` + + "Run update-apidocs to build it.", + ); +} + +/** + * Resolve the pair of versions to diff. With neither given, the two newest archived versions are + * used; with only one, the other end is the newest archived version. + * + * @returns {[string, string, string[]]} `[versionFrom, versionTo, available]`, oldest end first. + */ +export function resolveVersions(product, versionFrom = null, versionTo = null) { + const available = listArchivedVersions(product.code); + if (!available.length) { + throw new ArchiveError(`No archived versions found for ${product.code} under object-reference/.`); + } + + if (!versionFrom && !versionTo) { + if (available.length < 2) { + throw new ArchiveError( + `${product.code} has only one archived version (${available[0]}); nothing to diff against.`, + ); + } + return [available[available.length - 2], available[available.length - 1], available]; + } + + if (versionFrom && !versionTo) versionTo = available[available.length - 1]; + else if (versionTo && !versionFrom) versionFrom = available[available.length - 1]; + + requireVersion(product, versionFrom, available); + requireVersion(product, versionTo, available); + + if (versionFrom === versionTo) { + throw new ArchiveError(`--from and --to are both ${versionFrom}; nothing to diff.`); + } + + // Report oldest to newest regardless of the order the operator supplied them. + if (compareVersions(versionFrom, versionTo) > 0) [versionFrom, versionTo] = [versionTo, versionFrom]; + return [versionFrom, versionTo, available]; +} + +/** Path to one archived version directory. */ +export function versionDirectory(product, version) { + const path = getApidocPath(product, version); + const xrefmap = join(path, "xrefmap.yml"); + if (!existsSync(xrefmap) || !statSync(xrefmap).isFile()) { + throw new ArchiveError(`${product.code} ${version} has no xrefmap.yml at ${path}; the build may be incomplete.`); + } + return path; +} diff --git a/apidiff/archive.py b/apidiff/archive.py new file mode 100644 index 000000000..41c681185 --- /dev/null +++ b/apidiff/archive.py @@ -0,0 +1,156 @@ +"""Resolve a product and a pair of archived versions, entirely offline. + +Directory existence under ``object-reference//`` is the whole version index — there is no +manifest — so every lookup here is a filesystem read. Nothing contacts a package registry, which is +what lets the tool run on a machine with no network and no credentials. +""" + +import json +import os + +from apidocs import PRODUCTS_CATALOG, get_apidoc_path, list_archived_versions, version_sort_key + +# Only DocFX-generated (.NET) products carry the xrefmap.yml + api/*.html pair this tool reads. +SUPPORTED_PACKAGE_TYPES = ("nuget",) + + +class ArchiveError(Exception): + """A resolution failure with a message already written for the operator.""" + + +def load_product(product_code: str = None, product_name: str = None) -> dict: + """Return a product's catalog entry from iron-products.json. + + Raises: + ArchiveError: when neither identifier is given, or no entry matches. + """ + if not product_code and not product_name: + raise ArchiveError("Please specify product code or product name (-p, --product-code | -n, --product-name)") + + with open(PRODUCTS_CATALOG, "r", encoding="utf-8") as handle: + catalog = json.load(handle) + + for product in catalog["libraries"]: + if (product_code and product["code"] == product_code) or (product_name and product["name"] == product_name): + return product + + known = ", ".join(sorted(product["code"] for product in catalog["libraries"])) + raise ArchiveError(f"Specified product does not exist. Known product codes: {known}") + + +def supported_product_codes() -> list: + """Product codes this tool can diff, in catalog order.""" + with open(PRODUCTS_CATALOG, "r", encoding="utf-8") as handle: + catalog = json.load(handle) + return [ + product["code"] for product in catalog["libraries"] + if product.get("packageType") in SUPPORTED_PACKAGE_TYPES and list_archived_versions(product["code"]) + ] + + +def require_supported(product: dict) -> None: + """Reject products whose docs are not DocFX output. + + Raises: + ArchiveError: for JavaDoc/pip/npm products such as ironpdfjava. + """ + package_type = product.get("packageType") + if package_type not in SUPPORTED_PACKAGE_TYPES: + raise ArchiveError( + f"{product['code']} is a {'JavaDoc' if package_type == 'maven' else package_type} product " + f"(packageType: {package_type}).\n" + f"Signature diffing is not yet supported. Supported: {', '.join(supported_product_codes())}" + ) + + +# Distance stand-in for a component that cannot be compared numerically, so it always ranks last. +_INCOMPARABLE = 10 ** 9 + + +def _nearest(version: str, available: list, limit: int = 5) -> list: + """Archived versions closest to the requested one, nearest first. + + Candidates are ranked first by *how deep* the first differing component is — sharing a major + version matters more than a small difference in it, so 2026.5.9 suggests 2026.5.2 ahead of + 2025.1.1 — and only then by the size of that difference. + """ + target = version_sort_key(version) + + def distance(candidate: str) -> tuple: + key = version_sort_key(candidate) + for index, (left, right) in enumerate(zip(target, key)): + if left != right: + magnitude = abs(left[1] - right[1]) if left[0] == right[0] == 0 else _INCOMPARABLE + # Negated so a difference appearing later (a longer shared prefix) sorts first. + return (-index, magnitude, candidate) + return (-len(target), 0, candidate) + + return sorted(available, key=distance)[:limit] + + +def require_version(product: dict, version: str, available: list) -> None: + """Raise unless the version has a built directory in the archive. + + Raises: + ArchiveError: with the nearest archived versions listed. + """ + if version in available: + return + suggestions = ", ".join(_nearest(version, available)) if available else "(none archived)" + raise ArchiveError( + f"{product['code']} {version} is not in the archive.\n" + f"Nearest archived: {suggestions}\n" + f"Run update-apidocs to build it." + ) + + +def resolve_versions(product: dict, version_from: str = None, version_to: str = None) -> tuple: + """Resolve the pair of versions to diff. + + With neither given, the two newest archived versions are used. With only one given, the other + end is the newest archived version. + + Returns: + tuple: ``(version_from, version_to, available_versions)``, oldest end first. + + Raises: + ArchiveError: when the archive holds too few versions, or a requested one is missing. + """ + available = list_archived_versions(product["code"]) + if not available: + raise ArchiveError(f"No archived versions found for {product['code']} under object-reference/.") + + if not version_from and not version_to: + if len(available) < 2: + raise ArchiveError( + f"{product['code']} has only one archived version ({available[0]}); nothing to diff against." + ) + return available[-2], available[-1], available + + if version_from and not version_to: + version_to = available[-1] + elif version_to and not version_from: + version_from = available[-1] + + require_version(product, version_from, available) + require_version(product, version_to, available) + + if version_from == version_to: + raise ArchiveError(f"--from and --to are both {version_from}; nothing to diff.") + + # Report oldest to newest regardless of the order the operator supplied them. + if version_sort_key(version_from) > version_sort_key(version_to): + version_from, version_to = version_to, version_from + return version_from, version_to, available + + +def version_directory(product: dict, version: str) -> str: + """Path to one archived version directory. + + Raises: + ArchiveError: when the directory exists but holds no xrefmap.yml. + """ + path = get_apidoc_path(product, version) + if not os.path.isfile(os.path.join(path, "xrefmap.yml")): + raise ArchiveError(f"{product['code']} {version} has no xrefmap.yml at {path}; the build may be incomplete.") + return path diff --git a/apidiff/classify.mjs b/apidiff/classify.mjs new file mode 100644 index 000000000..3d417ac68 --- /dev/null +++ b/apidiff/classify.mjs @@ -0,0 +1,379 @@ +/** + * classify.mjs — diff two Surfaces and classify each change (Node port of classify.py). + * + * Because an xrefmap uid encodes parameter *types*, a parameter-type change or a new overload always + * surfaces as a removal plus an addition rather than a modification. A `changed` delta is therefore + * specifically about return type, modifiers, accessors, parameter names, parameter defaults, and + * base types — the things only the HTML declarations reveal. + * + * Every ordering here mirrors the Python port exactly, because byte-identical JSON between the two + * is the repo's dual-port parity gate. + */ + +import { parseDeclaration, simpleMemberName } from "./csharp.mjs"; +import { + ADDED, ADDITIVE, BREAKING, CHANGED, COSMETIC, REMOVED, SEVERITY_ORDER, bySeverity, makeDelta, summary, +} from "./model.mjs"; + +/** + * How each modifier is judged when it appears or disappears, as + * `[severityWhenAdded, reasonWhenAdded, severityWhenRemoved, reasonWhenRemoved]`. + * + * The table is exhaustive over the modifiers that actually occur in the archive so that common, + * well-understood changes are explained rather than falling through to the generic "declaration + * changed" verdict. Entries marked cosmetic are implementation detail a consumer never binds against. + * Insertion order is load-bearing: it fixes the order reasons appear in, which the parity gate checks. + */ +export const MODIFIER_RULES = { + sealed: [BREAKING, "sealed added (can no longer be inherited)", + ADDITIVE, "sealed removed (can now be inherited)"], + abstract: [BREAKING, "abstract added (must now be implemented)", + ADDITIVE, "abstract removed"], + virtual: [ADDITIVE, "virtual added (can now be overridden)", + BREAKING, "virtual removed (can no longer be overridden)"], + readonly: [BREAKING, "became readonly (assignment no longer permitted)", + ADDITIVE, "readonly removed (assignment now permitted)"], + // A const is inlined into the consumer's assembly, so moving either way is binary-breaking. + const: [BREAKING, "became const", BREAKING, "no longer const"], + // Flipping static changes the call syntax in both directions. + static: [BREAKING, "became static", BREAKING, "no longer static"], + async: [COSMETIC, "async added", COSMETIC, "async removed"], + new: [COSMETIC, "new modifier added", COSMETIC, "new modifier removed"], + override: [COSMETIC, "override added", COSMETIC, "override removed"], + partial: [COSMETIC, "partial added", COSMETIC, "partial removed"], + extern: [COSMETIC, "extern added", COSMETIC, "extern removed"], + unsafe: [COSMETIC, "unsafe added", COSMETIC, "unsafe removed"], + volatile: [COSMETIC, "volatile added", COSMETIC, "volatile removed"], +}; + +/** Visibility keywords ordered widest to narrowest; narrowing breaks consumers, widening does not. */ +const VISIBILITY_ORDER = ["public", "protected", "internal", "private"]; + +/** + * .NET naming convention for an interface: `I` followed by an upper-case letter. Used only to + * decide whether an unverifiable base-list difference should be downgraded, never to assert one. + */ +const INTERFACE_SHAPED = /^I[A-Z]/; + +/** Python-compatible string ordering (code point ascending). */ +const compareStrings = (a, b) => (a < b ? -1 : a > b ? 1 : 0); + +const difference = (a, b) => [...a].filter((value) => !b.has(value)); +const sortedDifference = (a, b) => difference(a, b).sort(compareStrings); + +function visibilityOf(modifiers) { + for (const keyword of VISIBILITY_ORDER) if (modifiers.has(keyword)) return keyword; + return ""; +} + +/** Property accessor changes. Losing an accessor breaks every caller that used it. */ +function accessorReasons(before, after) { + // Exactly one side has accessors: the member was converted between a field and a property. The uid + // is unchanged, but field and property access compile differently, so this is binary-breaking. + if ((before.accessors === null) !== (after.accessors === null)) { + return [[BREAKING, before.accessors === null ? "field converted to a property" : "property converted to a field"]]; + } + if (before.accessors === null || after.accessors === null) return []; + + const lost = sortedDifference(before.accessors, after.accessors); + const gained = sortedDifference(after.accessors, before.accessors); + const reasons = []; + if (lost.length) reasons.push([BREAKING, `${lost.join(", ")} accessor removed`]); + if (gained.length) reasons.push([ADDITIVE, `${gained.join(", ")} accessor added`]); + return reasons; +} + +function modifierReasons(before, after) { + const reasons = []; + const gained = new Set(difference(after.modifiers, before.modifiers)); + const lost = new Set(difference(before.modifiers, after.modifiers)); + + const oldVisibility = visibilityOf(before.modifiers); + const newVisibility = visibilityOf(after.modifiers); + if (oldVisibility && newVisibility && oldVisibility !== newVisibility) { + if (VISIBILITY_ORDER.indexOf(newVisibility) > VISIBILITY_ORDER.indexOf(oldVisibility)) { + reasons.push([BREAKING, `visibility narrowed from ${oldVisibility} to ${newVisibility}`]); + } else { + reasons.push([ADDITIVE, `visibility widened from ${oldVisibility} to ${newVisibility}`]); + } + } + + for (const [modifier, [addedSeverity, addedReason, removedSeverity, removedReason]] of Object.entries(MODIFIER_RULES)) { + if (gained.has(modifier)) reasons.push([addedSeverity, addedReason]); + else if (lost.has(modifier)) reasons.push([removedSeverity, removedReason]); + } + return reasons; +} + +/** Parameter differences that survive an identical uid: names and default values. */ +function parameterReasons(before, after) { + const oldParams = before.parameters; + const newParams = after.parameters; + if (oldParams === null || newParams === null || oldParams.length !== newParams.length) return []; + + const reasons = []; + for (let index = 0; index < oldParams.length; index++) { + const old = oldParams[index]; + const fresh = newParams[index]; + if (old.default !== null && fresh.default === null) { + reasons.push([BREAKING, `default value removed from '${fresh.name || old.name}'`]); + } else if (old.default === null && fresh.default !== null) { + reasons.push([ADDITIVE, `default value added to '${fresh.name}'`]); + } else if (old.default !== fresh.default) { + reasons.push([COSMETIC, `default for '${fresh.name}' changed: ${old.default} -> ${fresh.default}`]); + } + // Only breaks callers using named arguments, so it is reported but not counted breaking. + if (old.name !== fresh.name) reasons.push([COSMETIC, `parameter renamed: ${old.name} -> ${fresh.name}`]); + } + return reasons; +} + +/** + * Base type and interface differences. + * + * Entries naming a filtered-out type are ignored. Declarations render base types by simple name, so + * a namespace pattern cannot recognise them here — `IronSoftware.Deployment.BaseVersionFactory` + * implements an obfuscated interface that DocFX renders as bare `qdygyu`, and that name changes on + * every build. Without this the type reports a base removed plus a base added in every release. + */ +function baseReasons(before, after, blockedNames = new Set(), interfaces = new Set()) { + const keep = (base) => !blockedNames.has(base) && !interfaces.has(base); + let lost = before.bases.filter((base) => !after.bases.includes(base) && keep(base)); + let gained = after.bases.filter((base) => !before.bases.includes(base) && keep(base)); + + // Anything interface-shaped that survived the `interfaces` exclusion had no Implements section to + // corroborate it — interface pages never get one, and a few classes do not either. The declaration + // line is not a trustworthy source for interfaces across DocFX versions (2026.7 stopped inlining + // them), so such a difference is reported but not counted as breaking. + const lostInterfaces = lost.filter((base) => INTERFACE_SHAPED.test(base)); + const gainedInterfaces = gained.filter((base) => INTERFACE_SHAPED.test(base)); + lost = lost.filter((base) => !lostInterfaces.includes(base)); + gained = gained.filter((base) => !gainedInterfaces.includes(base)); + + const reasons = []; + if (lost.length) reasons.push([BREAKING, `base type removed: ${lost.join(", ")}`]); + if (gained.length) reasons.push([ADDITIVE, `base type added: ${gained.join(", ")}`]); + if (lostInterfaces.length || gainedInterfaces.length) { + const detail = []; + if (lostInterfaces.length) detail.push(`no longer listed: ${lostInterfaces.join(", ")}`); + if (gainedInterfaces.length) detail.push(`newly listed: ${gainedInterfaces.join(", ")}`); + reasons.push([COSMETIC, `declaration interface list differs (${detail.join("; ")}) — unverifiable, ` + + "this page has no Implements section and DocFX renders the declaration's interface list " + + "inconsistently across versions"]); + } + return reasons; +} + +/** + * Interface differences, taken from the type page's Implements section — the authoritative and + * version-stable record of what a type implements. The declaration line is not. + */ +function implementsReasons(before, after, blockedNames = new Set()) { + const beforeSet = new Set(before.filter((name) => !blockedNames.has(name))); + const afterSet = new Set(after.filter((name) => !blockedNames.has(name))); + const lost = sortedDifference(beforeSet, afterSet); + const gained = sortedDifference(afterSet, beforeSet); + const reasons = []; + if (lost.length) reasons.push([BREAKING, `interface no longer implemented: ${lost.join(", ")}`]); + if (gained.length) reasons.push([ADDITIVE, `interface now implemented: ${gained.join(", ")}`]); + return reasons; +} + +/** Collapse the punctuation left behind after names are removed from a base list. */ +function normalizeBases(declaration) { + return declaration.replace(/[\s,:]+/g, " ").trim(); +} + +/** + * Drop whole-word occurrences of filtered-out type names from a declaration. + * + * Longest name first, which is load-bearing: `IEnumerable` is a whole-word match inside + * `IEnumerable` (`<` is a non-word character), so removing the short name first would leave a + * stray `` and the long name would then match nothing. Sorting also keeps the result + * independent of Set iteration order, matching the Python port exactly. + */ +function withoutBlocked(declaration, blockedNames) { + let result = declaration; + for (const name of [...blockedNames].sort((a, b) => b.length - a.length)) { + result = result.replace( + new RegExp(`(? ${after.return_type}`]); + } + reasons.push(...modifierReasons(before, after)); + reasons.push(...accessorReasons(before, after)); + reasons.push(...parameterReasons(before, after)); + reasons.push(...baseReasons(before, after, blockedNames, interfaces)); + reasons.push(...implementsResult); + + if (reasons.length === 0) { + // Declarations differing only in how interfaces are rendered are equivalent; the Implements + // comparison above is the authority on whether anything really changed. + const strippedBefore = withoutBlocked(beforeText, interfaces); + const strippedAfter = withoutBlocked(afterText, interfaces); + if (normalizeBases(strippedBefore) !== normalizeBases(strippedAfter)) { + reasons.push([BREAKING, "declaration changed"]); + } + } + return reasons; +} + +function severityOf(reasons) { + const severities = new Set(reasons.map(([severity]) => severity)); + if (severities.has(BREAKING)) return BREAKING; + return severities.has(ADDITIVE) ? ADDITIVE : COSMETIC; +} + +function compareDeltas(a, b) { + const severity = SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity); + if (severity !== 0) return severity; + return compareStrings(a.typeUid, b.typeUid) + || compareStrings(a.display, b.display) + || compareStrings(a.uid, b.uid); +} + +/** Compare two Surfaces and return every classified change. */ +export function diffSurfaces(surfaceFrom, surfaceTo, productName) { + const result = { + productCode: surfaceFrom.productCode, + productName, + versionFrom: surfaceFrom.version, + versionTo: surfaceTo.version, + deltas: [], + warnings: [...surfaceFrom.warnings, ...surfaceTo.warnings], + surfaceFrom, + surfaceTo, + }; + + // A base type filtered out of either side is not documented surface, so ignore it in both. + const blockedNames = new Set([...surfaceFrom.blockedTypeNames, ...surfaceTo.blockedTypeNames]); + + // Namespaces. + for (const namespace of sortedDifference(surfaceFrom.namespaces, surfaceTo.namespaces)) { + result.deltas.push(makeDelta({ + kind: REMOVED, severity: BREAKING, target: "namespace", typeUid: "", uid: namespace, + display: namespace, before: namespace, reasons: ["namespace removed"], + })); + } + for (const namespace of sortedDifference(surfaceTo.namespaces, surfaceFrom.namespaces)) { + result.deltas.push(makeDelta({ + kind: ADDED, severity: ADDITIVE, target: "namespace", typeUid: "", uid: namespace, + display: namespace, after: namespace, reasons: ["namespace added"], + })); + } + + const fromTypeUids = new Set(surfaceFrom.types.keys()); + const toTypeUids = new Set(surfaceTo.types.keys()); + + // Types. + for (const typeUid of sortedDifference(fromTypeUids, toTypeUids)) { + const entry = surfaceFrom.types.get(typeUid); + result.deltas.push(makeDelta({ + kind: REMOVED, severity: BREAKING, target: "type", typeUid, uid: typeUid, display: typeUid, + before: entry.declaration || typeUid, reasons: ["type removed"], + })); + } + for (const typeUid of sortedDifference(toTypeUids, fromTypeUids)) { + const entry = surfaceTo.types.get(typeUid); + result.deltas.push(makeDelta({ + kind: ADDED, severity: ADDITIVE, target: "type", typeUid, uid: typeUid, display: typeUid, + after: entry.declaration || typeUid, reasons: ["type added"], + })); + } + + // Types present in both: their own declaration, then their members. + const shared = [...fromTypeUids].filter((uid) => toTypeUids.has(uid)).sort(compareStrings); + for (const typeUid of shared) { + const beforeType = surfaceFrom.types.get(typeUid); + const afterType = surfaceTo.types.get(typeUid); + + const typeReasons = compareDeclarations(beforeType.declaration, afterType.declaration, blockedNames, + beforeType.implementsList, afterType.implementsList); + if (typeReasons.length) { + result.deltas.push(makeDelta({ + kind: CHANGED, severity: severityOf(typeReasons), target: "type", typeUid, uid: typeUid, + display: typeUid, before: beforeType.declaration, after: afterType.declaration, + reasons: typeReasons.map(([, reason]) => reason), + })); + } + + const beforeMemberUids = new Set(beforeType.members.keys()); + const afterMemberUids = new Set(afterType.members.keys()); + const removedUids = sortedDifference(beforeMemberUids, afterMemberUids); + const addedUids = sortedDifference(afterMemberUids, beforeMemberUids); + + // A removed and an added member sharing a simple name is one overload signature change, not two + // unrelated events; note it on both so the report reads correctly. + const removedNames = new Set(removedUids.map(simpleMemberName)); + const addedNames = new Set(addedUids.map(simpleMemberName)); + const overloaded = new Set([...removedNames].filter((name) => addedNames.has(name))); + + for (const uid of removedUids) { + const member = beforeType.members.get(uid); + const reasons = ["member removed"]; + if (overloaded.has(simpleMemberName(uid))) reasons.push("overload signature change (see the matching addition)"); + result.deltas.push(makeDelta({ + kind: REMOVED, severity: BREAKING, target: "member", typeUid, uid, + display: member.nameWithType, before: member.declaration || member.fullName, reasons, + })); + } + for (const uid of addedUids) { + const member = afterType.members.get(uid); + const reasons = ["member added"]; + if (overloaded.has(simpleMemberName(uid))) reasons.push("overload signature change (see the matching removal)"); + result.deltas.push(makeDelta({ + kind: ADDED, severity: ADDITIVE, target: "member", typeUid, uid, + display: member.nameWithType, after: member.declaration || member.fullName, reasons, + })); + } + + const sharedMembers = [...beforeMemberUids].filter((uid) => afterMemberUids.has(uid)).sort(compareStrings); + for (const uid of sharedMembers) { + const beforeMember = beforeType.members.get(uid); + const afterMember = afterType.members.get(uid); + const memberReasons = compareDeclarations(beforeMember.declaration, afterMember.declaration, blockedNames); + if (memberReasons.length) { + result.deltas.push(makeDelta({ + kind: CHANGED, severity: severityOf(memberReasons), target: "member", typeUid, uid, + display: afterMember.nameWithType, before: beforeMember.declaration, after: afterMember.declaration, + reasons: memberReasons.map(([, reason]) => reason), + })); + } + } + } + + result.deltas.sort(compareDeltas); + return result; +} + +export { bySeverity, summary }; diff --git a/apidiff/classify.py b/apidiff/classify.py new file mode 100644 index 000000000..9c24c3922 --- /dev/null +++ b/apidiff/classify.py @@ -0,0 +1,344 @@ +"""Diff two Surfaces and classify each change as breaking, additive, or cosmetic. + +Because an xrefmap uid encodes parameter *types*, a parameter-type change or a new overload always +surfaces as a removal plus an addition rather than a modification. A ``changed`` delta is therefore +specifically about return type, modifiers, accessors, parameter names, parameter defaults, and base +types — the things only the HTML declarations reveal. +""" + +import re + +from .csharp import parse_declaration, simple_member_name +from .model import (ADDED, ADDITIVE, BREAKING, CHANGED, COSMETIC, Delta, DiffResult, REMOVED) + +# How each modifier is judged when it appears or disappears, as +# ``modifier: (severity_when_added, reason_when_added, severity_when_removed, reason_when_removed)``. +# +# The table is exhaustive over the modifiers that actually occur in the archive so that common, +# well-understood changes are explained rather than falling through to the generic "declaration +# changed" verdict. Entries marked cosmetic are implementation detail a consumer never binds against. +MODIFIER_RULES = { + "sealed": (BREAKING, "sealed added (can no longer be inherited)", + ADDITIVE, "sealed removed (can now be inherited)"), + "abstract": (BREAKING, "abstract added (must now be implemented)", + ADDITIVE, "abstract removed"), + "virtual": (ADDITIVE, "virtual added (can now be overridden)", + BREAKING, "virtual removed (can no longer be overridden)"), + "readonly": (BREAKING, "became readonly (assignment no longer permitted)", + ADDITIVE, "readonly removed (assignment now permitted)"), + # A const is inlined into the consumer's assembly, so moving either way is binary-breaking. + "const": (BREAKING, "became const", BREAKING, "no longer const"), + # Flipping static changes the call syntax in both directions. + "static": (BREAKING, "became static", BREAKING, "no longer static"), + "async": (COSMETIC, "async added", COSMETIC, "async removed"), + "new": (COSMETIC, "new modifier added", COSMETIC, "new modifier removed"), + "override": (COSMETIC, "override added", COSMETIC, "override removed"), + "partial": (COSMETIC, "partial added", COSMETIC, "partial removed"), + "extern": (COSMETIC, "extern added", COSMETIC, "extern removed"), + "unsafe": (COSMETIC, "unsafe added", COSMETIC, "unsafe removed"), + "volatile": (COSMETIC, "volatile added", COSMETIC, "volatile removed"), +} + +# Visibility keywords ordered widest to narrowest; narrowing breaks consumers, widening does not. +VISIBILITY_ORDER = ("public", "protected", "internal", "private") + +# .NET naming convention for an interface: `I` followed by an upper-case letter. Used only to decide +# whether an unverifiable base-list difference should be downgraded, never to assert a change. +INTERFACE_SHAPED = re.compile(r"^I[A-Z]") + + +def _accessor_reasons(before: dict, after: dict) -> list: + """Property accessor changes. Losing an accessor breaks every caller that used it.""" + # Exactly one side has accessors: the member was converted between a field and a property. The + # uid is unchanged, but field and property access compile differently, so this is binary-breaking. + if (before["accessors"] is None) != (after["accessors"] is None): + if before["accessors"] is None: + return [(BREAKING, "field converted to a property")] + return [(BREAKING, "property converted to a field")] + if before["accessors"] is None or after["accessors"] is None: + return [] + lost = sorted(before["accessors"] - after["accessors"]) + gained = sorted(after["accessors"] - before["accessors"]) + reasons = [] + if lost: + reasons.append((BREAKING, f"{', '.join(lost)} accessor removed")) + if gained: + reasons.append((ADDITIVE, f"{', '.join(gained)} accessor added")) + return reasons + + +def _visibility_of(modifiers: frozenset) -> str: + for keyword in VISIBILITY_ORDER: + if keyword in modifiers: + return keyword + return "" + + +def _modifier_reasons(before: dict, after: dict) -> list: + reasons = [] + gained = after["modifiers"] - before["modifiers"] + lost = before["modifiers"] - after["modifiers"] + + old_visibility = _visibility_of(before["modifiers"]) + new_visibility = _visibility_of(after["modifiers"]) + if old_visibility and new_visibility and old_visibility != new_visibility: + if VISIBILITY_ORDER.index(new_visibility) > VISIBILITY_ORDER.index(old_visibility): + reasons.append((BREAKING, f"visibility narrowed from {old_visibility} to {new_visibility}")) + else: + reasons.append((ADDITIVE, f"visibility widened from {old_visibility} to {new_visibility}")) + + for modifier, (added_severity, added_reason, removed_severity, removed_reason) in MODIFIER_RULES.items(): + if modifier in gained: + reasons.append((added_severity, added_reason)) + elif modifier in lost: + reasons.append((removed_severity, removed_reason)) + return reasons + + +def _parameter_reasons(before: dict, after: dict) -> list: + """Parameter differences that survive an identical uid: names and default values.""" + old_params, new_params = before["parameters"], after["parameters"] + if old_params is None or new_params is None or len(old_params) != len(new_params): + return [] + + reasons = [] + for old, new in zip(old_params, new_params): + if old["default"] is not None and new["default"] is None: + reasons.append((BREAKING, f"default value removed from '{new['name'] or old['name']}'")) + elif old["default"] is None and new["default"] is not None: + reasons.append((ADDITIVE, f"default value added to '{new['name']}'")) + elif old["default"] != new["default"]: + reasons.append((COSMETIC, f"default for '{new['name']}' changed: {old['default']} -> {new['default']}")) + if old["name"] != new["name"]: + # Only breaks callers using named arguments, so it is reported but not counted breaking. + reasons.append((COSMETIC, f"parameter renamed: {old['name']} -> {new['name']}")) + return reasons + + +def _base_reasons(before: dict, after: dict, blocked_names: frozenset = frozenset(), + interfaces: frozenset = frozenset()) -> list: + """Base *class* differences taken from the declaration line. + + Interfaces are deliberately excluded here and compared from the page's Implements section + instead (see ``_implements_reasons``): DocFX stopped inlining them in the declaration between the + 2026.6 and 2026.7 builds, so reading them from the declaration reports a rendering change as + dozens of removals. ``interfaces`` carries the names to ignore for exactly that reason. + + Entries naming a filtered-out type are also ignored. Declarations render base types by simple + name, so a namespace pattern cannot recognise them here — `IronSoftware.Deployment. + BaseVersionFactory` implements an obfuscated interface DocFX renders as bare `qdygyu`, and that + name changes on every build. + """ + def keep(base: str) -> bool: + return base not in blocked_names and base not in interfaces + + lost = [base for base in before["bases"] if base not in after["bases"] and keep(base)] + gained = [base for base in after["bases"] if base not in before["bases"] and keep(base)] + + # Anything interface-shaped that survived the `interfaces` exclusion had no Implements section to + # corroborate it — interface pages never get one, and a few classes do not either. The + # declaration line is not a trustworthy source for interfaces across DocFX versions (2026.7 + # stopped inlining them), so such a difference is reported but not counted as breaking. + lost_interfaces = [base for base in lost if INTERFACE_SHAPED.match(base)] + gained_interfaces = [base for base in gained if INTERFACE_SHAPED.match(base)] + lost = [base for base in lost if base not in lost_interfaces] + gained = [base for base in gained if base not in gained_interfaces] + + reasons = [] + if lost: + reasons.append((BREAKING, f"base type removed: {', '.join(lost)}")) + if gained: + reasons.append((ADDITIVE, f"base type added: {', '.join(gained)}")) + if lost_interfaces or gained_interfaces: + detail = [] + if lost_interfaces: + detail.append(f"no longer listed: {', '.join(lost_interfaces)}") + if gained_interfaces: + detail.append(f"newly listed: {', '.join(gained_interfaces)}") + reasons.append((COSMETIC, ( + f"declaration interface list differs ({'; '.join(detail)}) — unverifiable, this page has " + f"no Implements section and DocFX renders the declaration's interface list inconsistently " + f"across versions" + ))) + return reasons + + +def _implements_reasons(before: list, after: list, blocked_names: frozenset = frozenset()) -> list: + """Interface differences, taken from the type page's Implements section. + + This section is the authoritative and version-stable record of what a type implements; the + declaration line is not. + """ + before_set = {name for name in before if name not in blocked_names} + after_set = {name for name in after if name not in blocked_names} + lost = sorted(before_set - after_set) + gained = sorted(after_set - before_set) + reasons = [] + if lost: + reasons.append((BREAKING, f"interface no longer implemented: {', '.join(lost)}")) + if gained: + reasons.append((ADDITIVE, f"interface now implemented: {', '.join(gained)}")) + return reasons + + +def _normalize_bases(declaration: str) -> str: + """Collapse the punctuation left behind after names are removed from a base list.""" + return re.sub(r"[\s,:]+", " ", declaration).strip() + + +def _without_blocked(declaration: str, blocked_names: frozenset) -> str: + """Drop whole-word occurrences of filtered-out type names from a declaration. + + Longest name first, which is load-bearing in two ways. `IEnumerable` is a whole-word match inside + `IEnumerable` (``<`` is a non-word character), so removing the short name first would leave + a stray ```` and the long name would then match nothing. And because the caller passes a + set, iterating it unsorted made the result depend on PYTHONHASHSEED — the same diff produced + different counts run to run. + """ + for name in sorted(blocked_names, key=len, reverse=True): + declaration = re.sub(rf"(? list: + """Return ``(severity, reason)`` pairs describing how two declarations differ. + + An empty list means the declarations are equivalent. A difference no specific rule explains is + reported as breaking, since an unexplained signature change is more likely to matter than not — + the raw before/after is always shown so the reader can judge. + """ + interfaces = frozenset((before_implements or []) + (after_implements or [])) + implements_reasons = _implements_reasons(before_implements or [], after_implements or [], blocked_names) + + if before_text == after_text: + return implements_reasons + if not before_text or not after_text: + # One side had no page to parse; the identity is unchanged, so there is nothing to claim. + return implements_reasons + # Declarations that differ only by the name of a filtered-out type are equivalent as far as the + # documented surface goes. Checking here rather than after the rules run matters: otherwise every + # such difference would be filtered out of the reasons list and then trip the fallback below. + if blocked_names and _without_blocked(before_text, blocked_names) == _without_blocked(after_text, blocked_names): + return implements_reasons + + before = parse_declaration(before_text) + after = parse_declaration(after_text) + + reasons = [] + if before["return_type"] != after["return_type"]: + reasons.append((BREAKING, f"type changed: {before['return_type']} -> {after['return_type']}")) + reasons.extend(_modifier_reasons(before, after)) + reasons.extend(_accessor_reasons(before, after)) + reasons.extend(_parameter_reasons(before, after)) + reasons.extend(_base_reasons(before, after, blocked_names, interfaces)) + reasons.extend(implements_reasons) + + if not reasons: + # Declarations differing only in how interfaces are rendered are equivalent; the + # Implements comparison above is the authority on whether anything really changed. + stripped_before = _without_blocked(before_text, interfaces) + stripped_after = _without_blocked(after_text, interfaces) + if _normalize_bases(stripped_before) != _normalize_bases(stripped_after): + reasons.append((BREAKING, "declaration changed")) + return reasons + + +def _severity_of(reasons: list) -> str: + severities = {severity for severity, _ in reasons} + if BREAKING in severities: + return BREAKING + return ADDITIVE if ADDITIVE in severities else COSMETIC + + +def _delta_sort_key(delta: Delta) -> tuple: + from .model import SEVERITY_ORDER + return (SEVERITY_ORDER.index(delta.severity), delta.type_uid, delta.display, delta.uid) + + +def diff_surfaces(surface_from, surface_to, product_name: str) -> DiffResult: + """Compare two Surfaces and return every classified change.""" + result = DiffResult( + product_code=surface_from.product_code, + product_name=product_name, + version_from=surface_from.version, + version_to=surface_to.version, + warnings=list(surface_from.warnings) + list(surface_to.warnings), + surface_from=surface_from, + surface_to=surface_to, + ) + + # A base type filtered out of either side is not documented surface, so ignore it in both. + blocked_names = frozenset(surface_from.blocked_type_names | surface_to.blocked_type_names) + + # Namespaces. + for namespace in sorted(surface_from.namespaces - surface_to.namespaces): + result.deltas.append(Delta(REMOVED, BREAKING, "namespace", "", namespace, namespace, + before=namespace, reasons=["namespace removed"])) + for namespace in sorted(surface_to.namespaces - surface_from.namespaces): + result.deltas.append(Delta(ADDED, ADDITIVE, "namespace", "", namespace, namespace, + after=namespace, reasons=["namespace added"])) + + # Types. + for type_uid in sorted(set(surface_from.types) - set(surface_to.types)): + entry = surface_from.types[type_uid] + result.deltas.append(Delta(REMOVED, BREAKING, "type", type_uid, type_uid, type_uid, + before=entry.declaration or type_uid, reasons=["type removed"])) + for type_uid in sorted(set(surface_to.types) - set(surface_from.types)): + entry = surface_to.types[type_uid] + result.deltas.append(Delta(ADDED, ADDITIVE, "type", type_uid, type_uid, type_uid, + after=entry.declaration or type_uid, reasons=["type added"])) + + # Types present in both: their own declaration, then their members. + for type_uid in sorted(set(surface_from.types) & set(surface_to.types)): + before_type = surface_from.types[type_uid] + after_type = surface_to.types[type_uid] + + reasons = compare_declarations(before_type.declaration, after_type.declaration, blocked_names, + before_type.implements, after_type.implements) + if reasons: + result.deltas.append(Delta( + CHANGED, _severity_of(reasons), "type", type_uid, type_uid, type_uid, + before=before_type.declaration, after=after_type.declaration, + reasons=[reason for _, reason in reasons], + )) + + removed_uids = sorted(set(before_type.members) - set(after_type.members)) + added_uids = sorted(set(after_type.members) - set(before_type.members)) + + # A removed and an added member sharing a simple name is one overload signature change, not + # two unrelated events; note it on both so the report reads correctly. + removed_names = {simple_member_name(uid) for uid in removed_uids} + added_names = {simple_member_name(uid) for uid in added_uids} + overloaded = removed_names & added_names + + for uid in removed_uids: + member = before_type.members[uid] + reason_list = ["member removed"] + if simple_member_name(uid) in overloaded: + reason_list.append("overload signature change (see the matching addition)") + result.deltas.append(Delta(REMOVED, BREAKING, "member", type_uid, uid, + member.name_with_type, before=member.declaration or member.full_name, + reasons=reason_list)) + for uid in added_uids: + member = after_type.members[uid] + reason_list = ["member added"] + if simple_member_name(uid) in overloaded: + reason_list.append("overload signature change (see the matching removal)") + result.deltas.append(Delta(ADDED, ADDITIVE, "member", type_uid, uid, + member.name_with_type, after=member.declaration or member.full_name, + reasons=reason_list)) + + for uid in sorted(set(before_type.members) & set(after_type.members)): + before_member = before_type.members[uid] + after_member = after_type.members[uid] + reasons = compare_declarations(before_member.declaration, after_member.declaration, blocked_names) + if reasons: + result.deltas.append(Delta( + CHANGED, _severity_of(reasons), "member", type_uid, uid, after_member.name_with_type, + before=before_member.declaration, after=after_member.declaration, + reasons=[reason for _, reason in reasons], + )) + + result.deltas.sort(key=_delta_sort_key) + return result diff --git a/apidiff/csharp.mjs b/apidiff/csharp.mjs new file mode 100644 index 000000000..28a849550 --- /dev/null +++ b/apidiff/csharp.mjs @@ -0,0 +1,154 @@ +/** + * csharp.mjs — a deliberately small C# declaration reader (Node port of csharp.py). + * + * This is not a C# parser. It decomposes the single-line declarations DocFX renders into just the + * parts the classifier compares — modifiers, type kind, base list, return type, parameters, and + * property accessors — and is tolerant of anything it does not recognise, because an unparsed + * fragment simply falls through to a raw string comparison. + */ + +/** + * Keywords that may precede the return type. `event`, `operator`, `implicit`, and `explicit` are + * included so the tokens that follow them line up with the ordinary method/field shape. + */ +export const MODIFIERS = new Set([ + "public", "protected", "internal", "private", "static", "virtual", "abstract", "sealed", + "override", "readonly", "const", "extern", "unsafe", "async", "new", "partial", "volatile", + "event", "implicit", "explicit", "operator", "fixed", "delegate", +]); + +/** Declaration keywords that mark a type rather than a member. */ +export const TYPE_KINDS = new Set(["class", "interface", "enum", "struct", "record"]); + +const OPENERS = "<(["; +const CLOSERS = ">)]"; + +/** + * Split on `separator` only where generic/parameter/array brackets are balanced, so + * `Dictionary` stays in one piece when splitting a parameter list on commas. + */ +export function splitTopLevel(text, separator) { + const parts = []; + let depth = 0; + let current = ""; + for (const character of text) { + if (OPENERS.includes(character)) depth += 1; + // Clamped so a `>` from an operator declaration cannot drive the depth negative. + else if (CLOSERS.includes(character)) depth = Math.max(0, depth - 1); + + if (character === separator && depth === 0) { + parts.push(current); + current = ""; + } else { + current += character; + } + } + parts.push(current); + return parts.map((part) => part.trim()); +} + +/** Return `[start, end, inner]` for each balanced parenthesised group at depth zero. */ +function topLevelParenGroups(text) { + const groups = []; + let depth = 0; + let start = -1; + for (let index = 0; index < text.length; index++) { + const character = text[index]; + if (character === "(") { + if (depth === 0) start = index; + depth += 1; + } else if (character === ")" && depth > 0) { + depth -= 1; + if (depth === 0 && start >= 0) groups.push([start, index, text.slice(start + 1, index)]); + } + } + return groups; +} + +/** Split one parameter into its type, name, and default value. */ +export function parseParameter(text) { + const equals = text.indexOf("="); + const body = equals >= 0 ? text.slice(0, equals) : text; + const defaultValue = equals >= 0 ? text.slice(equals + 1).trim() : null; + const tokens = splitTopLevel(body.trim(), " ").filter(Boolean); + return { + type: tokens.length > 1 ? tokens.slice(0, -1).join(" ") : "", + name: tokens.length ? tokens[tokens.length - 1] : "", + default: defaultValue, + raw: text.trim(), + }; +} + +/** + * Decompose a rendered C# declaration. + * + * @returns {{modifiers:Set, kind:string, bases:string[], return_type:string, name:string, + * parameters:Array|null, accessors:Set|null, raw:string}} + */ +export function parseDeclaration(declaration) { + const parsed = { + modifiers: new Set(), kind: "", bases: [], return_type: "", + name: "", parameters: null, accessors: null, raw: declaration, + }; + if (!declaration) return parsed; + + let head = declaration; + + // 1. Property accessors, e.g. "{ get; protected set; }" at the end of the declaration. + if (head.trimEnd().endsWith("}") && head.includes("{")) { + const brace = head.lastIndexOf("{"); + const inner = head.slice(brace + 1, head.lastIndexOf("}")); + const accessors = new Set(); + for (const clause of inner.split(";")) { + const words = clause.split(/\s+/).filter(Boolean); + const last = words[words.length - 1]; + if (last === "get" || last === "set" || last === "init") accessors.add(last); + } + parsed.accessors = accessors; + head = head.slice(0, brace).trim(); + } + + // 2. Parameter list — the last top-level parenthesised group, so a tuple return type or a + // parenthesised default value inside the list is not mistaken for it. + const groups = topLevelParenGroups(head); + if (groups.length) { + const [start, end, inner] = groups[groups.length - 1]; + parsed.parameters = inner.trim() + ? splitTopLevel(inner, ",").filter(Boolean).map(parseParameter) + : []; + head = (head.slice(0, start) + head.slice(end + 1)).trim(); + } + + // 3. Base type / interface list, e.g. ": IronBaseArchive, IDisposable". + const headParts = splitTopLevel(head, ":"); + if (headParts.length > 1) { + head = headParts[0].trim(); + parsed.bases = splitTopLevel(headParts[headParts.length - 1], ",").filter(Boolean); + } + + // 4. Leading modifiers, then either a type keyword or a return type plus name. + const tokens = splitTopLevel(head, " ").filter(Boolean); + while (tokens.length && MODIFIERS.has(tokens[0])) parsed.modifiers.add(tokens.shift()); + + if (tokens.length && TYPE_KINDS.has(tokens[0])) { + parsed.kind = tokens.shift(); + parsed.name = tokens.length ? tokens[0] : ""; + } else if (tokens.length > 1) { + parsed.return_type = tokens.slice(0, -1).join(" "); + parsed.name = tokens[tokens.length - 1]; + } else if (tokens.length) { + // A constructor, or an operator whose name is its target type: no return type to record. + parsed.name = tokens[0]; + } + + return parsed; +} + +/** + * The bare member name from a uid, without namespace, owning type, or parameter list. + * `IronZip.IronZipArchive.Contains(System.String)` -> `Contains`. + */ +export function simpleMemberName(uid) { + const withoutParams = uid.split("(", 1)[0]; + return withoutParams.includes(".") ? withoutParams.slice(withoutParams.lastIndexOf(".") + 1) : withoutParams; +} diff --git a/apidiff/csharp.py b/apidiff/csharp.py new file mode 100644 index 000000000..5c2eb0c35 --- /dev/null +++ b/apidiff/csharp.py @@ -0,0 +1,142 @@ +"""A deliberately small C# declaration reader. + +This is not a C# parser. It decomposes the single-line declarations DocFX renders into just the +parts the classifier compares — modifiers, type kind, base list, return type, parameters, and +property accessors — and is tolerant of anything it does not recognise, because an unparsed +fragment simply falls through to a raw string comparison. +""" + +# Keywords that may precede the return type. `event`, `operator`, `implicit`, and `explicit` are +# included so the tokens that follow them line up with the ordinary method/field shape. +MODIFIERS = frozenset({ + "public", "protected", "internal", "private", "static", "virtual", "abstract", "sealed", + "override", "readonly", "const", "extern", "unsafe", "async", "new", "partial", "volatile", + "event", "implicit", "explicit", "operator", "fixed", "delegate", +}) + +# Declaration keywords that mark a type rather than a member. +TYPE_KINDS = frozenset({"class", "interface", "enum", "struct", "record"}) + +OPENERS = "<([" +CLOSERS = ">)]" + + +def split_top_level(text: str, separator: str) -> list: + """Split on ``separator`` only where generic/parameter/array brackets are balanced. + + Keeps ``Dictionary`` in one piece when splitting a parameter list on commas. + """ + parts, depth, current = [], 0, [] + for character in text: + if character in OPENERS: + depth += 1 + elif character in CLOSERS: + # Clamped so a `>` from an operator declaration cannot drive the depth negative. + depth = max(0, depth - 1) + if character == separator and depth == 0: + parts.append("".join(current)) + current = [] + else: + current.append(character) + parts.append("".join(current)) + return [part.strip() for part in parts] + + +def _top_level_paren_groups(text: str) -> list: + """Return ``(start, end, inner)`` for each balanced parenthesised group at depth zero.""" + groups, depth, start = [], 0, -1 + for index, character in enumerate(text): + if character == "(": + if depth == 0: + start = index + depth += 1 + elif character == ")" and depth > 0: + depth -= 1 + if depth == 0 and start >= 0: + groups.append((start, index, text[start + 1:index])) + return groups + + +def parse_parameter(text: str) -> dict: + """Split one parameter into its type, name, and default value.""" + body, separator, default = text.partition("=") + tokens = split_top_level(body.strip(), " ") + tokens = [token for token in tokens if token] + name = tokens[-1] if tokens else "" + return { + "type": " ".join(tokens[:-1]) if len(tokens) > 1 else "", + "name": name, + "default": default.strip() if separator else None, + "raw": text.strip(), + } + + +def parse_declaration(declaration: str) -> dict: + """Decompose a rendered C# declaration. + + Returns a dict with ``modifiers`` (frozenset), ``kind`` (type keyword or ``""``), ``bases`` + (list), ``return_type``, ``name``, ``parameters`` (list of parse_parameter dicts or ``None`` + when the declaration has no parameter list), ``accessors`` (frozenset or ``None``), and ``raw``. + """ + parsed = { + "modifiers": frozenset(), "kind": "", "bases": [], "return_type": "", + "name": "", "parameters": None, "accessors": None, "raw": declaration, + } + if not declaration: + return parsed + + head = declaration + + # 1. Property accessors, e.g. "{ get; protected set; }" at the end of the declaration. + if head.rstrip().endswith("}") and "{" in head: + brace = head.rindex("{") + inner = head[brace + 1:head.rindex("}")] + accessors = set() + for clause in inner.split(";"): + words = clause.split() + if words and words[-1] in ("get", "set", "init"): + accessors.add(words[-1]) + parsed["accessors"] = frozenset(accessors) + head = head[:brace].strip() + + # 2. Parameter list — the last top-level parenthesised group, so a tuple return type or a + # parenthesised default value inside the list is not mistaken for it. + groups = _top_level_paren_groups(head) + if groups: + start, end, inner = groups[-1] + parsed["parameters"] = [parse_parameter(part) for part in split_top_level(inner, ",") if part] if inner.strip() else [] + head = (head[:start] + head[end + 1:]).strip() + + # 3. Base type / interface list, e.g. ": IronBaseArchive, IDisposable". + head_parts = split_top_level(head, ":") + if len(head_parts) > 1: + head = head_parts[0].strip() + parsed["bases"] = [base for base in split_top_level(head_parts[-1], ",") if base] + + # 4. Leading modifiers, then either a type keyword or a return type plus name. + tokens = [token for token in split_top_level(head, " ") if token] + modifiers = set() + while tokens and tokens[0] in MODIFIERS: + modifiers.add(tokens.pop(0)) + parsed["modifiers"] = frozenset(modifiers) + + if tokens and tokens[0] in TYPE_KINDS: + parsed["kind"] = tokens.pop(0) + parsed["name"] = tokens[0] if tokens else "" + elif len(tokens) > 1: + parsed["return_type"] = " ".join(tokens[:-1]) + parsed["name"] = tokens[-1] + elif tokens: + # A constructor, or an operator whose name is its target type: no return type to record. + parsed["name"] = tokens[0] + + return parsed + + +def simple_member_name(uid: str) -> str: + """The bare member name from a uid, without namespace, owning type, or parameter list. + + ``IronZip.IronZipArchive.Contains(System.String)`` -> ``Contains``. + """ + without_params = uid.split("(", 1)[0] + return without_params.rsplit(".", 1)[-1] if "." in without_params else without_params diff --git a/apidiff/declarations.mjs b/apidiff/declarations.mjs new file mode 100644 index 000000000..a2e6d5195 --- /dev/null +++ b/apidiff/declarations.mjs @@ -0,0 +1,123 @@ +/** + * declarations.mjs — extract C# declarations from a DocFX type page (Node port of declarations.py). + * + * Every declaration is anchored to the `data-uid` on its heading, which DocFX writes byte-identical + * to the xrefmap `uid`, so no href/anchor demangling is needed. The type's own declaration hangs off + * its `

`. This layout is unchanged from the oldest archived pages (2022) to the newest. + * + * Anchoring is a correctness requirement, not a style preference: Archetype-N injects *code samples* + * into these same pages, so a flat scan for `lang-csharp` blocks — the approach in + * scaffolds/tools/archetype-n/facts.mjs — reports `using IronZip;` as a member. + */ + +import { stripGuidMarkers } from "./xrefmap.mjs"; + +/** Archetype-N injects prose and runnable samples between these sentinels; removed before parsing. */ +const ARCHETYPE_BLOCK = //gi; + +/** A heading carrying a uid. The `` overload anchors are not headings. */ +const HEADING_WITH_UID = /]*\sdata-uid="([^"]+)"[^>]*>/gi; + +/** One rendered declaration. DocFX emits `lang-csharp hljs`; the suffix is allowed to vary. */ +const CSHARP_BLOCK = /([\s\S]*?)<\/code>/gi; + +const TAG = /<[^>]+>/g; + +/** + * The "Implements" block a type page carries above its Syntax heading, e.g. + * + *
Implements
+ *
System.Collections.Generic.IEnumerable<…Cell…>
+ *
System.Collections.IEnumerable
+ * + * This is the authoritative record of the interfaces a type implements, and it is *stable across + * DocFX versions* — unlike the declaration line, which stopped inlining interfaces between the + * 2026.6 and 2026.7 builds while this section stayed byte-identical. + */ +const IMPLEMENTS_SECTION = /
\s*Implements\s*<\/h5>([\s\S]*?)(?=([\s\S]*?)<\/div>/g; + +/** A dotted, fully-qualified name; reduced to its last segment to match the declaration's form. */ +const QUALIFIED_NAME = /[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+/g; + +/** + * Strip namespaces from every qualified name in a type expression, so + * `IronSoftware.Abstractions.IParent` + * becomes `IParent`. + */ +export function simplifyTypeName(text) { + return text.replace(QUALIFIED_NAME, (match) => match.slice(match.lastIndexOf(".") + 1)); +} + +/** Minimal HTML entity decoding — the set DocFX actually emits inside declarations. */ +const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", "#39": "'", nbsp: " " }; + +function unescapeHtml(text) { + return text.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (match, name) => { + if (Object.prototype.hasOwnProperty.call(ENTITIES, name)) return ENTITIES[name]; + if (name.startsWith("#x") || name.startsWith("#X")) return String.fromCodePoint(parseInt(name.slice(2), 16)); + if (name.startsWith("#")) return String.fromCodePoint(parseInt(name.slice(1), 10)); + return match; + }); +} + +/** + * Turn a raw declaration code block into a single comparable line. + * + * GUID markers are stripped here too, so a declaration mentioning a marked type stays comparable + * across builds — and matches the uid, which xrefmap.mjs strips the same way. + */ +export function normalizeDeclaration(raw) { + return stripGuidMarkers(unescapeHtml(raw.replace(TAG, "")).replace(/\s+/g, " ").trim()); +} + +/** + * Map every `data-uid` on a DocFX type page to its C# declaration. + * + * Includes the type's own uid (from its `

`). Uids with no declaration between their heading and + * the next are omitted rather than recorded as empty. + * + * @param {string} pageHtml Full text of an `api/.html` page. + * @returns {Object} `{ [uid]: declaration }` + */ +export function parseTypePage(pageHtml) { + const cleaned = pageHtml.replace(ARCHETYPE_BLOCK, ""); + + // Overload-group uids end in `*` and describe a set of overloads, not a signature. + const anchors = []; + for (const match of cleaned.matchAll(HEADING_WITH_UID)) { + if (!match[1].endsWith("*")) anchors.push([match.index, stripGuidMarkers(match[1])]); + } + if (anchors.length === 0) return {}; + + const blocks = [...cleaned.matchAll(CSHARP_BLOCK)].map((match) => [match.index, match[1]]); + if (blocks.length === 0) return {}; + + const declarations = Object.create(null); + for (let index = 0; index < anchors.length; index++) { + const [position, uid] = anchors[index]; + // A declaration belongs to the nearest preceding heading, so bound the search at the next one. + const nextPosition = index + 1 < anchors.length ? anchors[index + 1][0] : cleaned.length; + for (const [blockPosition, blockText] of blocks) { + if (blockPosition < position) continue; + if (blockPosition >= nextPosition) break; + // The first block in a section is the Declaration; later ones are Examples. + const declaration = normalizeDeclaration(blockText); + if (declaration) declarations[uid] = declaration; + break; + } + } + return declarations; +} + +/** Return the interfaces listed in a type page's Implements section, simple-named and sorted. */ +export function parseImplements(pageHtml) { + const section = IMPLEMENTS_SECTION.exec(pageHtml); + if (!section) return []; + const interfaces = new Set(); + for (const entry of section[1].matchAll(IMPLEMENTS_ENTRY)) { + const name = normalizeDeclaration(entry[1]); + if (name) interfaces.add(simplifyTypeName(name)); + } + return [...interfaces].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)); +} diff --git a/apidiff/declarations.py b/apidiff/declarations.py new file mode 100644 index 000000000..db7a0202a --- /dev/null +++ b/apidiff/declarations.py @@ -0,0 +1,129 @@ +"""Extract C# declarations from a generated DocFX type page — the signature layer of a diff. + +Every declaration is anchored to the ``data-uid`` on its heading, which DocFX writes byte-identical +to the xrefmap ``uid``: + +

Contains(String)

+
Declaration
+
+ 
public bool Contains(string EntryName)
+
+ +so no href/anchor demangling is needed. The type's own declaration hangs off its ``

``. +This layout is unchanged from the oldest archived pages (2022) to the newest. + +Anchoring is a correctness requirement, not a style preference: Archetype-N injects *code samples* +into these same pages, so a flat scan for ``lang-csharp`` blocks — the approach in +``scaffolds/tools/archetype-n/facts.py`` — reports ``using IronZip;`` as a member. +""" + +import html +import re + +from .xrefmap import strip_guid_markers + +# Archetype-N injects prose and runnable samples between these sentinels. Removed before parsing so +# an injected sample can never be mistaken for a declaration. +ARCHETYPE_BLOCK = re.compile(r"", re.DOTALL | re.I) + +# A heading carrying a uid. The `` overload-group anchors are not headings and +# so are not matched here; the trailing-`*` guard below is a second line of defence. +HEADING_WITH_UID = re.compile(r"]*\sdata-uid=\"([^\"]+)\"[^>]*>", re.I) + +# One rendered declaration. DocFX emits `lang-csharp hljs`; the suffix is allowed to vary. +CSHARP_BLOCK = re.compile(r"(.*?)", re.DOTALL | re.I) + +# Inline markup can appear inside a declaration block (cross-reference links on type names). +TAG = re.compile(r"<[^>]+>") + +# The "Implements" block a type page carries above its Syntax heading, e.g. +# +#
Implements
+#
System.Collections.Generic.IEnumerable<…Cell…>
+#
System.Collections.IEnumerable
+# +# This is the authoritative record of the interfaces a type implements, and it is *stable across +# DocFX versions* — unlike the declaration line, which stopped inlining interfaces between the +# 2026.6 and 2026.7 builds while this section stayed byte-identical. Reading interfaces from here +# rather than from the declaration is what keeps a rendering change from reading as 162 removals. +IMPLEMENTS_SECTION = re.compile(r"
\s*Implements\s*
(.*?)(?=(.*?)", re.DOTALL) + +# A dotted, fully-qualified name; used to reduce `System.Collections.Generic.IEnumerable` to +# `IEnumerable` so entries compare against the simple names the declaration line uses. +QUALIFIED_NAME = re.compile(r"[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+") + + +def simplify_type_name(text: str) -> str: + """Strip namespaces from every qualified name in a type expression. + + ``IronSoftware.Abstractions.IParent`` + becomes ``IParent``, matching how the declaration line renders it. + """ + return QUALIFIED_NAME.sub(lambda match: match.group(0).rsplit(".", 1)[-1], text) + + +def parse_implements(page_html: str) -> list: + """Return the interfaces listed in a type page's Implements section, simple-named and sorted.""" + section = IMPLEMENTS_SECTION.search(page_html) + if not section: + return [] + interfaces = [] + for entry in IMPLEMENTS_ENTRY.findall(section.group(1)): + name = normalize_declaration(entry) + if name: + interfaces.append(simplify_type_name(name)) + return sorted(set(interfaces)) + + +def normalize_declaration(raw: str) -> str: + """Turn a raw declaration code block into a single comparable line. + + GUID markers are stripped here too, so a declaration mentioning a marked type stays comparable + across builds — and matches the uid, which xrefmap.py strips the same way. + """ + return strip_guid_markers(re.sub(r"\s+", " ", html.unescape(TAG.sub("", raw))).strip()) + + +def parse_type_page(page_html: str) -> dict: + """Map every ``data-uid`` on a DocFX type page to its C# declaration. + + Args: + page_html (str): Full text of an ``api/.html`` page. + + Returns: + dict: ``{uid: declaration}``. Includes the type's own uid (from its ``

``). Uids with no + declaration between their heading and the next are omitted rather than recorded as empty. + """ + cleaned = ARCHETYPE_BLOCK.sub("", page_html) + + # Overload-group uids end in `*` and describe a set of overloads, not a signature. + anchors = [ + (match.start(), strip_guid_markers(match.group(1))) + for match in HEADING_WITH_UID.finditer(cleaned) + if not match.group(1).endswith("*") + ] + if not anchors: + return {} + + blocks = [(match.start(), match.group(1)) for match in CSHARP_BLOCK.finditer(cleaned)] + if not blocks: + return {} + + declarations = {} + for index, (position, uid) in enumerate(anchors): + # A declaration belongs to the nearest preceding heading, so bound the search at the next one. + next_position = anchors[index + 1][0] if index + 1 < len(anchors) else len(cleaned) + for block_position, block_text in blocks: + if block_position < position: + continue + if block_position >= next_position: + break + # The first block in a section is the Declaration; later ones are Examples. + declaration = normalize_declaration(block_text) + if declaration: + declarations[uid] = declaration + break + + return declarations diff --git a/apidiff/filters.mjs b/apidiff/filters.mjs new file mode 100644 index 000000000..48495f727 --- /dev/null +++ b/apidiff/filters.mjs @@ -0,0 +1,105 @@ +/** + * filters.mjs — noise control for the reported surface (Node port of filters.py). + * + * Three independent filters, all applied while a Surface is being built so filtered types never cost + * an HTML read: vendored/internal namespaces, compiler-generated members, and operator globs. + */ + +/** + * Namespaces that are vendored or internal infrastructure rather than product surface. The first six + * alternatives are kept in sync with BLOCK_NS in scaffolds/tools/archetype-n/facts.mjs. + * + * `Iron.Pdf.Extensions` holds only obfuscator-generated types whose names change on every build + * (auxkyk/auxkyl in ironpdf 2025.12.2, kjmakb/kjmakc in 2026.1.3, bnubqp/bnubqq in 2026.6.1, + * qdygyt/qdygyu in 2026.7.2), which would otherwise report changes in every IronPDF diff forever. + * scaffolds/filterConfig.yml excludes them at generation time, but only for builds that pick that + * change up — every already-archived IronPDF version still contains them, so this stays regardless. + * + * Deliberately unanchored: member uids embed fully-qualified parameter types, so the namespace has to + * match mid-string too (see SurfaceFilter.allowsMember). The literal dots keep it from colliding with + * the legitimate `IronPdf.Extensions` namespace, which has no dot between Iron and Pdf. + */ +// `Interop` carries a word boundary that facts.mjs's copy lacks. Without it the alternative also +// matches `System.Runtime.InteropServices`, which is a legitimate BCL namespace — harmless when only +// type uids were tested, but once member uids are tested it wrongly drops every member taking a +// HandleRef (134 of ironocr 2026.7.2's 1522 members). `Interop\b` still matches a real `….Interop.…` +// namespace, since the following dot is a word boundary. +export const BLOCK_NS = /\.Internal\b|Interop\b|grpc|Pdfium|BouncyCastle|GrpcLayer|Iron\.Pdf\.Extensions\b/i; + +/** + * Compiler-generated members DocFX still emits. `value__` is the backing field every enum gets; it + * appears in the xrefmap (12 entries in irondrawing/2022.9.8843 alone) but is not API surface. + */ +export const COMPILER_GENERATED_MEMBERS = ["value__"]; + +/** Declarations a consumer can bind against. */ +const PUBLIC_PREFIXES = new Set(["public", "protected"]); + +/** + * Translate a shell-style glob to an anchored RegExp, matching Python's fnmatch.fnmatchcase for the + * `*`, `?`, and `[...]` forms the CLI accepts. + */ +function globToRegExp(pattern) { + let source = ""; + for (let index = 0; index < pattern.length; index++) { + const character = pattern[index]; + if (character === "*") source += ".*"; + else if (character === "?") source += "."; + else if (character === "[") { + const close = pattern.indexOf("]", index + 1); + if (close < 0) { + source += "\\["; + } else { + let body = pattern.slice(index + 1, close); + if (body.startsWith("!")) body = "^" + body.slice(1); + source += `[${body}]`; + index = close; + } + } else source += character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + } + return new RegExp(`^${source}$`); +} + +/** Decides which types and members appear in a Surface. */ +export class SurfaceFilter { + constructor({ includeInternal = false, namespaces = [], excludes = [], publicOnly = true } = {}) { + this.includeInternal = includeInternal; + this.namespaces = namespaces.map(globToRegExp); + this.excludes = excludes.map(globToRegExp); + this.publicOnly = publicOnly; + } + + /** Whether a type belongs in the reported surface, based on its uid alone. */ + allowsType(typeUid) { + if (!this.includeInternal && BLOCK_NS.test(typeUid)) return false; + // --namespace is an allow-list: when any pattern is given, the uid must match one of them. + if (this.namespaces.length && !this.namespaces.some((pattern) => pattern.test(typeUid))) return false; + if (this.excludes.some((pattern) => pattern.test(typeUid))) return false; + return true; + } + + /** + * Whether a member belongs in the reported surface. + * + * A member uid embeds the fully-qualified types of its parameters, e.g. + * `LicensingException.#ctor(Iron.Pdf.Extensions.bnubqp)`. Applying BLOCK_NS to the whole uid — not + * just the owning type — therefore also drops members whose *parameters* come from a blocked + * namespace. Those are not usable public surface (the parameter type is undocumented), and when + * the parameter is an obfuscated type the uid changes on every build, which would otherwise report + * the member as removed-and-added in every single release. + */ + allowsMember(uid, name) { + if (COMPILER_GENERATED_MEMBERS.includes(name) || uid.endsWith(`.${COMPILER_GENERATED_MEMBERS[0]}`)) return false; + if (!this.includeInternal && BLOCK_NS.test(uid)) return false; + return true; + } + + /** + * Whether a declaration is part of the bindable surface. An empty declaration means the HTML page + * did not yield one; those are kept, because the xrefmap only ever lists what DocFX documented. + */ + allowsDeclaration(declaration) { + if (!this.publicOnly || !declaration) return true; + return PUBLIC_PREFIXES.has(declaration.split(" ", 1)[0]); + } +} diff --git a/apidiff/filters.py b/apidiff/filters.py new file mode 100644 index 000000000..3eb5511b6 --- /dev/null +++ b/apidiff/filters.py @@ -0,0 +1,87 @@ +"""Noise control for the reported surface. + +Three independent filters, all applied while a Surface is being built so filtered types never cost +an HTML read: + +1. Vendored/internal namespaces (on by default, ``--include-internal`` to disable). +2. Compiler-generated members that are not real API surface. +3. Operator-supplied ``--namespace`` / ``--exclude`` globs. +""" + +import re +from fnmatch import fnmatchcase + +# Namespaces that are vendored or internal infrastructure rather than product surface. The first six +# alternatives are kept in sync with BLOCK_NS in scaffolds/tools/archetype-n/facts.py. +# +# `Iron.Pdf.Extensions` holds only obfuscator-generated types whose names change on every build +# (auxkyk/auxkyl in ironpdf 2025.12.2, kjmakb/kjmakc in 2026.1.3, bnubqp/bnubqq in 2026.6.1, +# qdygyt/qdygyu in 2026.7.2), which would otherwise report changes in every IronPDF diff forever. +# scaffolds/filterConfig.yml excludes them at generation time, but only for builds that pick that +# change up — every already-archived IronPDF version still contains them, so this stays regardless. +# +# Deliberately unanchored: member uids embed fully-qualified parameter types, so the namespace has to +# match mid-string too (see SurfaceFilter.allows_member). The literal dots keep it from colliding +# with the legitimate `IronPdf.Extensions` namespace, which has no dot between Iron and Pdf. +# `Interop` carries a word boundary that facts.py's copy lacks. Without it the alternative also +# matches `System.Runtime.InteropServices`, which is a legitimate BCL namespace — harmless when only +# type uids were tested, but once member uids are tested it wrongly drops every member taking a +# HandleRef (134 of ironocr 2026.7.2's 1522 members). `Interop\b` still matches a real `…​.Interop.…` +# namespace, since the following dot is a word boundary. +BLOCK_NS = re.compile(r"\.Internal\b|Interop\b|grpc|Pdfium|BouncyCastle|GrpcLayer|Iron\.Pdf\.Extensions\b", re.I) + +# Compiler-generated members DocFX still emits. `value__` is the backing field every enum gets; it +# appears in the xrefmap (12 entries in irondrawing/2022.9.8843 alone) but is not API surface. +COMPILER_GENERATED_MEMBERS = ("value__",) + +# Declarations a consumer can bind against. DocFX's filterConfig.yml already restricts output to the +# public surface, so this is a safety net for anything that slips through. +PUBLIC_PREFIXES = ("public", "protected") + + +class SurfaceFilter: + """Decides which types and members appear in a Surface.""" + + def __init__(self, include_internal: bool = False, namespaces: list = None, excludes: list = None, + public_only: bool = True): + self.include_internal = include_internal + self.namespaces = list(namespaces or []) + self.excludes = list(excludes or []) + self.public_only = public_only + + def allows_type(self, type_uid: str) -> bool: + """Whether a type belongs in the reported surface, based on its uid alone.""" + if not self.include_internal and BLOCK_NS.search(type_uid): + return False + # --namespace is an allow-list: when any pattern is given, the uid must match one of them. + if self.namespaces and not any(fnmatchcase(type_uid, pattern) for pattern in self.namespaces): + return False + if any(fnmatchcase(type_uid, pattern) for pattern in self.excludes): + return False + return True + + def allows_member(self, uid: str, name: str) -> bool: + """Whether a member belongs in the reported surface. + + A member uid embeds the fully-qualified types of its parameters, e.g. + ``LicensingException.#ctor(Iron.Pdf.Extensions.bnubqp)``. Applying BLOCK_NS to the whole uid + — not just the owning type — therefore also drops members whose *parameters* come from a + blocked namespace. Those are not usable public surface (the parameter type is undocumented), + and when the parameter is an obfuscated type the uid changes on every build, which would + otherwise report the member as removed-and-added in every single release. + """ + if name in COMPILER_GENERATED_MEMBERS or uid.endswith("." + COMPILER_GENERATED_MEMBERS[0]): + return False + if not self.include_internal and BLOCK_NS.search(uid): + return False + return True + + def allows_declaration(self, declaration: str) -> bool: + """Whether a declaration is part of the bindable surface. + + An empty declaration means the HTML page did not yield one; those are kept, because the + xrefmap only ever lists what DocFX chose to document in the first place. + """ + if not self.public_only or not declaration: + return True + return declaration.split(" ", 1)[0] in PUBLIC_PREFIXES diff --git a/apidiff/model.mjs b/apidiff/model.mjs new file mode 100644 index 000000000..508821e39 --- /dev/null +++ b/apidiff/model.mjs @@ -0,0 +1,63 @@ +/** + * model.mjs — records shared by the parsing, classification, and rendering stages + * (Node port of model.py). + */ + +/** Change classifications, most severe first. The order drives grouping in every renderer. */ +export const BREAKING = "BREAKING"; +export const ADDITIVE = "ADDITIVE"; +export const COSMETIC = "COSMETIC"; +export const SEVERITY_ORDER = [BREAKING, ADDITIVE, COSMETIC]; + +/** Delta kinds. */ +export const ADDED = "added"; +export const REMOVED = "removed"; +export const CHANGED = "changed"; + +/** One member (method, property, field, or event) of a type. */ +export function makeMember({ uid, kind, name, nameWithType, fullName, typeUid, declaration = "" }) { + return { uid, kind, name, nameWithType, fullName, typeUid, declaration }; +} + +/** One type page: its own declaration plus the members documented on it. */ +export function makeTypeEntry({ uid, name, namespace = "", declaration = "", implementsList = [] }) { + // `implements` is a reserved word, so the field is named `implementsList`. Interfaces are held + // apart from the declaration because DocFX stopped inlining them in the declaration line between + // the 2026.6 and 2026.7 builds while the Implements section stayed identical. + return { uid, name, namespace, declaration, implementsList, members: new Map() }; +} + +/** + * The complete public API surface of one archived product version. + * + * `blockedTypeNames` holds the simple names of types the filter rejected. Declarations render base + * types by simple name, so a namespace pattern cannot recognise them there; this lets the classifier + * ignore base-list entries that are not part of the documented surface. + */ +export function makeSurface(productCode, version) { + return { + productCode, version, namespaces: new Set(), types: new Map(), warnings: [], + blockedTypeNames: new Set(), + }; +} + +export function memberCount(surface) { + let total = 0; + for (const entry of surface.types.values()) total += entry.members.size; + return total; +} + +/** A single reported change. */ +export function makeDelta({ kind, severity, target, typeUid, uid, display, before = "", after = "", reasons = [] }) { + return { kind, severity, target, typeUid, uid, display, before, after, reasons }; +} + +export function bySeverity(result, severity) { + return result.deltas.filter((delta) => delta.severity === severity); +} + +export function summary(result) { + const counts = {}; + for (const severity of SEVERITY_ORDER) counts[severity.toLowerCase()] = bySeverity(result, severity).length; + return counts; +} diff --git a/apidiff/model.py b/apidiff/model.py new file mode 100644 index 000000000..f6462f47e --- /dev/null +++ b/apidiff/model.py @@ -0,0 +1,100 @@ +"""Data records shared by the parsing, classification, and rendering stages.""" + +from dataclasses import dataclass, field + + +# Change classifications, most severe first. The order is used for grouping in every renderer. +BREAKING = "BREAKING" +ADDITIVE = "ADDITIVE" +COSMETIC = "COSMETIC" +SEVERITY_ORDER = (BREAKING, ADDITIVE, COSMETIC) + +# Delta kinds. +ADDED = "added" +REMOVED = "removed" +CHANGED = "changed" + + +@dataclass +class Member: + """One member (method, property, field, or event) of a type.""" + + uid: str + kind: str # commentId prefix: M, P, F, or E + name: str # xrefmap `name`, e.g. "Contains(String)" + name_with_type: str + full_name: str + type_uid: str # owning type's uid + declaration: str = "" # C# declaration from the HTML page; "" when unavailable + + +@dataclass +class TypeEntry: + """One type page: its own declaration plus the members documented on it.""" + + uid: str # fully-qualified type name + name: str + namespace: str + declaration: str = "" # e.g. "public class IronZipArchive : IronBaseArchive, IDisposable" + # Interfaces from the page's Implements section, simple-named. Held separately from the + # declaration because DocFX stopped inlining interfaces in the declaration line between the + # 2026.6 and 2026.7 builds while this section stayed identical, so it is the stable source. + implements: list = field(default_factory=list) + members: dict = field(default_factory=dict) # uid -> Member + + +@dataclass +class Surface: + """The complete public API surface of one archived product version.""" + + product_code: str + version: str + namespaces: set = field(default_factory=set) + types: dict = field(default_factory=dict) # uid -> TypeEntry + warnings: list = field(default_factory=list) + # Simple names of types the filter rejected. Declarations render base types by simple name, so a + # namespace pattern cannot recognise them there; this set lets the classifier ignore base-list + # entries that are not part of the documented surface. + blocked_type_names: set = field(default_factory=set) + + def member_count(self) -> int: + return sum(len(entry.members) for entry in self.types.values()) + + +@dataclass +class Delta: + """A single reported change. + + ``before``/``after`` hold declarations (or the member name when no declaration was available), + and ``reasons`` explains *why* the classifier reached its verdict. + """ + + kind: str # ADDED, REMOVED, or CHANGED + severity: str # BREAKING, ADDITIVE, or COSMETIC + target: str # "type", "member", or "namespace" + type_uid: str + uid: str + display: str # human-facing label, e.g. "IronZipArchive.Contains(String)" + before: str = "" + after: str = "" + reasons: list = field(default_factory=list) + + +@dataclass +class DiffResult: + """Everything a renderer needs.""" + + product_code: str + product_name: str + version_from: str + version_to: str + deltas: list = field(default_factory=list) + warnings: list = field(default_factory=list) + surface_from: object = None + surface_to: object = None + + def by_severity(self, severity: str) -> list: + return [delta for delta in self.deltas if delta.severity == severity] + + def summary(self) -> dict: + return {name.lower(): len(self.by_severity(name)) for name in SEVERITY_ORDER} diff --git a/apidiff/render-json.mjs b/apidiff/render-json.mjs new file mode 100644 index 000000000..ebb0182b9 --- /dev/null +++ b/apidiff/render-json.mjs @@ -0,0 +1,54 @@ +/** + * render-json.mjs — machine-readable diff artifact (Node port of render_json.py). + * + * Key order is fixed and every collection is sorted so this and the Python port produce + * byte-identical files — that equality is the repo's dual-port parity gate. + */ + +import { SEVERITY_ORDER, summary } from "./model.mjs"; + +/** Return the JSON-serializable form of a diff. */ +export function build(result) { + const types = new Map(); + for (const delta of result.deltas) { + if (!types.has(delta.typeUid)) types.set(delta.typeUid, { added: [], removed: [], changed: [] }); + types.get(delta.typeUid)[delta.kind].push({ + uid: delta.uid, + display: delta.display, + severity: delta.severity, + target: delta.target, + before: delta.before, + after: delta.after, + reasons: [...delta.reasons], + }); + } + + const compareStrings = (a, b) => (a < b ? -1 : a > b ? 1 : 0); + + return { + product: result.productCode, + productName: result.productName, + from: result.versionFrom, + to: result.versionTo, + generatedFrom: "xrefmap+html", + summary: { + ...summary(result), + total: result.deltas.length, + typesFrom: result.surfaceFrom ? result.surfaceFrom.types.size : 0, + typesTo: result.surfaceTo ? result.surfaceTo.types.size : 0, + }, + severities: [...SEVERITY_ORDER], + types: [...types.keys()].sort(compareStrings).map((fqn) => ({ + fqn, + added: types.get(fqn).added, + removed: types.get(fqn).removed, + changed: types.get(fqn).changed, + })), + warnings: [...result.warnings].sort(compareStrings), + }; +} + +/** Serialize a diff as pretty-printed JSON with a trailing newline. */ +export function render(result) { + return `${JSON.stringify(build(result), null, 2)}\n`; +} diff --git a/apidiff/render-markdown.mjs b/apidiff/render-markdown.mjs new file mode 100644 index 000000000..fd3f7d883 --- /dev/null +++ b/apidiff/render-markdown.mjs @@ -0,0 +1,59 @@ +/** render-markdown.mjs — changelog-style report, breaking first (port of render_markdown.py). */ + +import { ADDED, CHANGED, SEVERITY_ORDER, bySeverity, summary } from "./model.mjs"; + +const HEADING = { + BREAKING: "Breaking changes", + ADDITIVE: "Additions", + COSMETIC: "Cosmetic", +}; + +/** Return the Markdown body for a diff. */ +export function render(result) { + const counts = summary(result); + const lines = [ + `# ${result.productName} API changes: ${result.versionFrom} -> ${result.versionTo}`, + "", + "Generated from the object-reference archive (xrefmap + DocFX declarations). " + + `**${counts.breaking} breaking**, ${counts.additive} additive, ${counts.cosmetic} cosmetic.`, + "", + ]; + + if (!result.deltas.length) { + lines.push("No public API changes.", ""); + return lines.join("\n"); + } + + for (const severity of SEVERITY_ORDER) { + const deltas = bySeverity(result, severity); + if (!deltas.length) continue; + lines.push(`## ${HEADING[severity]} (${deltas.length})`, ""); + + let currentType = null; + for (const delta of deltas) { + if (delta.typeUid !== currentType) { + currentType = delta.typeUid; + lines.push(currentType ? `### \`${currentType}\`` : "### Namespaces", ""); + } + if (delta.kind === CHANGED) { + lines.push(`- **${delta.display}** changed`); + lines.push(` - was: \`${delta.before}\``); + lines.push(` - now: \`${delta.after}\``); + } else { + lines.push(`- **${delta.display}** ${delta.kind === ADDED ? "added" : "removed"}`); + if (delta.before || delta.after) lines.push(` - \`${delta.before || delta.after}\``); + } + for (const reason of delta.reasons) lines.push(` - ${reason}`); + } + lines.push(""); + } + + if (result.warnings.length) { + lines.push(`## Warnings (${result.warnings.length})`, ""); + const sorted = [...result.warnings].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)); + for (const warning of sorted.slice(0, 50)) lines.push(`- ${warning}`); + lines.push(""); + } + + return lines.join("\n"); +} diff --git a/apidiff/render-text.mjs b/apidiff/render-text.mjs new file mode 100644 index 000000000..bc742ffa9 --- /dev/null +++ b/apidiff/render-text.mjs @@ -0,0 +1,62 @@ +/** render-text.mjs — terminal report, grouped breaking -> additive -> cosmetic (port of render_text.py). */ + +import { StatusLogger } from "../statuslogger.mjs"; +import { ADDED, BREAKING, ADDITIVE, CHANGED, COSMETIC, REMOVED, SEVERITY_ORDER, bySeverity, summary } from "./model.mjs"; + +/** Leading glyph per delta kind. */ +const MARKER = { [ADDED]: "+", [REMOVED]: "-", [CHANGED]: "~" }; + +const SEVERITY_LOGGER = { + [BREAKING]: StatusLogger.error, + [ADDITIVE]: StatusLogger.success, + [COSMETIC]: StatusLogger.debug, +}; + +function renderWarnings(result, showWarnings) { + if (!showWarnings || !result.warnings.length) return; + StatusLogger.warning(`\n${result.warnings.length} warning(s):`); + for (const warning of result.warnings.slice(0, 20)) StatusLogger.warning(` ${warning}`); + if (result.warnings.length > 20) StatusLogger.warning(` ... and ${result.warnings.length - 20} more`); +} + +/** Print a diff to the terminal. */ +export function render(result, showWarnings = true) { + StatusLogger.title( + `${result.productName} (${result.productCode}) ${result.versionFrom} -> ${result.versionTo}`, + ); + + if (!result.deltas.length) { + StatusLogger.success("No public API changes."); + renderWarnings(result, showWarnings); + return; + } + + for (const severity of SEVERITY_ORDER) { + const deltas = bySeverity(result, severity); + if (!deltas.length) continue; + const log = SEVERITY_LOGGER[severity]; + StatusLogger.notice(`\n${severity} (${deltas.length})`); + + let currentType = null; + for (const delta of deltas) { + if (delta.typeUid !== currentType) { + currentType = delta.typeUid; + StatusLogger.info(` ${currentType || "namespaces"}`); + } + log(` ${MARKER[delta.kind]} ${delta.display}`); + if (delta.kind === CHANGED) { + StatusLogger.message(` was: ${delta.before}`); + StatusLogger.message(` now: ${delta.after}`); + } else if (delta.before || delta.after) { + StatusLogger.message(` ${delta.before || delta.after}`); + } + for (const reason of delta.reasons) StatusLogger.message(` . ${reason}`); + } + } + + const counts = summary(result); + StatusLogger.title( + `\nSummary: ${counts.breaking} breaking, ${counts.additive} additive, ${counts.cosmetic} cosmetic`, + ); + renderWarnings(result, showWarnings); +} diff --git a/apidiff/render_json.py b/apidiff/render_json.py new file mode 100644 index 000000000..34fb7dad2 --- /dev/null +++ b/apidiff/render_json.py @@ -0,0 +1,50 @@ +"""Machine-readable diff artifact. + +Key order is fixed and every collection is sorted so the Python and Node ports produce byte-identical +files — that equality is the repo's dual-port parity gate. +""" + +import json + +from .model import SEVERITY_ORDER + + +def build(result) -> dict: + """Return the JSON-serializable form of a diff.""" + types = {} + for delta in result.deltas: + bucket = types.setdefault(delta.type_uid, {"added": [], "removed": [], "changed": []}) + bucket[delta.kind].append({ + "uid": delta.uid, + "display": delta.display, + "severity": delta.severity, + "target": delta.target, + "before": delta.before, + "after": delta.after, + "reasons": list(delta.reasons), + }) + + return { + "product": result.product_code, + "productName": result.product_name, + "from": result.version_from, + "to": result.version_to, + "generatedFrom": "xrefmap+html", + "summary": { + **result.summary(), + "total": len(result.deltas), + "typesFrom": len(result.surface_from.types) if result.surface_from else 0, + "typesTo": len(result.surface_to.types) if result.surface_to else 0, + }, + "severities": list(SEVERITY_ORDER), + "types": [ + {"fqn": fqn, **{kind: types[fqn][kind] for kind in ("added", "removed", "changed")}} + for fqn in sorted(types) + ], + "warnings": sorted(result.warnings), + } + + +def render(result) -> str: + """Serialize a diff as pretty-printed JSON with a trailing newline.""" + return json.dumps(build(result), indent=2, ensure_ascii=False) + "\n" diff --git a/apidiff/render_markdown.py b/apidiff/render_markdown.py new file mode 100644 index 000000000..43e65d87a --- /dev/null +++ b/apidiff/render_markdown.py @@ -0,0 +1,61 @@ +"""Changelog-style Markdown report, breaking changes first.""" + +from .model import CHANGED, SEVERITY_ORDER + +HEADING = { + "BREAKING": "Breaking changes", + "ADDITIVE": "Additions", + "COSMETIC": "Cosmetic", +} + + +def render(result) -> str: + """Return the Markdown body for a diff.""" + summary = result.summary() + lines = [ + f"# {result.product_name} API changes: {result.version_from} -> {result.version_to}", + "", + f"Generated from the object-reference archive (xrefmap + DocFX declarations). " + f"**{summary['breaking']} breaking**, {summary['additive']} additive, {summary['cosmetic']} cosmetic.", + "", + ] + + if not result.deltas: + lines.append("No public API changes.") + lines.append("") + return "\n".join(lines) + + for severity in SEVERITY_ORDER: + deltas = result.by_severity(severity) + if not deltas: + continue + lines.append(f"## {HEADING[severity]} ({len(deltas)})") + lines.append("") + + current_type = None + for delta in deltas: + if delta.type_uid != current_type: + current_type = delta.type_uid + lines.append(f"### `{current_type}`" if current_type else "### Namespaces") + lines.append("") + if delta.kind == CHANGED: + lines.append(f"- **{delta.display}** changed") + lines.append(f" - was: `{delta.before}`") + lines.append(f" - now: `{delta.after}`") + else: + verb = "added" if delta.kind == "added" else "removed" + lines.append(f"- **{delta.display}** {verb}") + if delta.before or delta.after: + lines.append(f" - `{delta.before or delta.after}`") + for reason in delta.reasons: + lines.append(f" - {reason}") + lines.append("") + + if result.warnings: + lines.append(f"## Warnings ({len(result.warnings)})") + lines.append("") + for warning in sorted(result.warnings)[:50]: + lines.append(f"- {warning}") + lines.append("") + + return "\n".join(lines) diff --git a/apidiff/render_text.py b/apidiff/render_text.py new file mode 100644 index 000000000..8f1ae17b7 --- /dev/null +++ b/apidiff/render_text.py @@ -0,0 +1,64 @@ +"""Terminal report, grouped breaking -> additive -> cosmetic.""" + +from statuslogger import StatusLogger + +from .model import ADDED, ADDITIVE, BREAKING, CHANGED, COSMETIC, REMOVED, SEVERITY_ORDER + +# Leading glyph per delta kind. +MARKER = {ADDED: "+", REMOVED: "-", CHANGED: "~"} + +SEVERITY_LOGGER = { + BREAKING: StatusLogger.error, + ADDITIVE: StatusLogger.success, + COSMETIC: StatusLogger.debug, +} + + +def render(result, show_warnings: bool = True) -> None: + """Print a diff to the terminal.""" + StatusLogger.title( + f"{result.product_name} ({result.product_code}) {result.version_from} -> {result.version_to}" + ) + + if not result.deltas: + StatusLogger.success("No public API changes.") + _render_warnings(result, show_warnings) + return + + for severity in SEVERITY_ORDER: + deltas = result.by_severity(severity) + if not deltas: + continue + log = SEVERITY_LOGGER[severity] + StatusLogger.notice(f"\n{severity} ({len(deltas)})") + + current_type = None + for delta in deltas: + if delta.type_uid != current_type: + current_type = delta.type_uid + StatusLogger.info(f" {current_type or 'namespaces'}") + log(f" {MARKER[delta.kind]} {delta.display}") + if delta.kind == CHANGED: + StatusLogger.message(f" was: {delta.before}") + StatusLogger.message(f" now: {delta.after}") + elif delta.before or delta.after: + StatusLogger.message(f" {delta.before or delta.after}") + for reason in delta.reasons: + StatusLogger.message(f" . {reason}") + + summary = result.summary() + StatusLogger.title( + f"\nSummary: {summary['breaking']} breaking, {summary['additive']} additive, " + f"{summary['cosmetic']} cosmetic" + ) + _render_warnings(result, show_warnings) + + +def _render_warnings(result, show_warnings: bool) -> None: + if not show_warnings or not result.warnings: + return + StatusLogger.warning(f"\n{len(result.warnings)} warning(s):") + for warning in result.warnings[:20]: + StatusLogger.warning(f" {warning}") + if len(result.warnings) > 20: + StatusLogger.warning(f" ... and {len(result.warnings) - 20} more") diff --git a/apidiff/surface.mjs b/apidiff/surface.mjs new file mode 100644 index 000000000..59cedaf29 --- /dev/null +++ b/apidiff/surface.mjs @@ -0,0 +1,114 @@ +/** surface.mjs — assemble a Surface for one archived version (Node port of surface.py). */ + +import { existsSync, readFileSync, statSync } from "node:fs"; +import { join } from "node:path"; + +import { parseImplements, parseTypePage } from "./declarations.mjs"; +import { makeMember, makeSurface, makeTypeEntry } from "./model.mjs"; +import { kindOf, pageStem, parseXrefmap } from "./xrefmap.mjs"; + +const MEMBER_KINDS = new Set(["M", "P", "F", "E"]); + +/** + * Longest known namespace that prefixes the type uid. Longest-match matters for nested namespaces: + * `IronPdf.Rendering.ChromePdfRenderer` must resolve to `IronPdf.Rendering`, not `IronPdf`. + */ +function namespaceOf(typeUid, namespaces) { + let best = ""; + for (const namespace of namespaces) { + if (typeUid.startsWith(`${namespace}.`) && namespace.length > best.length) best = namespace; + } + return best; +} + +/** + * Read one archived version directory into a Surface. + * + * xrefmap entries establish identity; each surviving type's HTML page is then opened once to attach + * declarations. Types the filter rejects are never opened, so a narrow `--namespace` makes the run + * proportionally cheaper. + */ +export function buildSurface(versionDir, productCode, version, surfaceFilter) { + const surface = makeSurface(productCode, version); + const entries = parseXrefmap(join(versionDir, "xrefmap.yml")); + + // Pass 1 — namespaces and types, so member attribution has somewhere to land. + // + // Every namespace is retained locally for attribution, but only the ones the filter admits are + // reported; otherwise `--exclude` would still surface namespace-level additions and removals for + // the very namespaces it was asked to hide. + const allNamespaces = new Set(); + for (const [uid, entry] of Object.entries(entries)) { + const kind = kindOf(entry); + if (kind === "N") { + allNamespaces.add(uid); + if (surfaceFilter.allowsType(uid)) surface.namespaces.add(uid); + } else if (kind === "T") { + if (surfaceFilter.allowsType(uid)) { + surface.types.set(uid, makeTypeEntry({ uid, name: entry.name ?? uid })); + } else { + // Remember the simple name so the classifier can ignore it in a base list. + surface.blockedTypeNames.add(uid.slice(uid.lastIndexOf(".") + 1)); + } + } + } + for (const [typeUid, typeEntry] of surface.types) { + typeEntry.namespace = namespaceOf(typeUid, allNamespaces); + } + + // Pass 2 — members, attributed to their owning type via the page their href points at. + for (const [uid, entry] of Object.entries(entries)) { + const kind = kindOf(entry); + if (!MEMBER_KINDS.has(kind)) continue; + const name = entry.name ?? uid; + if (!surfaceFilter.allowsMember(uid, name)) continue; + const owner = pageStem(entry); + const typeEntry = surface.types.get(owner); + // Either the owning type was filtered out, or the href pointed somewhere unexpected. + if (!typeEntry) continue; + typeEntry.members.set(uid, makeMember({ + uid, + kind, + name, + nameWithType: entry.nameWithType ?? name, + fullName: entry.fullName ?? uid, + typeUid: owner, + })); + } + + // Pass 3 — attach declarations from each type's HTML page. + const apiDir = join(versionDir, "api"); + for (const [typeUid, typeEntry] of surface.types) { + const pagePath = join(apiDir, `${typeUid}.html`); + if (!existsSync(pagePath) || !statSync(pagePath).isFile()) { + // Archived trees predating stripGuidMarkers() can carry unresolvable page names. Fall back to + // xrefmap-only identity for this type rather than aborting the whole diff. + surface.warnings.push(`${version}: no page for ${typeUid} (identity only, no signatures)`); + continue; + } + const pageHtml = readFileSync(pagePath, "utf-8"); + const declarations = parseTypePage(pageHtml); + typeEntry.implementsList = parseImplements(pageHtml); + if (Object.keys(declarations).length === 0) { + surface.warnings.push(`${version}: no declarations parsed from ${typeUid}.html`); + continue; + } + typeEntry.declaration = declarations[typeUid] ?? ""; + for (const member of typeEntry.members.values()) { + member.declaration = declarations[member.uid] ?? ""; + } + } + + // Pass 4 — drop anything the visibility filter rejects now that declarations are known. + for (const [typeUid, typeEntry] of [...surface.types]) { + if (!surfaceFilter.allowsDeclaration(typeEntry.declaration)) { + surface.types.delete(typeUid); + continue; + } + for (const [memberUid, member] of [...typeEntry.members]) { + if (!surfaceFilter.allowsDeclaration(member.declaration)) typeEntry.members.delete(memberUid); + } + } + + return surface; +} diff --git a/apidiff/surface.py b/apidiff/surface.py new file mode 100644 index 000000000..9f3ee299c --- /dev/null +++ b/apidiff/surface.py @@ -0,0 +1,117 @@ +"""Assemble a Surface for one archived version from its xrefmap and type pages.""" + +import os + +from .declarations import parse_implements, parse_type_page +from .model import Member, Surface, TypeEntry +from .xrefmap import kind_of, page_stem, parse_xrefmap + +MEMBER_KINDS = ("M", "P", "F", "E") + + +def _namespace_of(type_uid: str, namespaces: set) -> str: + """Longest known namespace that prefixes the type uid. + + Longest-match matters for nested namespaces: ``IronPdf.Rendering.ChromePdfRenderer`` must resolve + to ``IronPdf.Rendering`` rather than ``IronPdf``. + """ + best = "" + for namespace in namespaces: + if type_uid.startswith(namespace + ".") and len(namespace) > len(best): + best = namespace + return best + + +def build_surface(version_dir: str, product_code: str, version: str, surface_filter) -> Surface: + """Read one archived version directory into a Surface. + + xrefmap entries establish identity; each surviving type's HTML page is then opened once to + attach declarations. Types the filter rejects are never opened, so a narrow ``--namespace`` + makes the run proportionally cheaper. + + Args: + version_dir (str): Path to ``object-reference//``. + product_code (str): Product short code. + version (str): Version string. + surface_filter (SurfaceFilter): Decides which types and members are in scope. + + Returns: + Surface: The version's filtered public API surface. + """ + surface = Surface(product_code=product_code, version=version) + entries = parse_xrefmap(os.path.join(version_dir, "xrefmap.yml")) + + # Pass 1 — namespaces and types, so member attribution has somewhere to land. + # + # Every namespace is retained locally for attribution, but only the ones the filter admits are + # reported; otherwise `--exclude` would still surface namespace-level additions and removals for + # the very namespaces it was asked to hide. + all_namespaces = set() + for uid, entry in entries.items(): + kind = kind_of(entry) + if kind == "N": + all_namespaces.add(uid) + if surface_filter.allows_type(uid): + surface.namespaces.add(uid) + elif kind == "T": + if surface_filter.allows_type(uid): + surface.types[uid] = TypeEntry(uid=uid, name=entry.get("name", uid), namespace="") + else: + # Remember the simple name so the classifier can ignore it in a base list. + surface.blocked_type_names.add(uid.rsplit(".", 1)[-1]) + + for type_uid, type_entry in surface.types.items(): + type_entry.namespace = _namespace_of(type_uid, all_namespaces) + + # Pass 2 — members, attributed to their owning type via the page their href points at. + for uid, entry in entries.items(): + kind = kind_of(entry) + if kind not in MEMBER_KINDS: + continue + name = entry.get("name", uid) + if not surface_filter.allows_member(uid, name): + continue + owner = page_stem(entry) + type_entry = surface.types.get(owner) + if type_entry is None: + # Either the owning type was filtered out, or the href pointed somewhere unexpected. + continue + type_entry.members[uid] = Member( + uid=uid, + kind=kind, + name=name, + name_with_type=entry.get("nameWithType", name), + full_name=entry.get("fullName", uid), + type_uid=owner, + ) + + # Pass 3 — attach declarations from each type's HTML page. + api_dir = os.path.join(version_dir, "api") + for type_uid, type_entry in surface.types.items(): + page_path = os.path.join(api_dir, type_uid + ".html") + if not os.path.isfile(page_path): + # Archived trees predating strip_guid_markers() can carry unresolvable page names. Fall + # back to xrefmap-only identity for this type rather than aborting the whole diff. + surface.warnings.append(f"{version}: no page for {type_uid} (identity only, no signatures)") + continue + with open(page_path, "r", encoding="utf-8", errors="replace") as handle: + page_html = handle.read() + declarations = parse_type_page(page_html) + type_entry.implements = parse_implements(page_html) + if not declarations: + surface.warnings.append(f"{version}: no declarations parsed from {type_uid}.html") + continue + type_entry.declaration = declarations.get(type_uid, "") + for member_uid, member in type_entry.members.items(): + member.declaration = declarations.get(member_uid, "") + + # Pass 4 — drop anything the visibility filter rejects now that declarations are known. + for type_entry in list(surface.types.values()): + if not surface_filter.allows_declaration(type_entry.declaration): + del surface.types[type_entry.uid] + continue + for member_uid, member in list(type_entry.members.items()): + if not surface_filter.allows_declaration(member.declaration): + del type_entry.members[member_uid] + + return surface diff --git a/apidiff/xrefmap.mjs b/apidiff/xrefmap.mjs new file mode 100644 index 000000000..f22350379 --- /dev/null +++ b/apidiff/xrefmap.mjs @@ -0,0 +1,106 @@ +/** + * xrefmap.mjs — parser for DocFX `xrefmap.yml` (Node port of xrefmap.py). + * + * The archive's xrefmaps are a uniform, flat list of six-key blocks. Verified across the whole + * archive, oldest (`irondrawing/2022.9.8843`) to newest: no anchors, no nesting, no `isSpec`, and no + * `specification` blocks. A line parser is therefore sufficient, and is markedly faster than a YAML + * library on the 2.3 MB ironpdf map. + * + * Only two YAML subtleties actually occur and both are handled: the `- uid:` list-item marker, and + * quoted scalars (DocFX quotes `name: "True"` / `"False"` so they are not read as booleans). + */ + +import { readFileSync } from "node:fs"; + +/** The six keys every entry carries. Anything else is ignored so an added key cannot break parsing. */ +export const ENTRY_KEYS = new Set(["uid", "name", "href", "commentId", "fullName", "nameWithType"]); + +/** + * DocFX emits spurious `` markers on some vendored/unresolvable types, and mints a *fresh* + * GUID on every build — so the same member reads as a different uid in every release and shows up as + * a removal plus an addition forever (745 uids in ironpdf 2026.6.1, 663 in ironword, 2 in ironxl). + * + * Stripping the marker is exactly what update-apidocs' stripGuidMarkers() already does to the + * generated file names, so a stripped uid also matches the page actually on disk + * (`Org.BouncyCastle.Asn1.Asn1Encodable` -> `Org.BouncyCastle.Asn1.Asn1Encodable.html`). + * Both the raw and URL-encoded forms occur: uids carry `<…>`, hrefs carry `%3C…%3E`. + */ +const GUID_MARKER_RE = + /(?:<|%3[Cc])[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(?:>|%3[Ee])/g; + +/** Remove DocFX's per-build `` markers so identifiers compare across versions. */ +export function stripGuidMarkers(value) { + return value.replace(GUID_MARKER_RE, ""); +} + +/** + * Unwrap a YAML scalar, stripping matched surrounding quotes and DocFX GUID markers. + * + * DocFX emits `name: "True"` for members whose name would otherwise parse as a boolean; without this + * the quotes survive into the uid comparison and every such member reads as changed. + */ +function scalar(raw) { + let value = raw.trim(); + if (value.length >= 2 && value[0] === value[value.length - 1] && (value[0] === '"' || value[0] === "'")) { + const inner = value.slice(1, -1); + value = value[0] === '"' ? inner.replaceAll('\\"', '"').replaceAll("\\\\", "\\") : inner.replaceAll("''", "'"); + } + return stripGuidMarkers(value); +} + +/** + * Read an xrefmap into `{ [uid]: { ...keys } }`. + * + * @param {string} path Path to a version's `xrefmap.yml`. + */ +export function parseXrefmap(path) { + const entries = Object.create(null); + let current = null; + + for (const line of readFileSync(path, "utf-8").split("\n")) { + let stripped = line.trim(); + // Skip the YamlMime marker, the `sorted:`/`references:` headers, and blank lines. + if (!stripped || stripped.startsWith("#")) continue; + + if (stripped.startsWith("- ")) { + // A new list item always begins with `- uid: `. + if (current !== null && "uid" in current) entries[current.uid] = current; + current = {}; + stripped = stripped.slice(2).trim(); + } + if (current === null) continue; + + const separator = stripped.indexOf(":"); + if (separator < 0) continue; + const key = stripped.slice(0, separator); + if (!ENTRY_KEYS.has(key)) continue; + current[key] = scalar(stripped.slice(separator + 1)); + } + + if (current !== null && "uid" in current) entries[current.uid] = current; + return entries; +} + +/** + * An entry's kind from its `commentId` prefix: `N` namespace, `T` type, `M` method/constructor, + * `P` property, `F` field, `E` event. Returns `""` when there is no usable commentId. + */ +export function kindOf(entry) { + const commentId = entry.commentId ?? ""; + return commentId.length > 1 && commentId[1] === ":" ? commentId[0] : ""; +} + +/** + * The type page an entry is documented on, derived from its `href`. + * + * `href` is always `api/.html` with an optional `#anchor`. Deriving the owning type from + * the page — rather than splitting the uid on dots — is what keeps nested types, generics, and + * explicit interface implementations attributed correctly. Returns `""` for an unexpected shape. + */ +export function pageStem(entry) { + const href = entry.href ?? ""; + if (!href) return ""; + let path = href.split("#", 1)[0]; + if (path.startsWith("api/")) path = path.slice(4); + return path.endsWith(".html") ? path.slice(0, -5) : ""; +} diff --git a/apidiff/xrefmap.py b/apidiff/xrefmap.py new file mode 100644 index 000000000..adf4f9e1b --- /dev/null +++ b/apidiff/xrefmap.py @@ -0,0 +1,113 @@ +"""Parser for DocFX ``xrefmap.yml`` — the member-identity layer of a diff. + +The archive's xrefmaps are a uniform, flat list of six-key blocks. Verified across the whole +archive, oldest (``irondrawing/2022.9.8843``) to newest: no anchors, no nesting, no ``isSpec``, and +no ``specification`` blocks. A line parser is therefore sufficient, and is markedly faster than a +YAML library on the 2.3 MB ironpdf map. + +Only two YAML subtleties actually occur and both are handled: the ``- uid:`` list-item marker, and +quoted scalars (DocFX quotes ``name: "True"`` / ``"False"`` so they are not read as booleans). +""" + +import re + +# The six keys every entry carries. Anything else is ignored so an added key cannot break parsing. +ENTRY_KEYS = ("uid", "name", "href", "commentId", "fullName", "nameWithType") + +# DocFX emits spurious `` markers on some vendored/unresolvable types, and mints a *fresh* GUID +# on every build — so the same member reads as a different uid in every release and shows up as a +# removal plus an addition forever (745 uids in ironpdf 2026.6.1, 663 in ironword, 2 in ironxl). +# +# Stripping the marker is exactly what update-apidocs' strip_guid_markers() already does to the +# generated file names, so a stripped uid also matches the page actually on disk +# (`Org.BouncyCastle.Asn1.Asn1Encodable` -> `Org.BouncyCastle.Asn1.Asn1Encodable.html`). +# Both the raw and URL-encoded forms occur: uids carry `<…>`, hrefs carry `%3C…%3E`. +GUID_MARKER_RE = re.compile( + r"(?:<|%3[Cc])[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(?:>|%3[Ee])" +) + + +def strip_guid_markers(value: str) -> str: + """Remove DocFX's per-build ```` markers so identifiers compare across versions.""" + return GUID_MARKER_RE.sub("", value) + + +def _scalar(raw: str) -> str: + """Unwrap a YAML scalar, stripping matched surrounding quotes and DocFX GUID markers. + + DocFX emits ``name: "True"`` for members whose name would otherwise parse as a boolean; without + this the quotes survive into the uid comparison and every such member reads as changed. + """ + value = raw.strip() + if len(value) >= 2 and value[0] == value[-1] and value[0] in ('"', "'"): + inner = value[1:-1] + value = inner.replace('\\"', '"').replace("\\\\", "\\") if value[0] == '"' else inner.replace("''", "'") + return strip_guid_markers(value) + + +def parse_xrefmap(path: str) -> dict: + """Read an xrefmap into ``{uid: {key: value}}``. + + Args: + path (str): Path to a version's ``xrefmap.yml``. + + Returns: + dict: One entry per uid, each holding the six xrefmap keys present for it. + """ + entries = {} + current = None + + with open(path, "r", encoding="utf-8") as handle: + for line in handle: + stripped = line.strip() + # Skip the YamlMime marker, the `sorted:`/`references:` headers, and blank lines. + if not stripped or stripped.startswith("#"): + continue + + if stripped.startswith("- "): + # A new list item always begins with `- uid: `. + if current is not None and "uid" in current: + entries[current["uid"]] = current + current = {} + stripped = stripped[2:].strip() + + if current is None: + continue + + key, separator, value = stripped.partition(":") + if not separator or key not in ENTRY_KEYS: + continue + current[key] = _scalar(value) + + if current is not None and "uid" in current: + entries[current["uid"]] = current + + return entries + + +def kind_of(entry: dict) -> str: + """Return an entry's kind from its ``commentId`` prefix. + + ``N`` namespace, ``T`` type, ``M`` method/constructor, ``P`` property, ``F`` field, ``E`` event. + Returns ``""`` when the entry has no usable commentId. + """ + comment_id = entry.get("commentId", "") + return comment_id[0] if len(comment_id) > 1 and comment_id[1] == ":" else "" + + +def page_stem(entry: dict) -> str: + """Return the type page an entry is documented on, derived from its ``href``. + + ``href`` is always ``api/.html`` with an optional ``#anchor``. Deriving the owning type + from the page — rather than splitting the uid on dots — is what keeps nested types, generics, and + explicit interface implementations attributed correctly. + + Returns ``""`` when the href is missing or not the expected shape. + """ + href = entry.get("href", "") + if not href: + return "" + path = href.split("#", 1)[0] + if path.startswith("api/"): + path = path[4:] + return path[:-5] if path.endswith(".html") else "" diff --git a/apidocs.mjs b/apidocs.mjs index 3f1a8da35..09d7f1c2e 100644 --- a/apidocs.mjs +++ b/apidocs.mjs @@ -6,7 +6,7 @@ * and return shapes mirror the Python module so the two ports stay interchangeable. */ -import { readFileSync, existsSync } from "node:fs"; +import { readFileSync, existsSync, readdirSync, statSync } from "node:fs"; import { join, dirname } from "node:path"; import { fileURLToPath } from "node:url"; @@ -27,6 +27,57 @@ export const PRODUCTS_CATALOG = join(CWD, "iron-products.json"); /** Root of the object-reference cache where generated docs are stored. */ export const APIDOCS_STORAGE_PATH = join(CWD, "object-reference"); +/** + * Directory names that sit alongside the version directories under object-reference// but are + * not versions. Anything listed here is skipped by listArchivedVersions(). + */ +const NON_VERSION_DIRECTORIES = new Set(["_archetype-n-samples"]); + +/** + * Sort key for an archived version directory name, as an array of `[isNonNumeric, number, text]`. + * + * The archive spans two numbering eras — the old build-number style (`2021.9.3650`) and the modern + * `YYYY.M.P` style (`2026.6.1`) — but both are dot-separated integers, so comparing components + * numerically orders them correctly and sorts `2026.10.1` after `2026.9.1` (lexical does not). + * Non-numeric components sort last within their position rather than throwing. + */ +export function versionSortKey(versionString) { + return versionString.split(".").map((component) => + /^\d+$/.test(component) ? [0, Number(component), ""] : [1, 0, component], + ); +} + +/** Compare two version strings using versionSortKey ordering. */ +export function compareVersions(a, b) { + const keyA = versionSortKey(a); + const keyB = versionSortKey(b); + for (let i = 0; i < Math.max(keyA.length, keyB.length); i++) { + // A missing component sorts before a present one, matching Python's shorter-tuple-first rule. + const partA = keyA[i] ?? [-1, 0, ""]; + const partB = keyB[i] ?? [-1, 0, ""]; + if (partA[0] !== partB[0]) return partA[0] - partB[0]; + if (partA[1] !== partB[1]) return partA[1] - partB[1]; + if (partA[2] !== partB[2]) return partA[2] < partB[2] ? -1 : 1; + } + return 0; +} + +/** + * Return the versions already built into the object-reference cache, oldest first. + * + * Directory existence *is* the version index for this repo — there is no manifest to read — so this + * lists `object-reference//` and filters the non-version siblings. Empty when the product has + * no archive directory. + */ +export function listArchivedVersions(productCode) { + const productDir = join(APIDOCS_STORAGE_PATH, productCode); + if (!existsSync(productDir) || !statSync(productDir).isDirectory()) return []; + + return readdirSync(productDir) + .filter((entry) => !NON_VERSION_DIRECTORIES.has(entry) && statSync(join(productDir, entry)).isDirectory()) + .sort(compareVersions); +} + /** Build the storage path for a product's versioned API documentation. */ export function getApidocPath(info, versionString) { return join(APIDOCS_STORAGE_PATH, info.code, versionString); diff --git a/apidocs.py b/apidocs.py index 1c224d2c4..b8e549e03 100644 --- a/apidocs.py +++ b/apidocs.py @@ -28,6 +28,60 @@ # Reusable path template used to place generated API Documentation in their proper spots in the object-reference cache. APIDOCS_DESTINATION_PATH_TEMPLATE = APIDOCS_STORAGE_PATH + os.path.sep + "{}" + os.path.sep + "{}" +# Directory names that live alongside the version directories under object-reference// but are +# not versions. Anything listed here is skipped by list_archived_versions(). +NON_VERSION_DIRECTORIES = {"_archetype-n-samples"} + + +def version_sort_key(version_string:str) -> tuple: + """Sort key for an archived version directory name. + + The archive spans two numbering eras — the old build-number style (``2021.9.3650``, + ``2022.11.10341``) and the modern ``YYYY.M.P`` style (``2026.6.1``) — but both are + dot-separated integers, so a tuple of ints orders them correctly and, crucially, sorts + ``2026.10.1`` after ``2026.9.1`` (which a lexical sort does not). + + Non-numeric components sort last within their position rather than raising, so an unexpected + directory name degrades to a stable ordering instead of crashing the caller. + + Args: + version_string (str): A version directory name. + + Returns: + tuple: A comparable key of ``(is_non_numeric, value)`` pairs. + """ + key = [] + for component in version_string.split("."): + if component.isdigit(): + key.append((0, int(component), "")) + else: + key.append((1, 0, component)) + return tuple(key) + + +def list_archived_versions(product_code:str) -> list: + """Return the versions already built into the object-reference cache, oldest first. + + Directory existence *is* the version index for this repo — there is no manifest to read — so + this lists ``object-reference//`` and filters the non-version siblings. + + Args: + product_code (str): A product's short code (e.g. ``ironzip``). + + Returns: + list: Sorted version strings; empty when the product has no archive directory. + """ + product_dir = os.path.join(APIDOCS_STORAGE_PATH, product_code) + if not os.path.isdir(product_dir): + return [] + + versions = [ + entry for entry in os.listdir(product_dir) + if entry not in NON_VERSION_DIRECTORIES and os.path.isdir(os.path.join(product_dir, entry)) + ] + versions.sort(key=version_sort_key) + return versions + def get_apidoc_path(info:dict, version_string:str) -> str: """Builds the storage path for a product's API documentation diff --git a/diff-apidocs.mjs b/diff-apidocs.mjs new file mode 100644 index 000000000..0781323e3 --- /dev/null +++ b/diff-apidocs.mjs @@ -0,0 +1,185 @@ +#!/usr/bin/env node +/** + * diff-apidocs.mjs — diff the public API surface between two archived product versions + * (Node port of diff-apidocs.py; output format matches it exactly). + * + * Reads only the committed object-reference archive; nothing is downloaded and no build is + * triggered. Identity comes from each version's xrefmap.yml, signatures from its DocFX api/*.html + * pages. + * + * node diff-apidocs.mjs -p ironzip + * node diff-apidocs.mjs -p ironzip --from 2026.5.2 --to 2026.6.2 + * node diff-apidocs.mjs -p ironpdf --namespace 'IronPdf.Rendering.*' --markdown + * node diff-apidocs.mjs -p ironzip --json --fail-on-breaking + * + * Exit codes: 0 success, 1 tool error (unknown product, missing version), 2 breaking changes found + * with --fail-on-breaking. + */ + +import { mkdirSync, writeFileSync } from "node:fs"; +import { dirname, isAbsolute, join, resolve } from "node:path"; +import { parseArgs } from "node:util"; +import { fileURLToPath } from "node:url"; + +import { listArchivedVersions } from "./apidocs.mjs"; +import { StatusLogger } from "./statuslogger.mjs"; +import { + ArchiveError, loadProduct, requireSupported, resolveVersions, versionDirectory, +} from "./apidiff/archive.mjs"; +import { bySeverity, diffSurfaces } from "./apidiff/classify.mjs"; +import { SurfaceFilter } from "./apidiff/filters.mjs"; +import { BREAKING } from "./apidiff/model.mjs"; +import { render as renderJson } from "./apidiff/render-json.mjs"; +import { render as renderMarkdown } from "./apidiff/render-markdown.mjs"; +import { render as renderText } from "./apidiff/render-text.mjs"; +import { buildSurface } from "./apidiff/surface.mjs"; + +const CWD = dirname(fileURLToPath(import.meta.url)); + +/** + * Committed diff artifacts live under docs/, which _config.yml already excludes from the Jekyll + * build, so they stay private to the repo. + */ +const ARTIFACT_ROOT = join(CWD, "docs", "api-diffs"); + +const EXIT_OK = 0; +const EXIT_ERROR = 1; +const EXIT_BREAKING = 2; + +const USAGE = `usage: diff-apidocs [-h] [-p PRODUCT_CODE] [-n PRODUCT_NAME] [--from VERSION] [--to VERSION] + [--namespace GLOB] [--exclude GLOB] [--include-internal] [--all-visibility] + [--json [PATH]] [--markdown [PATH]] [--quiet] [--no-warnings] + [--fail-on-breaking] [--list-versions] + +Diff the public API surface between two archived versions of an Iron Software product. + + -p, --product-code Product short code, e.g. ironzip + -n, --product-name Product display name, e.g. IronZIP + --from Older version (default: previous archived) + --to Newer version (default: newest archived) + --namespace Only report types matching this glob; repeatable + --exclude Skip types matching this glob; repeatable + --include-internal Include vendored/internal namespaces (excluded by default) + --all-visibility Include non-public declarations (public/protected only by default) + --json [PATH] Write JSON; defaults to docs/api-diffs//...json + --markdown [PATH] Write Markdown; defaults alongside the JSON artifact + --quiet Suppress the terminal report + --no-warnings Suppress parser warnings + --fail-on-breaking Exit 2 when breaking changes are found + --list-versions List the product's archived versions and exit`; + +const OPTIONS = { + help: { type: "boolean", short: "h", default: false }, + "product-code": { type: "string", short: "p" }, + "product-name": { type: "string", short: "n" }, + from: { type: "string" }, + to: { type: "string" }, + namespace: { type: "string", multiple: true, default: [] }, + exclude: { type: "string", multiple: true, default: [] }, + "include-internal": { type: "boolean", default: false }, + "all-visibility": { type: "boolean", default: false }, + // parseArgs has no optional-value form, so these are strings defaulting to "" when bare. + json: { type: "string" }, + markdown: { type: "string" }, + quiet: { type: "boolean", default: false }, + "no-warnings": { type: "boolean", default: false }, + "fail-on-breaking": { type: "boolean", default: false }, + "list-versions": { type: "boolean", default: false }, +}; + +/** + * Allow `--json` and `--markdown` to be passed with no value, matching argparse's `nargs="?"`. + * A bare flag becomes "" (use the default artifact path); anything else is taken as a path. + */ +function normalizeOptionalValueFlags(argv) { + const normalized = []; + for (let index = 0; index < argv.length; index++) { + const argument = argv[index]; + if (argument === "--json" || argument === "--markdown") { + const next = argv[index + 1]; + if (next === undefined || next.startsWith("-")) { + normalized.push(`${argument}=`); + continue; + } + } + normalized.push(argument); + } + return normalized; +} + +function artifactPath(supplied, productCode, versionFrom, versionTo, extension) { + if (supplied) return isAbsolute(supplied) ? supplied : resolve(supplied); + return join(ARTIFACT_ROOT, productCode, `${versionFrom}..${versionTo}.${extension}`); +} + +function write(path, content) { + mkdirSync(dirname(path), { recursive: true }); + writeFileSync(path, content, "utf-8"); + StatusLogger.progress(`Wrote ${path}`); +} + +export function main(argv) { + let values; + try { + ({ values } = parseArgs({ args: normalizeOptionalValueFlags(argv), options: OPTIONS, allowPositionals: false })); + } catch (error) { + StatusLogger.error(error.message); + console.log(USAGE); + return EXIT_ERROR; + } + + if (values.help) { + console.log(USAGE); + return EXIT_OK; + } + + let product; + let versionFrom; + let versionTo; + let directoryFrom; + let directoryTo; + try { + product = loadProduct(values["product-code"] ?? null, values["product-name"] ?? null); + requireSupported(product); + + if (values["list-versions"]) { + const versions = listArchivedVersions(product.code); + StatusLogger.title(`${product.name} (${product.code}) — ${versions.length} archived versions`); + for (const version of versions) StatusLogger.message(` ${version}`); + return EXIT_OK; + } + + [versionFrom, versionTo] = resolveVersions(product, values.from ?? null, values.to ?? null); + directoryFrom = versionDirectory(product, versionFrom); + directoryTo = versionDirectory(product, versionTo); + } catch (error) { + if (!(error instanceof ArchiveError)) throw error; + StatusLogger.error(error.message); + return EXIT_ERROR; + } + + const surfaceFilter = new SurfaceFilter({ + includeInternal: values["include-internal"], + namespaces: values.namespace, + excludes: values.exclude, + publicOnly: !values["all-visibility"], + }); + + const surfaceFrom = buildSurface(directoryFrom, product.code, versionFrom, surfaceFilter); + const surfaceTo = buildSurface(directoryTo, product.code, versionTo, surfaceFilter); + const result = diffSurfaces(surfaceFrom, surfaceTo, product.name); + + if (!values.quiet) renderText(result, !values["no-warnings"]); + + if (values.json !== undefined) { + write(artifactPath(values.json, product.code, versionFrom, versionTo, "json"), renderJson(result)); + } + if (values.markdown !== undefined) { + write(artifactPath(values.markdown, product.code, versionFrom, versionTo, "md"), renderMarkdown(result)); + } + + if (values["fail-on-breaking"] && bySeverity(result, BREAKING).length) return EXIT_BREAKING; + return EXIT_OK; +} + +process.exitCode = main(process.argv.slice(2)); diff --git a/diff-apidocs.py b/diff-apidocs.py new file mode 100644 index 000000000..be0a44e83 --- /dev/null +++ b/diff-apidocs.py @@ -0,0 +1,141 @@ +#!/usr/bin/env python3 +"""diff-apidocs.py — Diff the public API surface between two archived product versions. + +Reads only the committed object-reference archive; nothing is downloaded and no build is triggered. +Identity comes from each version's xrefmap.yml, signatures from its DocFX api/*.html pages. + +Examples: + python diff-apidocs.py -p ironzip + python diff-apidocs.py -p ironzip --from 2026.5.2 --to 2026.6.2 + python diff-apidocs.py -p ironpdf --namespace 'IronPdf.Rendering.*' --markdown + python diff-apidocs.py -p ironzip --json --fail-on-breaking + +Exit codes: 0 success, 1 tool error (unknown product, missing version), 2 breaking changes found +with --fail-on-breaking. +""" + +import argparse +import os +import sys + +# Some archived uids carry Unicode Private Use Area markers that DocFX emits for unresolvable type +# parameters (U+E000, U+E396 and U+E397 appear in ironpdf 2023.11.7, for example). Writing those to a +# legacy cp1252 Windows console raises UnicodeEncodeError and kills the run, so force UTF-8 here. +# Scoped to this entry point so the shared StatusLogger keeps its existing behaviour for other tools. +for _stream in (sys.stdout, sys.stderr): + if hasattr(_stream, "reconfigure"): + _stream.reconfigure(encoding="utf-8") + +from apidiff.archive import (ArchiveError, load_product, require_supported, resolve_versions, + version_directory) +from apidiff.classify import diff_surfaces +from apidiff.filters import SurfaceFilter +from apidiff.model import BREAKING +from apidiff.render_json import render as render_json +from apidiff.render_markdown import render as render_markdown +from apidiff.render_text import render as render_text +from apidiff.surface import build_surface +from statuslogger import StatusLogger + +# Committed diff artifacts live under docs/, which _config.yml already excludes from the Jekyll +# build, so they stay private to the repo. +ARTIFACT_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "docs", "api-diffs") + +EXIT_OK = 0 +EXIT_ERROR = 1 +EXIT_BREAKING = 2 + + +def build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + prog="diff-apidocs", + description="Diff the public API surface between two archived versions of an Iron Software product.", + ) + parser.add_argument("-p", "--product-code", help="Product short code, e.g. ironzip") + parser.add_argument("-n", "--product-name", help="Product display name, e.g. IronZIP") + parser.add_argument("--from", dest="version_from", help="Older version (default: previous archived)") + parser.add_argument("--to", dest="version_to", help="Newer version (default: newest archived)") + parser.add_argument("--namespace", action="append", default=[], + help="Only report types matching this glob; repeatable") + parser.add_argument("--exclude", action="append", default=[], + help="Skip types matching this glob; repeatable") + parser.add_argument("--include-internal", action="store_true", + help="Include vendored/internal namespaces (excluded by default)") + parser.add_argument("--all-visibility", action="store_true", + help="Include non-public declarations (public/protected only by default)") + parser.add_argument("--json", nargs="?", const="", metavar="PATH", + help=f"Write JSON; defaults to {os.path.join('docs', 'api-diffs')}//...json") + parser.add_argument("--markdown", nargs="?", const="", metavar="PATH", + help="Write Markdown; defaults alongside the JSON artifact") + parser.add_argument("--quiet", action="store_true", help="Suppress the terminal report") + parser.add_argument("--no-warnings", action="store_true", help="Suppress parser warnings") + parser.add_argument("--fail-on-breaking", action="store_true", + help="Exit 2 when breaking changes are found") + parser.add_argument("--list-versions", action="store_true", + help="List the product's archived versions and exit") + return parser + + +def _artifact_path(supplied: str, product_code: str, version_from: str, version_to: str, extension: str) -> str: + if supplied: + return os.path.abspath(supplied) + return os.path.join(ARTIFACT_ROOT, product_code, f"{version_from}..{version_to}.{extension}") + + +def _write(path: str, content: str) -> None: + os.makedirs(os.path.dirname(path), exist_ok=True) + # newline="" keeps the "\n" line endings the renderers emit, so the two ports stay byte-identical + # on Windows as well as Linux. + with open(path, "w", encoding="utf-8", newline="") as handle: + handle.write(content) + StatusLogger.progress(f"Wrote {path}") + + +def main(argv) -> int: + args = build_parser().parse_args(argv) + + try: + product = load_product(args.product_code, args.product_name) + require_supported(product) + + if args.list_versions: + from apidocs import list_archived_versions + versions = list_archived_versions(product["code"]) + StatusLogger.title(f"{product['name']} ({product['code']}) — {len(versions)} archived versions") + for version in versions: + StatusLogger.message(f" {version}") + return EXIT_OK + + version_from, version_to, _ = resolve_versions(product, args.version_from, args.version_to) + directory_from = version_directory(product, version_from) + directory_to = version_directory(product, version_to) + except ArchiveError as error: + StatusLogger.error(str(error)) + return EXIT_ERROR + + surface_filter = SurfaceFilter( + include_internal=args.include_internal, + namespaces=args.namespace, + excludes=args.exclude, + public_only=not args.all_visibility, + ) + + surface_from = build_surface(directory_from, product["code"], version_from, surface_filter) + surface_to = build_surface(directory_to, product["code"], version_to, surface_filter) + result = diff_surfaces(surface_from, surface_to, product["name"]) + + if not args.quiet: + render_text(result, show_warnings=not args.no_warnings) + + if args.json is not None: + _write(_artifact_path(args.json, product["code"], version_from, version_to, "json"), render_json(result)) + if args.markdown is not None: + _write(_artifact_path(args.markdown, product["code"], version_from, version_to, "md"), render_markdown(result)) + + if args.fail_on_breaking and result.by_severity(BREAKING): + return EXIT_BREAKING + return EXIT_OK + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/docs/api-diffs/ironbarcode/2025.12.6..2026.1.8.json b/docs/api-diffs/ironbarcode/2025.12.6..2026.1.8.json new file mode 100644 index 000000000..01631fc59 --- /dev/null +++ b/docs/api-diffs/ironbarcode/2025.12.6..2026.1.8.json @@ -0,0 +1,164 @@ +{ + "product": "ironbarcode", + "productName": "IronBarcode", + "from": "2025.12.6", + "to": "2026.1.8", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 9, + "cosmetic": 0, + "total": 9, + "typesFrom": 54, + "typesTo": 57 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronBarCode.BarcodeReaderOptions", + "added": [ + { + "uid": "IronBarCode.BarcodeReaderOptions.MinScanLines", + "display": "BarcodeReaderOptions.MinScanLines", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int MinScanLines { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.Code128CharacterSet", + "added": [ + { + "uid": "IronBarCode.Code128CharacterSet", + "display": "IronBarCode.Code128CharacterSet", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class Code128CharacterSet : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.Code128EncodingInfo", + "added": [ + { + "uid": "IronBarCode.Code128EncodingInfo", + "display": "IronBarCode.Code128EncodingInfo", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class Code128EncodingInfo : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.Code128EncodingSegment", + "added": [ + { + "uid": "IronBarCode.Code128EncodingSegment", + "display": "IronBarCode.Code128EncodingSegment", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class Code128EncodingSegment : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.Code128GS1Parser", + "added": [ + { + "uid": "IronBarCode.Code128GS1Parser.GetEncodingInfo(System.String,System.Boolean)", + "display": "Code128GS1Parser.GetEncodingInfo(String, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Code128EncodingInfo GetEncodingInfo(string input, bool isGS1 = false)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronBarCode.Code128GS1Parser.ParseWithEncoding(System.String,System.Boolean)", + "display": "Code128GS1Parser.ParseWithEncoding(String, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static ParseResult ParseWithEncoding(string input, bool includeEncoding = true)", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.ParseResult", + "added": [ + { + "uid": "IronBarCode.ParseResult.CharacterSetSummary", + "display": "ParseResult.CharacterSetSummary", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string CharacterSetSummary { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronBarCode.ParseResult.EncodingInfo", + "display": "ParseResult.EncodingInfo", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Code128EncodingInfo EncodingInfo { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronBarCode.ParseResult.HasEncodingInfo", + "display": "ParseResult.HasEncodingInfo", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool HasEncodingInfo { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironbarcode/2025.12.6..2026.1.8.md b/docs/api-diffs/ironbarcode/2025.12.6..2026.1.8.md new file mode 100644 index 000000000..08a2d0e1d --- /dev/null +++ b/docs/api-diffs/ironbarcode/2025.12.6..2026.1.8.md @@ -0,0 +1,45 @@ +# IronBarcode API changes: 2025.12.6 -> 2026.1.8 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 9 additive, 0 cosmetic. + +## Additions (9) + +### `IronBarCode.BarcodeReaderOptions` + +- **BarcodeReaderOptions.MinScanLines** added + - `public int MinScanLines { get; set; }` + - member added +### `IronBarCode.Code128CharacterSet` + +- **IronBarCode.Code128CharacterSet** added + - `public sealed class Code128CharacterSet : Enum` + - type added +### `IronBarCode.Code128EncodingInfo` + +- **IronBarCode.Code128EncodingInfo** added + - `public class Code128EncodingInfo : Object` + - type added +### `IronBarCode.Code128EncodingSegment` + +- **IronBarCode.Code128EncodingSegment** added + - `public class Code128EncodingSegment : Object` + - type added +### `IronBarCode.Code128GS1Parser` + +- **Code128GS1Parser.GetEncodingInfo(String, Boolean)** added + - `public static Code128EncodingInfo GetEncodingInfo(string input, bool isGS1 = false)` + - member added +- **Code128GS1Parser.ParseWithEncoding(String, Boolean)** added + - `public static ParseResult ParseWithEncoding(string input, bool includeEncoding = true)` + - member added +### `IronBarCode.ParseResult` + +- **ParseResult.CharacterSetSummary** added + - `public string CharacterSetSummary { get; }` + - member added +- **ParseResult.EncodingInfo** added + - `public Code128EncodingInfo EncodingInfo { get; set; }` + - member added +- **ParseResult.HasEncodingInfo** added + - `public bool HasEncodingInfo { get; }` + - member added diff --git a/docs/api-diffs/ironbarcode/2025.12.6..2026.7.2.json b/docs/api-diffs/ironbarcode/2025.12.6..2026.7.2.json new file mode 100644 index 000000000..8cb0ac9ec --- /dev/null +++ b/docs/api-diffs/ironbarcode/2025.12.6..2026.7.2.json @@ -0,0 +1,164 @@ +{ + "product": "ironbarcode", + "productName": "IronBarcode", + "from": "2025.12.6", + "to": "2026.7.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 9, + "cosmetic": 0, + "total": 9, + "typesFrom": 54, + "typesTo": 57 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronBarCode.BarcodeReaderOptions", + "added": [ + { + "uid": "IronBarCode.BarcodeReaderOptions.MinScanLines", + "display": "BarcodeReaderOptions.MinScanLines", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int MinScanLines { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.Code128CharacterSet", + "added": [ + { + "uid": "IronBarCode.Code128CharacterSet", + "display": "IronBarCode.Code128CharacterSet", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class Code128CharacterSet : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.Code128EncodingInfo", + "added": [ + { + "uid": "IronBarCode.Code128EncodingInfo", + "display": "IronBarCode.Code128EncodingInfo", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class Code128EncodingInfo : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.Code128EncodingSegment", + "added": [ + { + "uid": "IronBarCode.Code128EncodingSegment", + "display": "IronBarCode.Code128EncodingSegment", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class Code128EncodingSegment : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.Code128GS1Parser", + "added": [ + { + "uid": "IronBarCode.Code128GS1Parser.GetEncodingInfo(System.String,System.Boolean)", + "display": "Code128GS1Parser.GetEncodingInfo(String, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Code128EncodingInfo GetEncodingInfo(string input, bool isGS1 = false)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronBarCode.Code128GS1Parser.ParseWithEncoding(System.String,System.Boolean)", + "display": "Code128GS1Parser.ParseWithEncoding(String, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static ParseResult ParseWithEncoding(string input, bool includeEncoding = true)", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronBarCode.ParseResult", + "added": [ + { + "uid": "IronBarCode.ParseResult.CharacterSetSummary", + "display": "ParseResult.CharacterSetSummary", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string CharacterSetSummary { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronBarCode.ParseResult.EncodingInfo", + "display": "ParseResult.EncodingInfo", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Code128EncodingInfo EncodingInfo { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronBarCode.ParseResult.HasEncodingInfo", + "display": "ParseResult.HasEncodingInfo", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool HasEncodingInfo { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironbarcode/2025.12.6..2026.7.2.md b/docs/api-diffs/ironbarcode/2025.12.6..2026.7.2.md new file mode 100644 index 000000000..ceeb1196f --- /dev/null +++ b/docs/api-diffs/ironbarcode/2025.12.6..2026.7.2.md @@ -0,0 +1,45 @@ +# IronBarcode API changes: 2025.12.6 -> 2026.7.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 9 additive, 0 cosmetic. + +## Additions (9) + +### `IronBarCode.BarcodeReaderOptions` + +- **BarcodeReaderOptions.MinScanLines** added + - `public int MinScanLines { get; set; }` + - member added +### `IronBarCode.Code128CharacterSet` + +- **IronBarCode.Code128CharacterSet** added + - `public sealed class Code128CharacterSet : Enum` + - type added +### `IronBarCode.Code128EncodingInfo` + +- **IronBarCode.Code128EncodingInfo** added + - `public class Code128EncodingInfo : Object` + - type added +### `IronBarCode.Code128EncodingSegment` + +- **IronBarCode.Code128EncodingSegment** added + - `public class Code128EncodingSegment : Object` + - type added +### `IronBarCode.Code128GS1Parser` + +- **Code128GS1Parser.GetEncodingInfo(String, Boolean)** added + - `public static Code128EncodingInfo GetEncodingInfo(string input, bool isGS1 = false)` + - member added +- **Code128GS1Parser.ParseWithEncoding(String, Boolean)** added + - `public static ParseResult ParseWithEncoding(string input, bool includeEncoding = true)` + - member added +### `IronBarCode.ParseResult` + +- **ParseResult.CharacterSetSummary** added + - `public string CharacterSetSummary { get; }` + - member added +- **ParseResult.EncodingInfo** added + - `public Code128EncodingInfo EncodingInfo { get; set; }` + - member added +- **ParseResult.HasEncodingInfo** added + - `public bool HasEncodingInfo { get; }` + - member added diff --git a/docs/api-diffs/ironbarcode/2026.1.8..2026.2.1.json b/docs/api-diffs/ironbarcode/2026.1.8..2026.2.1.json new file mode 100644 index 000000000..eee5fa31e --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.1.8..2026.2.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironbarcode", + "productName": "IronBarcode", + "from": "2026.1.8", + "to": "2026.2.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 57, + "typesTo": 57 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironbarcode/2026.1.8..2026.2.1.md b/docs/api-diffs/ironbarcode/2026.1.8..2026.2.1.md new file mode 100644 index 000000000..7f84c7bbe --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.1.8..2026.2.1.md @@ -0,0 +1,5 @@ +# IronBarcode API changes: 2026.1.8 -> 2026.2.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironbarcode/2026.2.1..2026.3.6.json b/docs/api-diffs/ironbarcode/2026.2.1..2026.3.6.json new file mode 100644 index 000000000..a4f47b945 --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.2.1..2026.3.6.json @@ -0,0 +1,22 @@ +{ + "product": "ironbarcode", + "productName": "IronBarcode", + "from": "2026.2.1", + "to": "2026.3.6", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 57, + "typesTo": 57 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironbarcode/2026.2.1..2026.3.6.md b/docs/api-diffs/ironbarcode/2026.2.1..2026.3.6.md new file mode 100644 index 000000000..7bf108b94 --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.2.1..2026.3.6.md @@ -0,0 +1,5 @@ +# IronBarcode API changes: 2026.2.1 -> 2026.3.6 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironbarcode/2026.3.6..2026.4.2.json b/docs/api-diffs/ironbarcode/2026.3.6..2026.4.2.json new file mode 100644 index 000000000..b9c12894c --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.3.6..2026.4.2.json @@ -0,0 +1,22 @@ +{ + "product": "ironbarcode", + "productName": "IronBarcode", + "from": "2026.3.6", + "to": "2026.4.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 57, + "typesTo": 57 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironbarcode/2026.3.6..2026.4.2.md b/docs/api-diffs/ironbarcode/2026.3.6..2026.4.2.md new file mode 100644 index 000000000..b31aa073b --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.3.6..2026.4.2.md @@ -0,0 +1,5 @@ +# IronBarcode API changes: 2026.3.6 -> 2026.4.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironbarcode/2026.4.2..2026.5.2.json b/docs/api-diffs/ironbarcode/2026.4.2..2026.5.2.json new file mode 100644 index 000000000..9f25d026b --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.4.2..2026.5.2.json @@ -0,0 +1,22 @@ +{ + "product": "ironbarcode", + "productName": "IronBarcode", + "from": "2026.4.2", + "to": "2026.5.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 57, + "typesTo": 57 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironbarcode/2026.4.2..2026.5.2.md b/docs/api-diffs/ironbarcode/2026.4.2..2026.5.2.md new file mode 100644 index 000000000..ebfc78fc8 --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.4.2..2026.5.2.md @@ -0,0 +1,5 @@ +# IronBarcode API changes: 2026.4.2 -> 2026.5.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironbarcode/2026.5.2..2026.6.2.json b/docs/api-diffs/ironbarcode/2026.5.2..2026.6.2.json new file mode 100644 index 000000000..8aa18a088 --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.5.2..2026.6.2.json @@ -0,0 +1,22 @@ +{ + "product": "ironbarcode", + "productName": "IronBarcode", + "from": "2026.5.2", + "to": "2026.6.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 57, + "typesTo": 57 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironbarcode/2026.5.2..2026.6.2.md b/docs/api-diffs/ironbarcode/2026.5.2..2026.6.2.md new file mode 100644 index 000000000..27b896e85 --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.5.2..2026.6.2.md @@ -0,0 +1,5 @@ +# IronBarcode API changes: 2026.5.2 -> 2026.6.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironbarcode/2026.6.2..2026.7.2.json b/docs/api-diffs/ironbarcode/2026.6.2..2026.7.2.json new file mode 100644 index 000000000..1acaaa188 --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.6.2..2026.7.2.json @@ -0,0 +1,22 @@ +{ + "product": "ironbarcode", + "productName": "IronBarcode", + "from": "2026.6.2", + "to": "2026.7.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 57, + "typesTo": 57 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironbarcode/2026.6.2..2026.7.2.md b/docs/api-diffs/ironbarcode/2026.6.2..2026.7.2.md new file mode 100644 index 000000000..f594ee5ab --- /dev/null +++ b/docs/api-diffs/ironbarcode/2026.6.2..2026.7.2.md @@ -0,0 +1,5 @@ +# IronBarcode API changes: 2026.6.2 -> 2026.7.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/irondrawing/2025.9.3..2026.1.2.json b/docs/api-diffs/irondrawing/2025.9.3..2026.1.2.json new file mode 100644 index 000000000..d724886e8 --- /dev/null +++ b/docs/api-diffs/irondrawing/2025.9.3..2026.1.2.json @@ -0,0 +1,22 @@ +{ + "product": "irondrawing", + "productName": "IronDrawing", + "from": "2025.9.3", + "to": "2026.1.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 17, + "typesTo": 17 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/irondrawing/2025.9.3..2026.1.2.md b/docs/api-diffs/irondrawing/2025.9.3..2026.1.2.md new file mode 100644 index 000000000..be91771e1 --- /dev/null +++ b/docs/api-diffs/irondrawing/2025.9.3..2026.1.2.md @@ -0,0 +1,5 @@ +# IronDrawing API changes: 2025.9.3 -> 2026.1.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/irondrawing/2025.9.3..2026.7.2.json b/docs/api-diffs/irondrawing/2025.9.3..2026.7.2.json new file mode 100644 index 000000000..799a4d780 --- /dev/null +++ b/docs/api-diffs/irondrawing/2025.9.3..2026.7.2.json @@ -0,0 +1,63 @@ +{ + "product": "irondrawing", + "productName": "IronDrawing", + "from": "2025.9.3", + "to": "2026.7.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 3, + "cosmetic": 0, + "total": 3, + "typesFrom": 17, + "typesTo": 17 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronSoftware.Drawing.AnyBitmap", + "added": [ + { + "uid": "IronSoftware.Drawing.AnyBitmap.ChangeBitsPerPixel(System.Int32)", + "display": "AnyBitmap.ChangeBitsPerPixel(Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public AnyBitmap ChangeBitsPerPixel(int bitsPerPixel)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.Drawing.AnyBitmap.CreateMultiFrameTiffBytes(System.Collections.Generic.IEnumerable{IronSoftware.Drawing.AnyBitmap})", + "display": "AnyBitmap.CreateMultiFrameTiffBytes(IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] CreateMultiFrameTiffBytes(IEnumerable images)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.Drawing.AnyBitmap.CreateMultiFrameTiffStream(System.Collections.Generic.IEnumerable{IronSoftware.Drawing.AnyBitmap})", + "display": "AnyBitmap.CreateMultiFrameTiffStream(IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static MemoryStream CreateMultiFrameTiffStream(IEnumerable images)", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/irondrawing/2025.9.3..2026.7.2.md b/docs/api-diffs/irondrawing/2025.9.3..2026.7.2.md new file mode 100644 index 000000000..1e735b453 --- /dev/null +++ b/docs/api-diffs/irondrawing/2025.9.3..2026.7.2.md @@ -0,0 +1,17 @@ +# IronDrawing API changes: 2025.9.3 -> 2026.7.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 3 additive, 0 cosmetic. + +## Additions (3) + +### `IronSoftware.Drawing.AnyBitmap` + +- **AnyBitmap.ChangeBitsPerPixel(Int32)** added + - `public AnyBitmap ChangeBitsPerPixel(int bitsPerPixel)` + - member added +- **AnyBitmap.CreateMultiFrameTiffBytes(IEnumerable)** added + - `public static byte[] CreateMultiFrameTiffBytes(IEnumerable images)` + - member added +- **AnyBitmap.CreateMultiFrameTiffStream(IEnumerable)** added + - `public static MemoryStream CreateMultiFrameTiffStream(IEnumerable images)` + - member added diff --git a/docs/api-diffs/irondrawing/2026.1.2..2026.4.1.json b/docs/api-diffs/irondrawing/2026.1.2..2026.4.1.json new file mode 100644 index 000000000..22dff3096 --- /dev/null +++ b/docs/api-diffs/irondrawing/2026.1.2..2026.4.1.json @@ -0,0 +1,22 @@ +{ + "product": "irondrawing", + "productName": "IronDrawing", + "from": "2026.1.2", + "to": "2026.4.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 17, + "typesTo": 17 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/irondrawing/2026.1.2..2026.4.1.md b/docs/api-diffs/irondrawing/2026.1.2..2026.4.1.md new file mode 100644 index 000000000..71c1d14b3 --- /dev/null +++ b/docs/api-diffs/irondrawing/2026.1.2..2026.4.1.md @@ -0,0 +1,5 @@ +# IronDrawing API changes: 2026.1.2 -> 2026.4.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/irondrawing/2026.4.1..2026.7.2.json b/docs/api-diffs/irondrawing/2026.4.1..2026.7.2.json new file mode 100644 index 000000000..ffb4839fc --- /dev/null +++ b/docs/api-diffs/irondrawing/2026.4.1..2026.7.2.json @@ -0,0 +1,63 @@ +{ + "product": "irondrawing", + "productName": "IronDrawing", + "from": "2026.4.1", + "to": "2026.7.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 3, + "cosmetic": 0, + "total": 3, + "typesFrom": 17, + "typesTo": 17 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronSoftware.Drawing.AnyBitmap", + "added": [ + { + "uid": "IronSoftware.Drawing.AnyBitmap.ChangeBitsPerPixel(System.Int32)", + "display": "AnyBitmap.ChangeBitsPerPixel(Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public AnyBitmap ChangeBitsPerPixel(int bitsPerPixel)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.Drawing.AnyBitmap.CreateMultiFrameTiffBytes(System.Collections.Generic.IEnumerable{IronSoftware.Drawing.AnyBitmap})", + "display": "AnyBitmap.CreateMultiFrameTiffBytes(IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] CreateMultiFrameTiffBytes(IEnumerable images)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.Drawing.AnyBitmap.CreateMultiFrameTiffStream(System.Collections.Generic.IEnumerable{IronSoftware.Drawing.AnyBitmap})", + "display": "AnyBitmap.CreateMultiFrameTiffStream(IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static MemoryStream CreateMultiFrameTiffStream(IEnumerable images)", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/irondrawing/2026.4.1..2026.7.2.md b/docs/api-diffs/irondrawing/2026.4.1..2026.7.2.md new file mode 100644 index 000000000..b1e1de227 --- /dev/null +++ b/docs/api-diffs/irondrawing/2026.4.1..2026.7.2.md @@ -0,0 +1,17 @@ +# IronDrawing API changes: 2026.4.1 -> 2026.7.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 3 additive, 0 cosmetic. + +## Additions (3) + +### `IronSoftware.Drawing.AnyBitmap` + +- **AnyBitmap.ChangeBitsPerPixel(Int32)** added + - `public AnyBitmap ChangeBitsPerPixel(int bitsPerPixel)` + - member added +- **AnyBitmap.CreateMultiFrameTiffBytes(IEnumerable)** added + - `public static byte[] CreateMultiFrameTiffBytes(IEnumerable images)` + - member added +- **AnyBitmap.CreateMultiFrameTiffStream(IEnumerable)** added + - `public static MemoryStream CreateMultiFrameTiffStream(IEnumerable images)` + - member added diff --git a/docs/api-diffs/ironocr/2025.12.3..2026.1.2.json b/docs/api-diffs/ironocr/2025.12.3..2026.1.2.json new file mode 100644 index 000000000..2d058e56b --- /dev/null +++ b/docs/api-diffs/ironocr/2025.12.3..2026.1.2.json @@ -0,0 +1,337 @@ +{ + "product": "ironocr", + "productName": "IronOCR", + "from": "2025.12.3", + "to": "2026.1.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 13, + "additive": 5, + "cosmetic": 1, + "total": 19, + "typesFrom": 109, + "typesTo": 109 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronOcr.IOcrPageObjectModel", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.IOcrPageObjectModel", + "display": "IronOcr.IOcrPageObjectModel", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "after": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.IronTesseract", + "added": [ + { + "uid": "IronOcr.IronTesseract.Read(IronSoftware.Abstractions.Pdf.IDocumentId)", + "display": "IronTesseract.Read(IDocumentId)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IOcrResult Read(IDocumentId Document)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.IronTesseract.Read(IronSoftware.Abstractions.Pdf.IDocumentId,IronOcr.PdfContents)", + "display": "IronTesseract.Read(IDocumentId, PdfContents)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IOcrResult Read(IDocumentId Document, PdfContents Contents)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.IronTesseract.Read(IronSoftware.IDocumentId)", + "display": "IronTesseract.Read(IDocumentId)", + "severity": "BREAKING", + "target": "member", + "before": "public IOcrResult Read(IDocumentId Document)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.IronTesseract.Read(IronSoftware.IDocumentId,IronOcr.PdfContents)", + "display": "IronTesseract.Read(IDocumentId, PdfContents)", + "severity": "BREAKING", + "target": "member", + "before": "public IOcrResult Read(IDocumentId Document, PdfContents Contents)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.OcrInput", + "added": [ + { + "uid": "IronOcr.OcrInput.LoadPdf(IronSoftware.Abstractions.Pdf.IDocumentId,System.Int32[],System.Int32,System.Boolean,IronSoftware.Drawing.Rectangle,System.String)", + "display": "OcrInput.LoadPdf(IDocumentId, Int32[], Int32, Boolean, Rectangle, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void LoadPdf(IDocumentId Document, int[] PageIndices, int DPI = 200, bool OnlyEmbeddedImages = false, Rectangle ContentArea = null, string PdfPassword = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.OcrInput.LoadScannedPdf(IronSoftware.Abstractions.Pdf.IDocumentId,System.Int32[],System.Int32,System.String)", + "display": "OcrInput.LoadScannedPdf(IDocumentId, Int32[], Int32, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void LoadScannedPdf(IDocumentId Document, int[] PageIndices = null, int DPI = 200, string PdfPassword = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.OcrInput.LoadPdf(IronSoftware.IDocumentId,System.Int32[],System.Int32,System.Boolean,IronSoftware.Drawing.Rectangle,System.String)", + "display": "OcrInput.LoadPdf(IDocumentId, Int32[], Int32, Boolean, Rectangle, String)", + "severity": "BREAKING", + "target": "member", + "before": "public void LoadPdf(IDocumentId Document, int[] PageIndices, int DPI = 200, bool OnlyEmbeddedImages = false, Rectangle ContentArea = null, string PdfPassword = null)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.OcrInput.LoadScannedPdf(IronSoftware.IDocumentId,System.Int32[],System.Int32,System.String)", + "display": "OcrInput.LoadScannedPdf(IDocumentId, Int32[], Int32, String)", + "severity": "BREAKING", + "target": "member", + "before": "public void LoadScannedPdf(IDocumentId Document, int[] PageIndices = null, int DPI = 200, string PdfPassword = null)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.OcrPdfInput", + "added": [ + { + "uid": "IronOcr.OcrPdfInput.#ctor(IronSoftware.Abstractions.Pdf.IDocumentId,IronOcr.PdfContents,System.Collections.Generic.IEnumerable{System.Int32},IronSoftware.Drawing.Rectangle[])", + "display": "OcrPdfInput.OcrPdfInput(IDocumentId, PdfContents, IEnumerable, Rectangle[])", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public OcrPdfInput(IDocumentId Document, PdfContents OcrContent, IEnumerable PageIndices = null, Rectangle[] ContentAreas = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.OcrPdfInput.#ctor(IronSoftware.IDocumentId,IronOcr.PdfContents,System.Collections.Generic.IEnumerable{System.Int32},IronSoftware.Drawing.Rectangle[])", + "display": "OcrPdfInput.OcrPdfInput(IDocumentId, PdfContents, IEnumerable, Rectangle[])", + "severity": "BREAKING", + "target": "member", + "before": "public OcrPdfInput(IDocumentId Document, PdfContents OcrContent, IEnumerable PageIndices = null, Rectangle[] ContentAreas = null)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.OcrResult.Block", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Block", + "display": "IronOcr.OcrResult.Block", + "severity": "BREAKING", + "target": "type", + "before": "public class Block : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Block : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Character", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Character", + "display": "IronOcr.OcrResult.Character", + "severity": "BREAKING", + "target": "type", + "before": "public class Character : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentCharacter, IDocumentObject", + "after": "public class Character : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentCharacter, IPdfDocumentObject, IDocumentObject", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Line", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Line", + "display": "IronOcr.OcrResult.Line", + "severity": "BREAKING", + "target": "type", + "before": "public class Line : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Line : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.OcrResultTextElement", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.OcrResultTextElement", + "display": "IronOcr.OcrResult.OcrResultTextElement", + "severity": "BREAKING", + "target": "type", + "before": "public abstract class OcrResultTextElement : OcrResult.OcrResultElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public abstract class OcrResultTextElement : OcrResult.OcrResultElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Page", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Page", + "display": "IronOcr.OcrResult.Page", + "severity": "BREAKING", + "target": "type", + "before": "public class Page : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentPage, IPageContainer", + "after": "public class Page : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentPage, IPageContainer", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Paragraph", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Paragraph", + "display": "IronOcr.OcrResult.Paragraph", + "severity": "BREAKING", + "target": "type", + "before": "public class Paragraph : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Paragraph : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Table", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Table", + "display": "IronOcr.OcrResult.Table", + "severity": "BREAKING", + "target": "type", + "before": "public class Table : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Table : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Word", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Word", + "display": "IronOcr.OcrResult.Word", + "severity": "BREAKING", + "target": "type", + "before": "public class Word : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Word : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironocr/2025.12.3..2026.1.2.md b/docs/api-diffs/ironocr/2025.12.3..2026.1.2.md new file mode 100644 index 000000000..2150833f1 --- /dev/null +++ b/docs/api-diffs/ironocr/2025.12.3..2026.1.2.md @@ -0,0 +1,126 @@ +# IronOCR API changes: 2025.12.3 -> 2026.1.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **13 breaking**, 5 additive, 1 cosmetic. + +## Breaking changes (13) + +### `IronOcr.IronTesseract` + +- **IronTesseract.Read(IDocumentId)** removed + - `public IOcrResult Read(IDocumentId Document)` + - member removed + - overload signature change (see the matching addition) +- **IronTesseract.Read(IDocumentId, PdfContents)** removed + - `public IOcrResult Read(IDocumentId Document, PdfContents Contents)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.OcrInput` + +- **OcrInput.LoadPdf(IDocumentId, Int32[], Int32, Boolean, Rectangle, String)** removed + - `public void LoadPdf(IDocumentId Document, int[] PageIndices, int DPI = 200, bool OnlyEmbeddedImages = false, Rectangle ContentArea = null, string PdfPassword = null)` + - member removed + - overload signature change (see the matching addition) +- **OcrInput.LoadScannedPdf(IDocumentId, Int32[], Int32, String)** removed + - `public void LoadScannedPdf(IDocumentId Document, int[] PageIndices = null, int DPI = 200, string PdfPassword = null)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.OcrPdfInput` + +- **OcrPdfInput.OcrPdfInput(IDocumentId, PdfContents, IEnumerable, Rectangle[])** removed + - `public OcrPdfInput(IDocumentId Document, PdfContents OcrContent, IEnumerable PageIndices = null, Rectangle[] ContentAreas = null)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.OcrResult.Block` + +- **IronOcr.OcrResult.Block** changed + - was: `public class Block : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Block : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Character` + +- **IronOcr.OcrResult.Character** changed + - was: `public class Character : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentCharacter, IDocumentObject` + - now: `public class Character : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentCharacter, IPdfDocumentObject, IDocumentObject` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Line` + +- **IronOcr.OcrResult.Line** changed + - was: `public class Line : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Line : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.OcrResultTextElement` + +- **IronOcr.OcrResult.OcrResultTextElement** changed + - was: `public abstract class OcrResultTextElement : OcrResult.OcrResultElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public abstract class OcrResultTextElement : OcrResult.OcrResultElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Page` + +- **IronOcr.OcrResult.Page** changed + - was: `public class Page : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentPage, IPageContainer` + - now: `public class Page : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentPage, IPageContainer` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Paragraph` + +- **IronOcr.OcrResult.Paragraph** changed + - was: `public class Paragraph : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Paragraph : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Table` + +- **IronOcr.OcrResult.Table** changed + - was: `public class Table : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Table : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Word` + +- **IronOcr.OcrResult.Word** changed + - was: `public class Word : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Word : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject + +## Additions (5) + +### `IronOcr.IronTesseract` + +- **IronTesseract.Read(IDocumentId)** added + - `public IOcrResult Read(IDocumentId Document)` + - member added + - overload signature change (see the matching removal) +- **IronTesseract.Read(IDocumentId, PdfContents)** added + - `public IOcrResult Read(IDocumentId Document, PdfContents Contents)` + - member added + - overload signature change (see the matching removal) +### `IronOcr.OcrInput` + +- **OcrInput.LoadPdf(IDocumentId, Int32[], Int32, Boolean, Rectangle, String)** added + - `public void LoadPdf(IDocumentId Document, int[] PageIndices, int DPI = 200, bool OnlyEmbeddedImages = false, Rectangle ContentArea = null, string PdfPassword = null)` + - member added + - overload signature change (see the matching removal) +- **OcrInput.LoadScannedPdf(IDocumentId, Int32[], Int32, String)** added + - `public void LoadScannedPdf(IDocumentId Document, int[] PageIndices = null, int DPI = 200, string PdfPassword = null)` + - member added + - overload signature change (see the matching removal) +### `IronOcr.OcrPdfInput` + +- **OcrPdfInput.OcrPdfInput(IDocumentId, PdfContents, IEnumerable, Rectangle[])** added + - `public OcrPdfInput(IDocumentId Document, PdfContents OcrContent, IEnumerable PageIndices = null, Rectangle[] ContentAreas = null)` + - member added + - overload signature change (see the matching removal) + +## Cosmetic (1) + +### `IronOcr.IOcrPageObjectModel` + +- **IronOcr.IOcrPageObjectModel** changed + - was: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - now: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironocr/2025.12.3..2026.7.2.json b/docs/api-diffs/ironocr/2025.12.3..2026.7.2.json new file mode 100644 index 000000000..a504c4b24 --- /dev/null +++ b/docs/api-diffs/ironocr/2025.12.3..2026.7.2.json @@ -0,0 +1,849 @@ +{ + "product": "ironocr", + "productName": "IronOCR", + "from": "2025.12.3", + "to": "2026.7.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 21, + "additive": 29, + "cosmetic": 6, + "total": 56, + "typesFrom": 109, + "typesTo": 113 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "DynamicTesseract.IResultRenderer", + "added": [], + "removed": [], + "changed": [ + { + "uid": "DynamicTesseract.IResultRenderer", + "display": "DynamicTesseract.IResultRenderer", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IResultRenderer : IDisposable", + "after": "public interface IResultRenderer", + "reasons": [ + "declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.AdvancedCharacter", + "added": [ + { + "uid": "IronOcr.AdvancedCharacter", + "display": "IronOcr.AdvancedCharacter", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class AdvancedCharacter : AdvancedOcrElement", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.AdvancedOcrElement", + "added": [ + { + "uid": "IronOcr.AdvancedOcrElement", + "display": "IronOcr.AdvancedOcrElement", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public abstract class AdvancedOcrElement : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.AdvancedOcrResultBase", + "added": [ + { + "uid": "IronOcr.AdvancedOcrResultBase.Characters", + "display": "AdvancedOcrResultBase.Characters", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public AdvancedCharacter[] Characters { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdf(System.String,System.Boolean,System.String,System.String)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdf(String, Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdfBytes(System.Boolean,System.String,System.String)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdfBytes(Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdfStream(System.Boolean,System.String,System.String)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdfStream(Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.Words", + "display": "AdvancedOcrResultBase.Words", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public AdvancedWord[] Words { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdf(System.String,System.Boolean)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdf(String, Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdfBytes(System.Boolean)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdfBytes(Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdfStream(System.Boolean)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdfStream(Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.AdvancedWord", + "added": [ + { + "uid": "IronOcr.AdvancedWord", + "display": "IronOcr.AdvancedWord", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class AdvancedWord : AdvancedOcrElement", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.Gender", + "added": [ + { + "uid": "IronOcr.Gender", + "display": "IronOcr.Gender", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class Gender : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.IOcrPageObjectModel", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.IOcrPageObjectModel", + "display": "IronOcr.IOcrPageObjectModel", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "after": "public interface IOcrPageObjectModel", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageObjectModel, IBounded, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.IronTesseract", + "added": [ + { + "uid": "IronOcr.IronTesseract.Read(IronSoftware.Abstractions.Pdf.IDocumentId)", + "display": "IronTesseract.Read(IDocumentId)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IOcrResult Read(IDocumentId Document)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.IronTesseract.Read(IronSoftware.Abstractions.Pdf.IDocumentId,IronOcr.PdfContents)", + "display": "IronTesseract.Read(IDocumentId, PdfContents)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IOcrResult Read(IDocumentId Document, PdfContents Contents)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.IronTesseract.Read(IronSoftware.IDocumentId)", + "display": "IronTesseract.Read(IDocumentId)", + "severity": "BREAKING", + "target": "member", + "before": "public IOcrResult Read(IDocumentId Document)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.IronTesseract.Read(IronSoftware.IDocumentId,IronOcr.PdfContents)", + "display": "IronTesseract.Read(IDocumentId, PdfContents)", + "severity": "BREAKING", + "target": "member", + "before": "public IOcrResult Read(IDocumentId Document, PdfContents Contents)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.OcrHandwritingResult.TextLine", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrHandwritingResult.TextLine", + "display": "IronOcr.OcrHandwritingResult.TextLine", + "severity": "COSMETIC", + "target": "type", + "before": "public sealed class TextLine : ValueType, IEquatable", + "after": "public sealed class TextLine : ValueType", + "reasons": [ + "declaration interface list differs (no longer listed: IEquatable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrInput", + "added": [ + { + "uid": "IronOcr.OcrInput.LoadPdf(IronSoftware.Abstractions.Pdf.IDocumentId,System.Int32[],System.Int32,System.Boolean,IronSoftware.Drawing.Rectangle,System.String)", + "display": "OcrInput.LoadPdf(IDocumentId, Int32[], Int32, Boolean, Rectangle, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void LoadPdf(IDocumentId Document, int[] PageIndices, int DPI = 200, bool OnlyEmbeddedImages = false, Rectangle ContentArea = null, string PdfPassword = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.OcrInput.LoadScannedPdf(IronSoftware.Abstractions.Pdf.IDocumentId,System.Int32[],System.Int32,System.String)", + "display": "OcrInput.LoadScannedPdf(IDocumentId, Int32[], Int32, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void LoadScannedPdf(IDocumentId Document, int[] PageIndices = null, int DPI = 200, string PdfPassword = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.OcrInput.LoadPdf(IronSoftware.IDocumentId,System.Int32[],System.Int32,System.Boolean,IronSoftware.Drawing.Rectangle,System.String)", + "display": "OcrInput.LoadPdf(IDocumentId, Int32[], Int32, Boolean, Rectangle, String)", + "severity": "BREAKING", + "target": "member", + "before": "public void LoadPdf(IDocumentId Document, int[] PageIndices, int DPI = 200, bool OnlyEmbeddedImages = false, Rectangle ContentArea = null, string PdfPassword = null)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.OcrInput.LoadScannedPdf(IronSoftware.IDocumentId,System.Int32[],System.Int32,System.String)", + "display": "OcrInput.LoadScannedPdf(IDocumentId, Int32[], Int32, String)", + "severity": "BREAKING", + "target": "member", + "before": "public void LoadScannedPdf(IDocumentId Document, int[] PageIndices = null, int DPI = 200, string PdfPassword = null)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.OcrPdfInput", + "added": [ + { + "uid": "IronOcr.OcrPdfInput.#ctor(IronSoftware.Abstractions.Pdf.IDocumentId,IronOcr.PdfContents,System.Collections.Generic.IEnumerable{System.Int32},IronSoftware.Drawing.Rectangle[])", + "display": "OcrPdfInput.OcrPdfInput(IDocumentId, PdfContents, IEnumerable, Rectangle[])", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public OcrPdfInput(IDocumentId Document, PdfContents OcrContent, IEnumerable PageIndices = null, Rectangle[] ContentAreas = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.OcrPdfInput.#ctor(IronSoftware.IDocumentId,IronOcr.PdfContents,System.Collections.Generic.IEnumerable{System.Int32},IronSoftware.Drawing.Rectangle[])", + "display": "OcrPdfInput.OcrPdfInput(IDocumentId, PdfContents, IEnumerable, Rectangle[])", + "severity": "BREAKING", + "target": "member", + "before": "public OcrPdfInput(IDocumentId Document, PdfContents OcrContent, IEnumerable PageIndices = null, Rectangle[] ContentAreas = null)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.OcrPhotoResult.TextRegion", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrPhotoResult.TextRegion", + "display": "IronOcr.OcrPhotoResult.TextRegion", + "severity": "COSMETIC", + "target": "type", + "before": "public sealed class TextRegion : ValueType, IEquatable", + "after": "public sealed class TextRegion : ValueType", + "reasons": [ + "declaration interface list differs (no longer listed: IEquatable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult", + "added": [ + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdf(System.String,System.Boolean,System.String,System.String)", + "display": "OcrResult.SaveAsSearchablePdf(String, Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdfBytes(System.Boolean,System.String,System.String)", + "display": "OcrResult.SaveAsSearchablePdfBytes(Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdfStream(System.Boolean,System.String,System.String)", + "display": "OcrResult.SaveAsSearchablePdfStream(Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdf(System.String,System.Boolean)", + "display": "OcrResult.SaveAsSearchablePdf(String, Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdfBytes(System.Boolean)", + "display": "OcrResult.SaveAsSearchablePdfBytes(Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdfStream(System.Boolean)", + "display": "OcrResult.SaveAsSearchablePdfStream(Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.OcrResult.Block", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Block", + "display": "IronOcr.OcrResult.Block", + "severity": "BREAKING", + "target": "type", + "before": "public class Block : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Block : OcrResult.OcrResultTextElement", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Character", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Character", + "display": "IronOcr.OcrResult.Character", + "severity": "BREAKING", + "target": "type", + "before": "public class Character : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentCharacter, IDocumentObject", + "after": "public class Character : OcrResult.OcrResultTextElement", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Line", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Line", + "display": "IronOcr.OcrResult.Line", + "severity": "BREAKING", + "target": "type", + "before": "public class Line : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Line : OcrResult.OcrResultTextElement", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.OcrResultTextElement", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.OcrResultTextElement", + "display": "IronOcr.OcrResult.OcrResultTextElement", + "severity": "BREAKING", + "target": "type", + "before": "public abstract class OcrResultTextElement : OcrResult.OcrResultElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public abstract class OcrResultTextElement : OcrResult.OcrResultElement", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Page", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Page", + "display": "IronOcr.OcrResult.Page", + "severity": "BREAKING", + "target": "type", + "before": "public class Page : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentPage, IPageContainer", + "after": "public class Page : OcrResult.OcrResultTextElement", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Paragraph", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Paragraph", + "display": "IronOcr.OcrResult.Paragraph", + "severity": "BREAKING", + "target": "type", + "before": "public class Paragraph : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Paragraph : OcrResult.OcrResultTextElement", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Table", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Table", + "display": "IronOcr.OcrResult.Table", + "severity": "BREAKING", + "target": "type", + "before": "public class Table : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Table : OcrResult.OcrResultTextElement", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult.Word", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResult.Word", + "display": "IronOcr.OcrResult.Word", + "severity": "BREAKING", + "target": "type", + "before": "public class Word : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable", + "after": "public class Word : OcrResult.OcrResultTextElement", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResults.IOcrPageCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResults.IOcrPageCollection", + "display": "IronOcr.OcrResults.IOcrPageCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageCollection : IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable", + "after": "public interface IOcrPageCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResults.OcrResultPagesCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResults.OcrResultPagesCollection", + "display": "IronOcr.OcrResults.OcrResultPagesCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public class OcrResultPagesCollection : List, IOcrPageCollection, IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable", + "after": "public class OcrResultPagesCollection : List, IOcrPageCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.PassportInfo", + "added": [ + { + "uid": "IronOcr.PassportInfo.DateOfIssue", + "display": "PassportInfo.DateOfIssue", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string DateOfIssue { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.DocumentType", + "display": "PassportInfo.DocumentType", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string DocumentType { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.op_Equality(IronOcr.PassportInfo,IronOcr.PassportInfo)", + "display": "PassportInfo.Equality(PassportInfo, PassportInfo)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static bool operator ==(PassportInfo left, PassportInfo right)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.Gender", + "display": "PassportInfo.Gender", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Gender Gender { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.GetHashCode", + "display": "PassportInfo.GetHashCode()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public override int GetHashCode()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.op_Inequality(IronOcr.PassportInfo,IronOcr.PassportInfo)", + "display": "PassportInfo.Inequality(PassportInfo, PassportInfo)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static bool operator !=(PassportInfo left, PassportInfo right)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.InvalidCountryCodePrefix", + "display": "PassportInfo.InvalidCountryCodePrefix", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public const string InvalidCountryCodePrefix = \"Invalid country code\"", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.IssuingCountryCode", + "display": "PassportInfo.IssuingCountryCode", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string IssuingCountryCode { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.Nationality", + "display": "PassportInfo.Nationality", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string Nationality { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.NationalityCode", + "display": "PassportInfo.NationalityCode", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string NationalityCode { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.#ctor(System.String,System.String,System.String,System.String,System.String,System.String,IronOcr.Gender,System.String,System.String,System.String,System.String,System.String,System.String)", + "display": "PassportInfo.PassportInfo(String, String, String, String, String, String, Gender, String, String, String, String, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PassportInfo(string surname, string givenName, string passportNumber, string country, string dateOfBirth, string dateOfExpiry, Gender gender, string documentType, string nationality, string personalNumber, string dateOfIssue, string issuingCountryCode, string nationalityCode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.PersonalNumber", + "display": "PassportInfo.PersonalNumber", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string PersonalNumber { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "ZXing.ResultMetadataType", + "added": [], + "removed": [ + { + "uid": "ZXing.ResultMetadataType.ERASURES_CORRECTED", + "display": "ResultMetadataType.ERASURES_CORRECTED", + "severity": "BREAKING", + "target": "member", + "before": "ZXing.ResultMetadataType.ERASURES_CORRECTED", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "ZXing.ResultMetadataType.ERRORS_CORRECTED", + "display": "ResultMetadataType.ERRORS_CORRECTED", + "severity": "BREAKING", + "target": "member", + "before": "ZXing.ResultMetadataType.ERRORS_CORRECTED", + "after": "", + "reasons": [ + "member removed" + ] + } + ], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironocr/2025.12.3..2026.7.2.md b/docs/api-diffs/ironocr/2025.12.3..2026.7.2.md new file mode 100644 index 000000000..30baa1259 --- /dev/null +++ b/docs/api-diffs/ironocr/2025.12.3..2026.7.2.md @@ -0,0 +1,284 @@ +# IronOCR API changes: 2025.12.3 -> 2026.7.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **21 breaking**, 29 additive, 6 cosmetic. + +## Breaking changes (21) + +### `IronOcr.AdvancedOcrResultBase` + +- **AdvancedOcrResultBase.SaveAsSearchablePdf(String, Boolean)** removed + - `public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +- **AdvancedOcrResultBase.SaveAsSearchablePdfBytes(Boolean)** removed + - `public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +- **AdvancedOcrResultBase.SaveAsSearchablePdfStream(Boolean)** removed + - `public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.IronTesseract` + +- **IronTesseract.Read(IDocumentId)** removed + - `public IOcrResult Read(IDocumentId Document)` + - member removed + - overload signature change (see the matching addition) +- **IronTesseract.Read(IDocumentId, PdfContents)** removed + - `public IOcrResult Read(IDocumentId Document, PdfContents Contents)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.OcrInput` + +- **OcrInput.LoadPdf(IDocumentId, Int32[], Int32, Boolean, Rectangle, String)** removed + - `public void LoadPdf(IDocumentId Document, int[] PageIndices, int DPI = 200, bool OnlyEmbeddedImages = false, Rectangle ContentArea = null, string PdfPassword = null)` + - member removed + - overload signature change (see the matching addition) +- **OcrInput.LoadScannedPdf(IDocumentId, Int32[], Int32, String)** removed + - `public void LoadScannedPdf(IDocumentId Document, int[] PageIndices = null, int DPI = 200, string PdfPassword = null)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.OcrPdfInput` + +- **OcrPdfInput.OcrPdfInput(IDocumentId, PdfContents, IEnumerable, Rectangle[])** removed + - `public OcrPdfInput(IDocumentId Document, PdfContents OcrContent, IEnumerable PageIndices = null, Rectangle[] ContentAreas = null)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.OcrResult` + +- **OcrResult.SaveAsSearchablePdf(String, Boolean)** removed + - `public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +- **OcrResult.SaveAsSearchablePdfBytes(Boolean)** removed + - `public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +- **OcrResult.SaveAsSearchablePdfStream(Boolean)** removed + - `public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.OcrResult.Block` + +- **IronOcr.OcrResult.Block** changed + - was: `public class Block : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Block : OcrResult.OcrResultTextElement` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Character` + +- **IronOcr.OcrResult.Character** changed + - was: `public class Character : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentCharacter, IDocumentObject` + - now: `public class Character : OcrResult.OcrResultTextElement` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Line` + +- **IronOcr.OcrResult.Line** changed + - was: `public class Line : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Line : OcrResult.OcrResultTextElement` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.OcrResultTextElement` + +- **IronOcr.OcrResult.OcrResultTextElement** changed + - was: `public abstract class OcrResultTextElement : OcrResult.OcrResultElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public abstract class OcrResultTextElement : OcrResult.OcrResultElement` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Page` + +- **IronOcr.OcrResult.Page** changed + - was: `public class Page : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentPage, IPageContainer` + - now: `public class Page : OcrResult.OcrResultTextElement` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Paragraph` + +- **IronOcr.OcrResult.Paragraph** changed + - was: `public class Paragraph : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Paragraph : OcrResult.OcrResultTextElement` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Table` + +- **IronOcr.OcrResult.Table** changed + - was: `public class Table : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Table : OcrResult.OcrResultTextElement` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `IronOcr.OcrResult.Word` + +- **IronOcr.OcrResult.Word** changed + - was: `public class Word : OcrResult.OcrResultTextElement, IDocumentTextObject, IBoundedDocumentObject, IDocumentObject, IBounded, ITransformable, IColored, ICloneable` + - now: `public class Word : OcrResult.OcrResultTextElement` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject, IPdfDocumentObject +### `ZXing.ResultMetadataType` + +- **ResultMetadataType.ERASURES_CORRECTED** removed + - `ZXing.ResultMetadataType.ERASURES_CORRECTED` + - member removed +- **ResultMetadataType.ERRORS_CORRECTED** removed + - `ZXing.ResultMetadataType.ERRORS_CORRECTED` + - member removed + +## Additions (29) + +### `IronOcr.AdvancedCharacter` + +- **IronOcr.AdvancedCharacter** added + - `public class AdvancedCharacter : AdvancedOcrElement` + - type added +### `IronOcr.AdvancedOcrElement` + +- **IronOcr.AdvancedOcrElement** added + - `public abstract class AdvancedOcrElement : Object` + - type added +### `IronOcr.AdvancedOcrResultBase` + +- **AdvancedOcrResultBase.Characters** added + - `public AdvancedCharacter[] Characters { get; }` + - member added +- **AdvancedOcrResultBase.SaveAsSearchablePdf(String, Boolean, String, String)** added + - `public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **AdvancedOcrResultBase.SaveAsSearchablePdfBytes(Boolean, String, String)** added + - `public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **AdvancedOcrResultBase.SaveAsSearchablePdfStream(Boolean, String, String)** added + - `public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **AdvancedOcrResultBase.Words** added + - `public AdvancedWord[] Words { get; }` + - member added +### `IronOcr.AdvancedWord` + +- **IronOcr.AdvancedWord** added + - `public class AdvancedWord : AdvancedOcrElement` + - type added +### `IronOcr.Gender` + +- **IronOcr.Gender** added + - `public sealed class Gender : Enum` + - type added +### `IronOcr.IronTesseract` + +- **IronTesseract.Read(IDocumentId)** added + - `public IOcrResult Read(IDocumentId Document)` + - member added + - overload signature change (see the matching removal) +- **IronTesseract.Read(IDocumentId, PdfContents)** added + - `public IOcrResult Read(IDocumentId Document, PdfContents Contents)` + - member added + - overload signature change (see the matching removal) +### `IronOcr.OcrInput` + +- **OcrInput.LoadPdf(IDocumentId, Int32[], Int32, Boolean, Rectangle, String)** added + - `public void LoadPdf(IDocumentId Document, int[] PageIndices, int DPI = 200, bool OnlyEmbeddedImages = false, Rectangle ContentArea = null, string PdfPassword = null)` + - member added + - overload signature change (see the matching removal) +- **OcrInput.LoadScannedPdf(IDocumentId, Int32[], Int32, String)** added + - `public void LoadScannedPdf(IDocumentId Document, int[] PageIndices = null, int DPI = 200, string PdfPassword = null)` + - member added + - overload signature change (see the matching removal) +### `IronOcr.OcrPdfInput` + +- **OcrPdfInput.OcrPdfInput(IDocumentId, PdfContents, IEnumerable, Rectangle[])** added + - `public OcrPdfInput(IDocumentId Document, PdfContents OcrContent, IEnumerable PageIndices = null, Rectangle[] ContentAreas = null)` + - member added + - overload signature change (see the matching removal) +### `IronOcr.OcrResult` + +- **OcrResult.SaveAsSearchablePdf(String, Boolean, String, String)** added + - `public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **OcrResult.SaveAsSearchablePdfBytes(Boolean, String, String)** added + - `public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **OcrResult.SaveAsSearchablePdfStream(Boolean, String, String)** added + - `public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +### `IronOcr.PassportInfo` + +- **PassportInfo.DateOfIssue** added + - `public string DateOfIssue { get; }` + - member added +- **PassportInfo.DocumentType** added + - `public string DocumentType { get; }` + - member added +- **PassportInfo.Equality(PassportInfo, PassportInfo)** added + - `public static bool operator ==(PassportInfo left, PassportInfo right)` + - member added +- **PassportInfo.Gender** added + - `public Gender Gender { get; }` + - member added +- **PassportInfo.GetHashCode()** added + - `public override int GetHashCode()` + - member added +- **PassportInfo.Inequality(PassportInfo, PassportInfo)** added + - `public static bool operator !=(PassportInfo left, PassportInfo right)` + - member added +- **PassportInfo.InvalidCountryCodePrefix** added + - `public const string InvalidCountryCodePrefix = "Invalid country code"` + - member added +- **PassportInfo.IssuingCountryCode** added + - `public string IssuingCountryCode { get; }` + - member added +- **PassportInfo.Nationality** added + - `public string Nationality { get; }` + - member added +- **PassportInfo.NationalityCode** added + - `public string NationalityCode { get; }` + - member added +- **PassportInfo.PassportInfo(String, String, String, String, String, String, Gender, String, String, String, String, String, String)** added + - `public PassportInfo(string surname, string givenName, string passportNumber, string country, string dateOfBirth, string dateOfExpiry, Gender gender, string documentType, string nationality, string personalNumber, string dateOfIssue, string issuingCountryCode, string nationalityCode)` + - member added +- **PassportInfo.PersonalNumber** added + - `public string PersonalNumber { get; }` + - member added + +## Cosmetic (6) + +### `DynamicTesseract.IResultRenderer` + +- **DynamicTesseract.IResultRenderer** changed + - was: `public interface IResultRenderer : IDisposable` + - now: `public interface IResultRenderer` + - declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.IOcrPageObjectModel` + +- **IronOcr.IOcrPageObjectModel** changed + - was: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - now: `public interface IOcrPageObjectModel` + - declaration interface list differs (no longer listed: IDocumentPageObjectModel, IBounded, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.OcrHandwritingResult.TextLine` + +- **IronOcr.OcrHandwritingResult.TextLine** changed + - was: `public sealed class TextLine : ValueType, IEquatable` + - now: `public sealed class TextLine : ValueType` + - declaration interface list differs (no longer listed: IEquatable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.OcrPhotoResult.TextRegion` + +- **IronOcr.OcrPhotoResult.TextRegion** changed + - was: `public sealed class TextRegion : ValueType, IEquatable` + - now: `public sealed class TextRegion : ValueType` + - declaration interface list differs (no longer listed: IEquatable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.OcrResults.IOcrPageCollection` + +- **IronOcr.OcrResults.IOcrPageCollection** changed + - was: `public interface IOcrPageCollection : IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable` + - now: `public interface IOcrPageCollection` + - declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.OcrResults.OcrResultPagesCollection` + +- **IronOcr.OcrResults.OcrResultPagesCollection** changed + - was: `public class OcrResultPagesCollection : List, IOcrPageCollection, IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable` + - now: `public class OcrResultPagesCollection : List, IOcrPageCollection` + - declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironocr/2026.1.2..2026.2.1.json b/docs/api-diffs/ironocr/2026.1.2..2026.2.1.json new file mode 100644 index 000000000..549954f28 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.1.2..2026.2.1.json @@ -0,0 +1,41 @@ +{ + "product": "ironocr", + "productName": "IronOCR", + "from": "2026.1.2", + "to": "2026.2.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 1, + "total": 1, + "typesFrom": 109, + "typesTo": 109 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronOcr.IOcrPageObjectModel", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.IOcrPageObjectModel", + "display": "IronOcr.IOcrPageObjectModel", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "after": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironocr/2026.1.2..2026.2.1.md b/docs/api-diffs/ironocr/2026.1.2..2026.2.1.md new file mode 100644 index 000000000..fca619d53 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.1.2..2026.2.1.md @@ -0,0 +1,12 @@ +# IronOCR API changes: 2026.1.2 -> 2026.2.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 1 cosmetic. + +## Cosmetic (1) + +### `IronOcr.IOcrPageObjectModel` + +- **IronOcr.IOcrPageObjectModel** changed + - was: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - now: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironocr/2026.2.1..2026.3.3.json b/docs/api-diffs/ironocr/2026.2.1..2026.3.3.json new file mode 100644 index 000000000..a3424bf93 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.2.1..2026.3.3.json @@ -0,0 +1,201 @@ +{ + "product": "ironocr", + "productName": "IronOCR", + "from": "2026.2.1", + "to": "2026.3.3", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 6, + "additive": 6, + "cosmetic": 1, + "total": 13, + "typesFrom": 109, + "typesTo": 109 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronOcr.AdvancedOcrResultBase", + "added": [ + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdf(System.String,System.Boolean,System.String,System.String)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdf(String, Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdfBytes(System.Boolean,System.String,System.String)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdfBytes(Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdfStream(System.Boolean,System.String,System.String)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdfStream(Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdf(System.String,System.Boolean)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdf(String, Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdfBytes(System.Boolean)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdfBytes(Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.SaveAsSearchablePdfStream(System.Boolean)", + "display": "AdvancedOcrResultBase.SaveAsSearchablePdfStream(Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronOcr.IOcrPageObjectModel", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.IOcrPageObjectModel", + "display": "IronOcr.IOcrPageObjectModel", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "after": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResult", + "added": [ + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdf(System.String,System.Boolean,System.String,System.String)", + "display": "OcrResult.SaveAsSearchablePdf(String, Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdfBytes(System.Boolean,System.String,System.String)", + "display": "OcrResult.SaveAsSearchablePdfBytes(Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdfStream(System.Boolean,System.String,System.String)", + "display": "OcrResult.SaveAsSearchablePdfStream(Boolean, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdf(System.String,System.Boolean)", + "display": "OcrResult.SaveAsSearchablePdf(String, Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdfBytes(System.Boolean)", + "display": "OcrResult.SaveAsSearchablePdfBytes(Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronOcr.OcrResult.SaveAsSearchablePdfStream(System.Boolean)", + "display": "OcrResult.SaveAsSearchablePdfStream(Boolean)", + "severity": "BREAKING", + "target": "member", + "before": "public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironocr/2026.2.1..2026.3.3.md b/docs/api-diffs/ironocr/2026.2.1..2026.3.3.md new file mode 100644 index 000000000..d4820dbae --- /dev/null +++ b/docs/api-diffs/ironocr/2026.2.1..2026.3.3.md @@ -0,0 +1,74 @@ +# IronOCR API changes: 2026.2.1 -> 2026.3.3 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **6 breaking**, 6 additive, 1 cosmetic. + +## Breaking changes (6) + +### `IronOcr.AdvancedOcrResultBase` + +- **AdvancedOcrResultBase.SaveAsSearchablePdf(String, Boolean)** removed + - `public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +- **AdvancedOcrResultBase.SaveAsSearchablePdfBytes(Boolean)** removed + - `public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +- **AdvancedOcrResultBase.SaveAsSearchablePdfStream(Boolean)** removed + - `public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +### `IronOcr.OcrResult` + +- **OcrResult.SaveAsSearchablePdf(String, Boolean)** removed + - `public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +- **OcrResult.SaveAsSearchablePdfBytes(Boolean)** removed + - `public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) +- **OcrResult.SaveAsSearchablePdfStream(Boolean)** removed + - `public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false)` + - member removed + - overload signature change (see the matching addition) + +## Additions (6) + +### `IronOcr.AdvancedOcrResultBase` + +- **AdvancedOcrResultBase.SaveAsSearchablePdf(String, Boolean, String, String)** added + - `public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **AdvancedOcrResultBase.SaveAsSearchablePdfBytes(Boolean, String, String)** added + - `public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **AdvancedOcrResultBase.SaveAsSearchablePdfStream(Boolean, String, String)** added + - `public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +### `IronOcr.OcrResult` + +- **OcrResult.SaveAsSearchablePdf(String, Boolean, String, String)** added + - `public byte[] SaveAsSearchablePdf(string Path = null, bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **OcrResult.SaveAsSearchablePdfBytes(Boolean, String, String)** added + - `public byte[] SaveAsSearchablePdfBytes(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) +- **OcrResult.SaveAsSearchablePdfStream(Boolean, String, String)** added + - `public Stream SaveAsSearchablePdfStream(bool ApplyFilters = false, string CustomFontFile = null, string CustomFontName = null)` + - member added + - overload signature change (see the matching removal) + +## Cosmetic (1) + +### `IronOcr.IOcrPageObjectModel` + +- **IronOcr.IOcrPageObjectModel** changed + - was: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - now: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironocr/2026.3.3..2026.4.1.json b/docs/api-diffs/ironocr/2026.3.3..2026.4.1.json new file mode 100644 index 000000000..6c177d3e4 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.3.3..2026.4.1.json @@ -0,0 +1,227 @@ +{ + "product": "ironocr", + "productName": "IronOCR", + "from": "2026.3.3", + "to": "2026.4.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 2, + "additive": 13, + "cosmetic": 1, + "total": 16, + "typesFrom": 109, + "typesTo": 110 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronOcr.Gender", + "added": [ + { + "uid": "IronOcr.Gender", + "display": "IronOcr.Gender", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class Gender : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.IOcrPageObjectModel", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.IOcrPageObjectModel", + "display": "IronOcr.IOcrPageObjectModel", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "after": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.PassportInfo", + "added": [ + { + "uid": "IronOcr.PassportInfo.DateOfIssue", + "display": "PassportInfo.DateOfIssue", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string DateOfIssue { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.DocumentType", + "display": "PassportInfo.DocumentType", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string DocumentType { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.op_Equality(IronOcr.PassportInfo,IronOcr.PassportInfo)", + "display": "PassportInfo.Equality(PassportInfo, PassportInfo)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static bool operator ==(PassportInfo left, PassportInfo right)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.Gender", + "display": "PassportInfo.Gender", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Gender Gender { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.GetHashCode", + "display": "PassportInfo.GetHashCode()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public override int GetHashCode()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.op_Inequality(IronOcr.PassportInfo,IronOcr.PassportInfo)", + "display": "PassportInfo.Inequality(PassportInfo, PassportInfo)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static bool operator !=(PassportInfo left, PassportInfo right)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.InvalidCountryCodePrefix", + "display": "PassportInfo.InvalidCountryCodePrefix", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public const string InvalidCountryCodePrefix = \"Invalid country code\"", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.IssuingCountryCode", + "display": "PassportInfo.IssuingCountryCode", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string IssuingCountryCode { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.Nationality", + "display": "PassportInfo.Nationality", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string Nationality { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.NationalityCode", + "display": "PassportInfo.NationalityCode", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string NationalityCode { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.#ctor(System.String,System.String,System.String,System.String,System.String,System.String,IronOcr.Gender,System.String,System.String,System.String,System.String,System.String,System.String)", + "display": "PassportInfo.PassportInfo(String, String, String, String, String, String, Gender, String, String, String, String, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PassportInfo(string surname, string givenName, string passportNumber, string country, string dateOfBirth, string dateOfExpiry, Gender gender, string documentType, string nationality, string personalNumber, string dateOfIssue, string issuingCountryCode, string nationalityCode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.PassportInfo.PersonalNumber", + "display": "PassportInfo.PersonalNumber", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string PersonalNumber { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "ZXing.ResultMetadataType", + "added": [], + "removed": [ + { + "uid": "ZXing.ResultMetadataType.ERASURES_CORRECTED", + "display": "ResultMetadataType.ERASURES_CORRECTED", + "severity": "BREAKING", + "target": "member", + "before": "ZXing.ResultMetadataType.ERASURES_CORRECTED", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "ZXing.ResultMetadataType.ERRORS_CORRECTED", + "display": "ResultMetadataType.ERRORS_CORRECTED", + "severity": "BREAKING", + "target": "member", + "before": "ZXing.ResultMetadataType.ERRORS_CORRECTED", + "after": "", + "reasons": [ + "member removed" + ] + } + ], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironocr/2026.3.3..2026.4.1.md b/docs/api-diffs/ironocr/2026.3.3..2026.4.1.md new file mode 100644 index 000000000..7d539686b --- /dev/null +++ b/docs/api-diffs/ironocr/2026.3.3..2026.4.1.md @@ -0,0 +1,69 @@ +# IronOCR API changes: 2026.3.3 -> 2026.4.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **2 breaking**, 13 additive, 1 cosmetic. + +## Breaking changes (2) + +### `ZXing.ResultMetadataType` + +- **ResultMetadataType.ERASURES_CORRECTED** removed + - `ZXing.ResultMetadataType.ERASURES_CORRECTED` + - member removed +- **ResultMetadataType.ERRORS_CORRECTED** removed + - `ZXing.ResultMetadataType.ERRORS_CORRECTED` + - member removed + +## Additions (13) + +### `IronOcr.Gender` + +- **IronOcr.Gender** added + - `public sealed class Gender : Enum` + - type added +### `IronOcr.PassportInfo` + +- **PassportInfo.DateOfIssue** added + - `public string DateOfIssue { get; }` + - member added +- **PassportInfo.DocumentType** added + - `public string DocumentType { get; }` + - member added +- **PassportInfo.Equality(PassportInfo, PassportInfo)** added + - `public static bool operator ==(PassportInfo left, PassportInfo right)` + - member added +- **PassportInfo.Gender** added + - `public Gender Gender { get; }` + - member added +- **PassportInfo.GetHashCode()** added + - `public override int GetHashCode()` + - member added +- **PassportInfo.Inequality(PassportInfo, PassportInfo)** added + - `public static bool operator !=(PassportInfo left, PassportInfo right)` + - member added +- **PassportInfo.InvalidCountryCodePrefix** added + - `public const string InvalidCountryCodePrefix = "Invalid country code"` + - member added +- **PassportInfo.IssuingCountryCode** added + - `public string IssuingCountryCode { get; }` + - member added +- **PassportInfo.Nationality** added + - `public string Nationality { get; }` + - member added +- **PassportInfo.NationalityCode** added + - `public string NationalityCode { get; }` + - member added +- **PassportInfo.PassportInfo(String, String, String, String, String, String, Gender, String, String, String, String, String, String)** added + - `public PassportInfo(string surname, string givenName, string passportNumber, string country, string dateOfBirth, string dateOfExpiry, Gender gender, string documentType, string nationality, string personalNumber, string dateOfIssue, string issuingCountryCode, string nationalityCode)` + - member added +- **PassportInfo.PersonalNumber** added + - `public string PersonalNumber { get; }` + - member added + +## Cosmetic (1) + +### `IronOcr.IOcrPageObjectModel` + +- **IronOcr.IOcrPageObjectModel** changed + - was: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - now: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironocr/2026.4.1..2026.5.2.json b/docs/api-diffs/ironocr/2026.4.1..2026.5.2.json new file mode 100644 index 000000000..493caf11a --- /dev/null +++ b/docs/api-diffs/ironocr/2026.4.1..2026.5.2.json @@ -0,0 +1,124 @@ +{ + "product": "ironocr", + "productName": "IronOCR", + "from": "2026.4.1", + "to": "2026.5.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 5, + "cosmetic": 1, + "total": 6, + "typesFrom": 110, + "typesTo": 113 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronOcr.AdvancedCharacter", + "added": [ + { + "uid": "IronOcr.AdvancedCharacter", + "display": "IronOcr.AdvancedCharacter", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class AdvancedCharacter : AdvancedOcrElement", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.AdvancedOcrElement", + "added": [ + { + "uid": "IronOcr.AdvancedOcrElement", + "display": "IronOcr.AdvancedOcrElement", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public abstract class AdvancedOcrElement : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.AdvancedOcrResultBase", + "added": [ + { + "uid": "IronOcr.AdvancedOcrResultBase.Characters", + "display": "AdvancedOcrResultBase.Characters", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public AdvancedCharacter[] Characters { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronOcr.AdvancedOcrResultBase.Words", + "display": "AdvancedOcrResultBase.Words", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public AdvancedWord[] Words { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.AdvancedWord", + "added": [ + { + "uid": "IronOcr.AdvancedWord", + "display": "IronOcr.AdvancedWord", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class AdvancedWord : AdvancedOcrElement", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronOcr.IOcrPageObjectModel", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.IOcrPageObjectModel", + "display": "IronOcr.IOcrPageObjectModel", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "after": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironocr/2026.4.1..2026.5.2.md b/docs/api-diffs/ironocr/2026.4.1..2026.5.2.md new file mode 100644 index 000000000..3d50558a2 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.4.1..2026.5.2.md @@ -0,0 +1,38 @@ +# IronOCR API changes: 2026.4.1 -> 2026.5.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 5 additive, 1 cosmetic. + +## Additions (5) + +### `IronOcr.AdvancedCharacter` + +- **IronOcr.AdvancedCharacter** added + - `public class AdvancedCharacter : AdvancedOcrElement` + - type added +### `IronOcr.AdvancedOcrElement` + +- **IronOcr.AdvancedOcrElement** added + - `public abstract class AdvancedOcrElement : Object` + - type added +### `IronOcr.AdvancedOcrResultBase` + +- **AdvancedOcrResultBase.Characters** added + - `public AdvancedCharacter[] Characters { get; }` + - member added +- **AdvancedOcrResultBase.Words** added + - `public AdvancedWord[] Words { get; }` + - member added +### `IronOcr.AdvancedWord` + +- **IronOcr.AdvancedWord** added + - `public class AdvancedWord : AdvancedOcrElement` + - type added + +## Cosmetic (1) + +### `IronOcr.IOcrPageObjectModel` + +- **IronOcr.IOcrPageObjectModel** changed + - was: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - now: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironocr/2026.5.2..2026.6.1.json b/docs/api-diffs/ironocr/2026.5.2..2026.6.1.json new file mode 100644 index 000000000..9c25ef9b4 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.5.2..2026.6.1.json @@ -0,0 +1,41 @@ +{ + "product": "ironocr", + "productName": "IronOCR", + "from": "2026.5.2", + "to": "2026.6.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 1, + "total": 1, + "typesFrom": 113, + "typesTo": 113 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronOcr.IOcrPageObjectModel", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.IOcrPageObjectModel", + "display": "IronOcr.IOcrPageObjectModel", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "after": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironocr/2026.5.2..2026.6.1.md b/docs/api-diffs/ironocr/2026.5.2..2026.6.1.md new file mode 100644 index 000000000..0734165c8 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.5.2..2026.6.1.md @@ -0,0 +1,12 @@ +# IronOCR API changes: 2026.5.2 -> 2026.6.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 1 cosmetic. + +## Cosmetic (1) + +### `IronOcr.IOcrPageObjectModel` + +- **IronOcr.IOcrPageObjectModel** changed + - was: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - now: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - declaration interface list differs (no longer listed: IDocumentPageObjectModel; newly listed: IDocumentPageObjectModel) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironocr/2026.6.1..2026.7.2.json b/docs/api-diffs/ironocr/2026.6.1..2026.7.2.json new file mode 100644 index 000000000..530b77e72 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.6.1..2026.7.2.json @@ -0,0 +1,131 @@ +{ + "product": "ironocr", + "productName": "IronOCR", + "from": "2026.6.1", + "to": "2026.7.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 6, + "total": 6, + "typesFrom": 113, + "typesTo": 113 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "DynamicTesseract.IResultRenderer", + "added": [], + "removed": [], + "changed": [ + { + "uid": "DynamicTesseract.IResultRenderer", + "display": "DynamicTesseract.IResultRenderer", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IResultRenderer : IDisposable", + "after": "public interface IResultRenderer", + "reasons": [ + "declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.IOcrPageObjectModel", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.IOcrPageObjectModel", + "display": "IronOcr.IOcrPageObjectModel", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable", + "after": "public interface IOcrPageObjectModel", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageObjectModel, IBounded, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrHandwritingResult.TextLine", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrHandwritingResult.TextLine", + "display": "IronOcr.OcrHandwritingResult.TextLine", + "severity": "COSMETIC", + "target": "type", + "before": "public sealed class TextLine : ValueType, IEquatable", + "after": "public sealed class TextLine : ValueType", + "reasons": [ + "declaration interface list differs (no longer listed: IEquatable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrPhotoResult.TextRegion", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrPhotoResult.TextRegion", + "display": "IronOcr.OcrPhotoResult.TextRegion", + "severity": "COSMETIC", + "target": "type", + "before": "public sealed class TextRegion : ValueType, IEquatable", + "after": "public sealed class TextRegion : ValueType", + "reasons": [ + "declaration interface list differs (no longer listed: IEquatable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResults.IOcrPageCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResults.IOcrPageCollection", + "display": "IronOcr.OcrResults.IOcrPageCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IOcrPageCollection : IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable", + "after": "public interface IOcrPageCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronOcr.OcrResults.OcrResultPagesCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronOcr.OcrResults.OcrResultPagesCollection", + "display": "IronOcr.OcrResults.OcrResultPagesCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public class OcrResultPagesCollection : List, IOcrPageCollection, IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable", + "after": "public class OcrResultPagesCollection : List, IOcrPageCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironocr/2026.6.1..2026.7.2.md b/docs/api-diffs/ironocr/2026.6.1..2026.7.2.md new file mode 100644 index 000000000..3fdca9ab1 --- /dev/null +++ b/docs/api-diffs/ironocr/2026.6.1..2026.7.2.md @@ -0,0 +1,42 @@ +# IronOCR API changes: 2026.6.1 -> 2026.7.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 6 cosmetic. + +## Cosmetic (6) + +### `DynamicTesseract.IResultRenderer` + +- **DynamicTesseract.IResultRenderer** changed + - was: `public interface IResultRenderer : IDisposable` + - now: `public interface IResultRenderer` + - declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.IOcrPageObjectModel` + +- **IronOcr.IOcrPageObjectModel** changed + - was: `public interface IOcrPageObjectModel : IDocumentPageObjectModel, IBounded, IJsonSerializable` + - now: `public interface IOcrPageObjectModel` + - declaration interface list differs (no longer listed: IDocumentPageObjectModel, IBounded, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.OcrHandwritingResult.TextLine` + +- **IronOcr.OcrHandwritingResult.TextLine** changed + - was: `public sealed class TextLine : ValueType, IEquatable` + - now: `public sealed class TextLine : ValueType` + - declaration interface list differs (no longer listed: IEquatable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.OcrPhotoResult.TextRegion` + +- **IronOcr.OcrPhotoResult.TextRegion** changed + - was: `public sealed class TextRegion : ValueType, IEquatable` + - now: `public sealed class TextRegion : ValueType` + - declaration interface list differs (no longer listed: IEquatable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.OcrResults.IOcrPageCollection` + +- **IronOcr.OcrResults.IOcrPageCollection** changed + - was: `public interface IOcrPageCollection : IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable` + - now: `public interface IOcrPageCollection` + - declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronOcr.OcrResults.OcrResultPagesCollection` + +- **IronOcr.OcrResults.OcrResultPagesCollection** changed + - was: `public class OcrResultPagesCollection : List, IOcrPageCollection, IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable` + - now: `public class OcrResultPagesCollection : List, IOcrPageCollection` + - declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironpdf/2025.12.2..2026.1.3.json b/docs/api-diffs/ironpdf/2025.12.2..2026.1.3.json new file mode 100644 index 000000000..77b10a00f --- /dev/null +++ b/docs/api-diffs/ironpdf/2025.12.2..2026.1.3.json @@ -0,0 +1,1298 @@ +{ + "product": "ironpdf", + "productName": "IronPDF", + "from": "2025.12.2", + "to": "2026.1.3", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 25, + "additive": 51, + "cosmetic": 5, + "total": 81, + "typesFrom": 197, + "typesTo": 223 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "", + "added": [ + { + "uid": "IronPdf.Extractions", + "display": "IronPdf.Extractions", + "severity": "ADDITIVE", + "target": "namespace", + "before": "", + "after": "IronPdf.Extractions", + "reasons": [ + "namespace added" + ] + }, + { + "uid": "UglyToad.PdfPig.Core", + "display": "UglyToad.PdfPig.Core", + "severity": "ADDITIVE", + "target": "namespace", + "before": "", + "after": "UglyToad.PdfPig.Core", + "reasons": [ + "namespace added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ChromePdfRenderOptions", + "added": [ + { + "uid": "IronPdf.ChromePdfRenderOptions.CustomHyphenation", + "display": "ChromePdfRenderOptions.CustomHyphenation", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public CustomHyphenationDefinitions CustomHyphenation { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.CustomHyphenationDefinitions", + "added": [ + { + "uid": "IronPdf.CustomHyphenationDefinitions", + "display": "IronPdf.CustomHyphenationDefinitions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class CustomHyphenationDefinitions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extensions.ConversionExtensions", + "added": [ + { + "uid": "IronPdf.Extensions.ConversionExtensions.ToPdf(System.Collections.Generic.List{IronSoftware.Abstractions.Pdf.IBoundedPdfDocumentObject},System.Collections.Generic.List{System.Drawing.RectangleF})", + "display": "ConversionExtensions.ToPdf(List, List)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static PdfDocument ToPdf(this List objects, List bounds)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.Extensions.ConversionExtensions.ToPdf(System.Collections.Generic.List{IronSoftware.IBoundedDocumentObject},System.Collections.Generic.List{System.Drawing.RectangleF})", + "display": "ConversionExtensions.ToPdf(List, List)", + "severity": "BREAKING", + "target": "member", + "before": "public static PdfDocument ToPdf(this List objects, List bounds)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.CsvExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.CsvExportOptions", + "display": "IronPdf.Extractions.CsvExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class CsvExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.DocumentMetadata", + "added": [ + { + "uid": "IronPdf.Extractions.DocumentMetadata", + "display": "IronPdf.Extractions.DocumentMetadata", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class DocumentMetadata : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExportConfiguration", + "added": [ + { + "uid": "IronPdf.Extractions.ExportConfiguration", + "display": "IronPdf.Extractions.ExportConfiguration", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class ExportConfiguration : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExportFormat", + "added": [ + { + "uid": "IronPdf.Extractions.ExportFormat", + "display": "IronPdf.Extractions.ExportFormat", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class ExportFormat : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExportManager", + "added": [ + { + "uid": "IronPdf.Extractions.ExportManager", + "display": "IronPdf.Extractions.ExportManager", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public static class ExportManager : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExportOptionsBase", + "added": [ + { + "uid": "IronPdf.Extractions.ExportOptionsBase", + "display": "IronPdf.Extractions.ExportOptionsBase", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class ExportOptionsBase : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExtractionProgress", + "added": [ + { + "uid": "IronPdf.Extractions.ExtractionProgress", + "display": "IronPdf.Extractions.ExtractionProgress", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class ExtractionProgress : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.HtmlExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.HtmlExportOptions", + "display": "IronPdf.Extractions.HtmlExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class HtmlExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.JsonExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.JsonExportOptions", + "display": "IronPdf.Extractions.JsonExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class JsonExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PageMetadata", + "added": [ + { + "uid": "IronPdf.Extractions.PageMetadata", + "display": "IronPdf.Extractions.PageMetadata", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PageMetadata : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PageText", + "added": [ + { + "uid": "IronPdf.Extractions.PageText", + "display": "IronPdf.Extractions.PageText", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PageText : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PdfExtractionOptions", + "added": [ + { + "uid": "IronPdf.Extractions.PdfExtractionOptions", + "display": "IronPdf.Extractions.PdfExtractionOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PdfExtractionOptions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PdfExtractionResult", + "added": [ + { + "uid": "IronPdf.Extractions.PdfExtractionResult", + "display": "IronPdf.Extractions.PdfExtractionResult", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PdfExtractionResult : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PdfExtractor", + "added": [ + { + "uid": "IronPdf.Extractions.PdfExtractor", + "display": "IronPdf.Extractions.PdfExtractor", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public static class PdfExtractor : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.SpanHandlingMode", + "added": [ + { + "uid": "IronPdf.Extractions.SpanHandlingMode", + "display": "IronPdf.Extractions.SpanHandlingMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class SpanHandlingMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TableCell", + "added": [ + { + "uid": "IronPdf.Extractions.TableCell", + "display": "IronPdf.Extractions.TableCell", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TableCell : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TableDetectionStrategy", + "added": [ + { + "uid": "IronPdf.Extractions.TableDetectionStrategy", + "display": "IronPdf.Extractions.TableDetectionStrategy", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class TableDetectionStrategy : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TableObject", + "added": [ + { + "uid": "IronPdf.Extractions.TableObject", + "display": "IronPdf.Extractions.TableObject", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TableObject : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TableRow", + "added": [ + { + "uid": "IronPdf.Extractions.TableRow", + "display": "IronPdf.Extractions.TableRow", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TableRow : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TextContent", + "added": [ + { + "uid": "IronPdf.Extractions.TextContent", + "display": "IronPdf.Extractions.TextContent", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TextContent : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TextExtractionMode", + "added": [ + { + "uid": "IronPdf.Extractions.TextExtractionMode", + "display": "IronPdf.Extractions.TextExtractionMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class TextExtractionMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TxtExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.TxtExportOptions", + "display": "IronPdf.Extractions.TxtExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TxtExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.XmlExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.XmlExportOptions", + "display": "IronPdf.Extractions.XmlExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class XmlExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Fonts.PdfFont", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Fonts.PdfFont", + "display": "IronPdf.Fonts.PdfFont", + "severity": "ADDITIVE", + "target": "type", + "before": "public class PdfFont : Object, IDocumentFontObject, IDocumentObject", + "after": "public class PdfFont : Object, IDocumentFontObject, IFont, IDocumentObject, IPdfDocumentObject", + "reasons": [ + "interface now implemented: IFont, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronPdf.Pages.LineTextObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Pages.LineTextObject", + "display": "IronPdf.Pages.LineTextObject", + "severity": "BREAKING", + "target": "type", + "before": "public class LineTextObject : TextObject, IPdfTextObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "after": "public class LineTextObject : TextObject, IPdfTextObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronPdf.PdfDocument", + "added": [ + { + "uid": "IronPdf.PdfDocument.CopyPage(System.Int32,System.Boolean)", + "display": "PdfDocument.CopyPage(Int32, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument CopyPage(int pageIndex, bool copyBookmarks = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPages(System.Collections.Generic.IEnumerable{System.Int32},System.Boolean)", + "display": "PdfDocument.CopyPages(IEnumerable, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument CopyPages(IEnumerable pageIndexes, bool copyBookmarks = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPages(System.Int32,System.Int32,System.Boolean)", + "display": "PdfDocument.CopyPages(Int32, Int32, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument CopyPages(int startIndex, int endIndex, bool copyBookmarks = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.op_Implicit(IronSoftware.Abstractions.Pdf.DocumentId)~IronPdf.PdfDocument", + "display": "PdfDocument.Implicit(DocumentId to PdfDocument)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static implicit operator PdfDocument(DocumentId id)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.#ctor(System.Collections.Generic.List{IronSoftware.Abstractions.Pdf.IBoundedPdfDocumentObject},System.Collections.Generic.List{System.Drawing.RectangleF})", + "display": "PdfDocument.PdfDocument(List, List)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument(List objects, List bounds)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.PdfDocument.CopyPage(System.Int32)", + "display": "PdfDocument.CopyPage(Int32)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument CopyPage(int PageIndex)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPages(System.Collections.Generic.IEnumerable{System.Int32})", + "display": "PdfDocument.CopyPages(IEnumerable)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument CopyPages(IEnumerable PageIndexes)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPages(System.Int32,System.Int32)", + "display": "PdfDocument.CopyPages(Int32, Int32)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument CopyPages(int StartIndex, int EndIndex)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.op_Implicit(IronSoftware.DocumentId)~IronPdf.PdfDocument", + "display": "PdfDocument.Implicit(DocumentId to PdfDocument)", + "severity": "BREAKING", + "target": "member", + "before": "public static implicit operator PdfDocument(DocumentId id)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.#ctor(System.Collections.Generic.List{IronSoftware.IBoundedDocumentObject},System.Collections.Generic.List{System.Drawing.RectangleF})", + "display": "PdfDocument.PdfDocument(List, List)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument(List objects, List bounds)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronPdf.PdfDocumentExtensions", + "added": [ + { + "uid": "IronPdf.PdfDocumentExtensions.ToDocument(IronSoftware.Abstractions.Pdf.IDocumentId,System.String,System.String)", + "display": "PdfDocumentExtensions.ToDocument(IDocumentId, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static PdfDocument ToDocument(this IDocumentId id, string Password = \"\", string OwnerPassword = \"\")", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.PdfDocumentExtensions.ToDocument(IronSoftware.IDocumentId,System.String,System.String)", + "display": "PdfDocumentExtensions.ToDocument(IDocumentId, String, String)", + "severity": "BREAKING", + "target": "member", + "before": "public static PdfDocument ToDocument(this IDocumentId id, string Password = \"\", string OwnerPassword = \"\")", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronSoftware.CharObjectCollection", + "added": [ + { + "uid": "IronSoftware.CharObjectCollection.Add(IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.Add(IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void Add(IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Contains(IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.Contains(IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool Contains(IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.CopyTo(IronSoftware.Abstractions.Pdf.IDocumentCharacter[],System.Int32)", + "display": "CharObjectCollection.CopyTo(IDocumentCharacter[], Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void CopyTo(IDocumentCharacter[] array, int arrayIndex)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.IndexOf(IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.IndexOf(IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int IndexOf(IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Insert(System.Int32,IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.Insert(Int32, IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void Insert(int index, IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Remove(IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.Remove(IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool Remove(IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronSoftware.CharObjectCollection.Add(IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.Add(IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public void Add(IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Contains(IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.Contains(IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public bool Contains(IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.CopyTo(IronSoftware.IDocumentCharacter[],System.Int32)", + "display": "CharObjectCollection.CopyTo(IDocumentCharacter[], Int32)", + "severity": "BREAKING", + "target": "member", + "before": "public void CopyTo(IDocumentCharacter[] array, int arrayIndex)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.IndexOf(IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.IndexOf(IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public int IndexOf(IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Insert(System.Int32,IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.Insert(Int32, IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public void Insert(int index, IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Remove(IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.Remove(IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public bool Remove(IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronSoftware.FontObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.FontObject", + "display": "IronSoftware.FontObject", + "severity": "ADDITIVE", + "target": "type", + "before": "public class FontObject : Object, IPdfFontObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IJsonSerializable", + "after": "public class FontObject : Object, IPdfFontObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IFont, IJsonSerializable", + "reasons": [ + "interface now implemented: IFont" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.ICheckableFormField", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.ICheckableFormField", + "display": "IronSoftware.Forms.ICheckableFormField", + "severity": "BREAKING", + "target": "type", + "before": "public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "reasons": [ + "declaration changed" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormField", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormField", + "display": "IronSoftware.Forms.IFormField", + "severity": "BREAKING", + "target": "type", + "before": "public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "reasons": [ + "declaration changed" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldAnnotation", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldAnnotation", + "display": "IronSoftware.Forms.IFormFieldAnnotation", + "severity": "BREAKING", + "target": "type", + "before": "public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "reasons": [ + "declaration changed" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldAnnotationObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldAnnotationObject", + "display": "IronSoftware.Forms.IFormFieldAnnotationObject", + "severity": "BREAKING", + "target": "type", + "before": "public interface IFormFieldAnnotationObject : IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldAnnotationObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "reasons": [ + "declaration changed" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldObject", + "display": "IronSoftware.Forms.IFormFieldObject", + "severity": "BREAKING", + "target": "type", + "before": "public interface IFormFieldObject : IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "reasons": [ + "declaration changed" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfDocumentObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfDocumentObject", + "display": "IronSoftware.IPdfDocumentObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfDocumentObject : IDocumentObject", + "after": "public interface IPdfDocumentObject : IPdfDocumentObject, IDocumentObject", + "reasons": [ + "declaration interface list differs (newly listed: IPdfDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfFontObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfFontObject", + "display": "IronSoftware.IPdfFontObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfFontObject : IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IJsonSerializable", + "after": "public interface IPdfFontObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IFont, IJsonSerializable", + "reasons": [ + "declaration interface list differs (newly listed: IFont) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfImageObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfImageObject", + "display": "IronSoftware.IPdfImageObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfImageObject : IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable", + "after": "public interface IPdfImageObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedPdfDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IBoundedDocumentObject; newly listed: IBoundedPdfDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfPathObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfPathObject", + "display": "IronSoftware.IPdfPathObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPathObject : IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable", + "after": "public interface IPdfPathObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IBoundedDocumentObject; newly listed: IBoundedPdfDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfTextObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfTextObject", + "display": "IronSoftware.IPdfTextObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfTextObject : IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "after": "public interface IPdfTextObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "reasons": [ + "declaration interface list differs (no longer listed: IBoundedDocumentObject; newly listed: IBoundedPdfDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.ImageObject", + "added": [ + { + "uid": "IronSoftware.ImageObject.ZOrder", + "display": "ImageObject.ZOrder", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public RelativeZOrder ZOrder { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.ImageObject.ZPosition", + "display": "ImageObject.ZPosition", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public long ZPosition { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.ImageObject", + "display": "IronSoftware.ImageObject", + "severity": "BREAKING", + "target": "type", + "before": "public class ImageObject : Object, IPdfImageObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable", + "after": "public class ImageObject : Object, IPdfImageObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedPdfDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronSoftware.PathObject", + "added": [ + { + "uid": "IronSoftware.PathObject.ZPosition", + "display": "PathObject.ZPosition", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public long ZPosition { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.PathObject", + "display": "IronSoftware.PathObject", + "severity": "BREAKING", + "target": "type", + "before": "public class PathObject : Object, IPdfPathObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable", + "after": "public class PathObject : Object, IPdfPathObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject" + ] + }, + { + "uid": "IronSoftware.PathObject.Points", + "display": "PathObject.Points", + "severity": "BREAKING", + "target": "member", + "before": "public IReadOnlyCollection Points { get; set; }", + "after": "public IReadOnlyCollection Points { get; set; }", + "reasons": [ + "type changed: IReadOnlyCollection -> IReadOnlyCollection" + ] + }, + { + "uid": "IronSoftware.PathObject.ZOrder", + "display": "PathObject.ZOrder", + "severity": "BREAKING", + "target": "member", + "before": "public LayoutZOrders ZOrder { get; set; }", + "after": "public RelativeZOrder ZOrder { get; set; }", + "reasons": [ + "type changed: LayoutZOrders -> RelativeZOrder" + ] + }, + { + "uid": "IronSoftware.PathObject._Points", + "display": "PathObject._Points", + "severity": "BREAKING", + "target": "member", + "before": "protected IReadOnlyCollection _Points", + "after": "protected IReadOnlyCollection _Points", + "reasons": [ + "type changed: IReadOnlyCollection -> IReadOnlyCollection" + ] + } + ] + }, + { + "fqn": "IronSoftware.PathSegment", + "added": [ + { + "uid": "IronSoftware.PathSegment.SeparateFromPrevious", + "display": "PathSegment.SeparateFromPrevious", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool SeparateFromPrevious { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.PathSegment", + "display": "IronSoftware.PathSegment", + "severity": "ADDITIVE", + "target": "type", + "before": "public class PathSegment : Object, IPathSegment", + "after": "public class PathSegment : Object, IPdfPathSegment, IPathSegment", + "reasons": [ + "interface now implemented: IPdfPathSegment" + ] + } + ] + }, + { + "fqn": "IronSoftware.TextObject", + "added": [ + { + "uid": "IronSoftware.TextObject.ZOrder", + "display": "TextObject.ZOrder", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public RelativeZOrder ZOrder { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.TextObject.ZPosition", + "display": "TextObject.ZPosition", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public long ZPosition { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.TextObject", + "display": "IronSoftware.TextObject", + "severity": "BREAKING", + "target": "type", + "before": "public class TextObject : Object, IPdfTextObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "after": "public class TextObject : Object, IPdfTextObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "UglyToad.PdfPig.Core.PdfPoint", + "added": [ + { + "uid": "UglyToad.PdfPig.Core.PdfPoint", + "display": "UglyToad.PdfPig.Core.PdfPoint", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "UglyToad.PdfPig.Core.PdfPoint", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "UglyToad.PdfPig.Core.PdfRectangle", + "added": [ + { + "uid": "UglyToad.PdfPig.Core.PdfRectangle", + "display": "UglyToad.PdfPig.Core.PdfRectangle", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "UglyToad.PdfPig.Core.PdfRectangle", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [ + "2025.12.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)", + "2026.1.3: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)" + ] +} diff --git a/docs/api-diffs/ironpdf/2025.12.2..2026.1.3.md b/docs/api-diffs/ironpdf/2025.12.2..2026.1.3.md new file mode 100644 index 000000000..84cd30f4b --- /dev/null +++ b/docs/api-diffs/ironpdf/2025.12.2..2026.1.3.md @@ -0,0 +1,422 @@ +# IronPDF API changes: 2025.12.2 -> 2026.1.3 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **25 breaking**, 51 additive, 5 cosmetic. + +## Breaking changes (25) + +### `IronPdf.Extensions.ConversionExtensions` + +- **ConversionExtensions.ToPdf(List, List)** removed + - `public static PdfDocument ToPdf(this List objects, List bounds)` + - member removed + - overload signature change (see the matching addition) +### `IronPdf.Pages.LineTextObject` + +- **IronPdf.Pages.LineTextObject** changed + - was: `public class LineTextObject : TextObject, IPdfTextObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - now: `public class LineTextObject : TextObject, IPdfTextObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject +### `IronPdf.PdfDocument` + +- **PdfDocument.CopyPage(Int32)** removed + - `public PdfDocument CopyPage(int PageIndex)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.CopyPages(IEnumerable)** removed + - `public PdfDocument CopyPages(IEnumerable PageIndexes)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.CopyPages(Int32, Int32)** removed + - `public PdfDocument CopyPages(int StartIndex, int EndIndex)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.Implicit(DocumentId to PdfDocument)** removed + - `public static implicit operator PdfDocument(DocumentId id)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.PdfDocument(List, List)** removed + - `public PdfDocument(List objects, List bounds)` + - member removed + - overload signature change (see the matching addition) +### `IronPdf.PdfDocumentExtensions` + +- **PdfDocumentExtensions.ToDocument(IDocumentId, String, String)** removed + - `public static PdfDocument ToDocument(this IDocumentId id, string Password = "", string OwnerPassword = "")` + - member removed + - overload signature change (see the matching addition) +### `IronSoftware.CharObjectCollection` + +- **CharObjectCollection.Add(IDocumentCharacter)** removed + - `public void Add(IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.Contains(IDocumentCharacter)** removed + - `public bool Contains(IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.CopyTo(IDocumentCharacter[], Int32)** removed + - `public void CopyTo(IDocumentCharacter[] array, int arrayIndex)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.IndexOf(IDocumentCharacter)** removed + - `public int IndexOf(IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.Insert(Int32, IDocumentCharacter)** removed + - `public void Insert(int index, IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.Remove(IDocumentCharacter)** removed + - `public bool Remove(IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +### `IronSoftware.Forms.ICheckableFormField` + +- **IronSoftware.Forms.ICheckableFormField** changed + - was: `public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - declaration changed +### `IronSoftware.Forms.IFormField` + +- **IronSoftware.Forms.IFormField** changed + - was: `public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - declaration changed +### `IronSoftware.Forms.IFormFieldAnnotation` + +- **IronSoftware.Forms.IFormFieldAnnotation** changed + - was: `public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - declaration changed +### `IronSoftware.Forms.IFormFieldAnnotationObject` + +- **IronSoftware.Forms.IFormFieldAnnotationObject** changed + - was: `public interface IFormFieldAnnotationObject : IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldAnnotationObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - declaration changed +### `IronSoftware.Forms.IFormFieldObject` + +- **IronSoftware.Forms.IFormFieldObject** changed + - was: `public interface IFormFieldObject : IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - declaration changed +### `IronSoftware.ImageObject` + +- **IronSoftware.ImageObject** changed + - was: `public class ImageObject : Object, IPdfImageObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable` + - now: `public class ImageObject : Object, IPdfImageObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedPdfDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject +### `IronSoftware.PathObject` + +- **IronSoftware.PathObject** changed + - was: `public class PathObject : Object, IPdfPathObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable` + - now: `public class PathObject : Object, IPdfPathObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject +- **PathObject.Points** changed + - was: `public IReadOnlyCollection Points { get; set; }` + - now: `public IReadOnlyCollection Points { get; set; }` + - type changed: IReadOnlyCollection -> IReadOnlyCollection +- **PathObject.ZOrder** changed + - was: `public LayoutZOrders ZOrder { get; set; }` + - now: `public RelativeZOrder ZOrder { get; set; }` + - type changed: LayoutZOrders -> RelativeZOrder +- **PathObject._Points** changed + - was: `protected IReadOnlyCollection _Points` + - now: `protected IReadOnlyCollection _Points` + - type changed: IReadOnlyCollection -> IReadOnlyCollection +### `IronSoftware.TextObject` + +- **IronSoftware.TextObject** changed + - was: `public class TextObject : Object, IPdfTextObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - now: `public class TextObject : Object, IPdfTextObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject + +## Additions (51) + +### Namespaces + +- **IronPdf.Extractions** added + - `IronPdf.Extractions` + - namespace added +- **UglyToad.PdfPig.Core** added + - `UglyToad.PdfPig.Core` + - namespace added +### `IronPdf.ChromePdfRenderOptions` + +- **ChromePdfRenderOptions.CustomHyphenation** added + - `public CustomHyphenationDefinitions CustomHyphenation { get; set; }` + - member added +### `IronPdf.CustomHyphenationDefinitions` + +- **IronPdf.CustomHyphenationDefinitions** added + - `public class CustomHyphenationDefinitions : Object` + - type added +### `IronPdf.Extensions.ConversionExtensions` + +- **ConversionExtensions.ToPdf(List, List)** added + - `public static PdfDocument ToPdf(this List objects, List bounds)` + - member added + - overload signature change (see the matching removal) +### `IronPdf.Extractions.CsvExportOptions` + +- **IronPdf.Extractions.CsvExportOptions** added + - `public class CsvExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Extractions.DocumentMetadata` + +- **IronPdf.Extractions.DocumentMetadata** added + - `public class DocumentMetadata : Object` + - type added +### `IronPdf.Extractions.ExportConfiguration` + +- **IronPdf.Extractions.ExportConfiguration** added + - `public class ExportConfiguration : Object` + - type added +### `IronPdf.Extractions.ExportFormat` + +- **IronPdf.Extractions.ExportFormat** added + - `public sealed class ExportFormat : Enum` + - type added +### `IronPdf.Extractions.ExportManager` + +- **IronPdf.Extractions.ExportManager** added + - `public static class ExportManager : Object` + - type added +### `IronPdf.Extractions.ExportOptionsBase` + +- **IronPdf.Extractions.ExportOptionsBase** added + - `public class ExportOptionsBase : Object` + - type added +### `IronPdf.Extractions.ExtractionProgress` + +- **IronPdf.Extractions.ExtractionProgress** added + - `public class ExtractionProgress : Object` + - type added +### `IronPdf.Extractions.HtmlExportOptions` + +- **IronPdf.Extractions.HtmlExportOptions** added + - `public class HtmlExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Extractions.JsonExportOptions` + +- **IronPdf.Extractions.JsonExportOptions** added + - `public class JsonExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Extractions.PageMetadata` + +- **IronPdf.Extractions.PageMetadata** added + - `public class PageMetadata : Object` + - type added +### `IronPdf.Extractions.PageText` + +- **IronPdf.Extractions.PageText** added + - `public class PageText : Object` + - type added +### `IronPdf.Extractions.PdfExtractionOptions` + +- **IronPdf.Extractions.PdfExtractionOptions** added + - `public class PdfExtractionOptions : Object` + - type added +### `IronPdf.Extractions.PdfExtractionResult` + +- **IronPdf.Extractions.PdfExtractionResult** added + - `public class PdfExtractionResult : Object` + - type added +### `IronPdf.Extractions.PdfExtractor` + +- **IronPdf.Extractions.PdfExtractor** added + - `public static class PdfExtractor : Object` + - type added +### `IronPdf.Extractions.SpanHandlingMode` + +- **IronPdf.Extractions.SpanHandlingMode** added + - `public sealed class SpanHandlingMode : Enum` + - type added +### `IronPdf.Extractions.TableCell` + +- **IronPdf.Extractions.TableCell** added + - `public class TableCell : Object` + - type added +### `IronPdf.Extractions.TableDetectionStrategy` + +- **IronPdf.Extractions.TableDetectionStrategy** added + - `public sealed class TableDetectionStrategy : Enum` + - type added +### `IronPdf.Extractions.TableObject` + +- **IronPdf.Extractions.TableObject** added + - `public class TableObject : Object` + - type added +### `IronPdf.Extractions.TableRow` + +- **IronPdf.Extractions.TableRow** added + - `public class TableRow : Object` + - type added +### `IronPdf.Extractions.TextContent` + +- **IronPdf.Extractions.TextContent** added + - `public class TextContent : Object` + - type added +### `IronPdf.Extractions.TextExtractionMode` + +- **IronPdf.Extractions.TextExtractionMode** added + - `public sealed class TextExtractionMode : Enum` + - type added +### `IronPdf.Extractions.TxtExportOptions` + +- **IronPdf.Extractions.TxtExportOptions** added + - `public class TxtExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Extractions.XmlExportOptions` + +- **IronPdf.Extractions.XmlExportOptions** added + - `public class XmlExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Fonts.PdfFont` + +- **IronPdf.Fonts.PdfFont** changed + - was: `public class PdfFont : Object, IDocumentFontObject, IDocumentObject` + - now: `public class PdfFont : Object, IDocumentFontObject, IFont, IDocumentObject, IPdfDocumentObject` + - interface now implemented: IFont, IPdfDocumentObject +### `IronPdf.PdfDocument` + +- **PdfDocument.CopyPage(Int32, Boolean)** added + - `public PdfDocument CopyPage(int pageIndex, bool copyBookmarks = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.CopyPages(IEnumerable, Boolean)** added + - `public PdfDocument CopyPages(IEnumerable pageIndexes, bool copyBookmarks = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.CopyPages(Int32, Int32, Boolean)** added + - `public PdfDocument CopyPages(int startIndex, int endIndex, bool copyBookmarks = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.Implicit(DocumentId to PdfDocument)** added + - `public static implicit operator PdfDocument(DocumentId id)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.PdfDocument(List, List)** added + - `public PdfDocument(List objects, List bounds)` + - member added + - overload signature change (see the matching removal) +### `IronPdf.PdfDocumentExtensions` + +- **PdfDocumentExtensions.ToDocument(IDocumentId, String, String)** added + - `public static PdfDocument ToDocument(this IDocumentId id, string Password = "", string OwnerPassword = "")` + - member added + - overload signature change (see the matching removal) +### `IronSoftware.CharObjectCollection` + +- **CharObjectCollection.Add(IDocumentCharacter)** added + - `public void Add(IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.Contains(IDocumentCharacter)** added + - `public bool Contains(IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.CopyTo(IDocumentCharacter[], Int32)** added + - `public void CopyTo(IDocumentCharacter[] array, int arrayIndex)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.IndexOf(IDocumentCharacter)** added + - `public int IndexOf(IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.Insert(Int32, IDocumentCharacter)** added + - `public void Insert(int index, IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.Remove(IDocumentCharacter)** added + - `public bool Remove(IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +### `IronSoftware.FontObject` + +- **IronSoftware.FontObject** changed + - was: `public class FontObject : Object, IPdfFontObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IJsonSerializable` + - now: `public class FontObject : Object, IPdfFontObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IFont, IJsonSerializable` + - interface now implemented: IFont +### `IronSoftware.ImageObject` + +- **ImageObject.ZOrder** added + - `public RelativeZOrder ZOrder { get; set; }` + - member added +- **ImageObject.ZPosition** added + - `public long ZPosition { get; set; }` + - member added +### `IronSoftware.PathObject` + +- **PathObject.ZPosition** added + - `public long ZPosition { get; set; }` + - member added +### `IronSoftware.PathSegment` + +- **IronSoftware.PathSegment** changed + - was: `public class PathSegment : Object, IPathSegment` + - now: `public class PathSegment : Object, IPdfPathSegment, IPathSegment` + - interface now implemented: IPdfPathSegment +- **PathSegment.SeparateFromPrevious** added + - `public bool SeparateFromPrevious { get; set; }` + - member added +### `IronSoftware.TextObject` + +- **TextObject.ZOrder** added + - `public RelativeZOrder ZOrder { get; set; }` + - member added +- **TextObject.ZPosition** added + - `public long ZPosition { get; set; }` + - member added +### `UglyToad.PdfPig.Core.PdfPoint` + +- **UglyToad.PdfPig.Core.PdfPoint** added + - `UglyToad.PdfPig.Core.PdfPoint` + - type added +### `UglyToad.PdfPig.Core.PdfRectangle` + +- **UglyToad.PdfPig.Core.PdfRectangle** added + - `UglyToad.PdfPig.Core.PdfRectangle` + - type added + +## Cosmetic (5) + +### `IronSoftware.IPdfDocumentObject` + +- **IronSoftware.IPdfDocumentObject** changed + - was: `public interface IPdfDocumentObject : IDocumentObject` + - now: `public interface IPdfDocumentObject : IPdfDocumentObject, IDocumentObject` + - declaration interface list differs (newly listed: IPdfDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfFontObject` + +- **IronSoftware.IPdfFontObject** changed + - was: `public interface IPdfFontObject : IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IJsonSerializable` + - now: `public interface IPdfFontObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IFont, IJsonSerializable` + - declaration interface list differs (newly listed: IFont) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfImageObject` + +- **IronSoftware.IPdfImageObject** changed + - was: `public interface IPdfImageObject : IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable` + - now: `public interface IPdfImageObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedPdfDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable` + - declaration interface list differs (no longer listed: IBoundedDocumentObject; newly listed: IBoundedPdfDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfPathObject` + +- **IronSoftware.IPdfPathObject** changed + - was: `public interface IPdfPathObject : IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable` + - now: `public interface IPdfPathObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable` + - declaration interface list differs (no longer listed: IBoundedDocumentObject; newly listed: IBoundedPdfDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfTextObject` + +- **IronSoftware.IPdfTextObject** changed + - was: `public interface IPdfTextObject : IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - now: `public interface IPdfTextObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - declaration interface list differs (no longer listed: IBoundedDocumentObject; newly listed: IBoundedPdfDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions + +## Warnings (2) + +- 2025.12.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) +- 2026.1.3: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) diff --git a/docs/api-diffs/ironpdf/2025.12.2..2026.7.2.json b/docs/api-diffs/ironpdf/2025.12.2..2026.7.2.json new file mode 100644 index 000000000..54a162c81 --- /dev/null +++ b/docs/api-diffs/ironpdf/2025.12.2..2026.7.2.json @@ -0,0 +1,2484 @@ +{ + "product": "ironpdf", + "productName": "IronPDF", + "from": "2025.12.2", + "to": "2026.7.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 25, + "additive": 127, + "cosmetic": 18, + "total": 170, + "typesFrom": 197, + "typesTo": 239 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "", + "added": [ + { + "uid": "IronPdf.Extractions", + "display": "IronPdf.Extractions", + "severity": "ADDITIVE", + "target": "namespace", + "before": "", + "after": "IronPdf.Extractions", + "reasons": [ + "namespace added" + ] + }, + { + "uid": "UglyToad.PdfPig.Core", + "display": "UglyToad.PdfPig.Core", + "severity": "ADDITIVE", + "target": "namespace", + "before": "", + "after": "UglyToad.PdfPig.Core", + "reasons": [ + "namespace added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.AdvancedCompressionOptions", + "added": [ + { + "uid": "IronPdf.AdvancedCompressionOptions", + "display": "IronPdf.AdvancedCompressionOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class AdvancedCompressionOptions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Annotations.LinkAnnotation", + "added": [ + { + "uid": "IronPdf.Annotations.LinkAnnotation", + "display": "IronPdf.Annotations.LinkAnnotation", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class LinkAnnotation : PdfClientAccessor, IAnnotation", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.BrowserPoolOptions", + "added": [ + { + "uid": "IronPdf.BrowserPoolOptions", + "display": "IronPdf.BrowserPoolOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class BrowserPoolOptions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ChromePdfRenderOptions", + "added": [ + { + "uid": "IronPdf.ChromePdfRenderOptions.AutoBookmarkCssSelectors", + "display": "ChromePdfRenderOptions.AutoBookmarkCssSelectors", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string[] AutoBookmarkCssSelectors { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.AutoBookmarkMaxHeadingLevel", + "display": "ChromePdfRenderOptions.AutoBookmarkMaxHeadingLevel", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int AutoBookmarkMaxHeadingLevel { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.AutoBookmarkMinHeadingLevel", + "display": "ChromePdfRenderOptions.AutoBookmarkMinHeadingLevel", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int AutoBookmarkMinHeadingLevel { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.AutoBookmarksFromHeadings", + "display": "ChromePdfRenderOptions.AutoBookmarksFromHeadings", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool AutoBookmarksFromHeadings { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.BrowserPool", + "display": "ChromePdfRenderOptions.BrowserPool", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public BrowserPoolOptions BrowserPool { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.CssPageRulePolicy", + "display": "ChromePdfRenderOptions.CssPageRulePolicy", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public CssPageRulePolicy CssPageRulePolicy { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.CustomHyphenation", + "display": "ChromePdfRenderOptions.CustomHyphenation", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public CustomHyphenationDefinitions CustomHyphenation { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.ElementQuerySelectors", + "display": "ChromePdfRenderOptions.ElementQuerySelectors", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string[] ElementQuerySelectors { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.HeaderFooterOverlapBehavior", + "display": "ChromePdfRenderOptions.HeaderFooterOverlapBehavior", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public ContentOverlapBehavior HeaderFooterOverlapBehavior { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.MaxDynamicHFPagesPerBatch", + "display": "ChromePdfRenderOptions.MaxDynamicHFPagesPerBatch", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int MaxDynamicHFPagesPerBatch { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ChromePdfRenderer", + "added": [ + { + "uid": "IronPdf.ChromePdfRenderer.RenderRtfFileAsPdf(System.String,IronPdf.RtfConversionOptions)", + "display": "ChromePdfRenderer.RenderRtfFileAsPdf(String, RtfConversionOptions)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument RenderRtfFileAsPdf(string FilePath, RtfConversionOptions options = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderer.RenderRtfStringAsPdf(System.String,IronPdf.RtfConversionOptions)", + "display": "ChromePdfRenderer.RenderRtfStringAsPdf(String, RtfConversionOptions)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument RenderRtfStringAsPdf(string RtfString, RtfConversionOptions options = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.ChromePdfRenderer.RenderRtfFileAsPdf(System.String)", + "display": "ChromePdfRenderer.RenderRtfFileAsPdf(String)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument RenderRtfFileAsPdf(string FilePath)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderer.RenderRtfStringAsPdf(System.String)", + "display": "ChromePdfRenderer.RenderRtfStringAsPdf(String)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument RenderRtfStringAsPdf(string RtfString)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronPdf.CompressionMode", + "added": [ + { + "uid": "IronPdf.CompressionMode", + "display": "IronPdf.CompressionMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class CompressionMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ContentOverlapBehavior", + "added": [ + { + "uid": "IronPdf.ContentOverlapBehavior", + "display": "IronPdf.ContentOverlapBehavior", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class ContentOverlapBehavior : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.CssPageRulePolicy", + "added": [ + { + "uid": "IronPdf.CssPageRulePolicy", + "display": "IronPdf.CssPageRulePolicy", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class CssPageRulePolicy : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.CustomHyphenationDefinitions", + "added": [ + { + "uid": "IronPdf.CustomHyphenationDefinitions", + "display": "IronPdf.CustomHyphenationDefinitions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class CustomHyphenationDefinitions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extensions.ConversionExtensions", + "added": [ + { + "uid": "IronPdf.Extensions.ConversionExtensions.ToPdf(System.Collections.Generic.List{IronSoftware.Abstractions.Pdf.IBoundedPdfDocumentObject},System.Collections.Generic.List{System.Drawing.RectangleF})", + "display": "ConversionExtensions.ToPdf(List, List)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static PdfDocument ToPdf(this List objects, List bounds)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.Extensions.ConversionExtensions.ToPdf(System.Collections.Generic.List{IronSoftware.IBoundedDocumentObject},System.Collections.Generic.List{System.Drawing.RectangleF})", + "display": "ConversionExtensions.ToPdf(List, List)", + "severity": "BREAKING", + "target": "member", + "before": "public static PdfDocument ToPdf(this List objects, List bounds)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.CsvExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.CsvExportOptions", + "display": "IronPdf.Extractions.CsvExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class CsvExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.DocumentMetadata", + "added": [ + { + "uid": "IronPdf.Extractions.DocumentMetadata", + "display": "IronPdf.Extractions.DocumentMetadata", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class DocumentMetadata : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExportConfiguration", + "added": [ + { + "uid": "IronPdf.Extractions.ExportConfiguration", + "display": "IronPdf.Extractions.ExportConfiguration", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class ExportConfiguration : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExportFormat", + "added": [ + { + "uid": "IronPdf.Extractions.ExportFormat", + "display": "IronPdf.Extractions.ExportFormat", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class ExportFormat : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExportManager", + "added": [ + { + "uid": "IronPdf.Extractions.ExportManager", + "display": "IronPdf.Extractions.ExportManager", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public static class ExportManager : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExportOptionsBase", + "added": [ + { + "uid": "IronPdf.Extractions.ExportOptionsBase", + "display": "IronPdf.Extractions.ExportOptionsBase", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class ExportOptionsBase : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.ExtractionProgress", + "added": [ + { + "uid": "IronPdf.Extractions.ExtractionProgress", + "display": "IronPdf.Extractions.ExtractionProgress", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class ExtractionProgress : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.HtmlExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.HtmlExportOptions", + "display": "IronPdf.Extractions.HtmlExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class HtmlExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.JsonExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.JsonExportOptions", + "display": "IronPdf.Extractions.JsonExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class JsonExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PageMetadata", + "added": [ + { + "uid": "IronPdf.Extractions.PageMetadata", + "display": "IronPdf.Extractions.PageMetadata", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PageMetadata : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PageText", + "added": [ + { + "uid": "IronPdf.Extractions.PageText", + "display": "IronPdf.Extractions.PageText", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PageText : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PdfExtractionOptions", + "added": [ + { + "uid": "IronPdf.Extractions.PdfExtractionOptions", + "display": "IronPdf.Extractions.PdfExtractionOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PdfExtractionOptions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PdfExtractionResult", + "added": [ + { + "uid": "IronPdf.Extractions.PdfExtractionResult", + "display": "IronPdf.Extractions.PdfExtractionResult", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PdfExtractionResult : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PdfExtractor", + "added": [ + { + "uid": "IronPdf.Extractions.PdfExtractor", + "display": "IronPdf.Extractions.PdfExtractor", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public static class PdfExtractor : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.SpanHandlingMode", + "added": [ + { + "uid": "IronPdf.Extractions.SpanHandlingMode", + "display": "IronPdf.Extractions.SpanHandlingMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class SpanHandlingMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TableCell", + "added": [ + { + "uid": "IronPdf.Extractions.TableCell", + "display": "IronPdf.Extractions.TableCell", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TableCell : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TableDetectionStrategy", + "added": [ + { + "uid": "IronPdf.Extractions.TableDetectionStrategy", + "display": "IronPdf.Extractions.TableDetectionStrategy", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class TableDetectionStrategy : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TableObject", + "added": [ + { + "uid": "IronPdf.Extractions.TableObject", + "display": "IronPdf.Extractions.TableObject", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TableObject : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TableRow", + "added": [ + { + "uid": "IronPdf.Extractions.TableRow", + "display": "IronPdf.Extractions.TableRow", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TableRow : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TextContent", + "added": [ + { + "uid": "IronPdf.Extractions.TextContent", + "display": "IronPdf.Extractions.TextContent", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TextContent : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TextExtractionMode", + "added": [ + { + "uid": "IronPdf.Extractions.TextExtractionMode", + "display": "IronPdf.Extractions.TextExtractionMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class TextExtractionMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.TxtExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.TxtExportOptions", + "display": "IronPdf.Extractions.TxtExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class TxtExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.XmlExportOptions", + "added": [ + { + "uid": "IronPdf.Extractions.XmlExportOptions", + "display": "IronPdf.Extractions.XmlExportOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class XmlExportOptions : ExportOptionsBase", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Fonts.PdfFont", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Fonts.PdfFont", + "display": "IronPdf.Fonts.PdfFont", + "severity": "ADDITIVE", + "target": "type", + "before": "public class PdfFont : Object, IDocumentFontObject, IDocumentObject", + "after": "public class PdfFont : Object", + "reasons": [ + "interface now implemented: IFont, IPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronPdf.Installation", + "added": [ + { + "uid": "IronPdf.Installation.JobQueueWatchdogTimeout", + "display": "Installation.JobQueueWatchdogTimeout", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static TimeSpan JobQueueWatchdogTimeout { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.LinearizationMode", + "added": [ + { + "uid": "IronPdf.LinearizationMode", + "display": "IronPdf.LinearizationMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class LinearizationMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ObjectStreamMode", + "added": [ + { + "uid": "IronPdf.ObjectStreamMode", + "display": "IronPdf.ObjectStreamMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class ObjectStreamMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Pages.IPdfPage", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Pages.IPdfPage", + "display": "IronPdf.Pages.IPdfPage", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPage : IDocumentPage, IPageContainer", + "after": "public interface IPdfPage", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPage, IPageContainer) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronPdf.Pages.IPdfPageCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Pages.IPdfPageCollection", + "display": "IronPdf.Pages.IPdfPageCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPageCollection : IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable", + "after": "public interface IPdfPageCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronPdf.Pages.LineTextObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Pages.LineTextObject", + "display": "IronPdf.Pages.LineTextObject", + "severity": "BREAKING", + "target": "type", + "before": "public class LineTextObject : TextObject, IPdfTextObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "after": "public class LineTextObject : TextObject, IPdfTextObject, IPdfDocumentObject", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronPdf.PdfDocument", + "added": [ + { + "uid": "IronPdf.PdfDocument.AddHtmlFooters(IronPdf.HtmlHeaderFooter,IronPdf.ContentOverlapBehavior,System.Int32,System.Collections.Generic.IEnumerable{System.Int32})", + "display": "PdfDocument.AddHtmlFooters(HtmlHeaderFooter, ContentOverlapBehavior, Int32, IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument AddHtmlFooters(HtmlHeaderFooter Footer, ContentOverlapBehavior OverlapBehavior, int FirstPageNumber = 1, IEnumerable PageIndexesToAddFootersTo = null)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.AddHtmlHeaders(IronPdf.HtmlHeaderFooter,IronPdf.ContentOverlapBehavior,System.Int32,System.Collections.Generic.IEnumerable{System.Int32})", + "display": "PdfDocument.AddHtmlHeaders(HtmlHeaderFooter, ContentOverlapBehavior, Int32, IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument AddHtmlHeaders(HtmlHeaderFooter Header, ContentOverlapBehavior OverlapBehavior, int FirstPageNumber = 1, IEnumerable PageIndexesToAddHeadersTo = null)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressAndSaveAs(System.Byte[],System.String,IronPdf.AdvancedCompressionOptions,System.String)", + "display": "PdfDocument.CompressAndSaveAs(Byte[], String, AdvancedCompressionOptions, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static void CompressAndSaveAs(byte[] PdfBytes, string OutputPath, AdvancedCompressionOptions Options, string Password = \"\")", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressAndSaveAs(System.IO.Stream,System.String,IronPdf.AdvancedCompressionOptions,System.String)", + "display": "PdfDocument.CompressAndSaveAs(Stream, String, AdvancedCompressionOptions, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static void CompressAndSaveAs(Stream Stream, string OutputPath, AdvancedCompressionOptions Options, string Password = \"\")", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressAndSaveAs(System.String,IronPdf.AdvancedCompressionOptions)", + "display": "PdfDocument.CompressAndSaveAs(String, AdvancedCompressionOptions)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void CompressAndSaveAs(string OutputPath, AdvancedCompressionOptions Options)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToBytes(System.Byte[],System.Nullable{System.Int32},System.String,System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToBytes(Byte[], Nullable, String, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] CompressPdfToBytes(byte[] PdfBytes, Nullable JpegQuality = null, string Password = \"\", bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToBytes(System.Nullable{System.Int32},System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToBytes(Nullable, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] CompressPdfToBytes(Nullable JpegQuality = null, bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToBytes(System.IO.Stream,System.Nullable{System.Int32},System.String,System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToBytes(Stream, Nullable, String, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] CompressPdfToBytes(Stream PdfStream, Nullable JpegQuality = null, string Password = \"\", bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToStream(System.Byte[],System.Nullable{System.Int32},System.String,System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToStream(Byte[], Nullable, String, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Stream CompressPdfToStream(byte[] PdfBytes, Nullable JpegQuality = null, string Password = \"\", bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToStream(System.Nullable{System.Int32},System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToStream(Nullable, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Stream CompressPdfToStream(Nullable JpegQuality = null, bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToStream(System.IO.Stream,System.Nullable{System.Int32},System.String,System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToStream(Stream, Nullable, String, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Stream CompressPdfToStream(Stream PdfStream, Nullable JpegQuality = null, string Password = \"\", bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPage(System.Int32,System.Boolean)", + "display": "PdfDocument.CopyPage(Int32, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument CopyPage(int pageIndex, bool copyBookmarks = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPages(System.Collections.Generic.IEnumerable{System.Int32},System.Boolean)", + "display": "PdfDocument.CopyPages(IEnumerable, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument CopyPages(IEnumerable pageIndexes, bool copyBookmarks = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPages(System.Int32,System.Int32,System.Boolean)", + "display": "PdfDocument.CopyPages(Int32, Int32, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument CopyPages(int startIndex, int endIndex, bool copyBookmarks = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.DisableFormFontFallback", + "display": "PdfDocument.DisableFormFontFallback()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void DisableFormFontFallback()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ExtractTextFromLayer(System.Int32)", + "display": "PdfDocument.ExtractTextFromLayer(Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string ExtractTextFromLayer(int ocgId)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ExtractTextFromLayer(System.String)", + "display": "PdfDocument.ExtractTextFromLayer(String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string ExtractTextFromLayer(string layerName)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ExtractTextFromLayers(System.Collections.Generic.IEnumerable{System.Int32})", + "display": "PdfDocument.ExtractTextFromLayers(IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string ExtractTextFromLayers(IEnumerable ocgIds)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ExtractTextFromLayers(System.Collections.Generic.IEnumerable{System.String})", + "display": "PdfDocument.ExtractTextFromLayers(IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string ExtractTextFromLayers(IEnumerable layerNames)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetElementLocations", + "display": "PdfDocument.GetElementLocations()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public List GetElementLocations()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetPathObjectsByLayer(System.Int32)", + "display": "PdfDocument.GetPathObjectsByLayer(Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList GetPathObjectsByLayer(int ocgId)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetTextObjectsByLayer(System.Int32)", + "display": "PdfDocument.GetTextObjectsByLayer(Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList GetTextObjectsByLayer(int ocgId)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetTextObjectsByLayer(System.String)", + "display": "PdfDocument.GetTextObjectsByLayer(String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList GetTextObjectsByLayer(string layerName)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetVerifiedSignatures(System.Boolean)", + "display": "PdfDocument.GetVerifiedSignatures(Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public List GetVerifiedSignatures(bool detectIncrementalTampering = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.op_Implicit(IronSoftware.Abstractions.Pdf.DocumentId)~IronPdf.PdfDocument", + "display": "PdfDocument.Implicit(DocumentId to PdfDocument)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static implicit operator PdfDocument(DocumentId id)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.Layers", + "display": "PdfDocument.Layers", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfLayerCollection Layers { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToBytes(System.Byte[],System.String,IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToBytes(Byte[], String, LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] LinearizePdfToBytes(byte[] PdfBytes, string Password = \"\", LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToBytes(IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToBytes(LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] LinearizePdfToBytes(LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToBytes(System.IO.Stream,System.String,IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToBytes(Stream, String, LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] LinearizePdfToBytes(Stream PdfStream, string Password = \"\", LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToStream(System.Byte[],System.String,IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToStream(Byte[], String, LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Stream LinearizePdfToStream(byte[] PdfBytes, string Password = \"\", LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToStream(IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToStream(LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Stream LinearizePdfToStream(LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToStream(System.IO.Stream,System.String,IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToStream(Stream, String, LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Stream LinearizePdfToStream(Stream PdfStream, string Password = \"\", LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.#ctor(System.Collections.Generic.List{IronSoftware.Abstractions.Pdf.IBoundedPdfDocumentObject},System.Collections.Generic.List{System.Drawing.RectangleF})", + "display": "PdfDocument.PdfDocument(List, List)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument(List objects, List bounds)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.ResetElementLocationCache", + "display": "PdfDocument.ResetElementLocationCache()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void ResetElementLocationCache()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.SetFormFont(System.String,System.Byte[],System.Boolean)", + "display": "PdfDocument.SetFormFont(String, Byte[], Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void SetFormFont(string fontName, byte[] fontData = null, bool forceEmbed = false)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.SetFormFontFromFile(System.String,System.String,System.Boolean)", + "display": "PdfDocument.SetFormFontFromFile(String, String, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void SetFormFontFromFile(string fontFilePath, string fontName = null, bool forceEmbed = false)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.VerifyPdfSignatures(System.Boolean)", + "display": "PdfDocument.VerifyPdfSignatures(Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool VerifyPdfSignatures(bool detectIncrementalTampering = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.VerifyPdfSignaturesInFile(System.String,System.Boolean)", + "display": "PdfDocument.VerifyPdfSignaturesInFile(String, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static bool VerifyPdfSignaturesInFile(string PdfFilePath, bool detectIncrementalTampering = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.PdfDocument.CopyPage(System.Int32)", + "display": "PdfDocument.CopyPage(Int32)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument CopyPage(int PageIndex)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPages(System.Collections.Generic.IEnumerable{System.Int32})", + "display": "PdfDocument.CopyPages(IEnumerable)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument CopyPages(IEnumerable PageIndexes)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.CopyPages(System.Int32,System.Int32)", + "display": "PdfDocument.CopyPages(Int32, Int32)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument CopyPages(int StartIndex, int EndIndex)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetVerifiedSignatures", + "display": "PdfDocument.GetVerifiedSignatures()", + "severity": "BREAKING", + "target": "member", + "before": "public List GetVerifiedSignatures()", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.op_Implicit(IronSoftware.DocumentId)~IronPdf.PdfDocument", + "display": "PdfDocument.Implicit(DocumentId to PdfDocument)", + "severity": "BREAKING", + "target": "member", + "before": "public static implicit operator PdfDocument(DocumentId id)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.#ctor(System.Collections.Generic.List{IronSoftware.IBoundedDocumentObject},System.Collections.Generic.List{System.Drawing.RectangleF})", + "display": "PdfDocument.PdfDocument(List, List)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument(List objects, List bounds)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.VerifyPdfSignatures", + "display": "PdfDocument.VerifyPdfSignatures()", + "severity": "BREAKING", + "target": "member", + "before": "public bool VerifyPdfSignatures()", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.VerifyPdfSignaturesInFile(System.String)", + "display": "PdfDocument.VerifyPdfSignaturesInFile(String)", + "severity": "BREAKING", + "target": "member", + "before": "public static bool VerifyPdfSignaturesInFile(string PdfFilePath)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronPdf.PdfDocumentExtensions", + "added": [ + { + "uid": "IronPdf.PdfDocumentExtensions.ToDocument(IronSoftware.Abstractions.Pdf.IDocumentId,System.String,System.String)", + "display": "PdfDocumentExtensions.ToDocument(IDocumentId, String, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static PdfDocument ToDocument(this IDocumentId id, string Password = \"\", string OwnerPassword = \"\")", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.PdfDocumentExtensions.ToDocument(IronSoftware.IDocumentId,System.String,System.String)", + "display": "PdfDocumentExtensions.ToDocument(IDocumentId, String, String)", + "severity": "BREAKING", + "target": "member", + "before": "public static PdfDocument ToDocument(this IDocumentId id, string Password = \"\", string OwnerPassword = \"\")", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronPdf.RenderedElementLocation", + "added": [ + { + "uid": "IronPdf.RenderedElementLocation", + "display": "IronPdf.RenderedElementLocation", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class RenderedElementLocation : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.RtfConversionOptions", + "added": [ + { + "uid": "IronPdf.RtfConversionOptions", + "display": "IronPdf.RtfConversionOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class RtfConversionOptions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Signing.Inspection.SignatureStatus", + "added": [ + { + "uid": "IronPdf.Signing.Inspection.SignatureStatus", + "display": "IronPdf.Signing.Inspection.SignatureStatus", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class SignatureStatus : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Signing.Inspection.SignerCertificateInfo", + "added": [ + { + "uid": "IronPdf.Signing.Inspection.SignerCertificateInfo", + "display": "IronPdf.Signing.Inspection.SignerCertificateInfo", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class SignerCertificateInfo : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Signing.Inspection.VerifiedSignature", + "added": [ + { + "uid": "IronPdf.Signing.Inspection.VerifiedSignature.CertificateChain", + "display": "VerifiedSignature.CertificateChain", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList CertificateChain { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.Signing.Inspection.VerifiedSignature.SignerCertificate", + "display": "VerifiedSignature.SignerCertificate", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public SignerCertificateInfo SignerCertificate { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.Signing.Inspection.VerifiedSignature.Status", + "display": "VerifiedSignature.Status", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public SignatureStatus Status { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.Signing.Inspection.VerifiedSignature.Warnings", + "display": "VerifiedSignature.Warnings", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public List Warnings { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.CharObjectCollection", + "added": [ + { + "uid": "IronSoftware.CharObjectCollection.Add(IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.Add(IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void Add(IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Contains(IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.Contains(IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool Contains(IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.CopyTo(IronSoftware.Abstractions.Pdf.IDocumentCharacter[],System.Int32)", + "display": "CharObjectCollection.CopyTo(IDocumentCharacter[], Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void CopyTo(IDocumentCharacter[] array, int arrayIndex)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.IndexOf(IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.IndexOf(IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int IndexOf(IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Insert(System.Int32,IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.Insert(Int32, IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void Insert(int index, IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Remove(IronSoftware.Abstractions.Pdf.IDocumentCharacter)", + "display": "CharObjectCollection.Remove(IDocumentCharacter)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool Remove(IDocumentCharacter item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronSoftware.CharObjectCollection.Add(IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.Add(IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public void Add(IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Contains(IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.Contains(IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public bool Contains(IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.CopyTo(IronSoftware.IDocumentCharacter[],System.Int32)", + "display": "CharObjectCollection.CopyTo(IDocumentCharacter[], Int32)", + "severity": "BREAKING", + "target": "member", + "before": "public void CopyTo(IDocumentCharacter[] array, int arrayIndex)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.IndexOf(IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.IndexOf(IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public int IndexOf(IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Insert(System.Int32,IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.Insert(Int32, IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public void Insert(int index, IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronSoftware.CharObjectCollection.Remove(IronSoftware.IDocumentCharacter)", + "display": "CharObjectCollection.Remove(IDocumentCharacter)", + "severity": "BREAKING", + "target": "member", + "before": "public bool Remove(IDocumentCharacter item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronSoftware.Deployment.SmartDeploymentBase", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Deployment.SmartDeploymentBase", + "display": "IronSoftware.Deployment.SmartDeploymentBase", + "severity": "COSMETIC", + "target": "type", + "before": "public abstract class SmartDeploymentBase : Object, IDeployment, ICombinedDeployment", + "after": "public abstract class SmartDeploymentBase : Object, IDeployment", + "reasons": [ + "declaration interface list differs (no longer listed: ICombinedDeployment) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.FontObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.FontObject", + "display": "IronSoftware.FontObject", + "severity": "ADDITIVE", + "target": "type", + "before": "public class FontObject : Object, IPdfFontObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IJsonSerializable", + "after": "public class FontObject : Object, IPdfFontObject, IPdfDocumentObject", + "reasons": [ + "interface now implemented: IFont" + ] + } + ] + }, + { + "fqn": "IronSoftware.FormFieldCollection", + "added": [ + { + "uid": "IronSoftware.FormFieldCollection.DisableFormFontFallback", + "display": "FormFieldCollection.DisableFormFontFallback()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void DisableFormFontFallback()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.FormFieldCollection.SetFormFont(System.String,System.Byte[],System.Boolean)", + "display": "FormFieldCollection.SetFormFont(String, Byte[], Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void SetFormFont(string fontName, byte[] fontData, bool forceEmbed = false)", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.Forms.ICheckableFormField", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.ICheckableFormField", + "display": "IronSoftware.Forms.ICheckableFormField", + "severity": "COSMETIC", + "target": "type", + "before": "public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormField", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormField", + "display": "IronSoftware.Forms.IFormField", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldAnnotation", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldAnnotation", + "display": "IronSoftware.Forms.IFormFieldAnnotation", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldAnnotationObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldAnnotationObject", + "display": "IronSoftware.Forms.IFormFieldAnnotationObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormFieldAnnotationObject : IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldAnnotationObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldCollection", + "display": "IronSoftware.Forms.IFormFieldCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormFieldCollection : IList, ICollection, IEnumerable, IEnumerable", + "after": "public interface IFormFieldCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IList, ICollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldObject", + "display": "IronSoftware.Forms.IFormFieldObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormFieldObject : IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfDocumentObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfDocumentObject", + "display": "IronSoftware.IPdfDocumentObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfDocumentObject : IDocumentObject", + "after": "public interface IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfFontObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfFontObject", + "display": "IronSoftware.IPdfFontObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfFontObject : IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IJsonSerializable", + "after": "public interface IPdfFontObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject, IDocumentFontObject, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfFontObjectCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfFontObjectCollection", + "display": "IronSoftware.IPdfFontObjectCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfFontObjectCollection : IDocumentFontObjectCollection, IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IEnumerable, IJsonSerializable", + "after": "public interface IPdfFontObjectCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentFontObjectCollection, IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IEnumerable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfImageObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfImageObject", + "display": "IronSoftware.IPdfImageObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfImageObject : IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable", + "after": "public interface IPdfImageObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfImageObjectCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfImageObjectCollection", + "display": "IronSoftware.IPdfImageObjectCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfImageObjectCollection : IDocumentImageObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable", + "after": "public interface IPdfImageObjectCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentImageObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfPathObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfPathObject", + "display": "IronSoftware.IPdfPathObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPathObject : IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable", + "after": "public interface IPdfPathObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfPathObjectCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfPathObjectCollection", + "display": "IronSoftware.IPdfPathObjectCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPathObjectCollection : IDocumentPathObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable", + "after": "public interface IPdfPathObjectCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPathObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfTextObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfTextObject", + "display": "IronSoftware.IPdfTextObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfTextObject : IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "after": "public interface IPdfTextObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfTextObjectCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfTextObjectCollection", + "display": "IronSoftware.IPdfTextObjectCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfTextObjectCollection : IDocumentTextObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable", + "after": "public interface IPdfTextObjectCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentTextObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.ImageObject", + "added": [ + { + "uid": "IronSoftware.ImageObject.ZOrder", + "display": "ImageObject.ZOrder", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public RelativeZOrder ZOrder { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.ImageObject.ZPosition", + "display": "ImageObject.ZPosition", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public long ZPosition { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.ImageObject", + "display": "IronSoftware.ImageObject", + "severity": "BREAKING", + "target": "type", + "before": "public class ImageObject : Object, IPdfImageObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable", + "after": "public class ImageObject : Object, IPdfImageObject, IPdfDocumentObject", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "IronSoftware.LineCaps", + "added": [ + { + "uid": "IronSoftware.LineCaps", + "display": "IronSoftware.LineCaps", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class LineCaps : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.LineJoins", + "added": [ + { + "uid": "IronSoftware.LineJoins", + "display": "IronSoftware.LineJoins", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class LineJoins : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.PathObject", + "added": [ + { + "uid": "IronSoftware.PathObject.DashPattern", + "display": "PathObject.DashPattern", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList DashPattern { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.DashPhase", + "display": "PathObject.DashPhase", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public float DashPhase { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.GetLayer", + "display": "PathObject.GetLayer()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfLayer GetLayer()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.LineCap", + "display": "PathObject.LineCap", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public LineCaps LineCap { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.LineJoin", + "display": "PathObject.LineJoin", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public LineJoins LineJoin { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.OcgId", + "display": "PathObject.OcgId", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int OcgId { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.StrokeWidth", + "display": "PathObject.StrokeWidth", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public float StrokeWidth { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.ZPosition", + "display": "PathObject.ZPosition", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public long ZPosition { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.PathObject", + "display": "IronSoftware.PathObject", + "severity": "BREAKING", + "target": "type", + "before": "public class PathObject : Object, IPdfPathObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable", + "after": "public class PathObject : Object, IPdfPathObject, IPdfDocumentObject", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject" + ] + }, + { + "uid": "IronSoftware.PathObject.Points", + "display": "PathObject.Points", + "severity": "BREAKING", + "target": "member", + "before": "public IReadOnlyCollection Points { get; set; }", + "after": "public IReadOnlyCollection Points { get; set; }", + "reasons": [ + "type changed: IReadOnlyCollection -> IReadOnlyCollection" + ] + }, + { + "uid": "IronSoftware.PathObject.ZOrder", + "display": "PathObject.ZOrder", + "severity": "BREAKING", + "target": "member", + "before": "public LayoutZOrders ZOrder { get; set; }", + "after": "public RelativeZOrder ZOrder { get; set; }", + "reasons": [ + "type changed: LayoutZOrders -> RelativeZOrder" + ] + }, + { + "uid": "IronSoftware.PathObject._Points", + "display": "PathObject._Points", + "severity": "BREAKING", + "target": "member", + "before": "protected IReadOnlyCollection _Points", + "after": "protected IReadOnlyCollection _Points", + "reasons": [ + "type changed: IReadOnlyCollection -> IReadOnlyCollection" + ] + } + ] + }, + { + "fqn": "IronSoftware.PathSegment", + "added": [ + { + "uid": "IronSoftware.PathSegment.SeparateFromPrevious", + "display": "PathSegment.SeparateFromPrevious", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool SeparateFromPrevious { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.PathSegment", + "display": "IronSoftware.PathSegment", + "severity": "ADDITIVE", + "target": "type", + "before": "public class PathSegment : Object, IPathSegment", + "after": "public class PathSegment : Object", + "reasons": [ + "interface now implemented: IPdfPathSegment" + ] + } + ] + }, + { + "fqn": "IronSoftware.PdfLayer", + "added": [ + { + "uid": "IronSoftware.PdfLayer", + "display": "IronSoftware.PdfLayer", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PdfLayer : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.PdfLayerCollection", + "added": [ + { + "uid": "IronSoftware.PdfLayerCollection", + "display": "IronSoftware.PdfLayerCollection", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PdfLayerCollection : ReadOnlyCollection", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.TextObject", + "added": [ + { + "uid": "IronSoftware.TextObject.GetLayer", + "display": "TextObject.GetLayer()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfLayer GetLayer()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.TextObject.OcgId", + "display": "TextObject.OcgId", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int OcgId { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.TextObject.ZOrder", + "display": "TextObject.ZOrder", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public RelativeZOrder ZOrder { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.TextObject.ZPosition", + "display": "TextObject.ZPosition", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public long ZPosition { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.TextObject", + "display": "IronSoftware.TextObject", + "severity": "BREAKING", + "target": "type", + "before": "public class TextObject : Object, IPdfTextObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "after": "public class TextObject : Object, IPdfTextObject, IPdfDocumentObject", + "reasons": [ + "interface no longer implemented: IBoundedDocumentObject", + "interface now implemented: IBoundedPdfDocumentObject" + ] + } + ] + }, + { + "fqn": "UglyToad.PdfPig.Core.PdfPoint", + "added": [ + { + "uid": "UglyToad.PdfPig.Core.PdfPoint", + "display": "UglyToad.PdfPig.Core.PdfPoint", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "UglyToad.PdfPig.Core.PdfPoint", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "UglyToad.PdfPig.Core.PdfRectangle", + "added": [ + { + "uid": "UglyToad.PdfPig.Core.PdfRectangle", + "display": "UglyToad.PdfPig.Core.PdfRectangle", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "UglyToad.PdfPig.Core.PdfRectangle", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [ + "2025.12.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)", + "2026.7.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)" + ] +} diff --git a/docs/api-diffs/ironpdf/2025.12.2..2026.7.2.md b/docs/api-diffs/ironpdf/2025.12.2..2026.7.2.md new file mode 100644 index 000000000..f83ba3276 --- /dev/null +++ b/docs/api-diffs/ironpdf/2025.12.2..2026.7.2.md @@ -0,0 +1,765 @@ +# IronPDF API changes: 2025.12.2 -> 2026.7.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **25 breaking**, 127 additive, 18 cosmetic. + +## Breaking changes (25) + +### `IronPdf.ChromePdfRenderer` + +- **ChromePdfRenderer.RenderRtfFileAsPdf(String)** removed + - `public PdfDocument RenderRtfFileAsPdf(string FilePath)` + - member removed + - overload signature change (see the matching addition) +- **ChromePdfRenderer.RenderRtfStringAsPdf(String)** removed + - `public PdfDocument RenderRtfStringAsPdf(string RtfString)` + - member removed + - overload signature change (see the matching addition) +### `IronPdf.Extensions.ConversionExtensions` + +- **ConversionExtensions.ToPdf(List, List)** removed + - `public static PdfDocument ToPdf(this List objects, List bounds)` + - member removed + - overload signature change (see the matching addition) +### `IronPdf.Pages.LineTextObject` + +- **IronPdf.Pages.LineTextObject** changed + - was: `public class LineTextObject : TextObject, IPdfTextObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - now: `public class LineTextObject : TextObject, IPdfTextObject, IPdfDocumentObject` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject +### `IronPdf.PdfDocument` + +- **PdfDocument.CopyPage(Int32)** removed + - `public PdfDocument CopyPage(int PageIndex)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.CopyPages(IEnumerable)** removed + - `public PdfDocument CopyPages(IEnumerable PageIndexes)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.CopyPages(Int32, Int32)** removed + - `public PdfDocument CopyPages(int StartIndex, int EndIndex)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.GetVerifiedSignatures()** removed + - `public List GetVerifiedSignatures()` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.Implicit(DocumentId to PdfDocument)** removed + - `public static implicit operator PdfDocument(DocumentId id)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.PdfDocument(List, List)** removed + - `public PdfDocument(List objects, List bounds)` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.VerifyPdfSignatures()** removed + - `public bool VerifyPdfSignatures()` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.VerifyPdfSignaturesInFile(String)** removed + - `public static bool VerifyPdfSignaturesInFile(string PdfFilePath)` + - member removed + - overload signature change (see the matching addition) +### `IronPdf.PdfDocumentExtensions` + +- **PdfDocumentExtensions.ToDocument(IDocumentId, String, String)** removed + - `public static PdfDocument ToDocument(this IDocumentId id, string Password = "", string OwnerPassword = "")` + - member removed + - overload signature change (see the matching addition) +### `IronSoftware.CharObjectCollection` + +- **CharObjectCollection.Add(IDocumentCharacter)** removed + - `public void Add(IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.Contains(IDocumentCharacter)** removed + - `public bool Contains(IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.CopyTo(IDocumentCharacter[], Int32)** removed + - `public void CopyTo(IDocumentCharacter[] array, int arrayIndex)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.IndexOf(IDocumentCharacter)** removed + - `public int IndexOf(IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.Insert(Int32, IDocumentCharacter)** removed + - `public void Insert(int index, IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +- **CharObjectCollection.Remove(IDocumentCharacter)** removed + - `public bool Remove(IDocumentCharacter item)` + - member removed + - overload signature change (see the matching addition) +### `IronSoftware.ImageObject` + +- **IronSoftware.ImageObject** changed + - was: `public class ImageObject : Object, IPdfImageObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable` + - now: `public class ImageObject : Object, IPdfImageObject, IPdfDocumentObject` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject +### `IronSoftware.PathObject` + +- **IronSoftware.PathObject** changed + - was: `public class PathObject : Object, IPdfPathObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable` + - now: `public class PathObject : Object, IPdfPathObject, IPdfDocumentObject` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject +- **PathObject.Points** changed + - was: `public IReadOnlyCollection Points { get; set; }` + - now: `public IReadOnlyCollection Points { get; set; }` + - type changed: IReadOnlyCollection -> IReadOnlyCollection +- **PathObject.ZOrder** changed + - was: `public LayoutZOrders ZOrder { get; set; }` + - now: `public RelativeZOrder ZOrder { get; set; }` + - type changed: LayoutZOrders -> RelativeZOrder +- **PathObject._Points** changed + - was: `protected IReadOnlyCollection _Points` + - now: `protected IReadOnlyCollection _Points` + - type changed: IReadOnlyCollection -> IReadOnlyCollection +### `IronSoftware.TextObject` + +- **IronSoftware.TextObject** changed + - was: `public class TextObject : Object, IPdfTextObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - now: `public class TextObject : Object, IPdfTextObject, IPdfDocumentObject` + - interface no longer implemented: IBoundedDocumentObject + - interface now implemented: IBoundedPdfDocumentObject + +## Additions (127) + +### Namespaces + +- **IronPdf.Extractions** added + - `IronPdf.Extractions` + - namespace added +- **UglyToad.PdfPig.Core** added + - `UglyToad.PdfPig.Core` + - namespace added +### `IronPdf.AdvancedCompressionOptions` + +- **IronPdf.AdvancedCompressionOptions** added + - `public class AdvancedCompressionOptions : Object` + - type added +### `IronPdf.Annotations.LinkAnnotation` + +- **IronPdf.Annotations.LinkAnnotation** added + - `public class LinkAnnotation : PdfClientAccessor, IAnnotation` + - type added +### `IronPdf.BrowserPoolOptions` + +- **IronPdf.BrowserPoolOptions** added + - `public class BrowserPoolOptions : Object` + - type added +### `IronPdf.ChromePdfRenderOptions` + +- **ChromePdfRenderOptions.AutoBookmarkCssSelectors** added + - `public string[] AutoBookmarkCssSelectors { get; set; }` + - member added +- **ChromePdfRenderOptions.AutoBookmarkMaxHeadingLevel** added + - `public int AutoBookmarkMaxHeadingLevel { get; set; }` + - member added +- **ChromePdfRenderOptions.AutoBookmarkMinHeadingLevel** added + - `public int AutoBookmarkMinHeadingLevel { get; set; }` + - member added +- **ChromePdfRenderOptions.AutoBookmarksFromHeadings** added + - `public bool AutoBookmarksFromHeadings { get; set; }` + - member added +- **ChromePdfRenderOptions.BrowserPool** added + - `public BrowserPoolOptions BrowserPool { get; }` + - member added +- **ChromePdfRenderOptions.CssPageRulePolicy** added + - `public CssPageRulePolicy CssPageRulePolicy { get; set; }` + - member added +- **ChromePdfRenderOptions.CustomHyphenation** added + - `public CustomHyphenationDefinitions CustomHyphenation { get; set; }` + - member added +- **ChromePdfRenderOptions.ElementQuerySelectors** added + - `public string[] ElementQuerySelectors { get; set; }` + - member added +- **ChromePdfRenderOptions.HeaderFooterOverlapBehavior** added + - `public ContentOverlapBehavior HeaderFooterOverlapBehavior { get; set; }` + - member added +- **ChromePdfRenderOptions.MaxDynamicHFPagesPerBatch** added + - `public int MaxDynamicHFPagesPerBatch { get; set; }` + - member added +### `IronPdf.ChromePdfRenderer` + +- **ChromePdfRenderer.RenderRtfFileAsPdf(String, RtfConversionOptions)** added + - `public PdfDocument RenderRtfFileAsPdf(string FilePath, RtfConversionOptions options = null)` + - member added + - overload signature change (see the matching removal) +- **ChromePdfRenderer.RenderRtfStringAsPdf(String, RtfConversionOptions)** added + - `public PdfDocument RenderRtfStringAsPdf(string RtfString, RtfConversionOptions options = null)` + - member added + - overload signature change (see the matching removal) +### `IronPdf.CompressionMode` + +- **IronPdf.CompressionMode** added + - `public sealed class CompressionMode : Enum` + - type added +### `IronPdf.ContentOverlapBehavior` + +- **IronPdf.ContentOverlapBehavior** added + - `public sealed class ContentOverlapBehavior : Enum` + - type added +### `IronPdf.CssPageRulePolicy` + +- **IronPdf.CssPageRulePolicy** added + - `public sealed class CssPageRulePolicy : Enum` + - type added +### `IronPdf.CustomHyphenationDefinitions` + +- **IronPdf.CustomHyphenationDefinitions** added + - `public class CustomHyphenationDefinitions : Object` + - type added +### `IronPdf.Extensions.ConversionExtensions` + +- **ConversionExtensions.ToPdf(List, List)** added + - `public static PdfDocument ToPdf(this List objects, List bounds)` + - member added + - overload signature change (see the matching removal) +### `IronPdf.Extractions.CsvExportOptions` + +- **IronPdf.Extractions.CsvExportOptions** added + - `public class CsvExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Extractions.DocumentMetadata` + +- **IronPdf.Extractions.DocumentMetadata** added + - `public class DocumentMetadata : Object` + - type added +### `IronPdf.Extractions.ExportConfiguration` + +- **IronPdf.Extractions.ExportConfiguration** added + - `public class ExportConfiguration : Object` + - type added +### `IronPdf.Extractions.ExportFormat` + +- **IronPdf.Extractions.ExportFormat** added + - `public sealed class ExportFormat : Enum` + - type added +### `IronPdf.Extractions.ExportManager` + +- **IronPdf.Extractions.ExportManager** added + - `public static class ExportManager : Object` + - type added +### `IronPdf.Extractions.ExportOptionsBase` + +- **IronPdf.Extractions.ExportOptionsBase** added + - `public class ExportOptionsBase : Object` + - type added +### `IronPdf.Extractions.ExtractionProgress` + +- **IronPdf.Extractions.ExtractionProgress** added + - `public class ExtractionProgress : Object` + - type added +### `IronPdf.Extractions.HtmlExportOptions` + +- **IronPdf.Extractions.HtmlExportOptions** added + - `public class HtmlExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Extractions.JsonExportOptions` + +- **IronPdf.Extractions.JsonExportOptions** added + - `public class JsonExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Extractions.PageMetadata` + +- **IronPdf.Extractions.PageMetadata** added + - `public class PageMetadata : Object` + - type added +### `IronPdf.Extractions.PageText` + +- **IronPdf.Extractions.PageText** added + - `public class PageText : Object` + - type added +### `IronPdf.Extractions.PdfExtractionOptions` + +- **IronPdf.Extractions.PdfExtractionOptions** added + - `public class PdfExtractionOptions : Object` + - type added +### `IronPdf.Extractions.PdfExtractionResult` + +- **IronPdf.Extractions.PdfExtractionResult** added + - `public class PdfExtractionResult : Object` + - type added +### `IronPdf.Extractions.PdfExtractor` + +- **IronPdf.Extractions.PdfExtractor** added + - `public static class PdfExtractor : Object` + - type added +### `IronPdf.Extractions.SpanHandlingMode` + +- **IronPdf.Extractions.SpanHandlingMode** added + - `public sealed class SpanHandlingMode : Enum` + - type added +### `IronPdf.Extractions.TableCell` + +- **IronPdf.Extractions.TableCell** added + - `public class TableCell : Object` + - type added +### `IronPdf.Extractions.TableDetectionStrategy` + +- **IronPdf.Extractions.TableDetectionStrategy** added + - `public sealed class TableDetectionStrategy : Enum` + - type added +### `IronPdf.Extractions.TableObject` + +- **IronPdf.Extractions.TableObject** added + - `public class TableObject : Object` + - type added +### `IronPdf.Extractions.TableRow` + +- **IronPdf.Extractions.TableRow** added + - `public class TableRow : Object` + - type added +### `IronPdf.Extractions.TextContent` + +- **IronPdf.Extractions.TextContent** added + - `public class TextContent : Object` + - type added +### `IronPdf.Extractions.TextExtractionMode` + +- **IronPdf.Extractions.TextExtractionMode** added + - `public sealed class TextExtractionMode : Enum` + - type added +### `IronPdf.Extractions.TxtExportOptions` + +- **IronPdf.Extractions.TxtExportOptions** added + - `public class TxtExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Extractions.XmlExportOptions` + +- **IronPdf.Extractions.XmlExportOptions** added + - `public class XmlExportOptions : ExportOptionsBase` + - type added +### `IronPdf.Fonts.PdfFont` + +- **IronPdf.Fonts.PdfFont** changed + - was: `public class PdfFont : Object, IDocumentFontObject, IDocumentObject` + - now: `public class PdfFont : Object` + - interface now implemented: IFont, IPdfDocumentObject +### `IronPdf.Installation` + +- **Installation.JobQueueWatchdogTimeout** added + - `public static TimeSpan JobQueueWatchdogTimeout { get; set; }` + - member added +### `IronPdf.LinearizationMode` + +- **IronPdf.LinearizationMode** added + - `public sealed class LinearizationMode : Enum` + - type added +### `IronPdf.ObjectStreamMode` + +- **IronPdf.ObjectStreamMode** added + - `public sealed class ObjectStreamMode : Enum` + - type added +### `IronPdf.PdfDocument` + +- **PdfDocument.AddHtmlFooters(HtmlHeaderFooter, ContentOverlapBehavior, Int32, IEnumerable)** added + - `public PdfDocument AddHtmlFooters(HtmlHeaderFooter Footer, ContentOverlapBehavior OverlapBehavior, int FirstPageNumber = 1, IEnumerable PageIndexesToAddFootersTo = null)` + - member added +- **PdfDocument.AddHtmlHeaders(HtmlHeaderFooter, ContentOverlapBehavior, Int32, IEnumerable)** added + - `public PdfDocument AddHtmlHeaders(HtmlHeaderFooter Header, ContentOverlapBehavior OverlapBehavior, int FirstPageNumber = 1, IEnumerable PageIndexesToAddHeadersTo = null)` + - member added +- **PdfDocument.CompressAndSaveAs(Byte[], String, AdvancedCompressionOptions, String)** added + - `public static void CompressAndSaveAs(byte[] PdfBytes, string OutputPath, AdvancedCompressionOptions Options, string Password = "")` + - member added +- **PdfDocument.CompressAndSaveAs(Stream, String, AdvancedCompressionOptions, String)** added + - `public static void CompressAndSaveAs(Stream Stream, string OutputPath, AdvancedCompressionOptions Options, string Password = "")` + - member added +- **PdfDocument.CompressAndSaveAs(String, AdvancedCompressionOptions)** added + - `public void CompressAndSaveAs(string OutputPath, AdvancedCompressionOptions Options)` + - member added +- **PdfDocument.CompressPdfToBytes(Byte[], Nullable, String, Boolean, CompressionMode)** added + - `public static byte[] CompressPdfToBytes(byte[] PdfBytes, Nullable JpegQuality = null, string Password = "", bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToBytes(Nullable, Boolean, CompressionMode)** added + - `public byte[] CompressPdfToBytes(Nullable JpegQuality = null, bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToBytes(Stream, Nullable, String, Boolean, CompressionMode)** added + - `public static byte[] CompressPdfToBytes(Stream PdfStream, Nullable JpegQuality = null, string Password = "", bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToStream(Byte[], Nullable, String, Boolean, CompressionMode)** added + - `public static Stream CompressPdfToStream(byte[] PdfBytes, Nullable JpegQuality = null, string Password = "", bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToStream(Nullable, Boolean, CompressionMode)** added + - `public Stream CompressPdfToStream(Nullable JpegQuality = null, bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToStream(Stream, Nullable, String, Boolean, CompressionMode)** added + - `public static Stream CompressPdfToStream(Stream PdfStream, Nullable JpegQuality = null, string Password = "", bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CopyPage(Int32, Boolean)** added + - `public PdfDocument CopyPage(int pageIndex, bool copyBookmarks = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.CopyPages(IEnumerable, Boolean)** added + - `public PdfDocument CopyPages(IEnumerable pageIndexes, bool copyBookmarks = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.CopyPages(Int32, Int32, Boolean)** added + - `public PdfDocument CopyPages(int startIndex, int endIndex, bool copyBookmarks = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.DisableFormFontFallback()** added + - `public void DisableFormFontFallback()` + - member added +- **PdfDocument.ExtractTextFromLayer(Int32)** added + - `public string ExtractTextFromLayer(int ocgId)` + - member added +- **PdfDocument.ExtractTextFromLayer(String)** added + - `public string ExtractTextFromLayer(string layerName)` + - member added +- **PdfDocument.ExtractTextFromLayers(IEnumerable)** added + - `public string ExtractTextFromLayers(IEnumerable ocgIds)` + - member added +- **PdfDocument.ExtractTextFromLayers(IEnumerable)** added + - `public string ExtractTextFromLayers(IEnumerable layerNames)` + - member added +- **PdfDocument.GetElementLocations()** added + - `public List GetElementLocations()` + - member added +- **PdfDocument.GetPathObjectsByLayer(Int32)** added + - `public IReadOnlyList GetPathObjectsByLayer(int ocgId)` + - member added +- **PdfDocument.GetTextObjectsByLayer(Int32)** added + - `public IReadOnlyList GetTextObjectsByLayer(int ocgId)` + - member added +- **PdfDocument.GetTextObjectsByLayer(String)** added + - `public IReadOnlyList GetTextObjectsByLayer(string layerName)` + - member added +- **PdfDocument.GetVerifiedSignatures(Boolean)** added + - `public List GetVerifiedSignatures(bool detectIncrementalTampering = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.Implicit(DocumentId to PdfDocument)** added + - `public static implicit operator PdfDocument(DocumentId id)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.Layers** added + - `public PdfLayerCollection Layers { get; }` + - member added +- **PdfDocument.LinearizePdfToBytes(Byte[], String, LinearizationMode)** added + - `public static byte[] LinearizePdfToBytes(byte[] PdfBytes, string Password = "", LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToBytes(LinearizationMode)** added + - `public byte[] LinearizePdfToBytes(LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToBytes(Stream, String, LinearizationMode)** added + - `public static byte[] LinearizePdfToBytes(Stream PdfStream, string Password = "", LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToStream(Byte[], String, LinearizationMode)** added + - `public static Stream LinearizePdfToStream(byte[] PdfBytes, string Password = "", LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToStream(LinearizationMode)** added + - `public Stream LinearizePdfToStream(LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToStream(Stream, String, LinearizationMode)** added + - `public static Stream LinearizePdfToStream(Stream PdfStream, string Password = "", LinearizationMode mode)` + - member added +- **PdfDocument.PdfDocument(List, List)** added + - `public PdfDocument(List objects, List bounds)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.ResetElementLocationCache()** added + - `public void ResetElementLocationCache()` + - member added +- **PdfDocument.SetFormFont(String, Byte[], Boolean)** added + - `public void SetFormFont(string fontName, byte[] fontData = null, bool forceEmbed = false)` + - member added +- **PdfDocument.SetFormFontFromFile(String, String, Boolean)** added + - `public void SetFormFontFromFile(string fontFilePath, string fontName = null, bool forceEmbed = false)` + - member added +- **PdfDocument.VerifyPdfSignatures(Boolean)** added + - `public bool VerifyPdfSignatures(bool detectIncrementalTampering = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.VerifyPdfSignaturesInFile(String, Boolean)** added + - `public static bool VerifyPdfSignaturesInFile(string PdfFilePath, bool detectIncrementalTampering = false)` + - member added + - overload signature change (see the matching removal) +### `IronPdf.PdfDocumentExtensions` + +- **PdfDocumentExtensions.ToDocument(IDocumentId, String, String)** added + - `public static PdfDocument ToDocument(this IDocumentId id, string Password = "", string OwnerPassword = "")` + - member added + - overload signature change (see the matching removal) +### `IronPdf.RenderedElementLocation` + +- **IronPdf.RenderedElementLocation** added + - `public class RenderedElementLocation : Object` + - type added +### `IronPdf.RtfConversionOptions` + +- **IronPdf.RtfConversionOptions** added + - `public class RtfConversionOptions : Object` + - type added +### `IronPdf.Signing.Inspection.SignatureStatus` + +- **IronPdf.Signing.Inspection.SignatureStatus** added + - `public sealed class SignatureStatus : Enum` + - type added +### `IronPdf.Signing.Inspection.SignerCertificateInfo` + +- **IronPdf.Signing.Inspection.SignerCertificateInfo** added + - `public class SignerCertificateInfo : Object` + - type added +### `IronPdf.Signing.Inspection.VerifiedSignature` + +- **VerifiedSignature.CertificateChain** added + - `public IReadOnlyList CertificateChain { get; }` + - member added +- **VerifiedSignature.SignerCertificate** added + - `public SignerCertificateInfo SignerCertificate { get; }` + - member added +- **VerifiedSignature.Status** added + - `public SignatureStatus Status { get; }` + - member added +- **VerifiedSignature.Warnings** added + - `public List Warnings { get; }` + - member added +### `IronSoftware.CharObjectCollection` + +- **CharObjectCollection.Add(IDocumentCharacter)** added + - `public void Add(IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.Contains(IDocumentCharacter)** added + - `public bool Contains(IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.CopyTo(IDocumentCharacter[], Int32)** added + - `public void CopyTo(IDocumentCharacter[] array, int arrayIndex)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.IndexOf(IDocumentCharacter)** added + - `public int IndexOf(IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.Insert(Int32, IDocumentCharacter)** added + - `public void Insert(int index, IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +- **CharObjectCollection.Remove(IDocumentCharacter)** added + - `public bool Remove(IDocumentCharacter item)` + - member added + - overload signature change (see the matching removal) +### `IronSoftware.FontObject` + +- **IronSoftware.FontObject** changed + - was: `public class FontObject : Object, IPdfFontObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IJsonSerializable` + - now: `public class FontObject : Object, IPdfFontObject, IPdfDocumentObject` + - interface now implemented: IFont +### `IronSoftware.FormFieldCollection` + +- **FormFieldCollection.DisableFormFontFallback()** added + - `public void DisableFormFontFallback()` + - member added +- **FormFieldCollection.SetFormFont(String, Byte[], Boolean)** added + - `public void SetFormFont(string fontName, byte[] fontData, bool forceEmbed = false)` + - member added +### `IronSoftware.ImageObject` + +- **ImageObject.ZOrder** added + - `public RelativeZOrder ZOrder { get; set; }` + - member added +- **ImageObject.ZPosition** added + - `public long ZPosition { get; set; }` + - member added +### `IronSoftware.LineCaps` + +- **IronSoftware.LineCaps** added + - `public sealed class LineCaps : Enum` + - type added +### `IronSoftware.LineJoins` + +- **IronSoftware.LineJoins** added + - `public sealed class LineJoins : Enum` + - type added +### `IronSoftware.PathObject` + +- **PathObject.DashPattern** added + - `public IReadOnlyList DashPattern { get; set; }` + - member added +- **PathObject.DashPhase** added + - `public float DashPhase { get; set; }` + - member added +- **PathObject.GetLayer()** added + - `public PdfLayer GetLayer()` + - member added +- **PathObject.LineCap** added + - `public LineCaps LineCap { get; set; }` + - member added +- **PathObject.LineJoin** added + - `public LineJoins LineJoin { get; set; }` + - member added +- **PathObject.OcgId** added + - `public int OcgId { get; }` + - member added +- **PathObject.StrokeWidth** added + - `public float StrokeWidth { get; set; }` + - member added +- **PathObject.ZPosition** added + - `public long ZPosition { get; set; }` + - member added +### `IronSoftware.PathSegment` + +- **IronSoftware.PathSegment** changed + - was: `public class PathSegment : Object, IPathSegment` + - now: `public class PathSegment : Object` + - interface now implemented: IPdfPathSegment +- **PathSegment.SeparateFromPrevious** added + - `public bool SeparateFromPrevious { get; set; }` + - member added +### `IronSoftware.PdfLayer` + +- **IronSoftware.PdfLayer** added + - `public class PdfLayer : Object` + - type added +### `IronSoftware.PdfLayerCollection` + +- **IronSoftware.PdfLayerCollection** added + - `public class PdfLayerCollection : ReadOnlyCollection` + - type added +### `IronSoftware.TextObject` + +- **TextObject.GetLayer()** added + - `public PdfLayer GetLayer()` + - member added +- **TextObject.OcgId** added + - `public int OcgId { get; }` + - member added +- **TextObject.ZOrder** added + - `public RelativeZOrder ZOrder { get; set; }` + - member added +- **TextObject.ZPosition** added + - `public long ZPosition { get; set; }` + - member added +### `UglyToad.PdfPig.Core.PdfPoint` + +- **UglyToad.PdfPig.Core.PdfPoint** added + - `UglyToad.PdfPig.Core.PdfPoint` + - type added +### `UglyToad.PdfPig.Core.PdfRectangle` + +- **UglyToad.PdfPig.Core.PdfRectangle** added + - `UglyToad.PdfPig.Core.PdfRectangle` + - type added + +## Cosmetic (18) + +### `IronPdf.Pages.IPdfPage` + +- **IronPdf.Pages.IPdfPage** changed + - was: `public interface IPdfPage : IDocumentPage, IPageContainer` + - now: `public interface IPdfPage` + - declaration interface list differs (no longer listed: IDocumentPage, IPageContainer) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronPdf.Pages.IPdfPageCollection` + +- **IronPdf.Pages.IPdfPageCollection** changed + - was: `public interface IPdfPageCollection : IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable` + - now: `public interface IPdfPageCollection` + - declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Deployment.SmartDeploymentBase` + +- **IronSoftware.Deployment.SmartDeploymentBase** changed + - was: `public abstract class SmartDeploymentBase : Object, IDeployment, ICombinedDeployment` + - now: `public abstract class SmartDeploymentBase : Object, IDeployment` + - declaration interface list differs (no longer listed: ICombinedDeployment) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.ICheckableFormField` + +- **IronSoftware.Forms.ICheckableFormField** changed + - was: `public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormField` + +- **IronSoftware.Forms.IFormField** changed + - was: `public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormFieldAnnotation` + +- **IronSoftware.Forms.IFormFieldAnnotation** changed + - was: `public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormFieldAnnotationObject` + +- **IronSoftware.Forms.IFormFieldAnnotationObject** changed + - was: `public interface IFormFieldAnnotationObject : IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldAnnotationObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormFieldCollection` + +- **IronSoftware.Forms.IFormFieldCollection** changed + - was: `public interface IFormFieldCollection : IList, ICollection, IEnumerable, IEnumerable` + - now: `public interface IFormFieldCollection` + - declaration interface list differs (no longer listed: IList, ICollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormFieldObject` + +- **IronSoftware.Forms.IFormFieldObject** changed + - was: `public interface IFormFieldObject : IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfDocumentObject` + +- **IronSoftware.IPdfDocumentObject** changed + - was: `public interface IPdfDocumentObject : IDocumentObject` + - now: `public interface IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfFontObject` + +- **IronSoftware.IPdfFontObject** changed + - was: `public interface IPdfFontObject : IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IJsonSerializable` + - now: `public interface IPdfFontObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject, IDocumentFontObject, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfFontObjectCollection` + +- **IronSoftware.IPdfFontObjectCollection** changed + - was: `public interface IPdfFontObjectCollection : IDocumentFontObjectCollection, IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IEnumerable, IJsonSerializable` + - now: `public interface IPdfFontObjectCollection` + - declaration interface list differs (no longer listed: IDocumentFontObjectCollection, IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IEnumerable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfImageObject` + +- **IronSoftware.IPdfImageObject** changed + - was: `public interface IPdfImageObject : IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable` + - now: `public interface IPdfImageObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject, IDocumentImageObject, IBoundedDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfImageObjectCollection` + +- **IronSoftware.IPdfImageObjectCollection** changed + - was: `public interface IPdfImageObjectCollection : IDocumentImageObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable` + - now: `public interface IPdfImageObjectCollection` + - declaration interface list differs (no longer listed: IDocumentImageObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfPathObject` + +- **IronSoftware.IPdfPathObject** changed + - was: `public interface IPdfPathObject : IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable` + - now: `public interface IPdfPathObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject, IDocumentPathObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfPathObjectCollection` + +- **IronSoftware.IPdfPathObjectCollection** changed + - was: `public interface IPdfPathObjectCollection : IDocumentPathObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable` + - now: `public interface IPdfPathObjectCollection` + - declaration interface list differs (no longer listed: IDocumentPathObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfTextObject` + +- **IronSoftware.IPdfTextObject** changed + - was: `public interface IPdfTextObject : IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - now: `public interface IPdfTextObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject, IDocumentTextObject, IBoundedDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfTextObjectCollection` + +- **IronSoftware.IPdfTextObjectCollection** changed + - was: `public interface IPdfTextObjectCollection : IDocumentTextObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable` + - now: `public interface IPdfTextObjectCollection` + - declaration interface list differs (no longer listed: IDocumentTextObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions + +## Warnings (2) + +- 2025.12.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) +- 2026.7.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) diff --git a/docs/api-diffs/ironpdf/2026.1.3..2026.2.1.json b/docs/api-diffs/ironpdf/2026.1.3..2026.2.1.json new file mode 100644 index 000000000..621bdc35f --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.1.3..2026.2.1.json @@ -0,0 +1,25 @@ +{ + "product": "ironpdf", + "productName": "IronPDF", + "from": "2026.1.3", + "to": "2026.2.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 223, + "typesTo": 223 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [ + "2026.1.3: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)", + "2026.2.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)" + ] +} diff --git a/docs/api-diffs/ironpdf/2026.1.3..2026.2.1.md b/docs/api-diffs/ironpdf/2026.1.3..2026.2.1.md new file mode 100644 index 000000000..4ae7556a9 --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.1.3..2026.2.1.md @@ -0,0 +1,5 @@ +# IronPDF API changes: 2026.1.3 -> 2026.2.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironpdf/2026.2.1..2026.3.1.json b/docs/api-diffs/ironpdf/2026.2.1..2026.3.1.json new file mode 100644 index 000000000..59f29211b --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.2.1..2026.3.1.json @@ -0,0 +1,311 @@ +{ + "product": "ironpdf", + "productName": "IronPDF", + "from": "2026.2.1", + "to": "2026.3.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 5, + "additive": 16, + "cosmetic": 0, + "total": 21, + "typesFrom": 223, + "typesTo": 226 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPdf.ChromePdfRenderer", + "added": [ + { + "uid": "IronPdf.ChromePdfRenderer.RenderRtfFileAsPdf(System.String,IronPdf.RtfConversionOptions)", + "display": "ChromePdfRenderer.RenderRtfFileAsPdf(String, RtfConversionOptions)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument RenderRtfFileAsPdf(string FilePath, RtfConversionOptions options = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderer.RenderRtfStringAsPdf(System.String,IronPdf.RtfConversionOptions)", + "display": "ChromePdfRenderer.RenderRtfStringAsPdf(String, RtfConversionOptions)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument RenderRtfStringAsPdf(string RtfString, RtfConversionOptions options = null)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.ChromePdfRenderer.RenderRtfFileAsPdf(System.String)", + "display": "ChromePdfRenderer.RenderRtfFileAsPdf(String)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument RenderRtfFileAsPdf(string FilePath)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderer.RenderRtfStringAsPdf(System.String)", + "display": "ChromePdfRenderer.RenderRtfStringAsPdf(String)", + "severity": "BREAKING", + "target": "member", + "before": "public PdfDocument RenderRtfStringAsPdf(string RtfString)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronPdf.CompressionMode", + "added": [ + { + "uid": "IronPdf.CompressionMode", + "display": "IronPdf.CompressionMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class CompressionMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.PdfDocument", + "added": [ + { + "uid": "IronPdf.PdfDocument.CompressPdfToBytes(System.Byte[],System.Nullable{System.Int32},System.String,System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToBytes(Byte[], Nullable, String, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] CompressPdfToBytes(byte[] PdfBytes, Nullable JpegQuality = null, string Password = \"\", bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToBytes(System.Nullable{System.Int32},System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToBytes(Nullable, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] CompressPdfToBytes(Nullable JpegQuality = null, bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToBytes(System.IO.Stream,System.Nullable{System.Int32},System.String,System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToBytes(Stream, Nullable, String, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] CompressPdfToBytes(Stream PdfStream, Nullable JpegQuality = null, string Password = \"\", bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToStream(System.Byte[],System.Nullable{System.Int32},System.String,System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToStream(Byte[], Nullable, String, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Stream CompressPdfToStream(byte[] PdfBytes, Nullable JpegQuality = null, string Password = \"\", bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToStream(System.Nullable{System.Int32},System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToStream(Nullable, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Stream CompressPdfToStream(Nullable JpegQuality = null, bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressPdfToStream(System.IO.Stream,System.Nullable{System.Int32},System.String,System.Boolean,IronPdf.CompressionMode)", + "display": "PdfDocument.CompressPdfToStream(Stream, Nullable, String, Boolean, CompressionMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Stream CompressPdfToStream(Stream PdfStream, Nullable JpegQuality = null, string Password = \"\", bool CompressStructTree = false, CompressionMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetVerifiedSignatures(System.Boolean)", + "display": "PdfDocument.GetVerifiedSignatures(Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public List GetVerifiedSignatures(bool detectIncrementalTampering = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.VerifyPdfSignatures(System.Boolean)", + "display": "PdfDocument.VerifyPdfSignatures(Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool VerifyPdfSignatures(bool detectIncrementalTampering = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronPdf.PdfDocument.VerifyPdfSignaturesInFile(System.String,System.Boolean)", + "display": "PdfDocument.VerifyPdfSignaturesInFile(String, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static bool VerifyPdfSignaturesInFile(string PdfFilePath, bool detectIncrementalTampering = false)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronPdf.PdfDocument.GetVerifiedSignatures", + "display": "PdfDocument.GetVerifiedSignatures()", + "severity": "BREAKING", + "target": "member", + "before": "public List GetVerifiedSignatures()", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.VerifyPdfSignatures", + "display": "PdfDocument.VerifyPdfSignatures()", + "severity": "BREAKING", + "target": "member", + "before": "public bool VerifyPdfSignatures()", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronPdf.PdfDocument.VerifyPdfSignaturesInFile(System.String)", + "display": "PdfDocument.VerifyPdfSignaturesInFile(String)", + "severity": "BREAKING", + "target": "member", + "before": "public static bool VerifyPdfSignaturesInFile(string PdfFilePath)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [] + }, + { + "fqn": "IronPdf.RtfConversionOptions", + "added": [ + { + "uid": "IronPdf.RtfConversionOptions", + "display": "IronPdf.RtfConversionOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class RtfConversionOptions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Signing.Inspection.SignatureStatus", + "added": [ + { + "uid": "IronPdf.Signing.Inspection.SignatureStatus", + "display": "IronPdf.Signing.Inspection.SignatureStatus", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class SignatureStatus : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Signing.Inspection.VerifiedSignature", + "added": [ + { + "uid": "IronPdf.Signing.Inspection.VerifiedSignature.Status", + "display": "VerifiedSignature.Status", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public SignatureStatus Status { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.Signing.Inspection.VerifiedSignature.Warnings", + "display": "VerifiedSignature.Warnings", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public List Warnings { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [ + "2026.2.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)", + "2026.3.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)" + ] +} diff --git a/docs/api-diffs/ironpdf/2026.2.1..2026.3.1.md b/docs/api-diffs/ironpdf/2026.2.1..2026.3.1.md new file mode 100644 index 000000000..37d03379a --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.2.1..2026.3.1.md @@ -0,0 +1,103 @@ +# IronPDF API changes: 2026.2.1 -> 2026.3.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **5 breaking**, 16 additive, 0 cosmetic. + +## Breaking changes (5) + +### `IronPdf.ChromePdfRenderer` + +- **ChromePdfRenderer.RenderRtfFileAsPdf(String)** removed + - `public PdfDocument RenderRtfFileAsPdf(string FilePath)` + - member removed + - overload signature change (see the matching addition) +- **ChromePdfRenderer.RenderRtfStringAsPdf(String)** removed + - `public PdfDocument RenderRtfStringAsPdf(string RtfString)` + - member removed + - overload signature change (see the matching addition) +### `IronPdf.PdfDocument` + +- **PdfDocument.GetVerifiedSignatures()** removed + - `public List GetVerifiedSignatures()` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.VerifyPdfSignatures()** removed + - `public bool VerifyPdfSignatures()` + - member removed + - overload signature change (see the matching addition) +- **PdfDocument.VerifyPdfSignaturesInFile(String)** removed + - `public static bool VerifyPdfSignaturesInFile(string PdfFilePath)` + - member removed + - overload signature change (see the matching addition) + +## Additions (16) + +### `IronPdf.ChromePdfRenderer` + +- **ChromePdfRenderer.RenderRtfFileAsPdf(String, RtfConversionOptions)** added + - `public PdfDocument RenderRtfFileAsPdf(string FilePath, RtfConversionOptions options = null)` + - member added + - overload signature change (see the matching removal) +- **ChromePdfRenderer.RenderRtfStringAsPdf(String, RtfConversionOptions)** added + - `public PdfDocument RenderRtfStringAsPdf(string RtfString, RtfConversionOptions options = null)` + - member added + - overload signature change (see the matching removal) +### `IronPdf.CompressionMode` + +- **IronPdf.CompressionMode** added + - `public sealed class CompressionMode : Enum` + - type added +### `IronPdf.PdfDocument` + +- **PdfDocument.CompressPdfToBytes(Byte[], Nullable, String, Boolean, CompressionMode)** added + - `public static byte[] CompressPdfToBytes(byte[] PdfBytes, Nullable JpegQuality = null, string Password = "", bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToBytes(Nullable, Boolean, CompressionMode)** added + - `public byte[] CompressPdfToBytes(Nullable JpegQuality = null, bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToBytes(Stream, Nullable, String, Boolean, CompressionMode)** added + - `public static byte[] CompressPdfToBytes(Stream PdfStream, Nullable JpegQuality = null, string Password = "", bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToStream(Byte[], Nullable, String, Boolean, CompressionMode)** added + - `public static Stream CompressPdfToStream(byte[] PdfBytes, Nullable JpegQuality = null, string Password = "", bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToStream(Nullable, Boolean, CompressionMode)** added + - `public Stream CompressPdfToStream(Nullable JpegQuality = null, bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.CompressPdfToStream(Stream, Nullable, String, Boolean, CompressionMode)** added + - `public static Stream CompressPdfToStream(Stream PdfStream, Nullable JpegQuality = null, string Password = "", bool CompressStructTree = false, CompressionMode mode)` + - member added +- **PdfDocument.GetVerifiedSignatures(Boolean)** added + - `public List GetVerifiedSignatures(bool detectIncrementalTampering = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.VerifyPdfSignatures(Boolean)** added + - `public bool VerifyPdfSignatures(bool detectIncrementalTampering = false)` + - member added + - overload signature change (see the matching removal) +- **PdfDocument.VerifyPdfSignaturesInFile(String, Boolean)** added + - `public static bool VerifyPdfSignaturesInFile(string PdfFilePath, bool detectIncrementalTampering = false)` + - member added + - overload signature change (see the matching removal) +### `IronPdf.RtfConversionOptions` + +- **IronPdf.RtfConversionOptions** added + - `public class RtfConversionOptions : Object` + - type added +### `IronPdf.Signing.Inspection.SignatureStatus` + +- **IronPdf.Signing.Inspection.SignatureStatus** added + - `public sealed class SignatureStatus : Enum` + - type added +### `IronPdf.Signing.Inspection.VerifiedSignature` + +- **VerifiedSignature.Status** added + - `public SignatureStatus Status { get; }` + - member added +- **VerifiedSignature.Warnings** added + - `public List Warnings { get; }` + - member added + +## Warnings (2) + +- 2026.2.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) +- 2026.3.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) diff --git a/docs/api-diffs/ironpdf/2026.3.1..2026.4.1.json b/docs/api-diffs/ironpdf/2026.3.1..2026.4.1.json new file mode 100644 index 000000000..726d1b11b --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.3.1..2026.4.1.json @@ -0,0 +1,271 @@ +{ + "product": "ironpdf", + "productName": "IronPDF", + "from": "2026.3.1", + "to": "2026.4.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 14, + "additive": 3, + "cosmetic": 0, + "total": 17, + "typesFrom": 226, + "typesTo": 227 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPdf.BrowserPoolOptions", + "added": [ + { + "uid": "IronPdf.BrowserPoolOptions", + "display": "IronPdf.BrowserPoolOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class BrowserPoolOptions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ChromePdfRenderOptions", + "added": [ + { + "uid": "IronPdf.ChromePdfRenderOptions.BrowserPool", + "display": "ChromePdfRenderOptions.BrowserPool", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public BrowserPoolOptions BrowserPool { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.MaxDynamicHFPagesPerBatch", + "display": "ChromePdfRenderOptions.MaxDynamicHFPagesPerBatch", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int MaxDynamicHFPagesPerBatch { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Extractions.PageMetadata", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Extractions.PageMetadata.PageBounds", + "display": "PageMetadata.PageBounds", + "severity": "BREAKING", + "target": "member", + "before": "public < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle PageBounds { get; }", + "after": "public < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle PageBounds { get; }", + "reasons": [ + "type changed: < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle -> < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle" + ] + } + ] + }, + { + "fqn": "IronPdf.Extractions.PageText", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Extractions.PageText.PageBounds", + "display": "PageText.PageBounds", + "severity": "BREAKING", + "target": "member", + "before": "public < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle PageBounds { get; }", + "after": "public < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle PageBounds { get; }", + "reasons": [ + "type changed: < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle -> < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle" + ] + } + ] + }, + { + "fqn": "IronPdf.Extractions.TableCell", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Extractions.TableCell.BoundingBox", + "display": "TableCell.BoundingBox", + "severity": "BREAKING", + "target": "member", + "before": "public < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle BoundingBox { get; }", + "after": "public < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle BoundingBox { get; }", + "reasons": [ + "type changed: < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle -> < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle" + ] + } + ] + }, + { + "fqn": "IronPdf.Extractions.TableObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Extractions.TableObject.BoundingBox", + "display": "TableObject.BoundingBox", + "severity": "BREAKING", + "target": "member", + "before": "public < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle BoundingBox { get; }", + "after": "public < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle BoundingBox { get; }", + "reasons": [ + "type changed: < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle -> < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle" + ] + } + ] + }, + { + "fqn": "UglyToad.PdfPig.Core.PdfPoint", + "added": [], + "removed": [ + { + "uid": "UglyToad.PdfPig.Core.PdfPoint.op_Equality(UglyToad.PdfPig.Core.PdfPoint,UglyToad.PdfPig.Core.PdfPoint)", + "display": "PdfPoint.Equality(PdfPoint, PdfPoint)", + "severity": "BREAKING", + "target": "member", + "before": "UglyToad.PdfPig.Core.PdfPoint.Equality(UglyToad.PdfPig.Core.PdfPoint, UglyToad.PdfPig.Core.PdfPoint)", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "UglyToad.PdfPig.Core.PdfPoint.Equals(UglyToad.PdfPig.Core.PdfPoint)", + "display": "PdfPoint.Equals(PdfPoint)", + "severity": "BREAKING", + "target": "member", + "before": "UglyToad.PdfPig.Core.PdfPoint.Equals(UglyToad.PdfPig.Core.PdfPoint)", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "UglyToad.PdfPig.Core.PdfPoint.op_Inequality(UglyToad.PdfPig.Core.PdfPoint,UglyToad.PdfPig.Core.PdfPoint)", + "display": "PdfPoint.Inequality(PdfPoint, PdfPoint)", + "severity": "BREAKING", + "target": "member", + "before": "UglyToad.PdfPig.Core.PdfPoint.Inequality(UglyToad.PdfPig.Core.PdfPoint, UglyToad.PdfPig.Core.PdfPoint)", + "after": "", + "reasons": [ + "member removed" + ] + } + ], + "changed": [ + { + "uid": "UglyToad.PdfPig.Core.PdfPoint", + "display": "UglyToad.PdfPig.Core.PdfPoint", + "severity": "BREAKING", + "target": "type", + "before": "", + "after": "", + "reasons": [ + "interface no longer implemented: IEquatable" + ] + } + ] + }, + { + "fqn": "UglyToad.PdfPig.Core.PdfRectangle", + "added": [], + "removed": [ + { + "uid": "UglyToad.PdfPig.Core.PdfRectangle.op_Equality(UglyToad.PdfPig.Core.PdfRectangle,UglyToad.PdfPig.Core.PdfRectangle)", + "display": "PdfRectangle.Equality(PdfRectangle, PdfRectangle)", + "severity": "BREAKING", + "target": "member", + "before": "UglyToad.PdfPig.Core.PdfRectangle.Equality(UglyToad.PdfPig.Core.PdfRectangle, UglyToad.PdfPig.Core.PdfRectangle)", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "UglyToad.PdfPig.Core.PdfRectangle.Equals(System.Object)", + "display": "PdfRectangle.Equals(Object)", + "severity": "BREAKING", + "target": "member", + "before": "UglyToad.PdfPig.Core.PdfRectangle.Equals(System.Object)", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "UglyToad.PdfPig.Core.PdfRectangle.Equals(UglyToad.PdfPig.Core.PdfRectangle)", + "display": "PdfRectangle.Equals(PdfRectangle)", + "severity": "BREAKING", + "target": "member", + "before": "UglyToad.PdfPig.Core.PdfRectangle.Equals(UglyToad.PdfPig.Core.PdfRectangle)", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "UglyToad.PdfPig.Core.PdfRectangle.GetHashCode", + "display": "PdfRectangle.GetHashCode()", + "severity": "BREAKING", + "target": "member", + "before": "UglyToad.PdfPig.Core.PdfRectangle.GetHashCode()", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "UglyToad.PdfPig.Core.PdfRectangle.op_Inequality(UglyToad.PdfPig.Core.PdfRectangle,UglyToad.PdfPig.Core.PdfRectangle)", + "display": "PdfRectangle.Inequality(PdfRectangle, PdfRectangle)", + "severity": "BREAKING", + "target": "member", + "before": "UglyToad.PdfPig.Core.PdfRectangle.Inequality(UglyToad.PdfPig.Core.PdfRectangle, UglyToad.PdfPig.Core.PdfRectangle)", + "after": "", + "reasons": [ + "member removed" + ] + } + ], + "changed": [ + { + "uid": "UglyToad.PdfPig.Core.PdfRectangle", + "display": "UglyToad.PdfPig.Core.PdfRectangle", + "severity": "BREAKING", + "target": "type", + "before": "", + "after": "", + "reasons": [ + "interface no longer implemented: IEquatable" + ] + } + ] + } + ], + "warnings": [ + "2026.3.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)", + "2026.4.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)" + ] +} diff --git a/docs/api-diffs/ironpdf/2026.3.1..2026.4.1.md b/docs/api-diffs/ironpdf/2026.3.1..2026.4.1.md new file mode 100644 index 000000000..56c856475 --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.3.1..2026.4.1.md @@ -0,0 +1,87 @@ +# IronPDF API changes: 2026.3.1 -> 2026.4.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **14 breaking**, 3 additive, 0 cosmetic. + +## Breaking changes (14) + +### `IronPdf.Extractions.PageMetadata` + +- **PageMetadata.PageBounds** changed + - was: `public < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle PageBounds { get; }` + - now: `public < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle PageBounds { get; }` + - type changed: < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle -> < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle +### `IronPdf.Extractions.PageText` + +- **PageText.PageBounds** changed + - was: `public < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle PageBounds { get; }` + - now: `public < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle PageBounds { get; }` + - type changed: < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle -> < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle +### `IronPdf.Extractions.TableCell` + +- **TableCell.BoundingBox** changed + - was: `public < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle BoundingBox { get; }` + - now: `public < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle BoundingBox { get; }` + - type changed: < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle -> < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle +### `IronPdf.Extractions.TableObject` + +- **TableObject.BoundingBox** changed + - was: `public < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle BoundingBox { get; }` + - now: `public < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle BoundingBox { get; }` + - type changed: < dde4331f - cf4f - 4 a3f - 8e59 - 4 b3f67415fac > PdfRectangle -> < 7 b56d8b3 - e75c - 452 b - af2b - e32243b44b60 > PdfRectangle +### `UglyToad.PdfPig.Core.PdfPoint` + +- **PdfPoint.Equality(PdfPoint, PdfPoint)** removed + - `UglyToad.PdfPig.Core.PdfPoint.Equality(UglyToad.PdfPig.Core.PdfPoint, UglyToad.PdfPig.Core.PdfPoint)` + - member removed +- **PdfPoint.Equals(PdfPoint)** removed + - `UglyToad.PdfPig.Core.PdfPoint.Equals(UglyToad.PdfPig.Core.PdfPoint)` + - member removed +- **PdfPoint.Inequality(PdfPoint, PdfPoint)** removed + - `UglyToad.PdfPig.Core.PdfPoint.Inequality(UglyToad.PdfPig.Core.PdfPoint, UglyToad.PdfPig.Core.PdfPoint)` + - member removed +- **UglyToad.PdfPig.Core.PdfPoint** changed + - was: `` + - now: `` + - interface no longer implemented: IEquatable +### `UglyToad.PdfPig.Core.PdfRectangle` + +- **PdfRectangle.Equality(PdfRectangle, PdfRectangle)** removed + - `UglyToad.PdfPig.Core.PdfRectangle.Equality(UglyToad.PdfPig.Core.PdfRectangle, UglyToad.PdfPig.Core.PdfRectangle)` + - member removed +- **PdfRectangle.Equals(Object)** removed + - `UglyToad.PdfPig.Core.PdfRectangle.Equals(System.Object)` + - member removed +- **PdfRectangle.Equals(PdfRectangle)** removed + - `UglyToad.PdfPig.Core.PdfRectangle.Equals(UglyToad.PdfPig.Core.PdfRectangle)` + - member removed +- **PdfRectangle.GetHashCode()** removed + - `UglyToad.PdfPig.Core.PdfRectangle.GetHashCode()` + - member removed +- **PdfRectangle.Inequality(PdfRectangle, PdfRectangle)** removed + - `UglyToad.PdfPig.Core.PdfRectangle.Inequality(UglyToad.PdfPig.Core.PdfRectangle, UglyToad.PdfPig.Core.PdfRectangle)` + - member removed +- **UglyToad.PdfPig.Core.PdfRectangle** changed + - was: `` + - now: `` + - interface no longer implemented: IEquatable + +## Additions (3) + +### `IronPdf.BrowserPoolOptions` + +- **IronPdf.BrowserPoolOptions** added + - `public class BrowserPoolOptions : Object` + - type added +### `IronPdf.ChromePdfRenderOptions` + +- **ChromePdfRenderOptions.BrowserPool** added + - `public BrowserPoolOptions BrowserPool { get; }` + - member added +- **ChromePdfRenderOptions.MaxDynamicHFPagesPerBatch** added + - `public int MaxDynamicHFPagesPerBatch { get; set; }` + - member added + +## Warnings (2) + +- 2026.3.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) +- 2026.4.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) diff --git a/docs/api-diffs/ironpdf/2026.4.1..2026.5.2.json b/docs/api-diffs/ironpdf/2026.4.1..2026.5.2.json new file mode 100644 index 000000000..a57cf9aa7 --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.4.1..2026.5.2.json @@ -0,0 +1,284 @@ +{ + "product": "ironpdf", + "productName": "IronPDF", + "from": "2026.4.1", + "to": "2026.5.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 19, + "cosmetic": 0, + "total": 19, + "typesFrom": 227, + "typesTo": 231 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPdf.Annotations.LinkAnnotation", + "added": [ + { + "uid": "IronPdf.Annotations.LinkAnnotation", + "display": "IronPdf.Annotations.LinkAnnotation", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class LinkAnnotation : PdfClientAccessor, IAnnotation", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ChromePdfRenderOptions", + "added": [ + { + "uid": "IronPdf.ChromePdfRenderOptions.AutoBookmarkCssSelectors", + "display": "ChromePdfRenderOptions.AutoBookmarkCssSelectors", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string[] AutoBookmarkCssSelectors { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.AutoBookmarkMaxHeadingLevel", + "display": "ChromePdfRenderOptions.AutoBookmarkMaxHeadingLevel", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int AutoBookmarkMaxHeadingLevel { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.AutoBookmarkMinHeadingLevel", + "display": "ChromePdfRenderOptions.AutoBookmarkMinHeadingLevel", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int AutoBookmarkMinHeadingLevel { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.AutoBookmarksFromHeadings", + "display": "ChromePdfRenderOptions.AutoBookmarksFromHeadings", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool AutoBookmarksFromHeadings { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.ElementQuerySelectors", + "display": "ChromePdfRenderOptions.ElementQuerySelectors", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string[] ElementQuerySelectors { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.LinearizationMode", + "added": [ + { + "uid": "IronPdf.LinearizationMode", + "display": "IronPdf.LinearizationMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class LinearizationMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.PdfDocument", + "added": [ + { + "uid": "IronPdf.PdfDocument.GetElementLocations", + "display": "PdfDocument.GetElementLocations()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public List GetElementLocations()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToBytes(System.Byte[],System.String,IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToBytes(Byte[], String, LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] LinearizePdfToBytes(byte[] PdfBytes, string Password = \"\", LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToBytes(IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToBytes(LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public byte[] LinearizePdfToBytes(LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToBytes(System.IO.Stream,System.String,IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToBytes(Stream, String, LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static byte[] LinearizePdfToBytes(Stream PdfStream, string Password = \"\", LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToStream(System.Byte[],System.String,IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToStream(Byte[], String, LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Stream LinearizePdfToStream(byte[] PdfBytes, string Password = \"\", LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToStream(IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToStream(LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public Stream LinearizePdfToStream(LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.LinearizePdfToStream(System.IO.Stream,System.String,IronPdf.LinearizationMode)", + "display": "PdfDocument.LinearizePdfToStream(Stream, String, LinearizationMode)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static Stream LinearizePdfToStream(Stream PdfStream, string Password = \"\", LinearizationMode mode)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ResetElementLocationCache", + "display": "PdfDocument.ResetElementLocationCache()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void ResetElementLocationCache()", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.RenderedElementLocation", + "added": [ + { + "uid": "IronPdf.RenderedElementLocation", + "display": "IronPdf.RenderedElementLocation", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class RenderedElementLocation : Object, IEquatable", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Signing.Inspection.SignerCertificateInfo", + "added": [ + { + "uid": "IronPdf.Signing.Inspection.SignerCertificateInfo", + "display": "IronPdf.Signing.Inspection.SignerCertificateInfo", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class SignerCertificateInfo : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Signing.Inspection.VerifiedSignature", + "added": [ + { + "uid": "IronPdf.Signing.Inspection.VerifiedSignature.CertificateChain", + "display": "VerifiedSignature.CertificateChain", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList CertificateChain { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.Signing.Inspection.VerifiedSignature.SignerCertificate", + "display": "VerifiedSignature.SignerCertificate", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public SignerCertificateInfo SignerCertificate { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [ + "2026.4.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)", + "2026.5.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)" + ] +} diff --git a/docs/api-diffs/ironpdf/2026.4.1..2026.5.2.md b/docs/api-diffs/ironpdf/2026.4.1..2026.5.2.md new file mode 100644 index 000000000..eb70abdb4 --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.4.1..2026.5.2.md @@ -0,0 +1,82 @@ +# IronPDF API changes: 2026.4.1 -> 2026.5.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 19 additive, 0 cosmetic. + +## Additions (19) + +### `IronPdf.Annotations.LinkAnnotation` + +- **IronPdf.Annotations.LinkAnnotation** added + - `public class LinkAnnotation : PdfClientAccessor, IAnnotation` + - type added +### `IronPdf.ChromePdfRenderOptions` + +- **ChromePdfRenderOptions.AutoBookmarkCssSelectors** added + - `public string[] AutoBookmarkCssSelectors { get; set; }` + - member added +- **ChromePdfRenderOptions.AutoBookmarkMaxHeadingLevel** added + - `public int AutoBookmarkMaxHeadingLevel { get; set; }` + - member added +- **ChromePdfRenderOptions.AutoBookmarkMinHeadingLevel** added + - `public int AutoBookmarkMinHeadingLevel { get; set; }` + - member added +- **ChromePdfRenderOptions.AutoBookmarksFromHeadings** added + - `public bool AutoBookmarksFromHeadings { get; set; }` + - member added +- **ChromePdfRenderOptions.ElementQuerySelectors** added + - `public string[] ElementQuerySelectors { get; set; }` + - member added +### `IronPdf.LinearizationMode` + +- **IronPdf.LinearizationMode** added + - `public sealed class LinearizationMode : Enum` + - type added +### `IronPdf.PdfDocument` + +- **PdfDocument.GetElementLocations()** added + - `public List GetElementLocations()` + - member added +- **PdfDocument.LinearizePdfToBytes(Byte[], String, LinearizationMode)** added + - `public static byte[] LinearizePdfToBytes(byte[] PdfBytes, string Password = "", LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToBytes(LinearizationMode)** added + - `public byte[] LinearizePdfToBytes(LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToBytes(Stream, String, LinearizationMode)** added + - `public static byte[] LinearizePdfToBytes(Stream PdfStream, string Password = "", LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToStream(Byte[], String, LinearizationMode)** added + - `public static Stream LinearizePdfToStream(byte[] PdfBytes, string Password = "", LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToStream(LinearizationMode)** added + - `public Stream LinearizePdfToStream(LinearizationMode mode)` + - member added +- **PdfDocument.LinearizePdfToStream(Stream, String, LinearizationMode)** added + - `public static Stream LinearizePdfToStream(Stream PdfStream, string Password = "", LinearizationMode mode)` + - member added +- **PdfDocument.ResetElementLocationCache()** added + - `public void ResetElementLocationCache()` + - member added +### `IronPdf.RenderedElementLocation` + +- **IronPdf.RenderedElementLocation** added + - `public class RenderedElementLocation : Object, IEquatable` + - type added +### `IronPdf.Signing.Inspection.SignerCertificateInfo` + +- **IronPdf.Signing.Inspection.SignerCertificateInfo** added + - `public class SignerCertificateInfo : Object` + - type added +### `IronPdf.Signing.Inspection.VerifiedSignature` + +- **VerifiedSignature.CertificateChain** added + - `public IReadOnlyList CertificateChain { get; }` + - member added +- **VerifiedSignature.SignerCertificate** added + - `public SignerCertificateInfo SignerCertificate { get; }` + - member added + +## Warnings (2) + +- 2026.4.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) +- 2026.5.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) diff --git a/docs/api-diffs/ironpdf/2026.5.2..2026.6.1.json b/docs/api-diffs/ironpdf/2026.5.2..2026.6.1.json new file mode 100644 index 000000000..22169827b --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.5.2..2026.6.1.json @@ -0,0 +1,182 @@ +{ + "product": "ironpdf", + "productName": "IronPDF", + "from": "2026.5.2", + "to": "2026.6.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 11, + "cosmetic": 0, + "total": 11, + "typesFrom": 231, + "typesTo": 233 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPdf.AdvancedCompressionOptions", + "added": [ + { + "uid": "IronPdf.AdvancedCompressionOptions", + "display": "IronPdf.AdvancedCompressionOptions", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class AdvancedCompressionOptions : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Installation", + "added": [ + { + "uid": "IronPdf.Installation.JobQueueWatchdogTimeout", + "display": "Installation.JobQueueWatchdogTimeout", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static TimeSpan JobQueueWatchdogTimeout { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ObjectStreamMode", + "added": [ + { + "uid": "IronPdf.ObjectStreamMode", + "display": "IronPdf.ObjectStreamMode", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class ObjectStreamMode : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.PdfDocument", + "added": [ + { + "uid": "IronPdf.PdfDocument.CompressAndSaveAs(System.Byte[],System.String,IronPdf.AdvancedCompressionOptions,System.String)", + "display": "PdfDocument.CompressAndSaveAs(Byte[], String, AdvancedCompressionOptions, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static void CompressAndSaveAs(byte[] PdfBytes, string OutputPath, AdvancedCompressionOptions Options, string Password = \"\")", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressAndSaveAs(System.IO.Stream,System.String,IronPdf.AdvancedCompressionOptions,System.String)", + "display": "PdfDocument.CompressAndSaveAs(Stream, String, AdvancedCompressionOptions, String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public static void CompressAndSaveAs(Stream Stream, string OutputPath, AdvancedCompressionOptions Options, string Password = \"\")", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.CompressAndSaveAs(System.String,IronPdf.AdvancedCompressionOptions)", + "display": "PdfDocument.CompressAndSaveAs(String, AdvancedCompressionOptions)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void CompressAndSaveAs(string OutputPath, AdvancedCompressionOptions Options)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.DisableFormFontFallback", + "display": "PdfDocument.DisableFormFontFallback()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void DisableFormFontFallback()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.SetFormFont(System.String,System.Byte[],System.Boolean)", + "display": "PdfDocument.SetFormFont(String, Byte[], Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void SetFormFont(string fontName, byte[] fontData = null, bool forceEmbed = false)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.SetFormFontFromFile(System.String,System.String,System.Boolean)", + "display": "PdfDocument.SetFormFontFromFile(String, String, Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void SetFormFontFromFile(string fontFilePath, string fontName = null, bool forceEmbed = false)", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.FormFieldCollection", + "added": [ + { + "uid": "IronSoftware.FormFieldCollection.DisableFormFontFallback", + "display": "FormFieldCollection.DisableFormFontFallback()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void DisableFormFontFallback()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.FormFieldCollection.SetFormFont(System.String,System.Byte[],System.Boolean)", + "display": "FormFieldCollection.SetFormFont(String, Byte[], Boolean)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void SetFormFont(string fontName, byte[] fontData, bool forceEmbed = false)", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [ + "2026.5.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)", + "2026.6.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)" + ] +} diff --git a/docs/api-diffs/ironpdf/2026.5.2..2026.6.1.md b/docs/api-diffs/ironpdf/2026.5.2..2026.6.1.md new file mode 100644 index 000000000..59695da1b --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.5.2..2026.6.1.md @@ -0,0 +1,54 @@ +# IronPDF API changes: 2026.5.2 -> 2026.6.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 11 additive, 0 cosmetic. + +## Additions (11) + +### `IronPdf.AdvancedCompressionOptions` + +- **IronPdf.AdvancedCompressionOptions** added + - `public class AdvancedCompressionOptions : Object` + - type added +### `IronPdf.Installation` + +- **Installation.JobQueueWatchdogTimeout** added + - `public static TimeSpan JobQueueWatchdogTimeout { get; set; }` + - member added +### `IronPdf.ObjectStreamMode` + +- **IronPdf.ObjectStreamMode** added + - `public sealed class ObjectStreamMode : Enum` + - type added +### `IronPdf.PdfDocument` + +- **PdfDocument.CompressAndSaveAs(Byte[], String, AdvancedCompressionOptions, String)** added + - `public static void CompressAndSaveAs(byte[] PdfBytes, string OutputPath, AdvancedCompressionOptions Options, string Password = "")` + - member added +- **PdfDocument.CompressAndSaveAs(Stream, String, AdvancedCompressionOptions, String)** added + - `public static void CompressAndSaveAs(Stream Stream, string OutputPath, AdvancedCompressionOptions Options, string Password = "")` + - member added +- **PdfDocument.CompressAndSaveAs(String, AdvancedCompressionOptions)** added + - `public void CompressAndSaveAs(string OutputPath, AdvancedCompressionOptions Options)` + - member added +- **PdfDocument.DisableFormFontFallback()** added + - `public void DisableFormFontFallback()` + - member added +- **PdfDocument.SetFormFont(String, Byte[], Boolean)** added + - `public void SetFormFont(string fontName, byte[] fontData = null, bool forceEmbed = false)` + - member added +- **PdfDocument.SetFormFontFromFile(String, String, Boolean)** added + - `public void SetFormFontFromFile(string fontFilePath, string fontName = null, bool forceEmbed = false)` + - member added +### `IronSoftware.FormFieldCollection` + +- **FormFieldCollection.DisableFormFontFallback()** added + - `public void DisableFormFontFallback()` + - member added +- **FormFieldCollection.SetFormFont(String, Byte[], Boolean)** added + - `public void SetFormFont(string fontName, byte[] fontData, bool forceEmbed = false)` + - member added + +## Warnings (2) + +- 2026.5.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) +- 2026.6.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) diff --git a/docs/api-diffs/ironpdf/2026.6.1..2026.7.2.json b/docs/api-diffs/ironpdf/2026.6.1..2026.7.2.json new file mode 100644 index 000000000..50d373c1c --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.6.1..2026.7.2.json @@ -0,0 +1,717 @@ +{ + "product": "ironpdf", + "productName": "IronPDF", + "from": "2026.6.1", + "to": "2026.7.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 27, + "cosmetic": 18, + "total": 45, + "typesFrom": 233, + "typesTo": 239 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPdf.ChromePdfRenderOptions", + "added": [ + { + "uid": "IronPdf.ChromePdfRenderOptions.CssPageRulePolicy", + "display": "ChromePdfRenderOptions.CssPageRulePolicy", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public CssPageRulePolicy CssPageRulePolicy { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.ChromePdfRenderOptions.HeaderFooterOverlapBehavior", + "display": "ChromePdfRenderOptions.HeaderFooterOverlapBehavior", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public ContentOverlapBehavior HeaderFooterOverlapBehavior { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.ContentOverlapBehavior", + "added": [ + { + "uid": "IronPdf.ContentOverlapBehavior", + "display": "IronPdf.ContentOverlapBehavior", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class ContentOverlapBehavior : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.CssPageRulePolicy", + "added": [ + { + "uid": "IronPdf.CssPageRulePolicy", + "display": "IronPdf.CssPageRulePolicy", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class CssPageRulePolicy : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronPdf.Pages.IPdfPage", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Pages.IPdfPage", + "display": "IronPdf.Pages.IPdfPage", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPage : IDocumentPage, IPageContainer", + "after": "public interface IPdfPage", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPage, IPageContainer) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronPdf.Pages.IPdfPageCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronPdf.Pages.IPdfPageCollection", + "display": "IronPdf.Pages.IPdfPageCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPageCollection : IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable", + "after": "public interface IPdfPageCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronPdf.PdfDocument", + "added": [ + { + "uid": "IronPdf.PdfDocument.AddHtmlFooters(IronPdf.HtmlHeaderFooter,IronPdf.ContentOverlapBehavior,System.Int32,System.Collections.Generic.IEnumerable{System.Int32})", + "display": "PdfDocument.AddHtmlFooters(HtmlHeaderFooter, ContentOverlapBehavior, Int32, IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument AddHtmlFooters(HtmlHeaderFooter Footer, ContentOverlapBehavior OverlapBehavior, int FirstPageNumber = 1, IEnumerable PageIndexesToAddFootersTo = null)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.AddHtmlHeaders(IronPdf.HtmlHeaderFooter,IronPdf.ContentOverlapBehavior,System.Int32,System.Collections.Generic.IEnumerable{System.Int32})", + "display": "PdfDocument.AddHtmlHeaders(HtmlHeaderFooter, ContentOverlapBehavior, Int32, IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfDocument AddHtmlHeaders(HtmlHeaderFooter Header, ContentOverlapBehavior OverlapBehavior, int FirstPageNumber = 1, IEnumerable PageIndexesToAddHeadersTo = null)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ExtractTextFromLayer(System.Int32)", + "display": "PdfDocument.ExtractTextFromLayer(Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string ExtractTextFromLayer(int ocgId)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ExtractTextFromLayer(System.String)", + "display": "PdfDocument.ExtractTextFromLayer(String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string ExtractTextFromLayer(string layerName)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ExtractTextFromLayers(System.Collections.Generic.IEnumerable{System.Int32})", + "display": "PdfDocument.ExtractTextFromLayers(IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string ExtractTextFromLayers(IEnumerable ocgIds)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.ExtractTextFromLayers(System.Collections.Generic.IEnumerable{System.String})", + "display": "PdfDocument.ExtractTextFromLayers(IEnumerable)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public string ExtractTextFromLayers(IEnumerable layerNames)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetPathObjectsByLayer(System.Int32)", + "display": "PdfDocument.GetPathObjectsByLayer(Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList GetPathObjectsByLayer(int ocgId)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetTextObjectsByLayer(System.Int32)", + "display": "PdfDocument.GetTextObjectsByLayer(Int32)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList GetTextObjectsByLayer(int ocgId)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.GetTextObjectsByLayer(System.String)", + "display": "PdfDocument.GetTextObjectsByLayer(String)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList GetTextObjectsByLayer(string layerName)", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronPdf.PdfDocument.Layers", + "display": "PdfDocument.Layers", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfLayerCollection Layers { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.Deployment.SmartDeploymentBase", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Deployment.SmartDeploymentBase", + "display": "IronSoftware.Deployment.SmartDeploymentBase", + "severity": "COSMETIC", + "target": "type", + "before": "public abstract class SmartDeploymentBase : Object, IDeployment, ICombinedDeployment", + "after": "public abstract class SmartDeploymentBase : Object, IDeployment", + "reasons": [ + "declaration interface list differs (no longer listed: ICombinedDeployment) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.ICheckableFormField", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.ICheckableFormField", + "display": "IronSoftware.Forms.ICheckableFormField", + "severity": "COSMETIC", + "target": "type", + "before": "public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormField", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormField", + "display": "IronSoftware.Forms.IFormField", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldAnnotation", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldAnnotation", + "display": "IronSoftware.Forms.IFormFieldAnnotation", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldAnnotationObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldAnnotationObject", + "display": "IronSoftware.Forms.IFormFieldAnnotationObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormFieldAnnotationObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldAnnotationObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldCollection", + "display": "IronSoftware.Forms.IFormFieldCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormFieldCollection : IList, ICollection, IEnumerable, IEnumerable", + "after": "public interface IFormFieldCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IList, ICollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.Forms.IFormFieldObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.Forms.IFormFieldObject", + "display": "IronSoftware.Forms.IFormFieldObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IFormFieldObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject", + "after": "public interface IFormFieldObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfDocumentObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfDocumentObject", + "display": "IronSoftware.IPdfDocumentObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfDocumentObject : IPdfDocumentObject, IDocumentObject", + "after": "public interface IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IPdfDocumentObject, IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfFontObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfFontObject", + "display": "IronSoftware.IPdfFontObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfFontObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IFont, IJsonSerializable", + "after": "public interface IPdfFontObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject, IDocumentFontObject, IFont, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfFontObjectCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfFontObjectCollection", + "display": "IronSoftware.IPdfFontObjectCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfFontObjectCollection : IDocumentFontObjectCollection, IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IEnumerable, IJsonSerializable", + "after": "public interface IPdfFontObjectCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentFontObjectCollection, IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IEnumerable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfImageObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfImageObject", + "display": "IronSoftware.IPdfImageObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfImageObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedPdfDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable", + "after": "public interface IPdfImageObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject, IDocumentImageObject, IBoundedPdfDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfImageObjectCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfImageObjectCollection", + "display": "IronSoftware.IPdfImageObjectCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfImageObjectCollection : IDocumentImageObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable", + "after": "public interface IPdfImageObjectCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentImageObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfPathObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfPathObject", + "display": "IronSoftware.IPdfPathObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPathObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable", + "after": "public interface IPdfPathObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject, IDocumentPathObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfPathObjectCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfPathObjectCollection", + "display": "IronSoftware.IPdfPathObjectCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfPathObjectCollection : IDocumentPathObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable", + "after": "public interface IPdfPathObjectCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentPathObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfTextObject", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfTextObject", + "display": "IronSoftware.IPdfTextObject", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfTextObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable", + "after": "public interface IPdfTextObject : IPdfDocumentObject", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.IPdfTextObjectCollection", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronSoftware.IPdfTextObjectCollection", + "display": "IronSoftware.IPdfTextObjectCollection", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IPdfTextObjectCollection : IDocumentTextObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable", + "after": "public interface IPdfTextObjectCollection", + "reasons": [ + "declaration interface list differs (no longer listed: IDocumentTextObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronSoftware.LineCaps", + "added": [ + { + "uid": "IronSoftware.LineCaps", + "display": "IronSoftware.LineCaps", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class LineCaps : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.LineJoins", + "added": [ + { + "uid": "IronSoftware.LineJoins", + "display": "IronSoftware.LineJoins", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public sealed class LineJoins : Enum", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.PathObject", + "added": [ + { + "uid": "IronSoftware.PathObject.DashPattern", + "display": "PathObject.DashPattern", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public IReadOnlyList DashPattern { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.DashPhase", + "display": "PathObject.DashPhase", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public float DashPhase { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.GetLayer", + "display": "PathObject.GetLayer()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfLayer GetLayer()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.LineCap", + "display": "PathObject.LineCap", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public LineCaps LineCap { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.LineJoin", + "display": "PathObject.LineJoin", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public LineJoins LineJoin { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.OcgId", + "display": "PathObject.OcgId", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int OcgId { get; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.PathObject.StrokeWidth", + "display": "PathObject.StrokeWidth", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public float StrokeWidth { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.PdfLayer", + "added": [ + { + "uid": "IronSoftware.PdfLayer", + "display": "IronSoftware.PdfLayer", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PdfLayer : Object", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.PdfLayerCollection", + "added": [ + { + "uid": "IronSoftware.PdfLayerCollection", + "display": "IronSoftware.PdfLayerCollection", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class PdfLayerCollection : ReadOnlyCollection", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronSoftware.TextObject", + "added": [ + { + "uid": "IronSoftware.TextObject.GetLayer", + "display": "TextObject.GetLayer()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public PdfLayer GetLayer()", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronSoftware.TextObject.OcgId", + "display": "TextObject.OcgId", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int OcgId { get; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [ + "2026.6.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)", + "2026.7.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures)" + ] +} diff --git a/docs/api-diffs/ironpdf/2026.6.1..2026.7.2.md b/docs/api-diffs/ironpdf/2026.6.1..2026.7.2.md new file mode 100644 index 000000000..502a919db --- /dev/null +++ b/docs/api-diffs/ironpdf/2026.6.1..2026.7.2.md @@ -0,0 +1,223 @@ +# IronPDF API changes: 2026.6.1 -> 2026.7.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 27 additive, 18 cosmetic. + +## Additions (27) + +### `IronPdf.ChromePdfRenderOptions` + +- **ChromePdfRenderOptions.CssPageRulePolicy** added + - `public CssPageRulePolicy CssPageRulePolicy { get; set; }` + - member added +- **ChromePdfRenderOptions.HeaderFooterOverlapBehavior** added + - `public ContentOverlapBehavior HeaderFooterOverlapBehavior { get; set; }` + - member added +### `IronPdf.ContentOverlapBehavior` + +- **IronPdf.ContentOverlapBehavior** added + - `public sealed class ContentOverlapBehavior : Enum` + - type added +### `IronPdf.CssPageRulePolicy` + +- **IronPdf.CssPageRulePolicy** added + - `public sealed class CssPageRulePolicy : Enum` + - type added +### `IronPdf.PdfDocument` + +- **PdfDocument.AddHtmlFooters(HtmlHeaderFooter, ContentOverlapBehavior, Int32, IEnumerable)** added + - `public PdfDocument AddHtmlFooters(HtmlHeaderFooter Footer, ContentOverlapBehavior OverlapBehavior, int FirstPageNumber = 1, IEnumerable PageIndexesToAddFootersTo = null)` + - member added +- **PdfDocument.AddHtmlHeaders(HtmlHeaderFooter, ContentOverlapBehavior, Int32, IEnumerable)** added + - `public PdfDocument AddHtmlHeaders(HtmlHeaderFooter Header, ContentOverlapBehavior OverlapBehavior, int FirstPageNumber = 1, IEnumerable PageIndexesToAddHeadersTo = null)` + - member added +- **PdfDocument.ExtractTextFromLayer(Int32)** added + - `public string ExtractTextFromLayer(int ocgId)` + - member added +- **PdfDocument.ExtractTextFromLayer(String)** added + - `public string ExtractTextFromLayer(string layerName)` + - member added +- **PdfDocument.ExtractTextFromLayers(IEnumerable)** added + - `public string ExtractTextFromLayers(IEnumerable ocgIds)` + - member added +- **PdfDocument.ExtractTextFromLayers(IEnumerable)** added + - `public string ExtractTextFromLayers(IEnumerable layerNames)` + - member added +- **PdfDocument.GetPathObjectsByLayer(Int32)** added + - `public IReadOnlyList GetPathObjectsByLayer(int ocgId)` + - member added +- **PdfDocument.GetTextObjectsByLayer(Int32)** added + - `public IReadOnlyList GetTextObjectsByLayer(int ocgId)` + - member added +- **PdfDocument.GetTextObjectsByLayer(String)** added + - `public IReadOnlyList GetTextObjectsByLayer(string layerName)` + - member added +- **PdfDocument.Layers** added + - `public PdfLayerCollection Layers { get; }` + - member added +### `IronSoftware.LineCaps` + +- **IronSoftware.LineCaps** added + - `public sealed class LineCaps : Enum` + - type added +### `IronSoftware.LineJoins` + +- **IronSoftware.LineJoins** added + - `public sealed class LineJoins : Enum` + - type added +### `IronSoftware.PathObject` + +- **PathObject.DashPattern** added + - `public IReadOnlyList DashPattern { get; set; }` + - member added +- **PathObject.DashPhase** added + - `public float DashPhase { get; set; }` + - member added +- **PathObject.GetLayer()** added + - `public PdfLayer GetLayer()` + - member added +- **PathObject.LineCap** added + - `public LineCaps LineCap { get; set; }` + - member added +- **PathObject.LineJoin** added + - `public LineJoins LineJoin { get; set; }` + - member added +- **PathObject.OcgId** added + - `public int OcgId { get; }` + - member added +- **PathObject.StrokeWidth** added + - `public float StrokeWidth { get; set; }` + - member added +### `IronSoftware.PdfLayer` + +- **IronSoftware.PdfLayer** added + - `public class PdfLayer : Object` + - type added +### `IronSoftware.PdfLayerCollection` + +- **IronSoftware.PdfLayerCollection** added + - `public class PdfLayerCollection : ReadOnlyCollection` + - type added +### `IronSoftware.TextObject` + +- **TextObject.GetLayer()** added + - `public PdfLayer GetLayer()` + - member added +- **TextObject.OcgId** added + - `public int OcgId { get; }` + - member added + +## Cosmetic (18) + +### `IronPdf.Pages.IPdfPage` + +- **IronPdf.Pages.IPdfPage** changed + - was: `public interface IPdfPage : IDocumentPage, IPageContainer` + - now: `public interface IPdfPage` + - declaration interface list differs (no longer listed: IDocumentPage, IPageContainer) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronPdf.Pages.IPdfPageCollection` + +- **IronPdf.Pages.IPdfPageCollection** changed + - was: `public interface IPdfPageCollection : IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable` + - now: `public interface IPdfPageCollection` + - declaration interface list differs (no longer listed: IDocumentPageCollection, IReadOnlyCollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Deployment.SmartDeploymentBase` + +- **IronSoftware.Deployment.SmartDeploymentBase** changed + - was: `public abstract class SmartDeploymentBase : Object, IDeployment, ICombinedDeployment` + - now: `public abstract class SmartDeploymentBase : Object, IDeployment` + - declaration interface list differs (no longer listed: ICombinedDeployment) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.ICheckableFormField` + +- **IronSoftware.Forms.ICheckableFormField** changed + - was: `public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface ICheckableFormField : IFormField, IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormField` + +- **IronSoftware.Forms.IFormField** changed + - was: `public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormField : IFormFieldObject, IFormFieldAnnotationObject, IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormFieldAnnotation` + +- **IronSoftware.Forms.IFormFieldAnnotation** changed + - was: `public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldAnnotation : IFormFieldAnnotationObject, IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormFieldAnnotationObject` + +- **IronSoftware.Forms.IFormFieldAnnotationObject** changed + - was: `public interface IFormFieldAnnotationObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldAnnotationObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormFieldCollection` + +- **IronSoftware.Forms.IFormFieldCollection** changed + - was: `public interface IFormFieldCollection : IList, ICollection, IEnumerable, IEnumerable` + - now: `public interface IFormFieldCollection` + - declaration interface list differs (no longer listed: IList, ICollection, IEnumerable, IEnumerable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.Forms.IFormFieldObject` + +- **IronSoftware.Forms.IFormFieldObject** changed + - was: `public interface IFormFieldObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject` + - now: `public interface IFormFieldObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfDocumentObject` + +- **IronSoftware.IPdfDocumentObject** changed + - was: `public interface IPdfDocumentObject : IPdfDocumentObject, IDocumentObject` + - now: `public interface IPdfDocumentObject` + - declaration interface list differs (no longer listed: IPdfDocumentObject, IDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfFontObject` + +- **IronSoftware.IPdfFontObject** changed + - was: `public interface IPdfFontObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentFontObject, IFont, IJsonSerializable` + - now: `public interface IPdfFontObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject, IDocumentFontObject, IFont, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfFontObjectCollection` + +- **IronSoftware.IPdfFontObjectCollection** changed + - was: `public interface IPdfFontObjectCollection : IDocumentFontObjectCollection, IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IEnumerable, IJsonSerializable` + - now: `public interface IPdfFontObjectCollection` + - declaration interface list differs (no longer listed: IDocumentFontObjectCollection, IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IEnumerable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfImageObject` + +- **IronSoftware.IPdfImageObject** changed + - was: `public interface IPdfImageObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentImageObject, IBoundedPdfDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable` + - now: `public interface IPdfImageObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject, IDocumentImageObject, IBoundedPdfDocumentObject, IBounded, ITransformable, ICloneable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfImageObjectCollection` + +- **IronSoftware.IPdfImageObjectCollection** changed + - was: `public interface IPdfImageObjectCollection : IDocumentImageObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable` + - now: `public interface IPdfImageObjectCollection` + - declaration interface list differs (no longer listed: IDocumentImageObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfPathObject` + +- **IronSoftware.IPdfPathObject** changed + - was: `public interface IPdfPathObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentPathObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable` + - now: `public interface IPdfPathObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject, IDocumentPathObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IDocumentLayoutFriendly, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfPathObjectCollection` + +- **IronSoftware.IPdfPathObjectCollection** changed + - was: `public interface IPdfPathObjectCollection : IDocumentPathObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable` + - now: `public interface IPdfPathObjectCollection` + - declaration interface list differs (no longer listed: IDocumentPathObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfTextObject` + +- **IronSoftware.IPdfTextObject** changed + - was: `public interface IPdfTextObject : IPdfDocumentObject, IPdfDocumentObject, IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable` + - now: `public interface IPdfTextObject : IPdfDocumentObject` + - declaration interface list differs (no longer listed: IDocumentObject, IDocumentTextObject, IBoundedPdfDocumentObject, IBounded, ITransformable, IColored, ICloneable, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions +### `IronSoftware.IPdfTextObjectCollection` + +- **IronSoftware.IPdfTextObjectCollection** changed + - was: `public interface IPdfTextObjectCollection : IDocumentTextObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable` + - now: `public interface IPdfTextObjectCollection` + - declaration interface list differs (no longer listed: IDocumentTextObjectCollection, IEnumerable, IEnumerable, IList, ICollection, IJsonSerializable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions + +## Warnings (2) + +- 2026.6.1: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) +- 2026.7.2: no page for IronPdf.Engines.Chrome.ChromeClient`1 (identity only, no signatures) diff --git a/docs/api-diffs/ironppt/2025.12.1..2026.1.3.json b/docs/api-diffs/ironppt/2025.12.1..2026.1.3.json new file mode 100644 index 000000000..e3ea5ca27 --- /dev/null +++ b/docs/api-diffs/ironppt/2025.12.1..2026.1.3.json @@ -0,0 +1,41 @@ +{ + "product": "ironppt", + "productName": "IronPPT", + "from": "2025.12.1", + "to": "2026.1.3", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 1, + "cosmetic": 0, + "total": 1, + "typesFrom": 149, + "typesTo": 149 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPPT.Models.Container", + "added": [ + { + "uid": "IronPPT.Models.Container.Remove", + "display": "Container.Remove()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public override void Remove()", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironppt/2025.12.1..2026.1.3.md b/docs/api-diffs/ironppt/2025.12.1..2026.1.3.md new file mode 100644 index 000000000..3bf801274 --- /dev/null +++ b/docs/api-diffs/ironppt/2025.12.1..2026.1.3.md @@ -0,0 +1,11 @@ +# IronPPT API changes: 2025.12.1 -> 2026.1.3 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 1 additive, 0 cosmetic. + +## Additions (1) + +### `IronPPT.Models.Container` + +- **Container.Remove()** added + - `public override void Remove()` + - member added diff --git a/docs/api-diffs/ironppt/2025.12.1..2026.7.1.json b/docs/api-diffs/ironppt/2025.12.1..2026.7.1.json new file mode 100644 index 000000000..af1e9f00e --- /dev/null +++ b/docs/api-diffs/ironppt/2025.12.1..2026.7.1.json @@ -0,0 +1,41 @@ +{ + "product": "ironppt", + "productName": "IronPPT", + "from": "2025.12.1", + "to": "2026.7.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 1, + "cosmetic": 0, + "total": 1, + "typesFrom": 149, + "typesTo": 149 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPPT.Models.Container", + "added": [ + { + "uid": "IronPPT.Models.Container.Remove", + "display": "Container.Remove()", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public override void Remove()", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironppt/2025.12.1..2026.7.1.md b/docs/api-diffs/ironppt/2025.12.1..2026.7.1.md new file mode 100644 index 000000000..673b6aa45 --- /dev/null +++ b/docs/api-diffs/ironppt/2025.12.1..2026.7.1.md @@ -0,0 +1,11 @@ +# IronPPT API changes: 2025.12.1 -> 2026.7.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 1 additive, 0 cosmetic. + +## Additions (1) + +### `IronPPT.Models.Container` + +- **Container.Remove()** added + - `public override void Remove()` + - member added diff --git a/docs/api-diffs/ironppt/2026.1.3..2026.2.2.json b/docs/api-diffs/ironppt/2026.1.3..2026.2.2.json new file mode 100644 index 000000000..7c31bff13 --- /dev/null +++ b/docs/api-diffs/ironppt/2026.1.3..2026.2.2.json @@ -0,0 +1,22 @@ +{ + "product": "ironppt", + "productName": "IronPPT", + "from": "2026.1.3", + "to": "2026.2.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 149, + "typesTo": 149 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironppt/2026.1.3..2026.2.2.md b/docs/api-diffs/ironppt/2026.1.3..2026.2.2.md new file mode 100644 index 000000000..a89c71ce7 --- /dev/null +++ b/docs/api-diffs/ironppt/2026.1.3..2026.2.2.md @@ -0,0 +1,5 @@ +# IronPPT API changes: 2026.1.3 -> 2026.2.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironppt/2026.2.2..2026.3.1.json b/docs/api-diffs/ironppt/2026.2.2..2026.3.1.json new file mode 100644 index 000000000..279434e3a --- /dev/null +++ b/docs/api-diffs/ironppt/2026.2.2..2026.3.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironppt", + "productName": "IronPPT", + "from": "2026.2.2", + "to": "2026.3.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 149, + "typesTo": 149 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironppt/2026.2.2..2026.3.1.md b/docs/api-diffs/ironppt/2026.2.2..2026.3.1.md new file mode 100644 index 000000000..2dd92e211 --- /dev/null +++ b/docs/api-diffs/ironppt/2026.2.2..2026.3.1.md @@ -0,0 +1,5 @@ +# IronPPT API changes: 2026.2.2 -> 2026.3.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironppt/2026.3.1..2026.4.1.json b/docs/api-diffs/ironppt/2026.3.1..2026.4.1.json new file mode 100644 index 000000000..381d53e93 --- /dev/null +++ b/docs/api-diffs/ironppt/2026.3.1..2026.4.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironppt", + "productName": "IronPPT", + "from": "2026.3.1", + "to": "2026.4.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 149, + "typesTo": 149 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironppt/2026.3.1..2026.4.1.md b/docs/api-diffs/ironppt/2026.3.1..2026.4.1.md new file mode 100644 index 000000000..083bad390 --- /dev/null +++ b/docs/api-diffs/ironppt/2026.3.1..2026.4.1.md @@ -0,0 +1,5 @@ +# IronPPT API changes: 2026.3.1 -> 2026.4.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironppt/2026.4.1..2026.5.1.json b/docs/api-diffs/ironppt/2026.4.1..2026.5.1.json new file mode 100644 index 000000000..4239798aa --- /dev/null +++ b/docs/api-diffs/ironppt/2026.4.1..2026.5.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironppt", + "productName": "IronPPT", + "from": "2026.4.1", + "to": "2026.5.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 149, + "typesTo": 149 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironppt/2026.4.1..2026.5.1.md b/docs/api-diffs/ironppt/2026.4.1..2026.5.1.md new file mode 100644 index 000000000..bf779345d --- /dev/null +++ b/docs/api-diffs/ironppt/2026.4.1..2026.5.1.md @@ -0,0 +1,5 @@ +# IronPPT API changes: 2026.4.1 -> 2026.5.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironppt/2026.5.1..2026.6.1.json b/docs/api-diffs/ironppt/2026.5.1..2026.6.1.json new file mode 100644 index 000000000..cf11ecbbe --- /dev/null +++ b/docs/api-diffs/ironppt/2026.5.1..2026.6.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironppt", + "productName": "IronPPT", + "from": "2026.5.1", + "to": "2026.6.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 149, + "typesTo": 149 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironppt/2026.5.1..2026.6.1.md b/docs/api-diffs/ironppt/2026.5.1..2026.6.1.md new file mode 100644 index 000000000..a4aed94a5 --- /dev/null +++ b/docs/api-diffs/ironppt/2026.5.1..2026.6.1.md @@ -0,0 +1,5 @@ +# IronPPT API changes: 2026.5.1 -> 2026.6.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironppt/2026.6.1..2026.7.1.json b/docs/api-diffs/ironppt/2026.6.1..2026.7.1.json new file mode 100644 index 000000000..010206544 --- /dev/null +++ b/docs/api-diffs/ironppt/2026.6.1..2026.7.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironppt", + "productName": "IronPPT", + "from": "2026.6.1", + "to": "2026.7.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 149, + "typesTo": 149 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironppt/2026.6.1..2026.7.1.md b/docs/api-diffs/ironppt/2026.6.1..2026.7.1.md new file mode 100644 index 000000000..5a9224b14 --- /dev/null +++ b/docs/api-diffs/ironppt/2026.6.1..2026.7.1.md @@ -0,0 +1,5 @@ +# IronPPT API changes: 2026.6.1 -> 2026.7.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironprint/2025.12.1..2026.1.5.json b/docs/api-diffs/ironprint/2025.12.1..2026.1.5.json new file mode 100644 index 000000000..6712abbb5 --- /dev/null +++ b/docs/api-diffs/ironprint/2025.12.1..2026.1.5.json @@ -0,0 +1,22 @@ +{ + "product": "ironprint", + "productName": "IronPrint", + "from": "2025.12.1", + "to": "2026.1.5", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 6, + "typesTo": 6 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironprint/2025.12.1..2026.1.5.md b/docs/api-diffs/ironprint/2025.12.1..2026.1.5.md new file mode 100644 index 000000000..1071d539c --- /dev/null +++ b/docs/api-diffs/ironprint/2025.12.1..2026.1.5.md @@ -0,0 +1,5 @@ +# IronPrint API changes: 2025.12.1 -> 2026.1.5 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironprint/2025.12.1..2026.7.1.json b/docs/api-diffs/ironprint/2025.12.1..2026.7.1.json new file mode 100644 index 000000000..176fc2dcc --- /dev/null +++ b/docs/api-diffs/ironprint/2025.12.1..2026.7.1.json @@ -0,0 +1,41 @@ +{ + "product": "ironprint", + "productName": "IronPrint", + "from": "2025.12.1", + "to": "2026.7.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 1, + "cosmetic": 0, + "total": 1, + "typesFrom": 6, + "typesTo": 6 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPrint.PrintSettings", + "added": [ + { + "uid": "IronPrint.PrintSettings.CompactMemoryAfterPrint", + "display": "PrintSettings.CompactMemoryAfterPrint", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool CompactMemoryAfterPrint { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironprint/2025.12.1..2026.7.1.md b/docs/api-diffs/ironprint/2025.12.1..2026.7.1.md new file mode 100644 index 000000000..01c3172f0 --- /dev/null +++ b/docs/api-diffs/ironprint/2025.12.1..2026.7.1.md @@ -0,0 +1,11 @@ +# IronPrint API changes: 2025.12.1 -> 2026.7.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 1 additive, 0 cosmetic. + +## Additions (1) + +### `IronPrint.PrintSettings` + +- **PrintSettings.CompactMemoryAfterPrint** added + - `public bool CompactMemoryAfterPrint { get; set; }` + - member added diff --git a/docs/api-diffs/ironprint/2026.1.5..2026.2.1.json b/docs/api-diffs/ironprint/2026.1.5..2026.2.1.json new file mode 100644 index 000000000..492964ceb --- /dev/null +++ b/docs/api-diffs/ironprint/2026.1.5..2026.2.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironprint", + "productName": "IronPrint", + "from": "2026.1.5", + "to": "2026.2.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 6, + "typesTo": 6 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironprint/2026.1.5..2026.2.1.md b/docs/api-diffs/ironprint/2026.1.5..2026.2.1.md new file mode 100644 index 000000000..1e5e8eabf --- /dev/null +++ b/docs/api-diffs/ironprint/2026.1.5..2026.2.1.md @@ -0,0 +1,5 @@ +# IronPrint API changes: 2026.1.5 -> 2026.2.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironprint/2026.2.1..2026.3.1.json b/docs/api-diffs/ironprint/2026.2.1..2026.3.1.json new file mode 100644 index 000000000..d49cb69e2 --- /dev/null +++ b/docs/api-diffs/ironprint/2026.2.1..2026.3.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironprint", + "productName": "IronPrint", + "from": "2026.2.1", + "to": "2026.3.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 6, + "typesTo": 6 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironprint/2026.2.1..2026.3.1.md b/docs/api-diffs/ironprint/2026.2.1..2026.3.1.md new file mode 100644 index 000000000..806208d8d --- /dev/null +++ b/docs/api-diffs/ironprint/2026.2.1..2026.3.1.md @@ -0,0 +1,5 @@ +# IronPrint API changes: 2026.2.1 -> 2026.3.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironprint/2026.3.1..2026.4.2.json b/docs/api-diffs/ironprint/2026.3.1..2026.4.2.json new file mode 100644 index 000000000..78609b819 --- /dev/null +++ b/docs/api-diffs/ironprint/2026.3.1..2026.4.2.json @@ -0,0 +1,22 @@ +{ + "product": "ironprint", + "productName": "IronPrint", + "from": "2026.3.1", + "to": "2026.4.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 6, + "typesTo": 6 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironprint/2026.3.1..2026.4.2.md b/docs/api-diffs/ironprint/2026.3.1..2026.4.2.md new file mode 100644 index 000000000..a7970e98d --- /dev/null +++ b/docs/api-diffs/ironprint/2026.3.1..2026.4.2.md @@ -0,0 +1,5 @@ +# IronPrint API changes: 2026.3.1 -> 2026.4.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironprint/2026.4.2..2026.5.2.json b/docs/api-diffs/ironprint/2026.4.2..2026.5.2.json new file mode 100644 index 000000000..0f82c5ee2 --- /dev/null +++ b/docs/api-diffs/ironprint/2026.4.2..2026.5.2.json @@ -0,0 +1,22 @@ +{ + "product": "ironprint", + "productName": "IronPrint", + "from": "2026.4.2", + "to": "2026.5.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 6, + "typesTo": 6 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironprint/2026.4.2..2026.5.2.md b/docs/api-diffs/ironprint/2026.4.2..2026.5.2.md new file mode 100644 index 000000000..a56b31878 --- /dev/null +++ b/docs/api-diffs/ironprint/2026.4.2..2026.5.2.md @@ -0,0 +1,5 @@ +# IronPrint API changes: 2026.4.2 -> 2026.5.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironprint/2026.5.2..2026.6.1.json b/docs/api-diffs/ironprint/2026.5.2..2026.6.1.json new file mode 100644 index 000000000..991b2d437 --- /dev/null +++ b/docs/api-diffs/ironprint/2026.5.2..2026.6.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironprint", + "productName": "IronPrint", + "from": "2026.5.2", + "to": "2026.6.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 6, + "typesTo": 6 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironprint/2026.5.2..2026.6.1.md b/docs/api-diffs/ironprint/2026.5.2..2026.6.1.md new file mode 100644 index 000000000..e9c970684 --- /dev/null +++ b/docs/api-diffs/ironprint/2026.5.2..2026.6.1.md @@ -0,0 +1,5 @@ +# IronPrint API changes: 2026.5.2 -> 2026.6.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironprint/2026.6.1..2026.7.1.json b/docs/api-diffs/ironprint/2026.6.1..2026.7.1.json new file mode 100644 index 000000000..24b43b3d3 --- /dev/null +++ b/docs/api-diffs/ironprint/2026.6.1..2026.7.1.json @@ -0,0 +1,41 @@ +{ + "product": "ironprint", + "productName": "IronPrint", + "from": "2026.6.1", + "to": "2026.7.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 1, + "cosmetic": 0, + "total": 1, + "typesFrom": 6, + "typesTo": 6 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronPrint.PrintSettings", + "added": [ + { + "uid": "IronPrint.PrintSettings.CompactMemoryAfterPrint", + "display": "PrintSettings.CompactMemoryAfterPrint", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public bool CompactMemoryAfterPrint { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [], + "changed": [] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironprint/2026.6.1..2026.7.1.md b/docs/api-diffs/ironprint/2026.6.1..2026.7.1.md new file mode 100644 index 000000000..5eae5f104 --- /dev/null +++ b/docs/api-diffs/ironprint/2026.6.1..2026.7.1.md @@ -0,0 +1,11 @@ +# IronPrint API changes: 2026.6.1 -> 2026.7.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 1 additive, 0 cosmetic. + +## Additions (1) + +### `IronPrint.PrintSettings` + +- **PrintSettings.CompactMemoryAfterPrint** added + - `public bool CompactMemoryAfterPrint { get; set; }` + - member added diff --git a/docs/api-diffs/ironqr/2025.12.1..2026.1.1.json b/docs/api-diffs/ironqr/2025.12.1..2026.1.1.json new file mode 100644 index 000000000..e35717ab5 --- /dev/null +++ b/docs/api-diffs/ironqr/2025.12.1..2026.1.1.json @@ -0,0 +1,41 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2025.12.1", + "to": "2026.1.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 1, + "total": 1, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronQr.IQrInput", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronQr.IQrInput", + "display": "IronQr.IQrInput", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IQrInput : IDisposable", + "after": "public interface IQrInput", + "reasons": [ + "declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2025.12.1..2026.1.1.md b/docs/api-diffs/ironqr/2025.12.1..2026.1.1.md new file mode 100644 index 000000000..bd026887e --- /dev/null +++ b/docs/api-diffs/ironqr/2025.12.1..2026.1.1.md @@ -0,0 +1,12 @@ +# IronQR API changes: 2025.12.1 -> 2026.1.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 1 cosmetic. + +## Cosmetic (1) + +### `IronQr.IQrInput` + +- **IronQr.IQrInput** changed + - was: `public interface IQrInput : IDisposable` + - now: `public interface IQrInput` + - declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironqr/2025.12.1..2026.7.1.json b/docs/api-diffs/ironqr/2025.12.1..2026.7.1.json new file mode 100644 index 000000000..de84d8f2e --- /dev/null +++ b/docs/api-diffs/ironqr/2025.12.1..2026.7.1.json @@ -0,0 +1,41 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2025.12.1", + "to": "2026.7.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 1, + "total": 1, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronQr.IQrInput", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronQr.IQrInput", + "display": "IronQr.IQrInput", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IQrInput : IDisposable", + "after": "public interface IQrInput", + "reasons": [ + "declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2025.12.1..2026.7.1.md b/docs/api-diffs/ironqr/2025.12.1..2026.7.1.md new file mode 100644 index 000000000..3c9c9eb75 --- /dev/null +++ b/docs/api-diffs/ironqr/2025.12.1..2026.7.1.md @@ -0,0 +1,12 @@ +# IronQR API changes: 2025.12.1 -> 2026.7.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 1 cosmetic. + +## Cosmetic (1) + +### `IronQr.IQrInput` + +- **IronQr.IQrInput** changed + - was: `public interface IQrInput : IDisposable` + - now: `public interface IQrInput` + - declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironqr/2026.1.1..2026.1.2.json b/docs/api-diffs/ironqr/2026.1.1..2026.1.2.json new file mode 100644 index 000000000..8b413361e --- /dev/null +++ b/docs/api-diffs/ironqr/2026.1.1..2026.1.2.json @@ -0,0 +1,41 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2026.1.1", + "to": "2026.1.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 1, + "total": 1, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronQr.IQrInput", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronQr.IQrInput", + "display": "IronQr.IQrInput", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IQrInput", + "after": "public interface IQrInput : IDisposable", + "reasons": [ + "declaration interface list differs (newly listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2026.1.1..2026.1.2.md b/docs/api-diffs/ironqr/2026.1.1..2026.1.2.md new file mode 100644 index 000000000..b47e2033e --- /dev/null +++ b/docs/api-diffs/ironqr/2026.1.1..2026.1.2.md @@ -0,0 +1,12 @@ +# IronQR API changes: 2026.1.1 -> 2026.1.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 1 cosmetic. + +## Cosmetic (1) + +### `IronQr.IQrInput` + +- **IronQr.IQrInput** changed + - was: `public interface IQrInput` + - now: `public interface IQrInput : IDisposable` + - declaration interface list differs (newly listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironqr/2026.1.2..2026.2.1.json b/docs/api-diffs/ironqr/2026.1.2..2026.2.1.json new file mode 100644 index 000000000..5ad5dcbad --- /dev/null +++ b/docs/api-diffs/ironqr/2026.1.2..2026.2.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2026.1.2", + "to": "2026.2.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2026.1.2..2026.2.1.md b/docs/api-diffs/ironqr/2026.1.2..2026.2.1.md new file mode 100644 index 000000000..1a029a03c --- /dev/null +++ b/docs/api-diffs/ironqr/2026.1.2..2026.2.1.md @@ -0,0 +1,5 @@ +# IronQR API changes: 2026.1.2 -> 2026.2.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironqr/2026.2.1..2026.3.1.json b/docs/api-diffs/ironqr/2026.2.1..2026.3.1.json new file mode 100644 index 000000000..e0a7c273f --- /dev/null +++ b/docs/api-diffs/ironqr/2026.2.1..2026.3.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2026.2.1", + "to": "2026.3.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2026.2.1..2026.3.1.md b/docs/api-diffs/ironqr/2026.2.1..2026.3.1.md new file mode 100644 index 000000000..2cc6a830c --- /dev/null +++ b/docs/api-diffs/ironqr/2026.2.1..2026.3.1.md @@ -0,0 +1,5 @@ +# IronQR API changes: 2026.2.1 -> 2026.3.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironqr/2026.3.1..2026.4.1.json b/docs/api-diffs/ironqr/2026.3.1..2026.4.1.json new file mode 100644 index 000000000..6a6f16500 --- /dev/null +++ b/docs/api-diffs/ironqr/2026.3.1..2026.4.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2026.3.1", + "to": "2026.4.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2026.3.1..2026.4.1.md b/docs/api-diffs/ironqr/2026.3.1..2026.4.1.md new file mode 100644 index 000000000..b4affd001 --- /dev/null +++ b/docs/api-diffs/ironqr/2026.3.1..2026.4.1.md @@ -0,0 +1,5 @@ +# IronQR API changes: 2026.3.1 -> 2026.4.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironqr/2026.4.1..2026.5.1.json b/docs/api-diffs/ironqr/2026.4.1..2026.5.1.json new file mode 100644 index 000000000..ae5fab232 --- /dev/null +++ b/docs/api-diffs/ironqr/2026.4.1..2026.5.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2026.4.1", + "to": "2026.5.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2026.4.1..2026.5.1.md b/docs/api-diffs/ironqr/2026.4.1..2026.5.1.md new file mode 100644 index 000000000..e4e34765b --- /dev/null +++ b/docs/api-diffs/ironqr/2026.4.1..2026.5.1.md @@ -0,0 +1,5 @@ +# IronQR API changes: 2026.4.1 -> 2026.5.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironqr/2026.5.1..2026.6.1.json b/docs/api-diffs/ironqr/2026.5.1..2026.6.1.json new file mode 100644 index 000000000..bd9b937be --- /dev/null +++ b/docs/api-diffs/ironqr/2026.5.1..2026.6.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2026.5.1", + "to": "2026.6.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2026.5.1..2026.6.1.md b/docs/api-diffs/ironqr/2026.5.1..2026.6.1.md new file mode 100644 index 000000000..70e5c2dde --- /dev/null +++ b/docs/api-diffs/ironqr/2026.5.1..2026.6.1.md @@ -0,0 +1,5 @@ +# IronQR API changes: 2026.5.1 -> 2026.6.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironqr/2026.6.1..2026.7.1.json b/docs/api-diffs/ironqr/2026.6.1..2026.7.1.json new file mode 100644 index 000000000..c5268d915 --- /dev/null +++ b/docs/api-diffs/ironqr/2026.6.1..2026.7.1.json @@ -0,0 +1,41 @@ +{ + "product": "ironqr", + "productName": "IronQR", + "from": "2026.6.1", + "to": "2026.7.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 1, + "total": 1, + "typesFrom": 22, + "typesTo": 22 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronQr.IQrInput", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronQr.IQrInput", + "display": "IronQr.IQrInput", + "severity": "COSMETIC", + "target": "type", + "before": "public interface IQrInput : IDisposable", + "after": "public interface IQrInput", + "reasons": [ + "declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + } + ], + "warnings": [] +} diff --git a/docs/api-diffs/ironqr/2026.6.1..2026.7.1.md b/docs/api-diffs/ironqr/2026.6.1..2026.7.1.md new file mode 100644 index 000000000..9a436e1e6 --- /dev/null +++ b/docs/api-diffs/ironqr/2026.6.1..2026.7.1.md @@ -0,0 +1,12 @@ +# IronQR API changes: 2026.6.1 -> 2026.7.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 1 cosmetic. + +## Cosmetic (1) + +### `IronQr.IQrInput` + +- **IronQr.IQrInput** changed + - was: `public interface IQrInput : IDisposable` + - now: `public interface IQrInput` + - declaration interface list differs (no longer listed: IDisposable) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions diff --git a/docs/api-diffs/ironwebscraper/2025.12.2..2026.1.1.json b/docs/api-diffs/ironwebscraper/2025.12.2..2026.1.1.json new file mode 100644 index 000000000..8d2b6a18d --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2025.12.2..2026.1.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironwebscraper", + "productName": "IronWebscraper", + "from": "2025.12.2", + "to": "2026.1.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 13, + "typesTo": 13 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironwebscraper/2025.12.2..2026.1.1.md b/docs/api-diffs/ironwebscraper/2025.12.2..2026.1.1.md new file mode 100644 index 000000000..5d55eaa68 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2025.12.2..2026.1.1.md @@ -0,0 +1,5 @@ +# IronWebscraper API changes: 2025.12.2 -> 2026.1.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironwebscraper/2025.12.2..2026.7.1.json b/docs/api-diffs/ironwebscraper/2025.12.2..2026.7.1.json new file mode 100644 index 000000000..d703a0588 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2025.12.2..2026.7.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironwebscraper", + "productName": "IronWebscraper", + "from": "2025.12.2", + "to": "2026.7.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 13, + "typesTo": 13 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironwebscraper/2025.12.2..2026.7.1.md b/docs/api-diffs/ironwebscraper/2025.12.2..2026.7.1.md new file mode 100644 index 000000000..0db211f91 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2025.12.2..2026.7.1.md @@ -0,0 +1,5 @@ +# IronWebscraper API changes: 2025.12.2 -> 2026.7.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironwebscraper/2026.1.1..2026.2.1.json b/docs/api-diffs/ironwebscraper/2026.1.1..2026.2.1.json new file mode 100644 index 000000000..5746ae931 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.1.1..2026.2.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironwebscraper", + "productName": "IronWebscraper", + "from": "2026.1.1", + "to": "2026.2.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 13, + "typesTo": 13 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironwebscraper/2026.1.1..2026.2.1.md b/docs/api-diffs/ironwebscraper/2026.1.1..2026.2.1.md new file mode 100644 index 000000000..bceccce16 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.1.1..2026.2.1.md @@ -0,0 +1,5 @@ +# IronWebscraper API changes: 2026.1.1 -> 2026.2.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironwebscraper/2026.2.1..2026.3.2.json b/docs/api-diffs/ironwebscraper/2026.2.1..2026.3.2.json new file mode 100644 index 000000000..892925e6f --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.2.1..2026.3.2.json @@ -0,0 +1,22 @@ +{ + "product": "ironwebscraper", + "productName": "IronWebscraper", + "from": "2026.2.1", + "to": "2026.3.2", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 13, + "typesTo": 13 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironwebscraper/2026.2.1..2026.3.2.md b/docs/api-diffs/ironwebscraper/2026.2.1..2026.3.2.md new file mode 100644 index 000000000..09ad267e2 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.2.1..2026.3.2.md @@ -0,0 +1,5 @@ +# IronWebscraper API changes: 2026.2.1 -> 2026.3.2 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironwebscraper/2026.3.2..2026.4.1.json b/docs/api-diffs/ironwebscraper/2026.3.2..2026.4.1.json new file mode 100644 index 000000000..4d0d44b4b --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.3.2..2026.4.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironwebscraper", + "productName": "IronWebscraper", + "from": "2026.3.2", + "to": "2026.4.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 13, + "typesTo": 13 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironwebscraper/2026.3.2..2026.4.1.md b/docs/api-diffs/ironwebscraper/2026.3.2..2026.4.1.md new file mode 100644 index 000000000..7d13e0419 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.3.2..2026.4.1.md @@ -0,0 +1,5 @@ +# IronWebscraper API changes: 2026.3.2 -> 2026.4.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironwebscraper/2026.4.1..2026.5.1.json b/docs/api-diffs/ironwebscraper/2026.4.1..2026.5.1.json new file mode 100644 index 000000000..d5c996a95 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.4.1..2026.5.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironwebscraper", + "productName": "IronWebscraper", + "from": "2026.4.1", + "to": "2026.5.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 13, + "typesTo": 13 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironwebscraper/2026.4.1..2026.5.1.md b/docs/api-diffs/ironwebscraper/2026.4.1..2026.5.1.md new file mode 100644 index 000000000..e082587f7 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.4.1..2026.5.1.md @@ -0,0 +1,5 @@ +# IronWebscraper API changes: 2026.4.1 -> 2026.5.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironwebscraper/2026.5.1..2026.6.1.json b/docs/api-diffs/ironwebscraper/2026.5.1..2026.6.1.json new file mode 100644 index 000000000..53bb1bcd7 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.5.1..2026.6.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironwebscraper", + "productName": "IronWebscraper", + "from": "2026.5.1", + "to": "2026.6.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 13, + "typesTo": 13 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironwebscraper/2026.5.1..2026.6.1.md b/docs/api-diffs/ironwebscraper/2026.5.1..2026.6.1.md new file mode 100644 index 000000000..af137e2c7 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.5.1..2026.6.1.md @@ -0,0 +1,5 @@ +# IronWebscraper API changes: 2026.5.1 -> 2026.6.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironwebscraper/2026.6.1..2026.7.1.json b/docs/api-diffs/ironwebscraper/2026.6.1..2026.7.1.json new file mode 100644 index 000000000..e4ebc9ad5 --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.6.1..2026.7.1.json @@ -0,0 +1,22 @@ +{ + "product": "ironwebscraper", + "productName": "IronWebscraper", + "from": "2026.6.1", + "to": "2026.7.1", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 0, + "additive": 0, + "cosmetic": 0, + "total": 0, + "typesFrom": 13, + "typesTo": 13 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [], + "warnings": [] +} diff --git a/docs/api-diffs/ironwebscraper/2026.6.1..2026.7.1.md b/docs/api-diffs/ironwebscraper/2026.6.1..2026.7.1.md new file mode 100644 index 000000000..7b3d077ed --- /dev/null +++ b/docs/api-diffs/ironwebscraper/2026.6.1..2026.7.1.md @@ -0,0 +1,5 @@ +# IronWebscraper API changes: 2026.6.1 -> 2026.7.1 + +Generated from the object-reference archive (xrefmap + DocFX declarations). **0 breaking**, 0 additive, 0 cosmetic. + +No public API changes. diff --git a/docs/api-diffs/ironword/2025.12.1..2026.1.4.json b/docs/api-diffs/ironword/2025.12.1..2026.1.4.json new file mode 100644 index 000000000..b1a46dd45 --- /dev/null +++ b/docs/api-diffs/ironword/2025.12.1..2026.1.4.json @@ -0,0 +1,4577 @@ +{ + "product": "ironword", + "productName": "IronWord", + "from": "2025.12.1", + "to": "2026.1.4", + "generatedFrom": "xrefmap+html", + "summary": { + "breaking": 214, + "additive": 144, + "cosmetic": 5, + "total": 363, + "typesFrom": 168, + "typesTo": 180 + }, + "severities": [ + "BREAKING", + "ADDITIVE", + "COSMETIC" + ], + "types": [ + { + "fqn": "IronWord.Models.Abstract.ContentElement", + "added": [ + { + "uid": "IronWord.Models.Abstract.ContentElement.Replace(IronSoftware.Abstractions.Word.IWordDocumentObject)", + "display": "ContentElement.Replace(IWordDocumentObject)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void Replace(IWordDocumentObject newChild)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronWord.Models.Abstract.ContentElement.DocumentId", + "display": "ContentElement.DocumentId", + "severity": "BREAKING", + "target": "member", + "before": "public IDocumentId DocumentId { get; set; }", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElement.ObjNum", + "display": "ContentElement.ObjNum", + "severity": "BREAKING", + "target": "member", + "before": "public uint ObjNum { get; set; }", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElement.PageIndex", + "display": "ContentElement.PageIndex", + "severity": "BREAKING", + "target": "member", + "before": "public uint PageIndex { get; set; }", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElement.Replace(IronWord.Models.Abstract.ContentElement)", + "display": "ContentElement.Replace(ContentElement)", + "severity": "BREAKING", + "target": "member", + "before": "public void Replace(ContentElement newChild)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [ + { + "uid": "IronWord.Models.Abstract.ContentElement.Status", + "display": "ContentElement.Status", + "severity": "BREAKING", + "target": "member", + "before": "public ElementStatus Status", + "after": "public ElementStatus Status { get; set; }", + "reasons": [ + "field converted to a property" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElement", + "display": "IronWord.Models.Abstract.ContentElement", + "severity": "BREAKING", + "target": "type", + "before": "public abstract class ContentElement : Object, IDocumentElement, IDocumentObject, ICloneable", + "after": "public abstract class ContentElement : Object, IWordDocumentObject, IDocumentObject, ICloneable", + "reasons": [ + "interface no longer implemented: IDocumentElement", + "interface now implemented: IWordDocumentObject" + ] + } + ] + }, + { + "fqn": "IronWord.Models.Abstract.ContentElementCollection", + "added": [ + { + "uid": "IronWord.Models.Abstract.ContentElementCollection.#ctor(System.Collections.Generic.IList{IronSoftware.Abstractions.Word.IWordDocumentObject})", + "display": "ContentElementCollection.ContentElementCollection(IList)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public ContentElementCollection(IList collection_in)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElementCollection.IndexOf(IronSoftware.Abstractions.Word.IWordDocumentObject)", + "display": "ContentElementCollection.IndexOf(IWordDocumentObject)", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public int IndexOf(IWordDocumentObject item)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronWord.Models.Abstract.ContentElementCollection.#ctor(System.Collections.Generic.IList{IronWord.Models.Abstract.ContentElement})", + "display": "ContentElementCollection.ContentElementCollection(IList)", + "severity": "BREAKING", + "target": "member", + "before": "public ContentElementCollection(IList collection_in)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElementCollection.IndexOf(IronWord.Models.Abstract.ContentElement)", + "display": "ContentElementCollection.IndexOf(ContentElement)", + "severity": "BREAKING", + "target": "member", + "before": "public int IndexOf(ContentElement item)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [ + { + "uid": "IronWord.Models.Abstract.ContentElementCollection.First", + "display": "ContentElementCollection.First()", + "severity": "BREAKING", + "target": "member", + "before": "public ContentElement First()", + "after": "public IWordDocumentObject First()", + "reasons": [ + "type changed: ContentElement -> IWordDocumentObject" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElementCollection.GetEnumerator", + "display": "ContentElementCollection.GetEnumerator()", + "severity": "BREAKING", + "target": "member", + "before": "public IEnumerator GetEnumerator()", + "after": "public IEnumerator GetEnumerator()", + "reasons": [ + "type changed: IEnumerator -> IEnumerator" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElementCollection.Item(System.Int32)", + "display": "ContentElementCollection.Item[Int32]", + "severity": "BREAKING", + "target": "member", + "before": "public ContentElement this[int index] { get; }", + "after": "public IWordDocumentObject this[int index] { get; }", + "reasons": [ + "type changed: ContentElement -> IWordDocumentObject" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElementCollection.Last", + "display": "ContentElementCollection.Last()", + "severity": "BREAKING", + "target": "member", + "before": "public ContentElement Last()", + "after": "public IWordDocumentObject Last()", + "reasons": [ + "type changed: ContentElement -> IWordDocumentObject" + ] + }, + { + "uid": "IronWord.Models.Abstract.ContentElementCollection", + "display": "IronWord.Models.Abstract.ContentElementCollection", + "severity": "BREAKING", + "target": "type", + "before": "public class ContentElementCollection : Object, IEnumerable, IEnumerable", + "after": "public class ContentElementCollection : Object, IWordDocumentObjectCollection, IDocumentObjectCollection, IEnumerable, IEnumerable", + "reasons": [ + "interface no longer implemented: IEnumerable", + "interface now implemented: IDocumentObjectCollection, IEnumerable, IWordDocumentObjectCollection" + ] + } + ] + }, + { + "fqn": "IronWord.Models.Abstract.ParentElement", + "added": [ + { + "uid": "IronWord.Models.Abstract.ParentElement.AddChild(IronSoftware.Abstractions.Word.IWordDocumentObject[])", + "display": "ParentElement.AddChild(IWordDocumentObject[])", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public virtual void AddChild(params IWordDocumentObject[] children)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.InsertChildToIndex(System.Int32,IronSoftware.Abstractions.Word.IWordDocumentObject[])", + "display": "ParentElement.InsertChildToIndex(Int32, IWordDocumentObject[])", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void InsertChildToIndex(int index, params IWordDocumentObject[] children)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.#ctor(IronSoftware.Abstractions.Word.IWordDocumentObject[])", + "display": "ParentElement.ParentElement(IWordDocumentObject[])", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public ParentElement(params IWordDocumentObject[] children)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.RemoveChildren(IronSoftware.Abstractions.Word.IWordDocumentObject[])", + "display": "ParentElement.RemoveChildren(IWordDocumentObject[])", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public void RemoveChildren(params IWordDocumentObject[] children)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronWord.Models.Abstract.ParentElement.AddChild(IronWord.Models.Abstract.ContentElement[])", + "display": "ParentElement.AddChild(ContentElement[])", + "severity": "BREAKING", + "target": "member", + "before": "public virtual void AddChild(params ContentElement[] children)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.DefaultTextStyle", + "display": "ParentElement.DefaultTextStyle", + "severity": "BREAKING", + "target": "member", + "before": "public TextStyle DefaultTextStyle { get; set; }", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.InsertChildToIndex(System.Int32,IronWord.Models.Abstract.ContentElement[])", + "display": "ParentElement.InsertChildToIndex(Int32, ContentElement[])", + "severity": "BREAKING", + "target": "member", + "before": "public void InsertChildToIndex(int index, params ContentElement[] children)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.#ctor(IronWord.Models.Abstract.ContentElement[])", + "display": "ParentElement.ParentElement(ContentElement[])", + "severity": "BREAKING", + "target": "member", + "before": "public ParentElement(params ContentElement[] children)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.RemoveChildren(IronWord.Models.Abstract.ContentElement[])", + "display": "ParentElement.RemoveChildren(ContentElement[])", + "severity": "BREAKING", + "target": "member", + "before": "public void RemoveChildren(params ContentElement[] children)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [ + { + "uid": "IronWord.Models.Abstract.ParentElement", + "display": "IronWord.Models.Abstract.ParentElement", + "severity": "BREAKING", + "target": "type", + "before": "public abstract class ParentElement : ContentElement, IDocumentElement, IDocumentObject, ICloneable", + "after": "public abstract class ParentElement : ContentElement, IWordDocumentObject, IDocumentObject, ICloneable, IParent", + "reasons": [ + "interface no longer implemented: IDocumentElement", + "interface now implemented: IParent, IWordDocumentObject" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.Children", + "display": "ParentElement.Children", + "severity": "BREAKING", + "target": "member", + "before": "public ContentElementCollection Children { get; }", + "after": "public IWordDocumentObjectCollection Children { get; }", + "reasons": [ + "type changed: ContentElementCollection -> IWordDocumentObjectCollection" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.ExtractElements``1", + "display": "ParentElement.ExtractElements()", + "severity": "BREAKING", + "target": "member", + "before": "public List ExtractElements() where T : ContentElement", + "after": "public List ExtractElements() where T : IWordDocumentObject", + "reasons": [ + "base type removed: ContentElement", + "declaration interface list differs (newly listed: IWordDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + }, + { + "uid": "IronWord.Models.Abstract.ParentElement.GetChildByIndex``1(System.Int32)", + "display": "ParentElement.GetChildByIndex(Int32)", + "severity": "BREAKING", + "target": "member", + "before": "public ContentElement GetChildByIndex(int index) where T : ContentElement", + "after": "public IWordDocumentObject GetChildByIndex(int index) where T : IWordDocumentObject", + "reasons": [ + "type changed: ContentElement GetChildByIndex where -> IWordDocumentObject GetChildByIndex where", + "base type removed: ContentElement", + "declaration interface list differs (newly listed: IWordDocumentObject) — unverifiable, this page has no Implements section and DocFX renders the declaration's interface list inconsistently across versions" + ] + } + ] + }, + { + "fqn": "IronWord.Models.Abstract.TableElement", + "added": [ + { + "uid": "IronWord.Models.Abstract.TableElement", + "display": "IronWord.Models.Abstract.TableElement", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public abstract class TableElement : ParentElement, IWordDocumentObject, IDocumentObject, ICloneable, IParent", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronWord.Models.Abstract.TableElements", + "added": [], + "removed": [ + { + "uid": "IronWord.Models.Abstract.TableElements.ExtractImages", + "display": "TableElements.ExtractImages()", + "severity": "BREAKING", + "target": "member", + "before": "public List ExtractImages()", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "IronWord.Models.Abstract.TableElements.ExtractShapes", + "display": "TableElements.ExtractShapes()", + "severity": "BREAKING", + "target": "member", + "before": "public List> ExtractShapes()", + "after": "", + "reasons": [ + "member removed" + ] + } + ], + "changed": [ + { + "uid": "IronWord.Models.Abstract.TableElements", + "display": "IronWord.Models.Abstract.TableElements", + "severity": "BREAKING", + "target": "type", + "before": "public abstract class TableElements : ParentElement, IDocumentElement, IDocumentObject, ICloneable", + "after": "public abstract class TableElements : ParentElement, lyduza", + "reasons": [ + "base type added: lyduza", + "interface no longer implemented: ICloneable, IDocumentElement, IDocumentObject" + ] + } + ] + }, + { + "fqn": "IronWord.Models.Abstract.TextContainer", + "added": [ + { + "uid": "IronWord.Models.Abstract.TextContainer.AddChild(IronSoftware.Abstractions.Word.IWordDocumentObject[])", + "display": "TextContainer.AddChild(IWordDocumentObject[])", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public override void AddChild(params IWordDocumentObject[] children)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + } + ], + "removed": [ + { + "uid": "IronWord.Models.Abstract.TextContainer.AddChild(IronWord.Models.Abstract.ContentElement[])", + "display": "TextContainer.AddChild(ContentElement[])", + "severity": "BREAKING", + "target": "member", + "before": "public override void AddChild(params ContentElement[] children)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + } + ], + "changed": [ + { + "uid": "IronWord.Models.Abstract.TextContainer", + "display": "IronWord.Models.Abstract.TextContainer", + "severity": "BREAKING", + "target": "type", + "before": "public abstract class TextContainer : ParentElement, IDocumentElement, IDocumentObject, ICloneable, ITextContainer", + "after": "public abstract class TextContainer : ParentElement, IWordDocumentObject, IDocumentObject, ICloneable, IParent, ITextContainer", + "reasons": [ + "interface no longer implemented: IDocumentElement", + "interface now implemented: IParent, IWordDocumentObject" + ] + } + ] + }, + { + "fqn": "IronWord.Models.Abstract.TextContentElement", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronWord.Models.Abstract.TextContentElement", + "display": "IronWord.Models.Abstract.TextContentElement", + "severity": "BREAKING", + "target": "type", + "before": "public abstract class TextContentElement : ContentElement, IDocumentElement, IDocumentObject, ICloneable, ITextContentElement", + "after": "public abstract class TextContentElement : ContentElement, lyduza, ITextContentElement", + "reasons": [ + "base type added: lyduza", + "interface no longer implemented: ICloneable, IDocumentElement, IDocumentObject" + ] + } + ] + }, + { + "fqn": "IronWord.Models.BaseStyle", + "added": [ + { + "uid": "IronWord.Models.BaseStyle", + "display": "IronWord.Models.BaseStyle", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class BaseStyle : Object, IBaseStyle, IBaseStyle, IStyle, IWordDocumentObjectProperty, IDocumentObjectProperty", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronWord.Models.BezierSegment", + "added": [ + { + "uid": "IronWord.Models.BezierSegment", + "display": "IronWord.Models.BezierSegment", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class BezierSegment : Object, IBezierSegment, IPathSegment", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronWord.Models.Break", + "added": [ + { + "uid": "IronWord.Models.Break", + "display": "IronWord.Models.Break", + "severity": "ADDITIVE", + "target": "type", + "before": "", + "after": "public class Break : ContentElement, IBreak, IWordDocumentObject, IDocumentObject, ICloneable", + "reasons": [ + "type added" + ] + } + ], + "removed": [], + "changed": [] + }, + { + "fqn": "IronWord.Models.Chart", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronWord.Models.Chart", + "display": "IronWord.Models.Chart", + "severity": "BREAKING", + "target": "type", + "before": "public class Chart : ContentElement, IDocumentElement, IDocumentObject, ICloneable", + "after": "public class Chart : ContentElement, IWordDocumentObject, IDocumentObject, ICloneable", + "reasons": [ + "interface no longer implemented: IDocumentElement", + "interface now implemented: IWordDocumentObject" + ] + } + ] + }, + { + "fqn": "IronWord.Models.Color", + "added": [], + "removed": [], + "changed": [ + { + "uid": "IronWord.Models.Color", + "display": "IronWord.Models.Color", + "severity": "ADDITIVE", + "target": "type", + "before": "public class Color : Object", + "after": "public class Color : Object, IColor, IWordDocumentObjectProperty, IDocumentObjectProperty", + "reasons": [ + "interface now implemented: IColor, IDocumentObjectProperty, IWordDocumentObjectProperty" + ] + } + ] + }, + { + "fqn": "IronWord.Models.Container", + "added": [ + { + "uid": "IronWord.Models.Container.AddChild(IronSoftware.Abstractions.Word.IWordDocumentObject[])", + "display": "Container.AddChild(IWordDocumentObject[])", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public override void AddChild(params IWordDocumentObject[] children)", + "reasons": [ + "member added", + "overload signature change (see the matching removal)" + ] + }, + { + "uid": "IronWord.Models.Container.DefaultParagraphStyle", + "display": "Container.DefaultParagraphStyle", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public ParagraphStyle DefaultParagraphStyle { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronWord.Models.Container.DefaultTableStyle", + "display": "Container.DefaultTableStyle", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public TableStyle DefaultTableStyle { get; set; }", + "reasons": [ + "member added" + ] + }, + { + "uid": "IronWord.Models.Container.DefaultTextStyle", + "display": "Container.DefaultTextStyle", + "severity": "ADDITIVE", + "target": "member", + "before": "", + "after": "public TextStyle DefaultTextStyle { get; set; }", + "reasons": [ + "member added" + ] + } + ], + "removed": [ + { + "uid": "IronWord.Models.Container.AddChild(IronWord.Models.Abstract.ContentElement[])", + "display": "Container.AddChild(ContentElement[])", + "severity": "BREAKING", + "target": "member", + "before": "public override void AddChild(params ContentElement[] children)", + "after": "", + "reasons": [ + "member removed", + "overload signature change (see the matching addition)" + ] + }, + { + "uid": "IronWord.Models.Container.ParagraphsDefaultStyle", + "display": "Container.ParagraphsDefaultStyle", + "severity": "BREAKING", + "target": "member", + "before": "public ParagraphStyle ParagraphsDefaultStyle { get; set; }", + "after": "", + "reasons": [ + "member removed" + ] + }, + { + "uid": "IronWord.Models.Container.TextsDefaultStyle", + "display": "Container.TextsDefaultStyle", + "severity": "BREAKING", + "target": "member", + "before": "public TextStyle TextsDefaultStyle { get; set; }", + "after": "", + "reasons": [ + "member removed" + ] + } + ], + "changed": [ + { + "uid": "IronWord.Models.Container.BuiltInStyles", + "display": "Container.BuiltInStyles", + "severity": "BREAKING", + "target": "member", + "before": "public List