Referencia de la API de Julia
PDF Oxide ofrece bindings idiomáticos de Julia (PdfOxide.jl) que se apoyan directamente sobre la C ABI de pdf_oxide mediante ccall, sin ninguna capa intermedia. Los handles nativos se envuelven en structs mutables con finalizers, las cadenas C y los búferes se copian a Julia y se liberan automáticamente, y cualquier código de estado de la C ABI distinto de éxito lanza un PdfOxideError. Los índices de página empiezan en 0.
using Pkg
Pkg.add("PdfOxide")
La cdylib nativa libpdf_oxide se carga en tiempo de ejecución y se resuelve siguiendo el orden PDF_OXIDE_LIB_PATH → PDF_OXIDE_LIB_DIR → ../target/release → target/release → el cargador del sistema. Compílala con el conjunto de features necesario para los bindings:
cargo build --release --lib --features ocr,rendering,signatures,barcodes,tsa-client,system-fonts
using PdfOxide
pdf = from_markdown("# Hello\n\nbody\n")
doc = open_from_bytes(to_bytes(pdf))
page_count(doc)
extract_text(doc, 0) # 0-based page index
to_markdown_all(doc)
close!(doc)
Para la API de Rust, consulta la Referencia de la API de Rust. Para la API de Python, consulta la Referencia de la API de Python. Para más detalles sobre tipos, consulta Tipos y enumeraciones.
La mayoría de los tipos handle (PdfDocument, Pdf, DocumentEditor, DocumentBuilder, RenderedImage, Certificate, SignatureInfo, Timestamp, TsaClient, Dss, los resultados de validación, Barcode, OcrEngine, Renderer, ElementList, EmbeddedFont, PageBuilder) poseen memoria nativa. Libéralos cuanto antes con close!(x); es idempotente y también se ejecuta durante la finalización.
PdfDocument
El handle de lectura para abrir, extraer, buscar, renderizar, validar e inspeccionar un PDF existente.
Apertura
open_document(path::AbstractString; password::Union{Nothing,AbstractString} = nothing) -> PdfDocument
open_from_bytes(data::AbstractVector{UInt8}) -> PdfDocument
open_with_password(path::AbstractString, password::AbstractString) -> PdfDocument
| Función |
Descripción |
open_document(path; password=nothing) |
Abre un PDF desde una ruta del sistema de archivos (opcionalmente protegido con contraseña). |
open_from_bytes(data) |
Abre un PDF a partir de un vector de bytes en memoria. |
open_with_password(path, password) |
Abre en disco un PDF cifrado usando una contraseña. |
| Función |
Devuelve |
Descripción |
page_count(d) |
Int |
Número de páginas. |
version(d) |
PdfVersion |
Versión del PDF (major/minor). |
is_encrypted(d) |
Bool |
Indica si el documento está cifrado. |
has_structure_tree(d) |
Bool |
Indica si el documento es un PDF etiquetado con árbol de estructura. |
has_xfa(d) |
Bool |
Indica si el documento incluye un formulario XFA. |
authenticate(d, password) |
Bool |
Autentica la contraseña de un documento cifrado (una contraseña incorrecta devuelve false, no un error). |
Conversión del documento completo
| Función |
Devuelve |
Descripción |
to_markdown_all(d) |
String |
Markdown del documento completo. |
to_html_all(d) |
String |
HTML del documento completo. |
to_plain_text_all(d) |
String |
Texto plano del documento completo. |
extract_all_text(d) |
String |
Extracción automática de texto de todo el documento. |
classify_document(d) |
String |
Clasifica el documento completo; devuelve la cadena JSON del clasificador. |
extract_text(d::PdfDocument, page::Integer) -> String
to_plain_text(d::PdfDocument, page::Integer) -> String
to_markdown(d::PdfDocument, page::Integer) -> String
to_html(d::PdfDocument, page::Integer) -> String
extract_structured_json(d::PdfDocument, page::Integer) -> String
| Función |
Descripción |
extract_text(d, page) |
Extrae texto plano de una página (índice basado en 0). |
to_plain_text(d, page) |
Renderiza una página como texto plano respetando el layout. |
to_markdown(d, page) |
Renderiza una página a Markdown. |
to_html(d, page) |
Renderiza una página a HTML. |
extract_structured_json(d, page) |
Extrae un modelo JSON de documento estructurado para una página. |
extract_text_auto(d, page) |
Elige automáticamente la mejor extracción de texto para una página. |
extract_page_auto(d, page, options="{}") |
Extracción automática de página con una cadena JSON de opciones. |
classify_page(d, page) |
Clasifica una página; devuelve la cadena JSON del clasificador. |
extract_chars(d::PdfDocument, page::Integer) -> Vector{Char}
extract_words(d::PdfDocument, page::Integer) -> Vector{Word}
extract_text_lines(d::PdfDocument, page::Integer) -> Vector{TextLine}
extract_tables(d::PdfDocument, page::Integer) -> Vector{Table}
embedded_fonts(d::PdfDocument, page::Integer) -> Vector{Font}
embedded_images(d::PdfDocument, page::Integer) -> Vector{Image}
page_annotations(d::PdfDocument, page::Integer) -> Vector{Annotation}
extract_paths(d::PdfDocument, page::Integer) -> Vector{Path}
| Función |
Descripción |
extract_chars(d, page) |
Extrae los glifos de una página como un Vector{Char}. |
extract_words(d, page) |
Extrae las palabras de una página como un Vector{Word}. |
extract_text_lines(d, page) |
Extrae las líneas de texto como un Vector{TextLine}. |
extract_tables(d, page) |
Extrae las tablas como un Vector{Table}. |
embedded_fonts(d, page) |
Fuentes incrustadas como un Vector{Font}. |
embedded_images(d, page) |
Imágenes incrustadas como un Vector{Image}. |
page_annotations(d, page) |
Anotaciones como un Vector{Annotation}. |
extract_paths(d, page) |
Rutas vectoriales como un Vector{Path}. |
extract_text_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> String
extract_words_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> Vector{Word}
extract_lines_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> Vector{TextLine}
extract_tables_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> Vector{Table}
extract_images_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> Vector{Image}
Cada una restringe la extracción al rectángulo (x, y, w, h) en puntos del espacio de usuario PDF sobre una página (índice basado en 0).
Búsqueda
search(d::PdfDocument, page::Integer, term::AbstractString, caseSensitive::Bool) -> Vector{SearchResult}
search_all(d::PdfDocument, term::AbstractString, caseSensitive::Bool) -> Vector{SearchResult}
search_results_to_json(d::PdfDocument, term::AbstractString, caseSensitive::Bool) -> String
| Función |
Descripción |
search(d, page, term, caseSensitive) |
Busca term en una sola página. |
search_all(d, term, caseSensitive) |
Busca term en todo el documento. |
search_results_to_json(d, term, caseSensitive) |
Serializa a JSON los resultados de búsqueda de todo el documento. |
Geometría de página
| Función |
Devuelve |
Descripción |
page_get_width(d, page) |
Float64 |
Ancho de la página (puntos PDF). |
page_get_height(d, page) |
Float64 |
Alto de la página (puntos PDF). |
page_get_rotation(d, page) |
Int |
Rotación absoluta (grados) de una página. |
page(d, index) |
PdfPage |
Una vista de página (índice basado en 0) sobre el documento (ver PdfPage). |
| Función |
Devuelve |
Descripción |
get_outline(d) |
String |
Marcadores / tabla de contenidos (JSON). |
get_page_labels(d) |
String |
Rangos de etiquetas de página (JSON). |
get_xmp_metadata(d) |
String |
Metadatos XMP (JSON). |
get_source_bytes(d) |
Vector{UInt8} |
Los bytes de origen originales del documento. |
plan_split_by_bookmarks(d, options="{}") |
String |
Planifica una operación de división por marcadores (JSON). |
Inspección de anotaciones
annotations_to_json(d::PdfDocument, page::Integer) -> String
annotation_get_color(d::PdfDocument, page::Integer, index::Integer) -> UInt32
annotation_creation_date(d::PdfDocument, page::Integer, index::Integer) -> String
annotation_modification_date(d::PdfDocument, page::Integer, index::Integer) -> String
| Función |
Devuelve |
Descripción |
annotations_to_json(d, page) |
String |
Todas las anotaciones de una página como JSON. |
annotation_get_color(d, page, index) |
UInt32 |
Color RGBA empaquetado de 32 bits de una anotación. |
annotation_creation_date(d, page, index) |
String |
Fecha de creación de la anotación. |
annotation_modification_date(d, page, index) |
String |
Fecha de modificación de la anotación. |
annotation_is_hidden(d, page, index) |
Bool |
Indica si la anotación está oculta. |
annotation_is_marked_deleted(d, page, index) |
Bool |
Indica si la anotación está marcada como eliminada. |
annotation_is_printable(d, page, index) |
Bool |
Indica si la anotación es imprimible. |
annotation_is_read_only(d, page, index) |
Bool |
Indica si la anotación es de solo lectura. |
link_annotation_uri(d, page, index) |
String |
URI de una anotación Link. |
text_annotation_icon_name(d, page, index) |
String |
Nombre de icono de una anotación Text (nota adhesiva). |
highlight_quad_points_count(d, page, index) |
Int |
Número de cuadriláteros de una anotación Highlight. |
highlight_quad_point(d, page, index, quad_index) |
NTuple{8,Float64} |
El cuadrilátero número quad_index (8 floats). |
Ayudantes JSON de fuentes y elementos
| Función |
Devuelve |
Descripción |
fonts_to_json(d, page) |
String |
Fuentes incrustadas de una página como JSON. |
font_size(d, page, index) |
Float64 |
Tamaño de la fuente incrustada número index. |
page_get_elements(d, page) |
ElementList |
Elementos de las regiones de layout de la página como ElementList. |
get_form_fields(d::PdfDocument) -> Vector{FormField}
form_field_count(d::PdfDocument) -> Int
export_form_data_to_bytes(d::PdfDocument, format_type::Integer) -> Vector{UInt8}
import_form_data(d::PdfDocument, path::AbstractString) -> Int
form_import_from_file(d::PdfDocument, filename::AbstractString) -> Bool
| Función |
Descripción |
get_form_fields(d) |
Todos los campos AcroForm como un Vector{FormField}. |
form_field_count(d) |
Conteo rápido de campos. |
export_form_data_to_bytes(d, format_type) |
Exporta los datos del formulario (format_type selecciona FDF/XFDF). |
import_form_data(d, path) |
Importa datos de formulario desde un archivo; devuelve el código de estado de la C. |
form_import_from_file(d, filename) |
Importa datos de formulario; devuelve true si tiene éxito. |
OCR
page_needs_ocr(d::PdfDocument, page::Integer) -> Bool
ocr_extract_text(d::PdfDocument, page::Integer, engine::Union{Nothing,OcrEngine} = nothing) -> String
| Función |
Descripción |
page_needs_ocr(d, page) |
Indica si una página es escaneada/híbrida y necesita OCR. |
ocr_extract_text(d, page, engine=nothing) |
Extrae texto mediante OCR (nothing recurre solo a la extracción nativa). Ver OcrEngine. |
Firmas (a nivel de documento)
sign(d::PdfDocument, cert::Certificate; reason::AbstractString = "", location::AbstractString = "") -> Int
get_signature_count(d::PdfDocument) -> Int
get_signature(d::PdfDocument, index::Integer) -> SignatureInfo
verify_all_signatures(d::PdfDocument) -> Int
has_timestamp(d::PdfDocument) -> Int
document_get_dss(d::PdfDocument) -> Union{Dss,Nothing}
| Función |
Descripción |
sign(d, cert; reason, location) |
Firma el documento con cert; devuelve un código de estado. |
get_signature_count(d) |
Número de firmas en el documento. |
get_signature(d, index) |
La firma número index como un SignatureInfo. |
verify_all_signatures(d) |
Verifica todas las firmas; devuelve un código de estado. |
has_timestamp(d) |
Indica si el documento lleva una marca de tiempo a nivel de documento. |
document_get_dss(d) |
Lee el /DSS del documento en un Dss, o nothing si no hay ninguno. |
Validación y conversión
validate_pdf_a(d::PdfDocument, level::Integer) -> PdfAResults
validate_pdf_ua(d::PdfDocument, level::Integer) -> UaResults
validate_pdf_x(d::PdfDocument, level::Integer) -> PdfXResults
document_convert_to_pdf_a(d::PdfDocument, level::Integer) -> Bool
validatePdfA / validatePdfUa / validatePdfX son alias en camelCase de los tres validadores. Ver Resultados de validación.
Conversión a Office
to_docx(d::PdfDocument) -> Vector{UInt8}
to_pptx(d::PdfDocument) -> Vector{UInt8}
to_xlsx(d::PdfDocument) -> Vector{UInt8}
Convierte el PDF de vuelta a un búfer de bytes DOCX / PPTX / XLSX. Para abrir archivos de Office como PDF se usa open_from_docx_bytes / open_from_pptx_bytes / open_from_xlsx_bytes (ver Entrada desde Office).
Ciclo de vida
| Función |
Descripción |
close!(d) |
Libera el handle nativo de inmediato (idempotente; también se ejecuta en la finalización). |
PdfPage
Una vista ligera de página (índice basado en 0) devuelta por page(doc, index). Sus métodos delegan en el documento padre.
p = page(doc, 0)
text(p) # -> String
markdown(p) # -> String
extract_words(p) # -> Vector{Word}
search(p, "term", false) # -> Vector{SearchResult}
render_page(p) # -> RenderedImage
| Método |
Devuelve |
Descripción |
text(p) |
String |
Texto plano de la página. |
markdown(p) |
String |
Markdown de la página. |
html(p) |
String |
HTML de la página. |
plain_text(p) |
String |
Texto plano respetando el layout. |
extract_chars(p) |
Vector{Char} |
Glifos. |
extract_words(p) |
Vector{Word} |
Palabras. |
extract_text_lines(p) |
Vector{TextLine} |
Líneas de texto. |
extract_tables(p) |
Vector{Table} |
Tablas. |
embedded_fonts(p) |
Vector{Font} |
Fuentes incrustadas. |
embedded_images(p) |
Vector{Image} |
Imágenes incrustadas. |
page_annotations(p) |
Vector{Annotation} |
Anotaciones. |
extract_paths(p) |
Vector{Path} |
Rutas vectoriales. |
search(p, term, caseSensitive) |
Vector{SearchResult} |
Busca en la página. |
render_page(p, format=0) |
RenderedImage |
Renderiza la página (0=PNG). |
render_page_zoom(p, zoom, format=0) |
RenderedImage |
Renderiza con un factor de zoom. |
render_page_thumbnail(p, size, format=0) |
RenderedImage |
Renderiza una miniatura que se ajuste a size px. |
Rendering (renderizado)
Renderiza páginas de PdfDocument a imágenes. format: 0=PNG (por defecto), 1=JPEG. Las coordenadas están en puntos del espacio de usuario PDF.
render_page(d::PdfDocument, pageIndex::Integer, format::Integer = 0) -> RenderedImage
render_page_zoom(d::PdfDocument, pageIndex::Integer, zoom::Real, format::Integer = 0) -> RenderedImage
render_page_thumbnail(d::PdfDocument, pageIndex::Integer, size::Integer, format::Integer = 0) -> RenderedImage
render_page_region(d::PdfDocument, page::Integer, crop_x, crop_y, crop_width, crop_height, format::Integer = 0) -> RenderedImage
render_page_fit(d::PdfDocument, page::Integer, w::Integer, h::Integer, format::Integer = 0) -> RenderedImage
render_page_raw(d::PdfDocument, page::Integer, dpi::Integer) -> Tuple{RenderedImage,Int,Int}
render_page_with_options(d::PdfDocument, page::Integer, dpi, format, bg_r, bg_g, bg_b, bg_a, transparent_background, render_annotations, jpeg_quality) -> RenderedImage
render_page_with_options_ex(d::PdfDocument, page::Integer, dpi, format, bg_r, bg_g, bg_b, bg_a, transparent_background, render_annotations, jpeg_quality, excluded_layers::AbstractVector{<:AbstractString} = String[]) -> RenderedImage
| Función |
Descripción |
render_page(d, page, format=0) |
Renderiza una página (0=PNG). |
render_page_zoom(d, page, zoom, format=0) |
Renderiza con un factor de zoom. |
render_page_thumbnail(d, page, size, format=0) |
Renderiza una miniatura que se ajuste a size px. |
render_page_region(d, page, x, y, w, h, format=0) |
Renderiza un recorte rectangular (puntos del espacio de usuario). |
render_page_fit(d, page, w, h, format=0) |
Renderiza ajustándose dentro de w×h px, conservando la proporción. |
render_page_raw(d, page, dpi) |
Renderiza a un búfer RGBA8888 premultiplicado en bruto; devuelve (image, width, height). |
render_page_with_options(d, page, dpi, format, bg_r, bg_g, bg_b, bg_a, transparent_background, render_annotations, jpeg_quality) |
Renderiza con todas las opciones de RenderOptions (canales de fondo 0–1; las banderas son 0/1). |
render_page_with_options_ex(...; excluded_layers) |
Igual que el anterior más filtrado de capas OCG: suprime las capas /Name indicadas. |
estimate_render_time(d, page) |
Estima el tiempo de renderizado (ms) de una página. |
renderPage / renderPageZoom / renderPageThumbnail son alias en camelCase de render_page / render_page_zoom / render_page_thumbnail.
Renderer
Un handle de renderizador reutilizable.
create_renderer(dpi::Integer = 150, format::Integer = 0, quality::Integer = 90, anti_alias::Bool = true) -> Renderer
close!(r::Renderer)
RenderedImage
El resultado de una llamada de renderizado. Campos: width::Int, height::Int, data::Vector{UInt8} (bytes codificados, o RGBA en bruto en el caso de render_page_raw).
save(img::RenderedImage, path::AbstractString) # write to disk (format inferred)
close!(img::RenderedImage)
DocumentEditor
El handle de edición para modificar y volver a guardar un PDF existente.
Apertura y origen
open_editor(path::AbstractString) -> DocumentEditor
open_editor_from_bytes(data::AbstractVector{UInt8}) -> DocumentEditor
| Función |
Devuelve |
Descripción |
is_modified(e) |
Bool |
Indica si el editor tiene modificaciones sin guardar. |
get_source_path(e) |
String |
Ruta de origen desde la que se abrió el editor. |
page_count(e) |
Int |
Número de páginas. |
version(e) |
PdfVersion |
Versión del PDF. |
| Función |
Descripción |
get_producer(e) |
Productor desde /Info.Producer. |
set_producer(e, value) |
Establece /Info.Producer. |
get_creation_date(e) |
Fecha de creación desde /Info.CreationDate (cadena de fecha PDF en bruto). |
set_creation_date(e, date_str) |
Establece /Info.CreationDate (cadena de fecha PDF en bruto). |
Guardado
save(e::DocumentEditor, path::AbstractString)
save_to_bytes(e::DocumentEditor) -> Vector{UInt8}
save_to_bytes_with_options(e::DocumentEditor, compress::Bool, garbage_collect::Bool, linearize::Bool) -> Vector{UInt8}
extract_pages_to_bytes(e::DocumentEditor, pages::AbstractVector{<:Integer}) -> Vector{UInt8}
save_encrypted(e::DocumentEditor, path::AbstractString, user_password::AbstractString, owner_password::AbstractString)
save_encrypted_to_bytes(e::DocumentEditor, user_password::AbstractString, owner_password::AbstractString) -> Vector{UInt8}
convert_to_pdf_a(e::DocumentEditor, level::Integer)
| Función |
Descripción |
save(e, path) |
Guarda el documento editado en una ruta. |
save_to_bytes(e) |
Serializa el documento editado a bytes. |
save_to_bytes_with_options(e, compress, garbage_collect, linearize) |
Serializa con opciones de compresión / recolección de basura / linealización. |
extract_pages_to_bytes(e, pages) |
Extrae un subconjunto de páginas a un nuevo PDF en memoria. |
save_encrypted(e, path, user_pw, owner_pw) |
Guarda con cifrado AES-256 en una ruta. |
save_encrypted_to_bytes(e, user_pw, owner_pw) |
Guarda con cifrado AES-256 a bytes. |
convert_to_pdf_a(e, level) |
Convierte a PDF/A in situ (level: 0=A1b…7=A3u). |
Fusión y adjuntos
| Función |
Descripción |
merge_from(e, source_path) |
Fusiona páginas de un PDF en disco. |
merge_from_bytes(e, data) |
Fusiona páginas de un búfer PDF en memoria. |
embed_file(e, name, data) |
Incrusta un archivo adjunto (name, bytes data). |
Operaciones sobre páginas
rotate_all_pages(e::DocumentEditor, degrees::Integer)
rotate_page_by(e::DocumentEditor, page::Integer, degrees::Integer)
get_page_rotation(e::DocumentEditor, page::Integer) -> Int
set_page_rotation(e::DocumentEditor, page::Integer, degrees::Integer)
delete_page(e::DocumentEditor, page::Integer)
move_page(e::DocumentEditor, from::Integer, to::Integer)
| Función |
Descripción |
rotate_all_pages(e, degrees) |
Rota todas las páginas (de forma relativa). |
rotate_page_by(e, page, degrees) |
Rota una página de forma aditiva. |
get_page_rotation(e, page) |
Rotación absoluta de una página. |
set_page_rotation(e, page, degrees) |
Establece la rotación absoluta de una página. |
delete_page(e, page) |
Elimina una página. |
move_page(e, from, to) |
Mueve una página de un índice a otro. |
Cajas de página y recorte
get_page_media_box(e::DocumentEditor, page::Integer) -> NTuple{4,Float64}
get_page_crop_box(e::DocumentEditor, page::Integer) -> NTuple{4,Float64}
set_page_media_box(e::DocumentEditor, page::Integer, x, y, w, h)
set_page_crop_box(e::DocumentEditor, page::Integer, x, y, w, h)
crop_margins(e::DocumentEditor, left::Real, right::Real, top::Real, bottom::Real)
| Función |
Descripción |
get_page_media_box(e, page) |
Obtiene el MediaBox de una página. |
get_page_crop_box(e, page) |
Obtiene el CropBox de una página. |
set_page_media_box(e, page, x, y, w, h) |
Establece el MediaBox de una página. |
set_page_crop_box(e, page, x, y, w, h) |
Establece el CropBox de una página. |
crop_margins(e, left, right, top, bottom) |
Recorta todas las páginas por márgenes (espacio de usuario). |
Borrado / blanqueo
erase_region(e::DocumentEditor, page::Integer, x, y, w, h)
erase_regions(e::DocumentEditor, page::Integer, rects::AbstractVector{<:NTuple{4,<:Real}})
clear_erase_regions(e::DocumentEditor, page::Integer)
| Función |
Descripción |
erase_region(e, page, x, y, w, h) |
Borra una región rectangular. |
erase_regions(e, page, rects) |
Borra varias regiones (rects es un vector de tuplas (x, y, w, h)). |
clear_erase_regions(e, page) |
Elimina todas las entradas de borrado pendientes de una página. |
Eliminación de encabezados, pies y artefactos
erase_header(d::PdfDocument, page::Integer)
erase_footer(d::PdfDocument, page::Integer)
erase_artifacts(d::PdfDocument, page::Integer)
remove_headers(d::PdfDocument, threshold::Real = 0.5)
remove_footers(d::PdfDocument, threshold::Real = 0.5)
remove_artifacts(d::PdfDocument, threshold::Real = 0.5)
| Función |
Descripción |
erase_header(d, page) / erase_footer(d, page) / erase_artifacts(d, page) |
Borra el encabezado / pie / artefactos detectados en una página. |
remove_headers(d, threshold=0.5) / remove_footers(...) / remove_artifacts(...) |
Elimina encabezados / pies / artefactos repetidos en todo el documento por encima de un umbral de frecuencia. |
Aplanado de anotaciones
flatten_annotations(e::DocumentEditor, page::Integer)
flatten_all_annotations(e::DocumentEditor)
is_page_marked_for_flatten(e::DocumentEditor, page::Integer) -> Bool
unmark_page_for_flatten(e::DocumentEditor, page::Integer)
Redacción
apply_page_redactions(e::DocumentEditor, page::Integer)
apply_all_redactions(e::DocumentEditor)
is_page_marked_for_redaction(e::DocumentEditor, page::Integer) -> Bool
unmark_page_for_redaction(e::DocumentEditor, page::Integer)
redaction_add(e::DocumentEditor, page::Integer, x1, y1, x2, y2, r, g, b)
redaction_count(e::DocumentEditor, page::Integer) -> Int
redaction_apply(e::DocumentEditor, scrub_metadata::Bool, r::Real, g::Real, b::Real) -> Int
redaction_scrub_metadata(e::DocumentEditor) -> Int
| Función |
Descripción |
apply_page_redactions(e, page) |
Aplica (fija de forma permanente) las redacciones de una página. |
apply_all_redactions(e) |
Aplica todas las redacciones pendientes. |
is_page_marked_for_redaction(e, page) |
Indica si una página está marcada para redacción. |
unmark_page_for_redaction(e, page) |
Elimina la marca de redacción de una página. |
redaction_add(e, page, x1, y1, x2, y2, r, g, b) |
Encola un recuadro de redacción con color de superposición (DeviceRGB, 0–1). |
redaction_count(e, page) |
Número de regiones de redacción encoladas en una página. |
redaction_apply(e, scrub_metadata, r, g, b) |
Aplica de forma destructiva todas las redacciones encoladas; devuelve los glifos eliminados. |
redaction_scrub_metadata(e) |
Elimina Info/XMP/JavaScript/EmbeddedFiles; devuelve el número de elementos eliminados. |
set_form_field_value(e::DocumentEditor, name::AbstractString, value::AbstractString)
flatten_forms(e::DocumentEditor)
flatten_forms_on_page(e::DocumentEditor, page::Integer)
flatten_warnings_count(e::DocumentEditor) -> Int
flatten_warning(e::DocumentEditor, index::Integer) -> String
import_fdf_bytes(e::DocumentEditor, data::AbstractVector{UInt8})
import_xfdf_bytes(e::DocumentEditor, data::AbstractVector{UInt8})
| Función |
Descripción |
set_form_field_value(e, name, value) |
Establece el valor de un campo de formulario (UTF-8). |
flatten_forms(e) |
Aplana todos los formularios (incorpora los valores al contenido de la página). |
flatten_forms_on_page(e, page) |
Aplana los formularios de una sola página. |
flatten_warnings_count(e) |
Número de advertencias del último guardado con aplanado de formularios. |
flatten_warning(e, index) |
La advertencia de aplanado número index. |
import_fdf_bytes(e, data) |
Importa datos de formulario FDF desde bytes. |
import_xfdf_bytes(e, data) |
Importa datos de formulario XFDF desde bytes. |
Estampado de códigos de barras
add_barcode_to_page(e::DocumentEditor, page::Integer, b::Barcode, x, y, width, height)
Estampa un Barcode en una página en el rectángulo (x, y, width, height). Ver Códigos de barras.
Ciclo de vida
close!(e::DocumentEditor) libera el handle.
Pdf
El handle ligero de creación devuelto por las factorías from_*.
Factorías
from_markdown(input::AbstractString) -> Pdf
from_html(input::AbstractString) -> Pdf
from_text(input::AbstractString) -> Pdf
from_image(path::AbstractString) -> Pdf
from_image_bytes(data::AbstractVector{UInt8}) -> Pdf
from_html_css(html::AbstractString, css::AbstractString, font_bytes::Union{Nothing,AbstractVector{UInt8}} = nothing) -> Pdf
from_html_css_with_fonts(html::AbstractString, css::AbstractString, families::AbstractVector{<:AbstractString}, fonts::AbstractVector{<:AbstractVector{UInt8}}) -> Pdf
| Función |
Descripción |
from_markdown(input) |
Construye un Pdf a partir de Markdown. |
from_html(input) |
Construye un Pdf a partir de HTML. |
from_text(input) |
Construye un Pdf a partir de texto plano. |
from_image(path) |
Construye un Pdf a partir de un archivo de imagen. |
from_image_bytes(data) |
Construye un Pdf a partir de bytes de imagen en memoria. |
from_html_css(html, css, font_bytes=nothing) |
Construye a partir de HTML + CSS con una fuente incrustada opcional. |
from_html_css_with_fonts(html, css, families, fonts) |
Construye a partir de HTML + CSS con una cascada multi-fuente (families[i] nombra a fonts[i]). |
Métodos
| Función |
Devuelve |
Descripción |
save(p, path) |
— |
Escribe el PDF construido en una ruta. |
to_bytes(p) |
Vector{UInt8} |
Serializa el PDF construido a bytes. |
get_page_count(p) |
Int |
Número de páginas de un Pdf construido. |
close!(p) |
— |
Libera el handle. |
merge_pdfs
merge_pdfs(paths::AbstractVector{<:AbstractString}) -> Vector{UInt8}
Fusiona los PDF de paths (en orden) en un único búfer de bytes PDF.
Entrada desde Office
open_from_docx_bytes(data::AbstractVector{UInt8}) -> Pdf
open_from_pptx_bytes(data::AbstractVector{UInt8}) -> Pdf
open_from_xlsx_bytes(data::AbstractVector{UInt8}) -> Pdf
Convierte bytes DOCX / PPTX / XLSX en un Pdf.
DocumentBuilder
Un constructor de PDF fluido y consciente de la estructura. Crea páginas con a4_page / letter_page / page, organiza el contenido sobre el PageBuilder devuelto, llama a done para confirmar cada página y, por último, a build / save / sus variantes cifradas.
DocumentBuilder() -> DocumentBuilder
Configuración a nivel de documento
set_title(b::DocumentBuilder, value::AbstractString)
set_author(b::DocumentBuilder, value::AbstractString)
set_subject(b::DocumentBuilder, value::AbstractString)
set_keywords(b::DocumentBuilder, value::AbstractString)
set_creator(b::DocumentBuilder, value::AbstractString)
on_open(b::DocumentBuilder, value::AbstractString)
language(b::DocumentBuilder, value::AbstractString)
tagged_pdf_ua1(b::DocumentBuilder)
role_map(b::DocumentBuilder, custom::AbstractString, standard::AbstractString)
register_embedded_font(b::DocumentBuilder, name::AbstractString, f::EmbeddedFont)
| Función |
Descripción |
set_title / set_author / set_subject / set_keywords / set_creator |
Establece el campo de metadatos /Info correspondiente. |
on_open(b, value) |
Establece una acción JavaScript de apertura de documento. |
language(b, value) |
Establece el idioma del documento (p. ej. "en-US"). |
tagged_pdf_ua1(b) |
Activa el modo de PDF etiquetado PDF/UA-1. |
role_map(b, custom, standard) |
Asigna un tipo de estructura personalizado a uno estándar. |
register_embedded_font(b, name, f) |
Registra un EmbeddedFont cargado bajo el nombre name (consume la fuente). |
Páginas
a4_page(b::DocumentBuilder) -> PageBuilder
letter_page(b::DocumentBuilder) -> PageBuilder
page(b::DocumentBuilder, width::Real, height::Real) -> PageBuilder
Salida
build(b::DocumentBuilder) -> Vector{UInt8}
save(b::DocumentBuilder, path::AbstractString)
save_encrypted_builder(b::DocumentBuilder, path::AbstractString, user_password::AbstractString, owner_password::AbstractString)
to_bytes_encrypted(b::DocumentBuilder, user_password::AbstractString, owner_password::AbstractString) -> Vector{UInt8}
| Función |
Descripción |
build(b) |
Construye y devuelve los bytes del PDF (el builder debe cerrarse igualmente). |
save(b, path) |
Construye y guarda en una ruta. |
save_encrypted_builder(b, path, user_pw, owner_pw) |
Construye y guarda con cifrado AES-256. |
to_bytes_encrypted(b, user_pw, owner_pw) |
Construye bytes cifrados (AES-256). |
EmbeddedFont
embedded_font_from_file(path::AbstractString) -> EmbeddedFont
embedded_font_from_bytes(data::AbstractVector{UInt8}; name::Union{Nothing,AbstractString} = nothing) -> EmbeddedFont
| Función |
Descripción |
embedded_font_from_file(path) |
Carga una fuente TTF/OTF desde una ruta. |
embedded_font_from_bytes(data; name) |
Carga una fuente desde bytes (name puede dejarse vacío para usar el nombre PostScript). |
PageBuilder
Devuelto por a4_page / letter_page / page. Todos los métodos modifican la página in situ; llama a done(p) para confirmarla en el builder padre (esto consume el handle de la página).
Texto y diseño
font(p::PageBuilder, name::AbstractString, size::Real)
at(p::PageBuilder, x::Real, y::Real)
heading(p::PageBuilder, level::Integer, text::AbstractString)
| Método |
Descripción |
font(p, name, size) |
Establece la fuente y el tamaño para el texto siguiente. |
at(p, x, y) |
Mueve el cursor a la posición absoluta (x, y) (puntos, desde la esquina inferior izquierda). |
heading(p, level, text) |
Emite un encabezado de nivel level (1–6). |
Los siguientes métodos con valor de cadena comparten todos la firma f(p::PageBuilder, value::AbstractString):
| Método |
Descripción |
text(p, value) |
Emite un fragmento de texto de cuerpo. |
paragraph(p, value) |
Emite un párrafo con ajuste de línea. |
link_url(p, value) |
Convierte el texto anterior en un enlace URL. |
link_named(p, value) |
Enlaza el texto anterior a un destino con nombre. |
link_javascript(p, value) |
Adjunta una acción JavaScript al texto anterior. |
on_open(p, value) |
Establece una acción JavaScript de apertura de página. |
on_close(p, value) |
Establece una acción JavaScript de cierre de página. |
field_keystroke(p, value) / field_format(p, value) / field_validate(p, value) / field_calculate(p, value) |
Adjunta acciones JavaScript de campo AcroForm. |
sticky_note(p, value) |
Adjunta una nota adhesiva al contenido anterior. |
watermark(p, value) |
Añade una marca de agua de texto. |
stamp(p, value) |
Añade una anotación de sello. |
inline(p, value) |
Añade un fragmento de texto en línea. |
inline_bold(p, value) |
Añade un fragmento en línea en negrita. |
inline_italic(p, value) |
Añade un fragmento en línea en cursiva. |
Métodos de diseño sin argumentos, todos f(p::PageBuilder):
| Método |
Descripción |
horizontal_rule(p) |
Dibuja una línea horizontal. |
space(p) |
Inserta espacio vertical. |
newline(p) |
Salta a una nueva línea. |
new_page_same_size(p) |
Inicia una nueva página con las mismas dimensiones. |
watermark_confidential(p) |
Añade una marca de agua “CONFIDENTIAL”. |
watermark_draft(p) |
Añade una marca de agua “DRAFT”. |
link_page(p::PageBuilder, page_index::Integer)
sticky_note_at(p::PageBuilder, x::Real, y::Real, text::AbstractString)
freetext(p::PageBuilder, x::Real, y::Real, w::Real, h::Real, text::AbstractString)
footnote(p::PageBuilder, ref_mark::AbstractString, note_text::AbstractString)
columns(p::PageBuilder, column_count::Integer, gap_pt::Real, text::AbstractString)
inline_color(p::PageBuilder, r::Real, g::Real, b_::Real, text::AbstractString)
| Método |
Descripción |
link_page(p, page_index) |
Enlaza el texto anterior a un índice de página interno. |
sticky_note_at(p, x, y, text) |
Coloca una nota adhesiva independiente. |
freetext(p, x, y, w, h, text) |
Coloca una anotación de texto libre dentro de un rectángulo. |
footnote(p, ref_mark, note_text) |
Añade una nota al pie (superíndice en línea + cuerpo al final de la página). |
columns(p, column_count, gap_pt, text) |
Distribuye el texto en columnas equilibradas. |
inline_color(p, r, g, b_, text) |
Añade un fragmento en línea coloreado en RGB (canales 0–1). |
Anotaciones de marcado
Las cuatro comparten f(p::PageBuilder, r::Real, g::Real, b_::Real) y se aplican al texto anterior con un color RGB:
| Método |
Descripción |
highlight(p, r, g, b) |
Resalta el texto anterior. |
underline(p, r, g, b) |
Subraya el texto anterior. |
strikeout(p, r, g, b) |
Tacha el texto anterior. |
squiggly(p, r, g, b) |
Subraya con línea ondulada el texto anterior. |
text_field(p::PageBuilder, name, x, y, w, h; default_value::Union{Nothing,AbstractString} = nothing)
checkbox(p::PageBuilder, name, x, y, w, h, checked::Bool)
combo_box(p::PageBuilder, name, x, y, w, h, options::AbstractVector{<:AbstractString}; selected::Union{Nothing,AbstractString} = nothing)
radio_group(p::PageBuilder, name, values, xs, ys, ws, hs; selected::Union{Nothing,AbstractString} = nothing)
push_button(p::PageBuilder, name, x, y, w, h, caption::AbstractString)
signature_field(p::PageBuilder, name, x, y, w, h)
| Método |
Descripción |
text_field(p, name, x, y, w, h; default_value) |
Añade un campo de texto de una línea. |
checkbox(p, name, x, y, w, h, checked) |
Añade una casilla de verificación con un estado inicial. |
combo_box(p, name, x, y, w, h, options; selected) |
Añade un cuadro combinado desplegable. |
radio_group(p, name, values, xs, ys, ws, hs; selected) |
Añade un grupo de botones de radio (arrays paralelos que describen cada botón). |
push_button(p, name, x, y, w, h, caption) |
Añade un botón pulsador. |
signature_field(p, name, x, y, w, h) |
Añade un marcador de posición de firma sin firmar. |
Imágenes y códigos de barras
image(p::PageBuilder, bytes::AbstractVector{UInt8}, x, y, w, h)
image_with_alt(p::PageBuilder, bytes::AbstractVector{UInt8}, x, y, w, h, alt_text::AbstractString)
image_artifact(p::PageBuilder, bytes::AbstractVector{UInt8}, x, y, w, h)
barcode_1d(p::PageBuilder, barcode_type::Integer, data::AbstractString, x, y, w, h)
barcode_qr(p::PageBuilder, data::AbstractString, x, y, size::Real)
| Método |
Descripción |
image(p, bytes, x, y, w, h) |
Incrusta una imagen (JPEG/PNG/WebP en bruto). |
image_with_alt(p, bytes, x, y, w, h, alt_text) |
Incrusta una imagen con texto alternativo de accesibilidad. |
image_artifact(p, bytes, x, y, w, h) |
Incrusta una imagen decorativa como /Artifact. |
barcode_1d(p, barcode_type, data, x, y, w, h) |
Coloca un código de barras 1D (barcode_type: 0=Code128…7=Codabar). |
barcode_qr(p, data, x, y, size) |
Coloca un código QR cuadrado. |
Gráficos vectoriales
rect(p::PageBuilder, x, y, w, h)
filled_rect(p::PageBuilder, x, y, w, h, r, g, b_)
line(p::PageBuilder, x1, y1, x2, y2)
stroke_rect(p::PageBuilder, x, y, w, h, width, r, g, b_)
stroke_line(p::PageBuilder, x1, y1, x2, y2, width, r, g, b_)
stroke_rect_dashed(p::PageBuilder, x, y, w, h, width, r, g, b_, dash_array::AbstractVector{<:Real}, phase::Real)
stroke_line_dashed(p::PageBuilder, x1, y1, x2, y2, width, r, g, b_, dash_array::AbstractVector{<:Real}, phase::Real)
text_in_rect(p::PageBuilder, x, y, w, h, text::AbstractString, align::Integer)
| Método |
Descripción |
rect(p, x, y, w, h) |
Contorno de rectángulo trazado en negro de 1pt. |
filled_rect(p, x, y, w, h, r, g, b) |
Rectángulo relleno en RGB (0–1). |
line(p, x1, y1, x2, y2) |
Línea negra de 1pt. |
stroke_rect(p, x, y, w, h, width, r, g, b) |
Rectángulo trazado, widthpt en RGB. |
stroke_line(p, x1, y1, x2, y2, width, r, g, b) |
Línea trazada, widthpt en RGB. |
stroke_rect_dashed(...) |
Rectángulo trazado discontinuo (dash_array longitudes activo/inactivo, phase desplazamiento). |
stroke_line_dashed(...) |
Línea trazada discontinua. |
text_in_rect(p, x, y, w, h, text, align) |
Dibuja texto dentro de un rectángulo (align: 0=Left, 1=Center, 2=Right). |
Tablas
table(p::PageBuilder, n_columns::Integer, widths::AbstractVector{<:Real}, aligns::AbstractVector{<:Integer}, n_rows::Integer, cell_strings::AbstractMatrix{<:AbstractString}, has_header::Bool)
streaming_table_begin(p::PageBuilder, headers::AbstractVector{<:AbstractString}, widths::AbstractVector{<:Real}, aligns::AbstractVector{<:Integer}, repeat_header::Bool)
streaming_table_begin_v2(p::PageBuilder, headers, widths, aligns, repeat_header::Bool, mode::Integer, sample_rows::Integer, min_col_width_pt::Real, max_col_width_pt::Real, max_rowspan::Integer)
streaming_table_set_batch_size(p::PageBuilder, batch_size::Integer)
streaming_table_pending_row_count(p::PageBuilder) -> Int
streaming_table_batch_count(p::PageBuilder) -> Int
streaming_table_push_row(p::PageBuilder, cells::AbstractVector{<:AbstractString})
streaming_table_push_row_v2(p::PageBuilder, cells::AbstractVector{<:AbstractString}, rowspans::AbstractVector{<:Integer})
streaming_table_flush(p::PageBuilder)
streaming_table_finish(p::PageBuilder)
| Método |
Descripción |
table(p, n_columns, widths, aligns, n_rows, cell_strings, has_header) |
Emite una tabla en búfer (aligns: 0=Left/1=Center/2=Right; cell_strings está organizado por filas, n_rows × n_columns). |
streaming_table_begin(p, headers, widths, aligns, repeat_header) |
Abre una tabla en streaming (arrays paralelos de longitud n_columns). |
streaming_table_begin_v2(...) |
Abre una tabla en streaming con mode de ancho (0=Fixed, 1=Sample, 2=AutoAll) y max_rowspan. |
streaming_table_set_batch_size(p, batch_size) |
Establece el tamaño de lote (0 → 256). |
streaming_table_pending_row_count(p) |
Filas añadidas desde el último límite de lote. |
streaming_table_batch_count(p) |
Número de lotes completos hasta el momento. |
streaming_table_push_row(p, cells) |
Añade una fila (rowspan=1). |
streaming_table_push_row_v2(p, cells, rowspans) |
Añade una fila con rowspans por celda (≥2 abarca varias filas). |
streaming_table_flush(p) |
Vacía el lote actual. |
streaming_table_finish(p) |
Finaliza la tabla en streaming. |
Confirmación
done(p::PageBuilder) # commit this page's buffered operations to its parent builder (consumes the handle)
Tipos de valor
Structs inmutables devueltos por la extracción. Bbox tiene los campos x, y, width, height (unidades del espacio de usuario PDF).
| Tipo |
Campos |
Bbox |
x, y, width, height (Float64) |
Char |
character::UInt32, bbox::Bbox, font_name::String, font_size::Float64 |
Word |
text, bbox, font_name, font_size, bold |
TextLine |
text, bbox, word_count |
Table |
row_count, col_count, has_header, cells (usa cell(t, row, col) para una celda con índice basado en 0) |
Font |
name, type, encoding, embedded, subset |
Image |
width, height, bitsPerComponent, format, colorspace, data |
Annotation |
type, subtype, content, author, rect::Bbox, borderWidth |
Path |
bbox::Bbox, strokeWidth, hasStroke, hasFill, operationCount |
SearchResult |
text, page, bbox::Bbox |
FormField |
name, value, type, readonly, required |
PdfVersion |
major::Int, minor::Int |
cell(t::Table, row::Integer, col::Integer) -> String
form_field_name(f::FormField) -> String
form_field_value(f::FormField) -> String
form_field_type(f::FormField) -> String
form_field_is_readonly(f::FormField) -> Bool
form_field_is_required(f::FormField) -> Bool
ElementList
element_count(l::ElementList) -> Int
element_type(l::ElementList, index::Integer) -> String
element_text(l::ElementList, index::Integer) -> String
element_rect(l::ElementList, index::Integer) -> Bbox
elements_to_json(l::ElementList) -> String
close!(l::ElementList)
Firmas digitales
Certificate
certificate_load_from_bytes(data::AbstractVector{UInt8}, password::AbstractString = "") -> Certificate
certificate_load_from_pem(cert_pem::AbstractString, key_pem::AbstractString) -> Certificate
certificate_get_subject(c::Certificate) -> String
certificate_get_issuer(c::Certificate) -> String
certificate_get_serial(c::Certificate) -> String
certificate_get_validity(c::Certificate) -> Tuple{Int,Int}
certificate_is_valid(c::Certificate) -> Bool
| Función |
Descripción |
certificate_load_from_bytes(data, password="") |
Carga las credenciales de firma desde bytes PKCS#12 / PFX. |
certificate_load_from_pem(cert_pem, key_pem) |
Carga desde un certificado y una clave privada codificados en PEM. |
certificate_get_subject(c) / certificate_get_issuer(c) / certificate_get_serial(c) |
Cadenas de sujeto / emisor / número de serie. |
certificate_get_validity(c) |
Ventana de validez como (not_before, not_after) en segundos de época Unix. |
certificate_is_valid(c) |
Indica si el certificado es válido actualmente. |
Firma
sign_bytes(pdf::AbstractVector{UInt8}, cert::Certificate, reason::AbstractString, location::AbstractString) -> Vector{UInt8}
sign_bytes_pades(pdf::AbstractVector{UInt8}, cert::Certificate, level::Integer, tsa_url::Union{Nothing,AbstractString}, reason::AbstractString, location::AbstractString; certs = Vector{UInt8}[], crls = Vector{UInt8}[], ocsps = Vector{UInt8}[]) -> Vector{UInt8}
sign_bytes_pades_opts(pdf::AbstractVector{UInt8}, cert::Certificate, level::Integer, tsa_url, reason, location; certs = Vector{UInt8}[], crls = Vector{UInt8}[], ocsps = Vector{UInt8}[]) -> Vector{UInt8}
add_timestamp(pdf_data::AbstractVector{UInt8}, sig_index::Integer, tsa_url::AbstractString) -> Vector{UInt8}
| Función |
Descripción |
sign_bytes(pdf, cert, reason, location) |
Firma bytes de PDF en bruto; devuelve el PDF firmado. |
sign_bytes_pades(pdf, cert, level, tsa_url, reason, location; certs, crls, ocsps) |
Firma de línea base PAdES (level: 0=B-B, 1=B-T, 2=B-LT; tsa_url es obligatorio para level ≥ 1). |
sign_bytes_pades_opts(...) |
Variante de sign_bytes_pades basada en struct de opciones (mismo comportamiento, construye PadesSignOptionsC). |
add_timestamp(pdf_data, sig_index, tsa_url) |
Añade una marca de tiempo RFC 3161 a una firma; devuelve el PDF con la marca de tiempo. |
SignatureInfo
signature_get_signer_name(s::SignatureInfo) -> String
signature_get_signing_reason(s::SignatureInfo) -> String
signature_get_signing_location(s::SignatureInfo) -> String
signature_get_signing_time(s::SignatureInfo) -> Int
signature_get_certificate(s::SignatureInfo) -> Certificate
signature_get_pades_level(s::SignatureInfo) -> Int
signature_has_timestamp(s::SignatureInfo) -> Bool
signature_get_timestamp(s::SignatureInfo) -> Timestamp
signature_add_timestamp(s::SignatureInfo, ts) -> Bool
signature_verify(s::SignatureInfo) -> Int
signature_verify_detached(s::SignatureInfo, pdf::AbstractVector{UInt8}) -> Int
| Función |
Descripción |
signature_get_signer_name(s) / _reason(s) / _location(s) |
Nombre / motivo / ubicación del firmante. |
signature_get_signing_time(s) |
Hora de la firma (segundos de época Unix). |
signature_get_certificate(s) |
El Certificate del firmante (en propiedad). |
signature_get_pades_level(s) |
Código del nivel PAdES. |
signature_has_timestamp(s) |
Indica si hay una marca de tiempo RFC 3161 incrustada. |
signature_get_timestamp(s) |
El Timestamp incrustado (en propiedad). |
signature_add_timestamp(s, ts) |
Adjunta un Timestamp; devuelve true si tiene éxito. |
signature_verify(s) |
Verificación criptográfica de los atributos del firmante (1=válida, 0=inválida, -1=desconocida). |
signature_verify_detached(s, pdf) |
Verificación de extremo a extremo contra los bytes completos del PDF (1/0/-1). |
Timestamp
timestamp_parse(data::AbstractVector{UInt8}) -> Timestamp
timestamp_get_token(t::Timestamp) -> Vector{UInt8}
timestamp_get_message_imprint(t::Timestamp) -> Vector{UInt8}
timestamp_get_time(t::Timestamp) -> Int
timestamp_get_serial(t::Timestamp) -> String
timestamp_get_tsa_name(t::Timestamp) -> String
timestamp_get_policy_oid(t::Timestamp) -> String
timestamp_get_hash_algorithm(t::Timestamp) -> Int
timestamp_verify(t::Timestamp) -> Bool
| Función |
Descripción |
timestamp_parse(data) |
Analiza un TimeStampToken DER RFC 3161 (o un TSTInfo simple). |
timestamp_get_token(t) |
Los bytes en bruto del token. |
timestamp_get_message_imprint(t) |
Los bytes del digest de message-imprint. |
timestamp_get_time(t) |
Hora de la marca de tiempo (segundos de época Unix). |
timestamp_get_serial(t) |
Cadena de número de serie. |
timestamp_get_tsa_name(t) |
Nombre de la TSA. |
timestamp_get_policy_oid(t) |
OID de la política. |
timestamp_get_hash_algorithm(t) |
Código del algoritmo de digest. |
timestamp_verify(t) |
Indica si el token se verifica correctamente. |
TsaClient
tsa_client_create(url::AbstractString; username = nothing, password = nothing, timeout::Integer = 30, hash_algo::Integer = 0, use_nonce::Bool = true, cert_req::Bool = true) -> TsaClient
tsa_request_timestamp(t::TsaClient, data::AbstractVector{UInt8}) -> Timestamp
tsa_request_timestamp_hash(t::TsaClient, hash::AbstractVector{UInt8}, hash_algo::Integer) -> Timestamp
| Función |
Descripción |
tsa_client_create(url; …) |
Crea un cliente de TSA RFC 3161 (autenticación básica opcional, timeout, algoritmo de hash, nonce, cert-req). |
tsa_request_timestamp(t, data) |
Solicita una marca de tiempo sobre data (E/S de red). |
tsa_request_timestamp_hash(t, hash, hash_algo) |
Solicita una marca de tiempo sobre un digest precalculado. |
Dss (Document Security Store)
dss_cert_count(d::Dss) -> Int
dss_crl_count(d::Dss) -> Int
dss_ocsp_count(d::Dss) -> Int
dss_vri_count(d::Dss) -> Int
dss_get_cert(d::Dss, index::Integer) -> Vector{UInt8}
dss_get_crl(d::Dss, index::Integer) -> Vector{UInt8}
dss_get_ocsp(d::Dss, index::Integer) -> Vector{UInt8}
| Función |
Descripción |
dss_cert_count(d) / dss_crl_count(d) / dss_ocsp_count(d) / dss_vri_count(d) |
Conteos de certificados / CRL / respuestas OCSP / entradas VRI. |
dss_get_cert(d, index) / dss_get_crl(d, index) / dss_get_ocsp(d, index) |
El certificado / CRL / respuesta OCSP número index, en bytes. |
Resultados de validación
validate_pdf_a / validate_pdf_ua / validate_pdf_x devuelven PdfAResults / UaResults / PdfXResults.
| Función |
Devuelve |
Descripción |
is_compliant(r::PdfAResults) |
Bool |
Indica si el documento cumple PDF/A. |
is_compliant(r::PdfXResults) |
Bool |
Indica si el documento cumple PDF/X. |
is_accessible(r::UaResults) |
Bool |
Indica si el documento es accesible según PDF/UA. |
errors(r) |
Vector{String} |
Mensajes de error (PdfAResults / UaResults / PdfXResults). |
warnings(r) |
Vector{String} |
Mensajes de advertencia. |
ua_stats(r::UaResults) |
NamedTuple |
Conteos de elementos de accesibilidad (structure, images, tables, forms, annotations, pages). |
pdf_a_error_count(r) / pdf_a_warning_count(r) |
Int |
Conteos de errores / advertencias de PDF/A. |
pdf_ua_error_count(r) / pdf_ua_warning_count(r) |
Int |
Conteos de errores / advertencias de PDF/UA. |
pdf_x_error_count(r) |
Int |
Conteo de errores de PDF/X. |
Códigos de barras
generate_qr_code(data::AbstractString, error_correction::Integer = 0, size_px::Integer = 256) -> Barcode
generate_barcode(data::AbstractString, format::Integer = 0, size_px::Integer = 256) -> Barcode
barcode_get_data(b::Barcode) -> String
barcode_get_format(b::Barcode) -> Int
barcode_get_confidence(b::Barcode) -> Float64
barcode_get_image_png(b::Barcode, size_px::Integer = 256) -> Vector{UInt8}
barcode_get_svg(b::Barcode, size_px::Integer = 256) -> String
| Función |
Descripción |
generate_qr_code(data, error_correction=0, size_px=256) |
Genera un código QR. |
generate_barcode(data, format=0, size_px=256) |
Genera un código de barras 1D/2D. |
barcode_get_data(b) |
La cadena de carga útil decodificada/codificada. |
barcode_get_format(b) |
El código de formato. |
barcode_get_confidence(b) |
Confianza de la decodificación (0.0–1.0). |
barcode_get_image_png(b, size_px=256) |
Renderiza a bytes PNG. |
barcode_get_svg(b, size_px=256) |
Renderiza a una cadena SVG. |
Estampa un código de barras en una página del editor con add_barcode_to_page(e, page, b, x, y, width, height).
OCR
OcrEngine
ocr_engine_create(det_model_path::AbstractString, rec_model_path::AbstractString, dict_path::AbstractString) -> OcrEngine
Crea un motor de OCR a partir de las rutas del modelo de detección, el modelo de reconocimiento y el archivo de diccionario. Úsalo con ocr_extract_text(doc, page, engine) y page_needs_ocr(doc, page) (ver PdfDocument › OCR). close!(o::OcrEngine) lo libera.
Precarga de modelos
prefetch_models(languages_csv::AbstractString) -> String
prefetch_available() -> Int
model_manifest() -> String
| Función |
Descripción |
prefetch_models(languages_csv) |
Precarga los modelos de OCR/layout para idiomas separados por comas. |
prefetch_available() |
Indica si la precarga de modelos está disponible. |
model_manifest() |
El manifiesto de modelos incluido (JSON/cadena). |
Configuración global y criptografía
set_log_level(level::Integer) # 0=Off 1=Error 2=Warn 3=Info 4=Debug 5=Trace
get_log_level() -> Int
set_max_ops_per_stream(limit::Integer) -> Int
set_preserve_unmapped_glyphs(preserve::Integer) -> Int
| Función |
Descripción |
set_log_level(level) |
Establece el nivel de registro global (0–5). |
get_log_level() |
Obtiene el nivel de registro global actual. |
set_max_ops_per_stream(limit) |
Establece el límite de operaciones de contenido por stream; devuelve el límite anterior. |
set_preserve_unmapped_glyphs(preserve) |
Activa o desactiva la preservación de glifos no mapeados; devuelve el ajuste anterior. |
Política y catálogo criptográfico
crypto_active_provider() -> String
crypto_cbom() -> String
crypto_inventory() -> String
crypto_policy() -> String
crypto_set_policy(spec::AbstractString) -> Int
crypto_fips_available() -> Int
crypto_use_fips() -> Int
| Función |
Descripción |
crypto_active_provider() |
El nombre del proveedor criptográfico activo. |
crypto_cbom() |
Lista de materiales criptográficos (Cryptographic Bill of Materials, JSON). |
crypto_inventory() |
Catálogo de algoritmos criptográficos (JSON). |
crypto_policy() |
La política criptográfica activa. |
crypto_set_policy(spec) |
Establece la política criptográfica activa a partir de spec; devuelve un código de estado. |
crypto_fips_available() |
Indica si hay un proveedor FIPS disponible. |
crypto_use_fips() |
Indica si el modo FIPS está activo. |
Gestión de errores
Cualquier código de estado de la C ABI distinto de éxito lanza un PdfOxideError:
using PdfOxide
try
doc = open_document("file.pdf")
text = extract_text(doc, 0)
close!(doc)
catch e
if e isa PdfOxideError
@warn "PDF error" code=e.code op=e.op
else
rethrow()
end
end
PdfOxideError <: Exception lleva el code numérico de la C ABI y el nombre de la operación que falló.
Ejemplo completo
using PdfOxide
# --- Creation ---
doc_bytes = let b = DocumentBuilder()
set_title(b, "Report")
p = letter_page(b)
font(p, "Helvetica", 18)
at(p, 72, 720)
heading(p, 1, "Quarterly Report")
paragraph(p, "Generated by PDF Oxide.")
done(p)
out = build(b)
close!(b)
out
end
# --- Extraction ---
doc = open_from_bytes(doc_bytes)
println("Pages: ", page_count(doc))
for i in 0:page_count(doc)-1
println("Page ", i + 1, ": ", length(extract_text(doc, i)), " chars")
end
# Words + tables
words = extract_words(doc, 0)
tables = extract_tables(doc, 0)
# Search
for hit in search_all(doc, "report", false)
println("Found on page ", hit.page, " at ", hit.bbox)
end
close!(doc)
# --- Editing ---
e = open_editor("input.pdf")
rotate_all_pages(e, 90)
set_form_field_value(e, "name", "Jane Doe")
flatten_forms(e)
save(e, "output.pdf")
close!(e)
# --- Rendering ---
doc = open_document("input.pdf")
img = render_page(doc, 0) # PNG
save(img, "page0.png")
close!(img)
close!(doc)
Other Language Bindings
PDF Oxide ofrece bindings nativos para todos los ecosistemas principales: Rust, Python, Node.js, WASM, C#, Golang, Java, PHP, Ruby, C++, Swift, Kotlin, Dart, R, Zig, Scala, Clojure, Objective-C y Elixir.
Próximos pasos