@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/harfbuzz/functions.d.ts

@@ -22,477 +22,4293 @@ import { SetT } from "./set-t.js";
 import { ShapePlanT } from "./shape-plan-t.js";
 import { UnicodeFuncsT } from "./unicode-funcs-t.js";
 import * as GLib from "../glib/index.js";
+/**
+ * Fetches the name identifier of the specified feature type in the face's `name` table.
+ * @param face - #hb_face_t to work upon
+ * @param featureType - The #hb_aat_layout_feature_type_t of the requested feature type
+ */
 export declare const aatLayoutFeatureTypeGetNameId: (face: FaceT, featureType: AatLayoutFeatureTypeT) => number;
+/**
+ * Fetches a list of the selectors available for the specified feature in the given face.
+ *
+ * If upon return, `default_index` is set to #HB_AAT_LAYOUT_NO_SELECTOR_INDEX, then
+ * the feature type is non-exclusive.  Otherwise, `default_index` is the index of
+ * the selector that is selected by default.
+ * @param face - #hb_face_t to work upon
+ * @param featureType - The #hb_aat_layout_feature_type_t of the requested feature type
+ * @param startOffset - offset of the first feature type to retrieve
+ * @param selectorCount - Input = the maximum number of selectors to return;
+ * @param selectors - A buffer pointer. The selectors available for the feature type queries.
+ * @param defaultIndex - The index of the feature's default selector, if any
+ */
 export declare const aatLayoutFeatureTypeGetSelectorInfos: (face: FaceT, featureType: AatLayoutFeatureTypeT, startOffset: number, selectorCount?: Ref<number> | null, selectors?: Ref<number[]> | null, defaultIndex?: Ref<number> | null) => number;
+/**
+ * Fetches a list of the AAT feature types included in the specified face.
+ * @param face - #hb_face_t to work upon
+ * @param startOffset - offset of the first feature type to retrieve
+ * @param featureCount - Input = the maximum number of feature types to return;
+ * @param features - Array of feature types found
+ */
 export declare const aatLayoutGetFeatureTypes: (face: FaceT, startOffset: number, features: Ref<AatLayoutFeatureTypeT[]>, featureCount?: Ref<number> | null) => number;
+/**
+ * Tests whether the specified face includes any positioning information
+ * in the `kerx` table.
+ *
+ * <note>Note: does not examine the `GPOS` table.</note>
+ * @param face - #hb_face_t to work upon
+ */
 export declare const aatLayoutHasPositioning: (face: FaceT) => number;
+/**
+ * Tests whether the specified face includes any substitutions in the
+ * `morx` or `mort` tables.
+ *
+ * <note>Note: does not examine the `GSUB` table.</note>
+ * @param face - #hb_face_t to work upon
+ */
 export declare const aatLayoutHasSubstitution: (face: FaceT) => number;
+/**
+ * Tests whether the specified face includes any tracking information
+ * in the `trak` table.
+ * @param face - #hb_face_t to work upon
+ */
 export declare const aatLayoutHasTracking: (face: FaceT) => number;
+/**
+ * Makes a writable copy of @blob.
+ * @param blob - A blob.
+ */
 export declare const blobCopyWritableOrFail: (blob: BlobT) => BlobT;
+/**
+ * Creates a new blob containing the data from the
+ * specified binary font file.
+ *
+ * The filename is passed directly to the system on all platforms,
+ * except on Windows, where the filename is interpreted as UTF-8.
+ * Only if the filename is not valid UTF-8, it will be interpreted
+ * according to the system codepage.
+ * @param fileName - A font filename
+ */
 export declare const blobCreateFromFile: (fileName: string) => BlobT;
+/**
+ * Creates a new blob containing the data from the specified file.
+ *
+ * The filename is passed directly to the system on all platforms,
+ * except on Windows, where the filename is interpreted as UTF-8.
+ * Only if the filename is not valid UTF-8, it will be interpreted
+ * according to the system codepage.
+ * @param fileName - A filename
+ */
 export declare const blobCreateFromFileOrFail: (fileName: string) => BlobT;
+/**
+ * Returns a blob that represents a range of bytes in @parent.  The new
+ * blob is always created with #HB_MEMORY_MODE_READONLY, meaning that it
+ * will never modify data in the parent blob.  The parent data is not
+ * expected to be modified, and will result in undefined behavior if it
+ * is.
+ *
+ * Makes `parent` immutable.
+ * @param parent - Parent blob.
+ * @param offset - Start offset of sub-blob within @parent, in bytes.
+ * @param length - Length of sub-blob.
+ */
 export declare const blobCreateSubBlob: (parent: BlobT, offset: number, length: number) => BlobT;
+/**
+ * Fetches the data from a blob.
+ * @param blob - a blob.
+ * @param length - The length in bytes of the data retrieved
+ */
 export declare const blobGetData: (blob: BlobT, length: Ref<number>) => string[] | null;
+/**
+ * Tries to make blob data writable (possibly copying it) and
+ * return pointer to data.
+ *
+ * Fails if blob has been made immutable, or if memory allocation
+ * fails.
+ * @param blob - a blob.
+ * @param length - output length of the writable data.
+ */
 export declare const blobGetDataWritable: (blob: BlobT, length: Ref<number>) => string[];
+/**
+ * Returns the singleton empty blob.
+ *
+ * See TODO:link object types for more information.
+ */
 export declare const blobGetEmpty: () => BlobT;
+/**
+ * Fetches the length of a blob's data.
+ * @param blob - a blob.
+ */
 export declare const blobGetLength: (blob: BlobT) => number;
+/**
+ * Tests whether a blob is immutable.
+ * @param blob - a blob.
+ */
 export declare const blobIsImmutable: (blob: BlobT) => number;
+/**
+ * Makes a blob immutable.
+ * @param blob - a blob
+ */
 export declare const blobMakeImmutable: (blob: BlobT) => void;
+/**
+ * Appends a character with the Unicode value of `codepoint` to @buffer, and
+ * gives it the initial cluster value of @cluster. Clusters can be any thing
+ * the client wants, they are usually used to refer to the index of the
+ * character in the input text stream and are output in
+ * #hb_glyph_info_t.cluster field.
+ *
+ * This function does not check the validity of @codepoint, it is up to the
+ * caller to ensure it is a valid Unicode code point.
+ * @param buffer - An #hb_buffer_t
+ * @param codepoint - A Unicode code point.
+ * @param cluster - The cluster value of @codepoint.
+ */
 export declare const bufferAdd: (buffer: BufferT, codepoint: number, cluster: number) => void;
+/**
+ * Appends characters from `text` array to @buffer. The `item_offset` is the
+ * position of the first character from `text` that will be appended, and
+ * `item_length` is the number of character. When shaping part of a larger text
+ * (e.g. a run of text from a paragraph), instead of passing just the substring
+ * corresponding to the run, it is preferable to pass the whole
+ * paragraph and specify the run start and length as `item_offset` and
+ * @item_length, respectively, to give HarfBuzz the full context to be able,
+ * for example, to do cross-run Arabic shaping or properly handle combining
+ * marks at stat of run.
+ *
+ * This function does not check the validity of @text, it is up to the caller
+ * to ensure it contains a valid Unicode scalar values.  In contrast,
+ * hb_buffer_add_utf32() can be used that takes similar input but performs
+ * sanity-check on the input.
+ * @param buffer - a #hb_buffer_t to append characters to.
+ * @param text - an array of Unicode code points to append.
+ * @param textLength - the length of the @text, or -1 if it is `NULL` terminated.
+ * @param itemOffset - the offset of the first code point to add to the @buffer.
+ * @param itemLength - the number of code points to add to the @buffer, or -1 for the
+ */
 export declare const bufferAddCodepoints: (buffer: BufferT, text: number[], textLength: number, itemOffset: number, itemLength: number) => void;
+/**
+ * Similar to hb_buffer_add_codepoints(), but allows only access to first 256
+ * Unicode code points that can fit in 8-bit strings.
+ *
+ * <note>Has nothing to do with non-Unicode Latin-1 encoding.</note>
+ * @param buffer - An #hb_buffer_t
+ * @param text - an array of UTF-8
+ * @param textLength - the length of the @text, or -1 if it is `NULL` terminated
+ * @param itemOffset - the offset of the first character to add to the @buffer
+ * @param itemLength - the number of characters to add to the @buffer, or -1 for the
+ */
 export declare const bufferAddLatin1: (buffer: BufferT, text: number[], textLength: number, itemOffset: number, itemLength: number) => void;
+/**
+ * See hb_buffer_add_codepoints().
+ *
+ * Replaces invalid UTF-16 characters with the `buffer` replacement code point,
+ * see hb_buffer_set_replacement_codepoint().
+ * @param buffer - An #hb_buffer_t
+ * @param text - An array of UTF-16 characters to append
+ * @param textLength - The length of the @text, or -1 if it is `NULL` terminated
+ * @param itemOffset - The offset of the first character to add to the @buffer
+ * @param itemLength - The number of characters to add to the @buffer, or -1 for the
+ */
 export declare const bufferAddUtf16: (buffer: BufferT, text: number[], textLength: number, itemOffset: number, itemLength: number) => void;
+/**
+ * See hb_buffer_add_codepoints().
+ *
+ * Replaces invalid UTF-32 characters with the `buffer` replacement code point,
+ * see hb_buffer_set_replacement_codepoint().
+ * @param buffer - An #hb_buffer_t
+ * @param text - An array of UTF-32 characters to append
+ * @param textLength - The length of the @text, or -1 if it is `NULL` terminated
+ * @param itemOffset - The offset of the first character to add to the @buffer
+ * @param itemLength - The number of characters to add to the @buffer, or -1 for the
+ */
 export declare const bufferAddUtf32: (buffer: BufferT, text: number[], textLength: number, itemOffset: number, itemLength: number) => void;
+/**
+ * See hb_buffer_add_codepoints().
+ *
+ * Replaces invalid UTF-8 characters with the `buffer` replacement code point,
+ * see hb_buffer_set_replacement_codepoint().
+ * @param buffer - An #hb_buffer_t
+ * @param text - An array of UTF-8
+ * @param textLength - The length of the @text, or -1 if it is `NULL` terminated.
+ * @param itemOffset - The offset of the first character to add to the @buffer.
+ * @param itemLength - The number of characters to add to the @buffer, or -1 for the
+ */
 export declare const bufferAddUtf8: (buffer: BufferT, text: number[], textLength: number, itemOffset: number, itemLength: number) => void;
+/**
+ * Check if allocating memory for the buffer succeeded.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferAllocationSuccessful: (buffer: BufferT) => number;
+/**
+ * Append (part of) contents of another buffer to this buffer.
+ * @param buffer - An #hb_buffer_t
+ * @param source - source #hb_buffer_t
+ * @param start - start index into source buffer to copy.  Use 0 to copy from start of buffer.
+ * @param end - end index into source buffer to copy.  Use `UINT_MAX` (or ((unsigned int) -1)) to copy to end of buffer.
+ */
 export declare const bufferAppend: (buffer: BufferT, source: BufferT, start: number, end: number) => void;
+/**
+ * Similar to hb_buffer_reset(), but does not clear the Unicode functions and
+ * the replacement code point.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferClearContents: (buffer: BufferT) => void;
+/**
+ * Creates a new #hb_buffer_t with all properties to defaults.
+ */
 export declare const bufferCreate: () => BufferT;
+/**
+ * Creates a new #hb_buffer_t, similar to hb_buffer_create(). The only
+ * difference is that the buffer is configured similarly to @src.
+ * @param src - An #hb_buffer_t
+ */
 export declare const bufferCreateSimilar: (src: BufferT) => BufferT;
+/**
+ * Deserializes glyphs `buffer` from textual representation in the format
+ * produced by hb_buffer_serialize_glyphs().
+ * @param buffer - an #hb_buffer_t buffer.
+ * @param buf - string to deserialize
+ * @param bufLen - the size of @buf, or -1 if it is `NULL`-terminated
+ * @param endPtr - output pointer to the character after last
+ * @param font - font for getting glyph IDs
+ * @param format - the #hb_buffer_serialize_format_t of the input @buf
+ */
 export declare const bufferDeserializeGlyphs: (buffer: BufferT, buf: string[], bufLen: number, format: BufferSerializeFormatT, endPtr?: Ref<string> | null, font?: FontT | null) => number;
+/**
+ * Deserializes Unicode `buffer` from textual representation in the format
+ * produced by hb_buffer_serialize_unicode().
+ * @param buffer - an #hb_buffer_t buffer.
+ * @param buf - string to deserialize
+ * @param bufLen - the size of @buf, or -1 if it is `NULL`-terminated
+ * @param endPtr - output pointer to the character after last
+ * @param format - the #hb_buffer_serialize_format_t of the input @buf
+ */
 export declare const bufferDeserializeUnicode: (buffer: BufferT, buf: string[], bufLen: number, format: BufferSerializeFormatT, endPtr?: Ref<string> | null) => number;
+/**
+ * If dottedcircle_glyph is (hb_codepoint_t) -1 then #HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT
+ * and #HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT are never returned.  This should be used by most
+ * callers if just comparing two buffers is needed.
+ * @param buffer - a buffer.
+ * @param reference - other buffer to compare to.
+ * @param dottedcircleGlyph - glyph id of U+25CC DOTTED CIRCLE, or (hb_codepoint_t) -1.
+ * @param positionFuzz - allowed absolute difference in position values.
+ */
 export declare const bufferDiff: (buffer: BufferT, reference: BufferT, dottedcircleGlyph: number, positionFuzz: number) => BufferDiffFlagsT;
+/**
+ * Fetches the cluster level of a buffer. The #hb_buffer_cluster_level_t
+ * dictates one aspect of how HarfBuzz will treat non-base characters
+ * during shaping.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetClusterLevel: (buffer: BufferT) => BufferClusterLevelT;
+/**
+ * Fetches the type of `buffer` contents. Buffers are either empty, contain
+ * characters (before shaping), or contain glyphs (the result of shaping).
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetContentType: (buffer: BufferT) => BufferContentTypeT;
+/**
+ * See hb_buffer_set_direction()
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetDirection: (buffer: BufferT) => DirectionT;
+/**
+ * Fetches an empty #hb_buffer_t.
+ */
 export declare const bufferGetEmpty: () => BufferT;
+/**
+ * Fetches the #hb_buffer_flags_t of @buffer.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetFlags: (buffer: BufferT) => BufferFlagsT;
+/**
+ * Returns `buffer` glyph information array.  Returned pointer
+ * is valid as long as `buffer` contents are not modified.
+ * @param buffer - An #hb_buffer_t
+ * @param length - The output-array length.
+ */
 export declare const bufferGetGlyphInfos: (buffer: BufferT, length: Ref<number>) => GlyphInfoT[];
+/**
+ * Returns `buffer` glyph position array.  Returned pointer
+ * is valid as long as `buffer` contents are not modified.
+ *
+ * If buffer did not have positions before, the positions will be
+ * initialized to zeros, unless this function is called from
+ * within a buffer message callback (see hb_buffer_set_message_func()),
+ * in which case `NULL` is returned.
+ * @param buffer - An #hb_buffer_t
+ * @param length - The output length
+ */
 export declare const bufferGetGlyphPositions: (buffer: BufferT, length: Ref<number>) => GlyphPositionT[];
+/**
+ * See hb_buffer_set_invisible_glyph().
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetInvisibleGlyph: (buffer: BufferT) => number;
+/**
+ * See hb_buffer_set_language().
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetLanguage: (buffer: BufferT) => number;
+/**
+ * Returns the number of items in the buffer.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetLength: (buffer: BufferT) => number;
+/**
+ * See hb_buffer_set_not_found_glyph().
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetNotFoundGlyph: (buffer: BufferT) => number;
+/**
+ * See hb_buffer_set_not_found_variation_selector_glyph().
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetNotFoundVariationSelectorGlyph: (buffer: BufferT) => number;
+/**
+ * See hb_buffer_set_random_state().
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetRandomState: (buffer: BufferT) => number;
+/**
+ * Fetches the #hb_codepoint_t that replaces invalid entries for a given encoding
+ * when adding text to @buffer.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetReplacementCodepoint: (buffer: BufferT) => number;
+/**
+ * Fetches the script of @buffer.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetScript: (buffer: BufferT) => ScriptT;
+/**
+ * Sets `props` to the #hb_segment_properties_t of @buffer.
+ * @param buffer - An #hb_buffer_t
+ * @param props - The output #hb_segment_properties_t
+ */
 export declare const bufferGetSegmentProperties: (buffer: BufferT, props: Ref<SegmentPropertiesT>) => void;
+/**
+ * Fetches the Unicode-functions structure of a buffer.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGetUnicodeFuncs: (buffer: BufferT) => UnicodeFuncsT;
+/**
+ * Sets unset buffer segment properties based on buffer Unicode
+ * contents.  If buffer is not empty, it must have content type
+ * #HB_BUFFER_CONTENT_TYPE_UNICODE.
+ *
+ * If buffer script is not set (ie. is #HB_SCRIPT_INVALID), it
+ * will be set to the Unicode script of the first character in
+ * the buffer that has a script other than #HB_SCRIPT_COMMON,
+ * #HB_SCRIPT_INHERITED, and #HB_SCRIPT_UNKNOWN.
+ *
+ * Next, if buffer direction is not set (ie. is #HB_DIRECTION_INVALID),
+ * it will be set to the natural horizontal direction of the
+ * buffer script as returned by hb_script_get_horizontal_direction().
+ * If hb_script_get_horizontal_direction() returns #HB_DIRECTION_INVALID,
+ * then #HB_DIRECTION_LTR is used.
+ *
+ * Finally, if buffer language is not set (ie. is #HB_LANGUAGE_INVALID),
+ * it will be set to the process's default language as returned by
+ * hb_language_get_default().  This may change in the future by
+ * taking buffer script into consideration when choosing a language.
+ * Note that hb_language_get_default() is NOT threadsafe the first time
+ * it is called.  See documentation for that function for details.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferGuessSegmentProperties: (buffer: BufferT) => void;
+/**
+ * Returns whether `buffer` has glyph position data.
+ * A buffer gains position data when hb_buffer_get_glyph_positions() is called on it,
+ * and cleared of position data when hb_buffer_clear_contents() is called.
+ * @param buffer - an #hb_buffer_t.
+ */
 export declare const bufferHasPositions: (buffer: BufferT) => number;
+/**
+ * Reorders a glyph buffer to have canonical in-cluster glyph order / position.
+ * The resulting clusters should behave identical to pre-reordering clusters.
+ *
+ * <note>This has nothing to do with Unicode normalization.</note>
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferNormalizeGlyphs: (buffer: BufferT) => void;
+/**
+ * Pre allocates memory for `buffer` to fit at least `size` number of items.
+ * @param buffer - An #hb_buffer_t
+ * @param size - Number of items to pre allocate.
+ */
 export declare const bufferPreAllocate: (buffer: BufferT, size: number) => number;
+/**
+ * Resets the buffer to its initial status, as if it was just newly created
+ * with hb_buffer_create().
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferReset: (buffer: BufferT) => void;
+/**
+ * Reverses buffer contents.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferReverse: (buffer: BufferT) => void;
+/**
+ * Reverses buffer clusters.  That is, the buffer contents are
+ * reversed, then each cluster (consecutive items having the
+ * same cluster number) are reversed again.
+ * @param buffer - An #hb_buffer_t
+ */
 export declare const bufferReverseClusters: (buffer: BufferT) => void;
+/**
+ * Reverses buffer contents between `start` and @end.
+ * @param buffer - An #hb_buffer_t
+ * @param start - start index
+ * @param end - end index
+ */
 export declare const bufferReverseRange: (buffer: BufferT, start: number, end: number) => void;
+/**
+ * Serializes `buffer` into a textual representation of its content, whether
+ * Unicode codepoints or glyph identifiers and positioning information. This is
+ * useful for showing the contents of the buffer, for example during debugging.
+ * See the documentation of hb_buffer_serialize_unicode() and
+ * hb_buffer_serialize_glyphs() for a description of the output format.
+ * @param buffer - an #hb_buffer_t buffer.
+ * @param start - the first item in `buffer` to serialize.
+ * @param end - the last item in `buffer` to serialize.
+ * @param buf - output string to
+ * @param bufSize - the size of @buf.
+ * @param bufConsumed - if not `NULL`, will be set to the number of bytes written into @buf.
+ * @param font - the #hb_font_t used to shape this buffer, needed to
+ * @param format - the #hb_buffer_serialize_format_t to use for formatting the output.
+ * @param flags - the #hb_buffer_serialize_flags_t that control what glyph properties
+ */
 export declare const bufferSerialize: (buffer: BufferT, start: number, end: number, buf: Ref<number[]>, bufSize: Ref<number>, format: BufferSerializeFormatT, flags: BufferSerializeFlagsT, bufConsumed?: Ref<number> | null, font?: FontT | null) => number;
+/**
+ * Parses a string into an #hb_buffer_serialize_format_t. Does not check if
+ * `str` is a valid buffer serialization format, use
+ * hb_buffer_serialize_list_formats() to get the list of supported formats.
+ * @param str - a string to parse
+ * @param len - length of @str, or -1 if string is `NULL` terminated
+ */
 export declare const bufferSerializeFormatFromString: (str: number[], len: number) => BufferSerializeFormatT;
+/**
+ * Converts `format` to the string corresponding it, or `NULL` if it is not a valid
+ * #hb_buffer_serialize_format_t.
+ * @param format - an #hb_buffer_serialize_format_t to convert.
+ */
 export declare const bufferSerializeFormatToString: (format: BufferSerializeFormatT) => string;
+/**
+ * Serializes `buffer` into a textual representation of its glyph content,
+ * useful for showing the contents of the buffer, for example during debugging.
+ * There are currently two supported serialization formats:
+ *
+ * ## text
+ * A human-readable, plain text format.
+ * The serialized glyphs will look something like:
+ *
+ * ```
+ * [uni0651=0@518,0+0|uni0628=0+1897]
+ * ```
+ *
+ * - The serialized glyphs are delimited with `[` and `]`.
+ * - Glyphs are separated with `|`
+ * - Each glyph starts with glyph name, or glyph index if
+ * #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set. Then,
+ * - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, `=` then #hb_glyph_info_t.cluster.
+ * - If #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set, the #hb_glyph_position_t in the format:
+ * - If both #hb_glyph_position_t.x_offset and #hb_glyph_position_t.y_offset are not 0, `@x_offset,y_offset`. Then,
+ * - `+x_advance`, then `,y_advance` if #hb_glyph_position_t.y_advance is not 0. Then,
+ * - If #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set, the #hb_glyph_extents_t in the format `<x_bearing,y_bearing,width,height>`
+ *
+ * ## json
+ * A machine-readable, structured format.
+ * The serialized glyphs will look something like:
+ *
+ * ```
+ * [{"g":"uni0651","cl":0,"dx":518,"dy":0,"ax":0,"ay":0},
+ * {"g":"uni0628","cl":0,"dx":0,"dy":0,"ax":1897,"ay":0}]
+ * ```
+ *
+ * Each glyph is a JSON object, with the following properties:
+ * - `g`: the glyph name or glyph index if
+ * #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set.
+ * - `cl`: #hb_glyph_info_t.cluster if
+ * #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set.
+ * - `dx`,`dy`,`ax`,`ay`: #hb_glyph_position_t.x_offset, #hb_glyph_position_t.y_offset,
+ * #hb_glyph_position_t.x_advance and #hb_glyph_position_t.y_advance
+ * respectively, if #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set.
+ * - `xb`,`yb`,`w`,`h`: #hb_glyph_extents_t.x_bearing, #hb_glyph_extents_t.y_bearing,
+ * #hb_glyph_extents_t.width and #hb_glyph_extents_t.height respectively if
+ * #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set.
+ * @param buffer - an #hb_buffer_t buffer.
+ * @param start - the first item in `buffer` to serialize.
+ * @param end - the last item in `buffer` to serialize.
+ * @param buf - output string to
+ * @param bufSize - the size of @buf.
+ * @param bufConsumed - if not `NULL`, will be set to the number of bytes written into @buf.
+ * @param font - the #hb_font_t used to shape this buffer, needed to
+ * @param format - the #hb_buffer_serialize_format_t to use for formatting the output.
+ * @param flags - the #hb_buffer_serialize_flags_t that control what glyph properties
+ */
 export declare const bufferSerializeGlyphs: (buffer: BufferT, start: number, end: number, buf: Ref<number[]>, bufSize: Ref<number>, format: BufferSerializeFormatT, flags: BufferSerializeFlagsT, bufConsumed?: Ref<number> | null, font?: FontT | null) => number;
+/**
+ * Returns a list of supported buffer serialization formats.
+ */
 export declare const bufferSerializeListFormats: () => string[];
+/**
+ * Serializes `buffer` into a textual representation of its content,
+ * when the buffer contains Unicode codepoints (i.e., before shaping). This is
+ * useful for showing the contents of the buffer, for example during debugging.
+ * There are currently two supported serialization formats:
+ *
+ * ## text
+ * A human-readable, plain text format.
+ * The serialized codepoints will look something like:
+ *
+ * ```
+ * <U+0651=0|U+0628=1>
+ * ```
+ *
+ * - Glyphs are separated with `|`
+ * - Unicode codepoints are expressed as zero-padded four (or more)
+ * digit hexadecimal numbers preceded by `U+`
+ * - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, the cluster
+ * will be indicated with a `=` then #hb_glyph_info_t.cluster.
+ *
+ * ## json
+ * A machine-readable, structured format.
+ * The serialized codepoints will be a list of objects with the following
+ * properties:
+ * - `u`: the Unicode codepoint as a decimal integer
+ * - `cl`: #hb_glyph_info_t.cluster if
+ * #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set.
+ *
+ * For example:
+ *
+ * ```
+ * [{u:1617,cl:0},{u:1576,cl:1}]
+ * ```
+ * @param buffer - an #hb_buffer_t buffer.
+ * @param start - the first item in `buffer` to serialize.
+ * @param end - the last item in `buffer` to serialize.
+ * @param buf - output string to
+ * @param bufSize - the size of @buf.
+ * @param bufConsumed - if not `NULL`, will be set to the number of bytes written into @buf.
+ * @param format - the #hb_buffer_serialize_format_t to use for formatting the output.
+ * @param flags - the #hb_buffer_serialize_flags_t that control what glyph properties
+ */
 export declare const bufferSerializeUnicode: (buffer: BufferT, start: number, end: number, buf: Ref<number[]>, bufSize: Ref<number>, format: BufferSerializeFormatT, flags: BufferSerializeFlagsT, bufConsumed?: Ref<number> | null) => number;
+/**
+ * Sets the cluster level of a buffer. The #hb_buffer_cluster_level_t
+ * dictates one aspect of how HarfBuzz will treat non-base characters
+ * during shaping.
+ * @param buffer - An #hb_buffer_t
+ * @param clusterLevel - The cluster level to set on the buffer
+ */
 export declare const bufferSetClusterLevel: (buffer: BufferT, clusterLevel: BufferClusterLevelT) => void;
+/**
+ * Sets the type of `buffer` contents. Buffers are either empty, contain
+ * characters (before shaping), or contain glyphs (the result of shaping).
+ *
+ * You rarely need to call this function, since a number of other
+ * functions transition the content type for you. Namely:
+ *
+ * - A newly created buffer starts with content type
+ * %HB_BUFFER_CONTENT_TYPE_INVALID. Calling hb_buffer_reset(),
+ * hb_buffer_clear_contents(), as well as calling hb_buffer_set_length()
+ * with an argument of zero all set the buffer content type to invalid
+ * as well.
+ *
+ * - Calling hb_buffer_add_utf8(), hb_buffer_add_utf16(),
+ * hb_buffer_add_utf32(), hb_buffer_add_codepoints() and
+ * hb_buffer_add_latin1() expect that buffer is either empty and
+ * have a content type of invalid, or that buffer content type is
+ * %HB_BUFFER_CONTENT_TYPE_UNICODE, and they also set the content
+ * type to Unicode if they added anything to an empty buffer.
+ *
+ * - Finally hb_shape() and hb_shape_full() expect that the buffer
+ * is either empty and have content type of invalid, or that buffer
+ * content type is %HB_BUFFER_CONTENT_TYPE_UNICODE, and upon
+ * success they set the buffer content type to
+ * %HB_BUFFER_CONTENT_TYPE_GLYPHS.
+ *
+ * The above transitions are designed such that one can use a buffer
+ * in a loop of "reset : add-text : shape" without needing to ever
+ * modify the content type manually.
+ * @param buffer - An #hb_buffer_t
+ * @param contentType - The type of buffer contents to set
+ */
 export declare const bufferSetContentType: (buffer: BufferT, contentType: BufferContentTypeT) => void;
+/**
+ * Set the text flow direction of the buffer. No shaping can happen without
+ * setting `buffer` direction, and it controls the visual direction for the
+ * output glyphs; for RTL direction the glyphs will be reversed. Many layout
+ * features depend on the proper setting of the direction, for example,
+ * reversing RTL text before shaping, then shaping with LTR direction is not
+ * the same as keeping the text in logical order and shaping with RTL
+ * direction.
+ * @param buffer - An #hb_buffer_t
+ * @param direction - the #hb_direction_t of the @buffer
+ */
 export declare const bufferSetDirection: (buffer: BufferT, direction: DirectionT) => void;
+/**
+ * Sets `buffer` flags to @flags. See #hb_buffer_flags_t.
+ * @param buffer - An #hb_buffer_t
+ * @param flags - The buffer flags to set
+ */
 export declare const bufferSetFlags: (buffer: BufferT, flags: BufferFlagsT) => void;
+/**
+ * Sets the #hb_codepoint_t that replaces invisible characters in
+ * the shaping result.  If set to zero (default), the glyph for the
+ * U+0020 SPACE character is used.  Otherwise, this value is used
+ * verbatim.
+ * @param buffer - An #hb_buffer_t
+ * @param invisible - the invisible #hb_codepoint_t
+ */
 export declare const bufferSetInvisibleGlyph: (buffer: BufferT, invisible: number) => void;
+/**
+ * Sets the language of `buffer` to @language.
+ *
+ * Languages are crucial for selecting which OpenType feature to apply to the
+ * buffer which can result in applying language-specific behaviour. Languages
+ * are orthogonal to the scripts, and though they are related, they are
+ * different concepts and should not be confused with each other.
+ *
+ * Use hb_language_from_string() to convert from BCP 47 language tags to
+ * #hb_language_t.
+ * @param buffer - An #hb_buffer_t
+ * @param language - An hb_language_t to set
+ */
 export declare const bufferSetLanguage: (buffer: BufferT, language: number) => void;
+/**
+ * Similar to hb_buffer_pre_allocate(), but clears any new items added at the
+ * end.
+ * @param buffer - An #hb_buffer_t
+ * @param length - The new length of @buffer
+ */
 export declare const bufferSetLength: (buffer: BufferT, length: number) => number;
+/**
+ * Sets the implementation function for #hb_buffer_message_func_t.
+ * @param buffer - An #hb_buffer_t
+ * @param func - Callback function
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const bufferSetMessageFunc: (buffer: BufferT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the #hb_codepoint_t that replaces characters not found in
+ * the font during shaping.
+ *
+ * The not-found glyph defaults to zero, sometimes known as the
+ * ".notdef" glyph.  This API allows for differentiating the two.
+ * @param buffer - An #hb_buffer_t
+ * @param notFound - the not-found #hb_codepoint_t
+ */
 export declare const bufferSetNotFoundGlyph: (buffer: BufferT, notFound: number) => void;
+/**
+ * Sets the #hb_codepoint_t that replaces variation-selector characters not resolved
+ * in the font during shaping.
+ *
+ * The not-found-variation-selector glyph defaults to #HB_CODEPOINT_INVALID,
+ * in which case an unresolved variation-selector will be removed from the glyph
+ * string during shaping. This API allows for changing that and retaining a glyph,
+ * such that the situation can be detected by the client and handled accordingly
+ * (e.g. by using a different font).
+ * @param buffer - An #hb_buffer_t
+ * @param notFoundVariationSelector - the not-found-variation-selector #hb_codepoint_t
+ */
 export declare const bufferSetNotFoundVariationSelectorGlyph: (buffer: BufferT, notFoundVariationSelector: number) => void;
+/**
+ * Sets the random state of the buffer. The state changes
+ * every time a glyph uses randomness (eg. the `rand`
+ * OpenType feature). This function together with
+ * hb_buffer_get_random_state() allow for transferring
+ * the current random state to a subsequent buffer, to
+ * get better randomness distribution.
+ *
+ * Defaults to 1 and when buffer contents are cleared.
+ * A value of 0 disables randomness during shaping.
+ * @param buffer - An #hb_buffer_t
+ * @param state - the new random state
+ */
 export declare const bufferSetRandomState: (buffer: BufferT, state: number) => void;
+/**
+ * Sets the #hb_codepoint_t that replaces invalid entries for a given encoding
+ * when adding text to @buffer.
+ *
+ * Default is #HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT.
+ * @param buffer - An #hb_buffer_t
+ * @param replacement - the replacement #hb_codepoint_t
+ */
 export declare const bufferSetReplacementCodepoint: (buffer: BufferT, replacement: number) => void;
+/**
+ * Sets the script of `buffer` to @script.
+ *
+ * Script is crucial for choosing the proper shaping behaviour for scripts that
+ * require it (e.g. Arabic) and the which OpenType features defined in the font
+ * to be applied.
+ *
+ * You can pass one of the predefined #hb_script_t values, or use
+ * hb_script_from_string() or hb_script_from_iso15924_tag() to get the
+ * corresponding script from an ISO 15924 script tag.
+ * @param buffer - An #hb_buffer_t
+ * @param script - An #hb_script_t to set.
+ */
 export declare const bufferSetScript: (buffer: BufferT, script: ScriptT) => void;
+/**
+ * Sets the segment properties of the buffer, a shortcut for calling
+ * hb_buffer_set_direction(), hb_buffer_set_script() and
+ * hb_buffer_set_language() individually.
+ * @param buffer - An #hb_buffer_t
+ * @param props - An #hb_segment_properties_t to use
+ */
 export declare const bufferSetSegmentProperties: (buffer: BufferT, props: SegmentPropertiesT) => void;
+/**
+ * Sets the Unicode-functions structure of a buffer to
+ * @unicode_funcs.
+ * @param buffer - An #hb_buffer_t
+ * @param unicodeFuncs - The Unicode-functions structure
+ */
 export declare const bufferSetUnicodeFuncs: (buffer: BufferT, unicodeFuncs: UnicodeFuncsT) => void;
+/**
+ * Allocates `nmemb` elements of `size` bytes each, initialized to zero,
+ * using the allocator set at compile-time. Typically just calloc().
+ * @param nmemb - The number of elements to allocate.
+ * @param size - The size of each element.
+ */
 export declare const calloc: (nmemb: number, size: number) => number | null;
+/**
+ * Fetches the alpha channel of the given @color.
+ * @param color - an #hb_color_t we are interested in its channels.
+ */
 export declare const colorGetAlpha: (color: number) => number;
+/**
+ * Fetches the blue channel of the given @color.
+ * @param color - an #hb_color_t we are interested in its channels.
+ */
 export declare const colorGetBlue: (color: number) => number;
+/**
+ * Fetches the green channel of the given @color.
+ * @param color - an #hb_color_t we are interested in its channels.
+ */
 export declare const colorGetGreen: (color: number) => number;
+/**
+ * Fetches the red channel of the given @color.
+ * @param color - an #hb_color_t we are interested in its channels.
+ */
 export declare const colorGetRed: (color: number) => number;
+/**
+ * Fetches a list of color stops from the given color line object.
+ *
+ * Note that due to variations being applied, the returned color stops
+ * may be out of order. It is the callers responsibility to ensure that
+ * color stops are sorted by their offset before they are used.
+ * @param colorLine - a #hb_color_line_t object
+ * @param start - the index of the first color stop to return
+ * @param count - Input = the maximum number of feature tags to return;
+ * @param colorStops - Array of #hb_color_stop_t to populate
+ */
 export declare const colorLineGetColorStops: (colorLine: ColorLineT, start: number, count?: Ref<number> | null, colorStops?: Ref<ColorStopT[]> | null) => number;
+/**
+ * Fetches the extend mode of the color line object.
+ * @param colorLine - a #hb_color_line_t object
+ */
 export declare const colorLineGetExtend: (colorLine: ColorLineT) => PaintExtendT;
+/**
+ * Converts a string to an #hb_direction_t.
+ *
+ * Matching is loose and applies only to the first letter. For
+ * examples, "LTR" and "left-to-right" will both return #HB_DIRECTION_LTR.
+ *
+ * Unmatched strings will return #HB_DIRECTION_INVALID.
+ * @param str - String to convert
+ * @param len - Length of @str, or -1 if it is `NULL`-terminated
+ */
 export declare const directionFromString: (str: number[], len: number) => DirectionT;
+/**
+ * Converts an #hb_direction_t to a string.
+ * @param direction - The #hb_direction_t to convert
+ */
 export declare const directionToString: (direction: DirectionT) => string;
+/**
+ * Perform a "close-path" draw operation.
+ * @param dfuncs - draw functions
+ * @param drawData - associated draw data passed by the caller
+ * @param st - current draw state
+ */
 export declare const drawClosePath: (dfuncs: DrawFuncsT, st: DrawStateT, drawData?: number | null) => void;
+/**
+ * Perform a "cubic-to" draw operation.
+ * @param dfuncs - draw functions
+ * @param drawData - associated draw data passed by the caller
+ * @param st - current draw state
+ * @param control1X - X component of first control point
+ * @param control1Y - Y component of first control point
+ * @param control2X - X component of second control point
+ * @param control2Y - Y component of second control point
+ * @param toX - X component of target point
+ * @param toY - Y component of target point
+ */
 export declare const drawCubicTo: (dfuncs: DrawFuncsT, st: DrawStateT, control1X: number, control1Y: number, control2X: number, control2Y: number, toX: number, toY: number, drawData?: number | null) => void;
+/**
+ * Creates a new draw callbacks object.
+ */
 export declare const drawFuncsCreate: () => DrawFuncsT;
+/**
+ * Fetches the singleton empty draw-functions structure.
+ */
 export declare const drawFuncsGetEmpty: () => DrawFuncsT;
+/**
+ * Checks whether `dfuncs` is immutable.
+ * @param dfuncs - draw functions
+ */
 export declare const drawFuncsIsImmutable: (dfuncs: DrawFuncsT) => number;
+/**
+ * Makes `dfuncs` object immutable.
+ * @param dfuncs - draw functions
+ */
 export declare const drawFuncsMakeImmutable: (dfuncs: DrawFuncsT) => void;
+/**
+ * Sets close-path callback to the draw functions object.
+ * @param dfuncs - draw functions object
+ * @param func - close-path callback
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const drawFuncsSetClosePathFunc: (dfuncs: DrawFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets cubic-to callback to the draw functions object.
+ * @param dfuncs - draw functions
+ * @param func - cubic-to callback
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const drawFuncsSetCubicToFunc: (dfuncs: DrawFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets line-to callback to the draw functions object.
+ * @param dfuncs - draw functions object
+ * @param func - line-to callback
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const drawFuncsSetLineToFunc: (dfuncs: DrawFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets move-to callback to the draw functions object.
+ * @param dfuncs - draw functions object
+ * @param func - move-to callback
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const drawFuncsSetMoveToFunc: (dfuncs: DrawFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets quadratic-to callback to the draw functions object.
+ * @param dfuncs - draw functions object
+ * @param func - quadratic-to callback
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const drawFuncsSetQuadraticToFunc: (dfuncs: DrawFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Perform a "line-to" draw operation.
+ * @param dfuncs - draw functions
+ * @param drawData - associated draw data passed by the caller
+ * @param st - current draw state
+ * @param toX - X component of target point
+ * @param toY - Y component of target point
+ */
 export declare const drawLineTo: (dfuncs: DrawFuncsT, st: DrawStateT, toX: number, toY: number, drawData?: number | null) => void;
+/**
+ * Perform a "move-to" draw operation.
+ * @param dfuncs - draw functions
+ * @param drawData - associated draw data passed by the caller
+ * @param st - current draw state
+ * @param toX - X component of target point
+ * @param toY - Y component of target point
+ */
 export declare const drawMoveTo: (dfuncs: DrawFuncsT, st: DrawStateT, toX: number, toY: number, drawData?: number | null) => void;
+/**
+ * Perform a "quadratic-to" draw operation.
+ * @param dfuncs - draw functions
+ * @param drawData - associated draw data passed by the caller
+ * @param st - current draw state
+ * @param controlX - X component of control point
+ * @param controlY - Y component of control point
+ * @param toX - X component of target point
+ * @param toY - Y component of target point
+ */
 export declare const drawQuadraticTo: (dfuncs: DrawFuncsT, st: DrawStateT, controlX: number, controlY: number, toX: number, toY: number, drawData?: number | null) => void;
+/**
+ * Add table for `tag` with data provided by `blob` to the face.  `face` must
+ * be created using hb_face_builder_create().
+ * @param face - A face object created with hb_face_builder_create()
+ * @param tag - The #hb_tag_t of the table to add
+ * @param blob - The blob containing the table data to add
+ */
 export declare const faceBuilderAddTable: (face: FaceT, tag: number, blob: BlobT) => number;
+/**
+ * Creates a #hb_face_t that can be used with hb_face_builder_add_table().
+ * After tables are added to the face, it can be compiled to a binary
+ * font file by calling hb_face_reference_blob().
+ */
 export declare const faceBuilderCreate: () => FaceT;
+/**
+ * Set the ordering of tables for serialization. Any tables not
+ * specified in the tags list will be ordered after the tables in
+ * tags, ordered by the default sort ordering.
+ * @param face - A face object created with hb_face_builder_create()
+ * @param tags - ordered list of table tags terminated by
+ */
 export declare const faceBuilderSortTables: (face: FaceT, tags: number[]) => void;
+/**
+ * Collects the mapping from Unicode characters to nominal glyphs of the @face,
+ * and optionally all of the Unicode characters covered by @face.
+ * @param face - A face object
+ * @param mapping - The map to add Unicode-to-glyph mapping to
+ * @param unicodes - The set to add Unicode characters to, or `NULL`
+ */
 export declare const faceCollectNominalGlyphMapping: (face: FaceT, mapping: Ref<MapT>, unicodes?: Ref<SetT> | null) => void;
+/**
+ * Collects all of the Unicode characters covered by `face` and adds
+ * them to the #hb_set_t set @out.
+ * @param face - A face object
+ * @param out - The set to add Unicode characters to
+ */
 export declare const faceCollectUnicodes: (face: FaceT, out: Ref<SetT>) => void;
+/**
+ * Collects all Unicode "Variation Selector" characters covered by `face` and adds
+ * them to the #hb_set_t set @out.
+ * @param face - A face object
+ * @param out - The set to add Variation Selector characters to
+ */
 export declare const faceCollectVariationSelectors: (face: FaceT, out: Ref<SetT>) => void;
+/**
+ * Collects all Unicode characters for `variation_selector` covered by `face` and adds
+ * them to the #hb_set_t set @out.
+ * @param face - A face object
+ * @param variationSelector - The Variation Selector to query
+ * @param out - The set to add Unicode characters to
+ */
 export declare const faceCollectVariationUnicodes: (face: FaceT, variationSelector: number, out: Ref<SetT>) => void;
+/**
+ * Fetches the number of faces in a blob.
+ * @param blob - a blob.
+ */
 export declare const faceCount: (blob: BlobT) => number;
+/**
+ * Constructs a new face object from the specified blob and
+ * a face index into that blob.
+ *
+ * The face index is used for blobs of file formats such as TTC and
+ * DFont that can contain more than one face.  Face indices within
+ * such collections are zero-based.
+ *
+ * <note>Note: If the blob font format is not a collection, `index` is ignored.  Otherwise, only the lower 16-bits of `index` are used.
+ * The unmodified `index` can be accessed via hb_face_get_index().</note>
+ *
+ * <note>Note: The high 16-bits of @index, if non-zero, are used by
+ * hb_font_create() to load named-instances in variable fonts.  See
+ * hb_font_create() for details.</note>
+ * @param blob - #hb_blob_t to work upon
+ * @param index - The index of the face within @blob
+ */
 export declare const faceCreate: (blob: BlobT, index: number) => FaceT;
+/**
+ * Variant of hb_face_create(), built for those cases where it is more
+ * convenient to provide data for individual tables instead of the whole font
+ * data. With the caveat that hb_face_get_table_tags() would not work
+ * with faces created this way. You can address that by calling the
+ * hb_face_set_get_table_tags_func() function and setting the appropriate callback.
+ *
+ * Creates a new face object from the specified `user_data` and @reference_table_func,
+ * with the `destroy` callback.
+ * @param referenceTableFunc - Table-referencing function
+ * @param userData - A pointer to the user data
+ * @param destroy - A callback to call when `data` is not needed anymore
+ */
 export declare const faceCreateForTables: (referenceTableFunc: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => FaceT;
+/**
+ * A thin wrapper around hb_blob_create_from_file_or_fail()
+ * followed by hb_face_create_or_fail().
+ * @param fileName - A font filename
+ * @param index - The index of the face within the file
+ */
 export declare const faceCreateFromFileOrFail: (fileName: string, index: number) => FaceT;
+/**
+ * A thin wrapper around the face loader functions registered with HarfBuzz.
+ * If `loader_name` is `NULL` or the empty string, the first available loader
+ * is used.
+ *
+ * For example, the FreeType ("ft") loader might be able to load
+ * WOFF and WOFF2 files if FreeType is built with those features,
+ * whereas the OpenType ("ot") loader will not.
+ * @param fileName - A font filename
+ * @param index - The index of the face within the file
+ * @param loaderName - The name of the loader to use, or `NULL`
+ */
 export declare const faceCreateFromFileOrFailUsing: (fileName: string, index: number, loaderName?: string | null) => FaceT;
+/**
+ * Like hb_face_create(), but returns `NULL` if the blob data
+ * contains no usable font face at the specified index.
+ * @param blob - #hb_blob_t to work upon
+ * @param index - The index of the face within @blob
+ */
 export declare const faceCreateOrFail: (blob: BlobT, index: number) => FaceT;
+/**
+ * A thin wrapper around the face loader functions registered with HarfBuzz.
+ * If `loader_name` is `NULL` or the empty string, the first available loader
+ * is used.
+ *
+ * For example, the FreeType ("ft") loader might be able to load
+ * WOFF and WOFF2 files if FreeType is built with those features,
+ * whereas the OpenType ("ot") loader will not.
+ * @param blob - #hb_blob_t to work upon
+ * @param index - The index of the face within @blob
+ * @param loaderName - The name of the loader to use, or `NULL`
+ */
 export declare const faceCreateOrFailUsing: (blob: BlobT, index: number, loaderName?: string | null) => FaceT;
+/**
+ * Fetches the singleton empty face object.
+ */
 export declare const faceGetEmpty: () => FaceT;
+/**
+ * Fetches the glyph-count value of the specified face object.
+ * @param face - A face object
+ */
 export declare const faceGetGlyphCount: (face: FaceT) => number;
+/**
+ * Fetches the face-index corresponding to the given face.
+ *
+ * <note>Note: face indices within a collection are zero-based.</note>
+ * @param face - A face object
+ */
 export declare const faceGetIndex: (face: FaceT) => number;
+/**
+ * Fetches a list of all table tags for a face, if possible. The list returned will
+ * begin at the offset provided
+ * @param face - A face object
+ * @param startOffset - The index of first table tag to retrieve
+ * @param tableCount - Input = the maximum number of table tags to return;
+ * @param tableTags - The array of table tags found
+ */
 export declare const faceGetTableTags: (face: FaceT, startOffset: number, tableCount: Ref<number>, tableTags: Ref<number[]>) => number;
+/**
+ * Fetches the units-per-em (UPEM) value of the specified face object.
+ *
+ * Typical UPEM values for fonts are 1000, or 2048, but any value
+ * in between 16 and 16,384 is allowed for OpenType fonts.
+ * @param face - A face object
+ */
 export declare const faceGetUpem: (face: FaceT) => number;
+/**
+ * Tests whether the given face object is immutable.
+ * @param face - A face object
+ */
 export declare const faceIsImmutable: (face: FaceT) => number;
+/**
+ * Retrieves the list of face loaders supported by HarfBuzz.
+ */
 export declare const faceListLoaders: () => string[];
+/**
+ * Makes the given face object immutable.
+ * @param face - A face object
+ */
 export declare const faceMakeImmutable: (face: FaceT) => void;
+/**
+ * Fetches a pointer to the binary blob that contains the specified face.
+ * If referencing the face data is not possible, this function creates a blob
+ * out of individual table blobs if hb_face_get_table_tags() works with this
+ * face, otherwise it returns an empty blob.
+ * @param face - A face object
+ */
 export declare const faceReferenceBlob: (face: FaceT) => BlobT;
+/**
+ * Fetches a reference to the specified table within
+ * the specified face. Returns an empty blob if referencing table data is not
+ * possible.
+ * @param face - A face object
+ * @param tag - The #hb_tag_t of the table to query
+ */
 export declare const faceReferenceTable: (face: FaceT, tag: number) => BlobT;
+/**
+ * Sets the table-tag-fetching function for the specified face object.
+ * @param face - A face object
+ * @param func - The table-tag-fetching function
+ * @param userData - A pointer to the user data, to be destroyed by `destroy` when not needed anymore
+ * @param destroy - A callback to call when `func` is not needed anymore
+ */
 export declare const faceSetGetTableTagsFunc: (face: FaceT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the glyph count for a face object to the specified value.
+ *
+ * This API is used in rare circumstances.
+ * @param face - A face object
+ * @param glyphCount - The glyph-count value to assign
+ */
 export declare const faceSetGlyphCount: (face: FaceT, glyphCount: number) => void;
+/**
+ * Assigns the specified face-index to @face. Fails if the
+ * face is immutable.
+ *
+ * <note>Note: changing the index has no effect on the face itself
+ * This only changes the value returned by hb_face_get_index().</note>
+ * @param face - A face object
+ * @param index - The index to assign
+ */
 export declare const faceSetIndex: (face: FaceT, index: number) => void;
+/**
+ * Sets the units-per-em (upem) for a face object to the specified value.
+ *
+ * This API is used in rare circumstances.
+ * @param face - A face object
+ * @param upem - The units-per-em value to assign
+ */
 export declare const faceSetUpem: (face: FaceT, upem: number) => void;
+/**
+ * Parses a string into a #hb_feature_t.
+ *
+ * The format for specifying feature strings follows. All valid CSS
+ * font-feature-settings values other than 'normal' and the global values are
+ * also accepted, though not documented below. CSS string escapes are not
+ * supported.
+ *
+ * The range indices refer to the positions between Unicode characters. The
+ * position before the first character is always 0.
+ *
+ * The format is Python-esque.  Here is how it all works:
+ *
+ * <informaltable pgwide='1' align='left' frame='none'>
+ * <tgroup cols='5'>
+ * <thead>
+ * <row><entry>Syntax</entry>    <entry>Value</entry> <entry>Start</entry> <entry>End</entry></row>
+ * </thead>
+ * <tbody>
+ * <row><entry>Setting value:</entry></row>
+ * <row><entry>kern</entry>      <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+ * <row><entry>+kern</entry>     <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+ * <row><entry>-kern</entry>     <entry>0</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature off</entry></row>
+ * <row><entry>kern=0</entry>    <entry>0</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature off</entry></row>
+ * <row><entry>kern=1</entry>    <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+ * <row><entry>aalt=2</entry>    <entry>2</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Choose 2nd alternate</entry></row>
+ * <row><entry>Setting index:</entry></row>
+ * <row><entry>kern[]</entry>    <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+ * <row><entry>kern[:]</entry>   <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+ * <row><entry>kern[5:]</entry>  <entry>1</entry>     <entry>5</entry>      <entry>∞</entry>   <entry>Turn feature on, partial</entry></row>
+ * <row><entry>kern[:5]</entry>  <entry>1</entry>     <entry>0</entry>      <entry>5</entry>   <entry>Turn feature on, partial</entry></row>
+ * <row><entry>kern[3:5]</entry> <entry>1</entry>     <entry>3</entry>      <entry>5</entry>   <entry>Turn feature on, range</entry></row>
+ * <row><entry>kern[3]</entry>   <entry>1</entry>     <entry>3</entry>      <entry>3+1</entry> <entry>Turn feature on, single char</entry></row>
+ * <row><entry>Mixing it all:</entry></row>
+ * <row><entry>aalt[3:5]=2</entry> <entry>2</entry>   <entry>3</entry>      <entry>5</entry>   <entry>Turn 2nd alternate on for range</entry></row>
+ * </tbody>
+ * </tgroup>
+ * </informaltable>
+ * @param str - a string to parse
+ * @param len - length of @str, or -1 if string is `NULL` terminated
+ * @param feature - the #hb_feature_t to initialize with the parsed values
+ */
 export declare const featureFromString: (str: number[], len: number, feature: Ref<FeatureT>) => number;
+/**
+ * Converts a #hb_feature_t into a `NULL`-terminated string in the format
+ * understood by hb_feature_from_string(). The client in responsible for
+ * allocating big enough size for @buf, 128 bytes is more than enough.
+ *
+ * Note that the feature value will be omitted if it is '1', but the
+ * string won't include any whitespace.
+ * @param feature - an #hb_feature_t to convert
+ * @param buf - output string
+ * @param size - the allocated size of @buf
+ */
 export declare const featureToString: (feature: FeatureT, buf: Ref<string[]>, size: Ref<number>) => void;
+/**
+ * Adds the origin coordinates to an (X,Y) point coordinate, in
+ * the specified glyph ID in the specified font.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param direction - The direction of the text segment
+ * @param x - Input = The original X coordinate
+ * @param y - Input = The original Y coordinate
+ */
 export declare const fontAddGlyphOriginForDirection: (font: FontT, glyph: number, direction: DirectionT, x: Ref<number>, y: Ref<number>) => void;
+/**
+ * Notifies the `font` that underlying font data has changed.
+ * This has the effect of increasing the serial as returned
+ * by hb_font_get_serial(), which invalidates internal caches.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontChanged: (font: FontT) => void;
+/**
+ * Constructs a new font object from the specified face.
+ *
+ * <note>Note: If @face's index value (as passed to hb_face_create()
+ * has non-zero top 16-bits, those bits minus one are passed to
+ * hb_font_set_var_named_instance(), effectively loading a named-instance
+ * of a variable font, instead of the default-instance.  This allows
+ * specifying which named-instance to load by default when creating the
+ * face.</note>
+ * @param face - a face.
+ */
 export declare const fontCreate: (face: FaceT) => FontT;
+/**
+ * Constructs a sub-font font object from the specified `parent` font,
+ * replicating the parent's properties.
+ * @param parent - The parent font object
+ */
 export declare const fontCreateSubFont: (parent: FontT) => FontT;
+/**
+ * Draws the outline that corresponds to a glyph in the specified @font.
+ *
+ * This is an older name for hb_font_draw_glyph_or_fail(), with no
+ * return value.
+ *
+ * The outline is returned by way of calls to the callbacks of the `dfuncs` objects, with `draw_data` passed to them.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID
+ * @param dfuncs - #hb_draw_funcs_t to draw to
+ * @param drawData - User data to pass to draw callbacks
+ */
 export declare const fontDrawGlyph: (font: FontT, glyph: number, dfuncs: DrawFuncsT, drawData?: number | null) => void;
+/**
+ * Draws the outline that corresponds to a glyph in the specified @font.
+ *
+ * This is a newer name for hb_font_draw_glyph(), that returns `false`
+ * if the font has no outlines for the glyph.
+ *
+ * The outline is returned by way of calls to the callbacks of the `dfuncs` objects, with `draw_data` passed to them.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID
+ * @param dfuncs - #hb_draw_funcs_t to draw to
+ * @param drawData - User data to pass to draw callbacks
+ */
 export declare const fontDrawGlyphOrFail: (font: FontT, glyph: number, dfuncs: DrawFuncsT, drawData?: number | null) => number;
+/**
+ * Creates a new #hb_font_funcs_t structure of font functions.
+ */
 export declare const fontFuncsCreate: () => FontFuncsT;
+/**
+ * Fetches an empty font-functions structure.
+ */
 export declare const fontFuncsGetEmpty: () => FontFuncsT;
+/**
+ * Tests whether a font-functions structure is immutable.
+ * @param ffuncs - The font-functions structure
+ */
 export declare const fontFuncsIsImmutable: (ffuncs: FontFuncsT) => number;
+/**
+ * Makes a font-functions structure immutable.
+ * @param ffuncs - The font-functions structure
+ */
 export declare const fontFuncsMakeImmutable: (ffuncs: FontFuncsT) => void;
+/**
+ * Sets the implementation function for #hb_font_draw_glyph_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetDrawGlyphFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_draw_glyph_or_fail_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetDrawGlyphOrFailFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_font_h_extents_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetFontHExtentsFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_font_v_extents_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetFontVExtentsFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_contour_point_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphContourPointFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_extents_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphExtentsFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_from_name_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphFromNameFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Deprecated.  Use hb_font_funcs_set_nominal_glyph_func() and
+ * hb_font_funcs_set_variation_glyph_func() instead.
+ * @param ffuncs - The font-functions structure
+ * @param func - callback function
+ * @param userData - data to pass to @func
+ * @param destroy - function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_h_advance_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphHAdvanceFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_h_advances_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphHAdvancesFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_h_kerning_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphHKerningFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_h_origin_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphHOriginFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_h_origins_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphHOriginsFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_name_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphNameFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_shape_func_t,
+ * which is the same as #hb_font_draw_glyph_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphShapeFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_v_advance_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphVAdvanceFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_v_advances_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphVAdvancesFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_v_kerning_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphVKerningFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_v_origin_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphVOriginFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_glyph_v_origins_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetGlyphVOriginsFunc: (ffuncs: FontFuncsT, func: number, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_nominal_glyph_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetNominalGlyphFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_nominal_glyphs_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetNominalGlyphsFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_paint_glyph_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is no longer needed
+ */
 export declare const fontFuncsSetPaintGlyphFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_paint_glyph_or_fail_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is no longer needed
+ */
 export declare const fontFuncsSetPaintGlyphOrFailFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_font_get_variation_glyph_func_t.
+ * @param ffuncs - A font-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const fontFuncsSetVariationGlyphFunc: (ffuncs: FontFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Fetches the empty font object.
+ */
 export declare const fontGetEmpty: () => FontT;
+/**
+ * Fetches the extents for a font in a text segment of the
+ * specified direction.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param direction - The direction of the text segment
+ * @param extents - The #hb_font_extents_t retrieved
+ */
 export declare const fontGetExtentsForDirection: (font: FontT, direction: DirectionT, extents: Ref<number>) => void;
+/**
+ * Fetches the face associated with the specified font object.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontGetFace: (font: FontT) => FaceT;
+/**
+ * Fetches the glyph ID for a Unicode code point in the specified
+ * font, with an optional variation selector.
+ *
+ * If `variation_selector` is 0, calls hb_font_get_nominal_glyph();
+ * otherwise calls hb_font_get_variation_glyph().
+ * @param font - #hb_font_t to work upon
+ * @param unicode - The Unicode code point to query
+ * @param variationSelector - A variation-selector code point
+ * @param glyph - The glyph ID retrieved
+ */
 export declare const fontGetGlyph: (font: FontT, unicode: number, variationSelector: number, glyph: Ref<number>) => number;
+/**
+ * Fetches the advance for a glyph ID from the specified font,
+ * in a text segment of the specified direction.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param direction - The direction of the text segment
+ * @param x - The horizontal advance retrieved
+ * @param y - The vertical advance retrieved
+ */
 export declare const fontGetGlyphAdvanceForDirection: (font: FontT, glyph: number, direction: DirectionT, x: Ref<number>, y: Ref<number>) => void;
+/**
+ * Fetches the advances for a sequence of glyph IDs in the specified
+ * font, in a text segment of the specified direction.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param direction - The direction of the text segment
+ * @param count - The number of glyph IDs in the sequence queried
+ * @param firstGlyph - The first glyph ID to query
+ * @param glyphStride - The stride between successive glyph IDs
+ * @param firstAdvance - The first advance retrieved
+ * @param advanceStride - The stride between successive advances
+ */
 export declare const fontGetGlyphAdvancesForDirection: (font: FontT, direction: DirectionT, count: number, firstGlyph: number, glyphStride: number, firstAdvance: Ref<number>, advanceStride: Ref<number>) => void;
+/**
+ * Fetches the (x,y) coordinates of a specified contour-point index
+ * in the specified glyph, within the specified font.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param pointIndex - The contour-point index to query
+ * @param x - The X value retrieved for the contour point
+ * @param y - The Y value retrieved for the contour point
+ */
 export declare const fontGetGlyphContourPoint: (font: FontT, glyph: number, pointIndex: number, x: Ref<number>, y: Ref<number>) => number;
+/**
+ * Fetches the (X,Y) coordinates of a specified contour-point index
+ * in the specified glyph ID in the specified font, with respect
+ * to the origin in a text segment in the specified direction.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param pointIndex - The contour-point index to query
+ * @param direction - The direction of the text segment
+ * @param x - The X value retrieved for the contour point
+ * @param y - The Y value retrieved for the contour point
+ */
 export declare const fontGetGlyphContourPointForOrigin: (font: FontT, glyph: number, pointIndex: number, direction: DirectionT, x: Ref<number>, y: Ref<number>) => number;
+/**
+ * Fetches the #hb_glyph_extents_t data for a glyph ID
+ * in the specified font.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param extents - The #hb_glyph_extents_t retrieved
+ */
 export declare const fontGetGlyphExtents: (font: FontT, glyph: number, extents: Ref<number>) => number;
+/**
+ * Fetches the #hb_glyph_extents_t data for a glyph ID
+ * in the specified font, with respect to the origin in
+ * a text segment in the specified direction.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param direction - The direction of the text segment
+ * @param extents - The #hb_glyph_extents_t retrieved
+ */
 export declare const fontGetGlyphExtentsForOrigin: (font: FontT, glyph: number, direction: DirectionT, extents: Ref<number>) => number;
+/**
+ * Fetches the glyph ID that corresponds to a name string in the specified @font.
+ *
+ * <note>Note: `len` == -1 means the name string is null-terminated.</note>
+ * @param font - #hb_font_t to work upon
+ * @param name - The name string to query
+ * @param len - The length of the name queried
+ * @param glyph - The glyph ID retrieved
+ */
 export declare const fontGetGlyphFromName: (font: FontT, name: string[], len: number, glyph: Ref<number>) => number;
+/**
+ * Fetches the advance for a glyph ID in the specified font,
+ * for horizontal text segments.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ */
 export declare const fontGetGlyphHAdvance: (font: FontT, glyph: number) => number;
+/**
+ * Fetches the advances for a sequence of glyph IDs in the specified
+ * font, for horizontal text segments.
+ * @param font - #hb_font_t to work upon
+ * @param count - The number of glyph IDs in the sequence queried
+ * @param firstGlyph - The first glyph ID to query
+ * @param glyphStride - The stride between successive glyph IDs
+ * @param firstAdvance - The first advance retrieved
+ * @param advanceStride - The stride between successive advances
+ */
 export declare const fontGetGlyphHAdvances: (font: FontT, count: number, firstGlyph: number, glyphStride: number, firstAdvance: Ref<number>, advanceStride: number) => void;
+/**
+ * Fetches the kerning-adjustment value for a glyph-pair in
+ * the specified font, for horizontal text segments.
+ *
+ * <note>It handles legacy kerning only (as returned by the corresponding
+ * #hb_font_funcs_t function).</note>
+ * @param font - #hb_font_t to work upon
+ * @param leftGlyph - The glyph ID of the left glyph in the glyph pair
+ * @param rightGlyph - The glyph ID of the right glyph in the glyph pair
+ */
 export declare const fontGetGlyphHKerning: (font: FontT, leftGlyph: number, rightGlyph: number) => number;
+/**
+ * Fetches the (X,Y) coordinates of the origin for a glyph ID
+ * in the specified font, for horizontal text segments.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param x - The X coordinate of the origin
+ * @param y - The Y coordinate of the origin
+ */
 export declare const fontGetGlyphHOrigin: (font: FontT, glyph: number, x: Ref<number>, y: Ref<number>) => number;
+/**
+ * Fetches the (X,Y) coordinates of the origin for requested glyph IDs
+ * in the specified font, for horizontal text segments.
+ * @param font - #hb_font_t to work upon
+ * @param count - The number of glyph IDs in the sequence queried
+ * @param firstGlyph - The first glyph ID to query
+ * @param glyphStride - The stride between successive glyph IDs
+ * @param firstX - The first X coordinate of the origin retrieved
+ * @param xStride - The stride between successive X coordinates
+ * @param firstY - The first Y coordinate of the origin retrieved
+ * @param yStride - The stride between successive Y coordinates
+ */
 export declare const fontGetGlyphHOrigins: (font: FontT, count: number, firstGlyph: number, glyphStride: number, firstX: Ref<number>, xStride: number, firstY: Ref<number>, yStride: number) => number;
+/**
+ * Fetches the kerning-adjustment value for a glyph-pair in the specified font.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param firstGlyph - The glyph ID of the first glyph in the glyph pair to query
+ * @param secondGlyph - The glyph ID of the second glyph in the glyph pair to query
+ * @param direction - The direction of the text segment
+ * @param x - The horizontal kerning-adjustment value retrieved
+ * @param y - The vertical kerning-adjustment value retrieved
+ */
 export declare const fontGetGlyphKerningForDirection: (font: FontT, firstGlyph: number, secondGlyph: number, direction: DirectionT, x: Ref<number>, y: Ref<number>) => void;
+/**
+ * Fetches the glyph-name string for a glyph ID in the specified @font.
+ *
+ * According to the OpenType specification, glyph names are limited to 63
+ * characters and can only contain (a subset of) ASCII.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param name - Name string retrieved for the glyph ID
+ * @param size - Length of the glyph-name string retrieved
+ */
 export declare const fontGetGlyphName: (font: FontT, glyph: number, name: Ref<string[]>, size: Ref<number>) => number;
+/**
+ * Fetches the (X,Y) coordinates of the origin for a glyph in
+ * the specified font.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param direction - The direction of the text segment
+ * @param x - The X coordinate retrieved for the origin
+ * @param y - The Y coordinate retrieved for the origin
+ */
 export declare const fontGetGlyphOriginForDirection: (font: FontT, glyph: number, direction: DirectionT, x: Ref<number>, y: Ref<number>) => void;
+/**
+ * Fetches the glyph shape that corresponds to a glyph in the specified @font.
+ * The shape is returned by way of calls to the callbacks of the `dfuncs` objects, with `draw_data` passed to them.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID
+ * @param dfuncs - #hb_draw_funcs_t to draw to
+ * @param drawData - User data to pass to draw callbacks
+ */
 export declare const fontGetGlyphShape: (font: FontT, glyph: number, dfuncs: DrawFuncsT, drawData?: number | null) => void;
+/**
+ * Fetches the advance for a glyph ID in the specified font,
+ * for vertical text segments.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ */
 export declare const fontGetGlyphVAdvance: (font: FontT, glyph: number) => number;
+/**
+ * Fetches the advances for a sequence of glyph IDs in the specified
+ * font, for vertical text segments.
+ * @param font - #hb_font_t to work upon
+ * @param count - The number of glyph IDs in the sequence queried
+ * @param firstGlyph - The first glyph ID to query
+ * @param glyphStride - The stride between successive glyph IDs
+ * @param firstAdvance - The first advance retrieved
+ * @param advanceStride - The stride between successive advances
+ */
 export declare const fontGetGlyphVAdvances: (font: FontT, count: number, firstGlyph: number, glyphStride: number, firstAdvance: Ref<number>, advanceStride: Ref<number>) => void;
+/**
+ * Fetches the kerning-adjustment value for a glyph-pair in
+ * the specified font, for vertical text segments.
+ *
+ * <note>It handles legacy kerning only (as returned by the corresponding
+ * #hb_font_funcs_t function).</note>
+ * @param font - #hb_font_t to work upon
+ * @param topGlyph - The glyph ID of the top glyph in the glyph pair
+ * @param bottomGlyph - The glyph ID of the bottom glyph in the glyph pair
+ */
 export declare const fontGetGlyphVKerning: (font: FontT, topGlyph: number, bottomGlyph: number) => number;
+/**
+ * Fetches the (X,Y) coordinates of the origin for a glyph ID
+ * in the specified font, for vertical text segments.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param x - The X coordinate of the origin
+ * @param y - The Y coordinate of the origin
+ */
 export declare const fontGetGlyphVOrigin: (font: FontT, glyph: number, x: Ref<number>, y: Ref<number>) => number;
+/**
+ * Fetches the (X,Y) coordinates of the origin for requested glyph IDs
+ * in the specified font, for vertical text segments.
+ * @param font - #hb_font_t to work upon
+ * @param count - The number of glyph IDs in the sequence queried
+ * @param firstGlyph - The first glyph ID to query
+ * @param glyphStride - The stride between successive glyph IDs
+ * @param firstX - The first X coordinate of the origin retrieved
+ * @param xStride - The stride between successive X coordinates
+ * @param firstY - The first Y coordinate of the origin retrieved
+ * @param yStride - The stride between successive Y coordinates
+ */
 export declare const fontGetGlyphVOrigins: (font: FontT, count: number, firstGlyph: number, glyphStride: number, firstX: Ref<number>, xStride: number, firstY: Ref<number>, yStride: number) => number;
+/**
+ * Fetches the extents for a specified font, for horizontal
+ * text segments.
+ * @param font - #hb_font_t to work upon
+ * @param extents - The font extents retrieved
+ */
 export declare const fontGetHExtents: (font: FontT, extents: Ref<number>) => number;
+/**
+ * Fetches the nominal glyph ID for a Unicode code point in the
+ * specified font.
+ *
+ * This version of the function should not be used to fetch glyph IDs
+ * for code points modified by variation selectors. For variation-selector
+ * support, user hb_font_get_variation_glyph() or use hb_font_get_glyph().
+ * @param font - #hb_font_t to work upon
+ * @param unicode - The Unicode code point to query
+ * @param glyph - The glyph ID retrieved
+ */
 export declare const fontGetNominalGlyph: (font: FontT, unicode: number, glyph: Ref<number>) => number;
+/**
+ * Fetches the nominal glyph IDs for a sequence of Unicode code points. Glyph
+ * IDs must be returned in a #hb_codepoint_t output parameter. Stops at the
+ * first unsupported glyph ID.
+ * @param font - #hb_font_t to work upon
+ * @param count - number of code points to query
+ * @param firstUnicode - The first Unicode code point to query
+ * @param unicodeStride - The stride between successive code points
+ * @param firstGlyph - The first glyph ID retrieved
+ * @param glyphStride - The stride between successive glyph IDs
+ */
 export declare const fontGetNominalGlyphs: (font: FontT, count: number, firstUnicode: number, unicodeStride: number, firstGlyph: Ref<number>, glyphStride: number) => number;
+/**
+ * Fetches the parent font of @font.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontGetParent: (font: FontT) => FontT;
+/**
+ * Fetches the horizontal and vertical points-per-em (ppem) of a font.
+ * @param font - #hb_font_t to work upon
+ * @param xPpem - Horizontal ppem value
+ * @param yPpem - Vertical ppem value
+ */
 export declare const fontGetPpem: (font: FontT, xPpem: Ref<number>, yPpem: Ref<number>) => void;
+/**
+ * Fetches the "point size" of a font. Used in CoreText to
+ * implement optical sizing.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontGetPtem: (font: FontT) => number;
+/**
+ * Fetches the horizontal and vertical scale of a font.
+ * @param font - #hb_font_t to work upon
+ * @param xScale - Horizontal scale value
+ * @param yScale - Vertical scale value
+ */
 export declare const fontGetScale: (font: FontT, xScale: Ref<number>, yScale: Ref<number>) => void;
+/**
+ * Returns the internal serial number of the font. The serial
+ * number is increased every time a setting on the font is
+ * changed, using a setter function.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontGetSerial: (font: FontT) => number;
+/**
+ * Fetches the "synthetic boldness" parameters of a font.
+ * @param font - #hb_font_t to work upon
+ * @param xEmbolden - return location for horizontal value
+ * @param yEmbolden - return location for vertical value
+ * @param inPlace - return location for in-place value
+ */
 export declare const fontGetSyntheticBold: (font: FontT, xEmbolden: Ref<number>, yEmbolden: Ref<number>, inPlace: Ref<number>) => void;
+/**
+ * Fetches the "synthetic slant" of a font.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontGetSyntheticSlant: (font: FontT) => number;
+/**
+ * Fetches the extents for a specified font, for vertical
+ * text segments.
+ * @param font - #hb_font_t to work upon
+ * @param extents - The font extents retrieved
+ */
 export declare const fontGetVExtents: (font: FontT, extents: Ref<number>) => number;
+/**
+ * Fetches the list of variation coordinates (in design-space units) currently
+ * set on a font.
+ *
+ * <note>Note that if no variation coordinates are set, this function may
+ * return %NULL.</note>
+ *
+ * <note>If variations have been set on the font using normalized coordinates
+ * (i.e. via hb_font_set_var_coords_normalized()), the design coordinates will
+ * have NaN (Not a Number) values.</note>
+ *
+ * Return value is valid as long as variation coordinates of the font
+ * are not modified.
+ * @param font - #hb_font_t to work upon
+ * @param length - Number of coordinates retrieved
+ */
 export declare const fontGetVarCoordsDesign: (font: FontT, length: Ref<number>) => number;
+/**
+ * Fetches the list of normalized variation coordinates currently
+ * set on a font.
+ *
+ * <note>Note that if no variation coordinates are set, this function may
+ * return %NULL.</note>
+ *
+ * Return value is valid as long as variation coordinates of the font
+ * are not modified.
+ * @param font - #hb_font_t to work upon
+ * @param length - Number of coordinates retrieved
+ */
 export declare const fontGetVarCoordsNormalized: (font: FontT, length: Ref<number>) => number;
+/**
+ * Returns the currently-set named-instance index of the font.
+ * @param font - a font.
+ */
 export declare const fontGetVarNamedInstance: (font: FontT) => number;
+/**
+ * Fetches the glyph ID for a Unicode code point when followed by
+ * by the specified variation-selector code point, in the specified
+ * font.
+ * @param font - #hb_font_t to work upon
+ * @param unicode - The Unicode code point to query
+ * @param variationSelector - The  variation-selector code point to query
+ * @param glyph - The glyph ID retrieved
+ */
 export declare const fontGetVariationGlyph: (font: FontT, unicode: number, variationSelector: number, glyph: Ref<number>) => number;
+/**
+ * Fetches the glyph ID from `font` that matches the specified string.
+ * Strings of the format `gidDDD` or `uniUUUU` are parsed automatically.
+ *
+ * <note>Note: `len` == -1 means the string is null-terminated.</note>
+ * @param font - #hb_font_t to work upon
+ * @param s - string to query
+ * @param len - The length of the string @s
+ * @param glyph - The glyph ID corresponding to the string requested
+ */
 export declare const fontGlyphFromString: (font: FontT, s: number[], len: number, glyph: Ref<number>) => number;
+/**
+ * Fetches the name of the specified glyph ID in `font` and returns
+ * it in string @s.
+ *
+ * If the glyph ID has no name in @font, a string of the form `gidDDD` is
+ * generated, with `DDD` being the glyph ID.
+ *
+ * According to the OpenType specification, glyph names are limited to 63
+ * characters and can only contain (a subset of) ASCII.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param s - The string containing the glyph name
+ * @param size - Length of string @s
+ */
 export declare const fontGlyphToString: (font: FontT, glyph: number, s: Ref<string[]>, size: Ref<number>) => void;
+/**
+ * Tests whether a font object is immutable.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontIsImmutable: (font: FontT) => number;
+/**
+ * Tests whether a font is synthetic. A synthetic font is one
+ * that has either synthetic slant or synthetic bold set on it.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontIsSynthetic: (font: FontT) => number;
+/**
+ * Retrieves the list of font functions supported by HarfBuzz.
+ */
 export declare const fontListFuncs: () => string[];
+/**
+ * Makes `font` immutable.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const fontMakeImmutable: (font: FontT) => void;
+/**
+ * Paints the glyph. This function is similar to
+ * hb_font_paint_glyph_or_fail(), but if painting a color glyph
+ * failed, it will fall back to painting an outline monochrome
+ * glyph.
+ *
+ * The painting instructions are returned by way of calls to
+ * the callbacks of the `funcs` object, with `paint_data` passed
+ * to them.
+ *
+ * If the font has color palettes (see hb_ot_color_has_palettes()),
+ * then `palette_index` selects the palette to use. If the font only
+ * has one palette, this will be 0.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID
+ * @param pfuncs - #hb_paint_funcs_t to paint with
+ * @param paintData - User data to pass to paint callbacks
+ * @param paletteIndex - The index of the font's color palette to use
+ * @param foreground - The foreground color, unpremultipled
+ */
 export declare const fontPaintGlyph: (font: FontT, glyph: number, pfuncs: PaintFuncsT, paletteIndex: number, foreground: number, paintData?: number | null) => void;
+/**
+ * Paints a color glyph.
+ *
+ * This function is similar to, but lower-level than,
+ * hb_font_paint_glyph(). It is suitable for clients that
+ * need more control.  If there are no color glyphs available,
+ * it will return `false`. The client can then fall back to
+ * hb_font_draw_glyph_or_fail() for the monochrome outline glyph.
+ *
+ * The painting instructions are returned by way of calls to
+ * the callbacks of the `funcs` object, with `paint_data` passed
+ * to them.
+ *
+ * If the font has color palettes (see hb_ot_color_has_palettes()),
+ * then `palette_index` selects the palette to use. If the font only
+ * has one palette, this will be 0.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID
+ * @param pfuncs - #hb_paint_funcs_t to paint with
+ * @param paintData - User data to pass to paint callbacks
+ * @param paletteIndex - The index of the font's color palette to use
+ * @param foreground - The foreground color, unpremultipled
+ */
 export declare const fontPaintGlyphOrFail: (font: FontT, glyph: number, pfuncs: PaintFuncsT, paletteIndex: number, foreground: number, paintData?: number | null) => number;
+/**
+ * Sets `face` as the font-face value of @font.
+ * @param font - #hb_font_t to work upon
+ * @param face - The #hb_face_t to assign
+ */
 export declare const fontSetFace: (font: FontT, face: FaceT) => void;
+/**
+ * Sets the font-functions structure to use for a font, based on the
+ * specified name.
+ *
+ * If `name` is `NULL` or the empty string, the default (first) functioning font-functions
+ * are used.  This default can be changed by setting the `HB_FONT_FUNCS` environment
+ * variable to the name of the desired font-functions.
+ * @param font - #hb_font_t to work upon
+ * @param name - The name of the font-functions structure to use, or `NULL`
+ */
 export declare const fontSetFuncsUsing: (font: FontT, name: string) => number;
+/**
+ * Sets the parent font of @font.
+ * @param font - #hb_font_t to work upon
+ * @param parent - The parent font object to assign
+ */
 export declare const fontSetParent: (font: FontT, parent: FontT) => void;
+/**
+ * Sets the horizontal and vertical pixels-per-em (PPEM) of a font.
+ *
+ * These values are used for pixel-size-specific adjustment to
+ * shaping and draw results, though for the most part they are
+ * unused and can be left unset.
+ * @param font - #hb_font_t to work upon
+ * @param xPpem - Horizontal ppem value to assign
+ * @param yPpem - Vertical ppem value to assign
+ */
 export declare const fontSetPpem: (font: FontT, xPpem: number, yPpem: number) => void;
+/**
+ * Sets the "point size" of a font. Set to zero to unset.
+ * Used in CoreText to implement optical sizing.
+ *
+ * <note>Note: There are 72 points in an inch.</note>
+ * @param font - #hb_font_t to work upon
+ * @param ptem - font size in points.
+ */
 export declare const fontSetPtem: (font: FontT, ptem: number) => void;
+/**
+ * Sets the horizontal and vertical scale of a font.
+ *
+ * The font scale is a number related to, but not the same as,
+ * font size. Typically the client establishes a scale factor
+ * to be used between the two. For example, 64, or 256, which
+ * would be the fractional-precision part of the font scale.
+ * This is necessary because #hb_position_t values are integer
+ * types and you need to leave room for fractional values
+ * in there.
+ *
+ * For example, to set the font size to 20, with 64
+ * levels of fractional precision you would call
+ * `hb_font_set_scale(font, 20 * 64, 20 * 64)`.
+ *
+ * In the example above, even what font size 20 means is up to
+ * you. It might be 20 pixels, or 20 points, or 20 millimeters.
+ * HarfBuzz does not care about that.  You can set the point
+ * size of the font using hb_font_set_ptem(), and the pixel
+ * size using hb_font_set_ppem().
+ *
+ * The choice of scale is yours but needs to be consistent between
+ * what you set here, and what you expect out of #hb_position_t
+ * as well has draw / paint API output values.
+ *
+ * Fonts default to a scale equal to the UPEM value of their face.
+ * A font with this setting is sometimes called an "unscaled" font.
+ * @param font - #hb_font_t to work upon
+ * @param xScale - Horizontal scale value to assign
+ * @param yScale - Vertical scale value to assign
+ */
 export declare const fontSetScale: (font: FontT, xScale: number, yScale: number) => void;
+/**
+ * Sets the "synthetic boldness" of a font.
+ *
+ * Positive values for `x_embolden` / `y_embolden` make a font
+ * bolder, negative values thinner. Typical values are in the
+ * 0.01 to 0.05 range. The default value is zero.
+ *
+ * Synthetic boldness is applied by offsetting the contour
+ * points of the glyph shape.
+ *
+ * Synthetic boldness is applied when rendering a glyph via
+ * hb_font_draw_glyph_or_fail().
+ *
+ * If `in_place` is `false`, then glyph advance-widths are also
+ * adjusted, otherwise they are not.  The in-place mode is
+ * useful for simulating [font grading](https://fonts.google.com/knowledge/glossary/grade).
+ * @param font - #hb_font_t to work upon
+ * @param xEmbolden - the amount to embolden horizontally
+ * @param yEmbolden - the amount to embolden vertically
+ * @param inPlace - whether to embolden glyphs in-place
+ */
 export declare const fontSetSyntheticBold: (font: FontT, xEmbolden: number, yEmbolden: number, inPlace: number) => void;
+/**
+ * Sets the "synthetic slant" of a font.  By default is zero.
+ * Synthetic slant is the graphical skew applied to the font
+ * at rendering time.
+ *
+ * HarfBuzz needs to know this value to adjust shaping results,
+ * metrics, and style values to match the slanted rendering.
+ *
+ * <note>Note: The glyph shape fetched via the hb_font_draw_glyph_or_fail()
+ * function is slanted to reflect this value as well.</note>
+ *
+ * <note>Note: The slant value is a ratio.  For example, a
+ * 20% slant would be represented as a 0.2 value.</note>
+ * @param font - #hb_font_t to work upon
+ * @param slant - synthetic slant value.
+ */
 export declare const fontSetSyntheticSlant: (font: FontT, slant: number) => void;
+/**
+ * Applies a list of variation coordinates (in design-space units)
+ * to a font.
+ *
+ * Note that this overrides all existing variations set on @font.
+ * Axes not included in `coords` will be effectively set to their
+ * default values.
+ * @param font - #hb_font_t to work upon
+ * @param coords - Array of variation coordinates to apply
+ * @param coordsLength - Number of coordinates to apply
+ */
 export declare const fontSetVarCoordsDesign: (font: FontT, coords: number[], coordsLength: number) => void;
+/**
+ * Applies a list of variation coordinates (in normalized units)
+ * to a font.
+ *
+ * Note that this overrides all existing variations set on @font.
+ * Axes not included in `coords` will be effectively set to their
+ * default values.
+ *
+ * <note>Note: Coordinates should be normalized to 2.14.</note>
+ * @param font - #hb_font_t to work upon
+ * @param coords - Array of variation coordinates to apply
+ * @param coordsLength - Number of coordinates to apply
+ */
 export declare const fontSetVarCoordsNormalized: (font: FontT, coords: number[], coordsLength: number) => void;
+/**
+ * Sets design coords of a font from a named-instance index.
+ * @param font - a font.
+ * @param instanceIndex - named instance index.
+ */
 export declare const fontSetVarNamedInstance: (font: FontT, instanceIndex: number) => void;
+/**
+ * Change the value of one variation axis on the font.
+ *
+ * Note: This function is expensive to be called repeatedly.
+ * If you want to set multiple variation axes at the same time,
+ * use hb_font_set_variations() instead.
+ * @param font - #hb_font_t to work upon
+ * @param tag - The #hb_tag_t tag of the variation-axis name
+ * @param value - The value of the variation axis
+ */
 export declare const fontSetVariation: (font: FontT, tag: number, value: number) => void;
+/**
+ * Applies a list of font-variation settings to a font.
+ *
+ * Note that this overrides all existing variations set on @font.
+ * Axes not included in `variations` will be effectively set to their
+ * default values.
+ * @param font - #hb_font_t to work upon
+ * @param variations - Array of variation settings to apply
+ * @param variationsLength - Number of variations to apply
+ */
 export declare const fontSetVariations: (font: FontT, variations: number[], variationsLength: number) => void;
+/**
+ * Subtracts the origin coordinates from an (X,Y) point coordinate,
+ * in the specified glyph ID in the specified font.
+ *
+ * Calls the appropriate direction-specific variant (horizontal
+ * or vertical) depending on the value of @direction.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph ID to query
+ * @param direction - The direction of the text segment
+ * @param x - Input = The original X coordinate
+ * @param y - Input = The original Y coordinate
+ */
 export declare const fontSubtractGlyphOriginForDirection: (font: FontT, glyph: number, direction: DirectionT, x: Ref<number>, y: Ref<number>) => void;
+/**
+ * Frees the memory pointed to by @ptr, using the allocator set at
+ * compile-time. Typically just free().
+ * @param ptr - The pointer to the memory to free.
+ */
 export declare const free: (ptr?: number | null) => void;
+/**
+ * Creates an #hb_face_t face object from the specified FT_Face.
+ *
+ * Note that this is using the FT_Face object just to get at the underlying
+ * font data, and fonts created from the returned #hb_face_t will use the native
+ * HarfBuzz font implementation, unless you call hb_ft_font_set_funcs() on them.
+ *
+ * This variant of the function caches the newly created #hb_face_t
+ * face object, using the `generic` pointer of @ft_face. Subsequent function
+ * calls that are passed the same `ft_face` parameter will have the same
+ * #hb_face_t returned to them, and that #hb_face_t will be correctly
+ * reference counted.
+ *
+ * However, client programs are still responsible for destroying
+ * `ft_face` after the last #hb_face_t face object has been destroyed.
+ * @param ftFace - FT_Face to work upon
+ */
 export declare const ftFaceCreateCached: (ftFace: number) => FaceT;
+/**
+ * Creates an #hb_face_t face object from the specified
+ * font blob and face index.
+ *
+ * This is similar in functionality to hb_face_create_from_blob_or_fail(),
+ * but uses the FreeType library for loading the font blob. This can
+ * be useful, for example, to load WOFF and WOFF2 font data.
+ * @param blob - A blob
+ * @param index - The index of the face within the blob
+ */
 export declare const ftFaceCreateFromBlobOrFail: (blob: BlobT, index: number) => FaceT;
+/**
+ * Creates an #hb_face_t face object from the specified
+ * font file and face index.
+ *
+ * This is similar in functionality to hb_face_create_from_file_or_fail(),
+ * but uses the FreeType library for loading the font file. This can
+ * be useful, for example, to load WOFF and WOFF2 font data.
+ * @param fileName - A font filename
+ * @param index - The index of the face within the file
+ */
 export declare const ftFaceCreateFromFileOrFail: (fileName: string, index: number) => FaceT;
+/**
+ * Creates an #hb_face_t face object from the specified FT_Face.
+ *
+ * Note that this is using the FT_Face object just to get at the underlying
+ * font data, and fonts created from the returned #hb_face_t will use the native
+ * HarfBuzz font implementation, unless you call hb_ft_font_set_funcs() on them.
+ *
+ * This is the preferred variant of the hb_ft_face_create*
+ * function family, because it calls FT_Reference_Face() on @ft_face,
+ * ensuring that `ft_face` remains alive as long as the resulting
+ * #hb_face_t face object remains alive. Also calls FT_Done_Face()
+ * when the #hb_face_t face object is destroyed.
+ *
+ * Use this version unless you know you have good reasons not to.
+ * @param ftFace - FT_Face to work upon
+ */
 export declare const ftFaceCreateReferenced: (ftFace: number) => FaceT;
+/**
+ * Refreshes the state of `font` when the underlying FT_Face has changed.
+ * This function should be called after changing the size or
+ * variation-axis settings on the FT_Face.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const ftFontChanged: (font: FontT) => void;
+/**
+ * Creates an #hb_font_t font object from the specified FT_Face.
+ *
+ * <note>Note: You must set the face size on `ft_face` before calling
+ * hb_ft_font_create_referenced() on it. HarfBuzz assumes size is always set
+ * and will access `size` member of FT_Face unconditionally.</note>
+ *
+ * This is the preferred variant of the hb_ft_font_create*
+ * function family, because it calls FT_Reference_Face() on @ft_face,
+ * ensuring that `ft_face` remains alive as long as the resulting
+ * #hb_font_t font object remains alive.
+ *
+ * Use this version unless you know you have good reasons not to.
+ * @param ftFace - FT_Face to work upon
+ */
 export declare const ftFontCreateReferenced: (ftFace: number) => FontT;
+/**
+ * Fetches the FT_Load_Glyph load flags of the specified #hb_font_t.
+ *
+ * For more information, see
+ * <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_load_xxx>
+ *
+ * This function works with #hb_font_t objects created by
+ * hb_ft_font_create() or hb_ft_font_create_referenced().
+ * @param font - #hb_font_t to work upon
+ */
 export declare const ftFontGetLoadFlags: (font: FontT) => number;
+/**
+ * Configures the font-functions structure of the specified
+ * #hb_font_t font object to use FreeType font functions.
+ *
+ * In particular, you can use this function to configure an
+ * existing #hb_face_t face object for use with FreeType font
+ * functions even if that #hb_face_t face object was initially
+ * created with hb_face_create(), and therefore was not
+ * initially configured to use FreeType font functions.
+ *
+ * An #hb_font_t object created with hb_ft_font_create()
+ * is preconfigured for FreeType font functions and does not
+ * require this function to be used.
+ *
+ * Note that if you modify the underlying #hb_font_t after
+ * calling this function, you need to call hb_ft_hb_font_changed()
+ * to update the underlying FT_Face.
+ *
+ * <note>Note: Internally, this function creates an FT_Face.
+ * </note>
+ * @param font - #hb_font_t to work upon
+ */
 export declare const ftFontSetFuncs: (font: FontT) => void;
+/**
+ * Sets the FT_Load_Glyph load flags for the specified #hb_font_t.
+ *
+ * For more information, see
+ * <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_load_xxx>
+ *
+ * This function works with #hb_font_t objects created by
+ * hb_ft_font_create() or hb_ft_font_create_referenced().
+ * @param font - #hb_font_t to work upon
+ * @param loadFlags - The FreeType load flags to set
+ */
 export declare const ftFontSetLoadFlags: (font: FontT, loadFlags: number) => void;
+/**
+ * Refreshes the state of the underlying FT_Face of `font` when the hb_font_t
+ * `font` has changed.
+ * This function should be called after changing the size or
+ * variation-axis settings on the @font.
+ * This call is fast if nothing has changed on @font.
+ *
+ * Note that as of version 11.0.0, calling this function is not necessary,
+ * as HarfBuzz will automatically detect changes to the font and update
+ * the underlying FT_Face as needed.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const ftHbFontChanged: (font: FontT) => number;
+/**
+ * Creates an #hb_blob_t blob from the specified
+ * GBytes data structure.
+ * @param gbytes - the GBytes structure to work upon
+ */
 export declare const glibBlobCreate: (gbytes: GLib.Bytes) => BlobT;
+/**
+ * Fetches a Unicode-functions structure that is populated
+ * with the appropriate GLib function for each method.
+ */
 export declare const glibGetUnicodeFuncs: () => UnicodeFuncsT;
+/**
+ * Fetches the GUnicodeScript identifier that corresponds to the
+ * specified #hb_script_t script.
+ * @param script - The #hb_script_t to query
+ */
 export declare const glibScriptFromScript: (script: ScriptT) => GLib.UnicodeScript;
+/**
+ * Fetches the #hb_script_t script that corresponds to the
+ * specified GUnicodeScript identifier.
+ * @param script - The GUnicodeScript identifier to query
+ */
 export declare const glibScriptToScript: (script: GLib.UnicodeScript) => ScriptT;
+/**
+ * Returns glyph flags encoded within a #hb_glyph_info_t.
+ * @param info - a #hb_glyph_info_t
+ */
 export declare const glyphInfoGetGlyphFlags: (info: GlyphInfoT) => GlyphFlagsT;
+/**
+ * Converts `str` representing a BCP 47 language tag to the corresponding
+ * #hb_language_t.
+ * @param str - a string representing
+ * @param len - length of the @str, or -1 if it is `NULL`-terminated.
+ */
 export declare const languageFromString: (str: number[], len: number) => number;
+/**
+ * Fetch the default language from current locale.
+ *
+ * <note>Note that the first time this function is called, it calls
+ * "setlocale (LC_CTYPE, nullptr)" to fetch current locale.  The underlying
+ * setlocale function is, in many implementations, NOT threadsafe.  To avoid
+ * problems, call this function once before multiple threads can call it.
+ * This function is only used from hb_buffer_guess_segment_properties() by
+ * HarfBuzz itself.</note>
+ */
 export declare const languageGetDefault: () => number;
+/**
+ * Check whether a second language tag is the same or a more
+ * specific version of the provided language tag.  For example,
+ * "fa_IR.utf8" is a more specific tag for "fa" or for "fa_IR".
+ * @param language - The #hb_language_t to work on
+ * @param specific - Another #hb_language_t
+ */
 export declare const languageMatches: (language: number, specific: number) => number;
+/**
+ * Converts an #hb_language_t to a string.
+ * @param language - The #hb_language_t to convert
+ */
 export declare const languageToString: (language: number) => string;
+/**
+ * Allocates `size` bytes of memory, using the allocator set at
+ * compile-time. Typically just malloc().
+ * @param size - The size of the memory to allocate.
+ */
 export declare const malloc: (size: number) => number | null;
+/**
+ * Tests whether memory allocation for a set was successful.
+ * @param map - A map
+ */
 export declare const mapAllocationSuccessful: (map: MapT) => number;
+/**
+ * Clears out the contents of @map.
+ * @param map - A map
+ */
 export declare const mapClear: (map: MapT) => void;
+/**
+ * Allocate a copy of @map.
+ * @param map - A map
+ */
 export declare const mapCopy: (map: MapT) => MapT;
+/**
+ * Creates a new, initially empty map.
+ */
 export declare const mapCreate: () => MapT;
+/**
+ * Removes `key` and its stored value from @map.
+ * @param map - A map
+ * @param key - The key to delete
+ */
 export declare const mapDel: (map: MapT, key: number) => void;
+/**
+ * Fetches the value stored for `key` in @map.
+ * @param map - A map
+ * @param key - The key to query
+ */
 export declare const mapGet: (map: MapT, key: number) => number;
+/**
+ * Fetches the singleton empty #hb_map_t.
+ */
 export declare const mapGetEmpty: () => MapT;
+/**
+ * Returns the number of key-value pairs in the map.
+ * @param map - A map
+ */
 export declare const mapGetPopulation: (map: MapT) => number;
+/**
+ * Tests whether `key` is an element of @map.
+ * @param map - A map
+ * @param key - The key to query
+ */
 export declare const mapHas: (map: MapT, key: number) => number;
+/**
+ * Creates a hash representing @map.
+ * @param map - A map
+ */
 export declare const mapHash: (map: MapT) => number;
+/**
+ * Tests whether `map` is empty (contains no elements).
+ * @param map - A map
+ */
 export declare const mapIsEmpty: (map: MapT) => number;
+/**
+ * Tests whether `map` and `other` are equal (contain the same
+ * elements).
+ * @param map - A map
+ * @param other - Another map
+ */
 export declare const mapIsEqual: (map: MapT, other: MapT) => number;
+/**
+ * Add the keys of `map` to @keys.
+ * @param map - A map
+ * @param keys - A set
+ */
 export declare const mapKeys: (map: MapT, keys: SetT) => void;
+/**
+ * Fetches the next key/value pair in @map.
+ *
+ * Set `idx` to -1 to get started.
+ *
+ * If the map is modified during iteration, the behavior is undefined.
+ *
+ * The order in which the key/values are returned is undefined.
+ * @param map - A map
+ * @param idx - Iterator internal state
+ * @param key - Key retrieved
+ * @param value - Value retrieved
+ */
 export declare const mapNext: (map: MapT, idx: Ref<number>, key: Ref<number>, value: Ref<number>) => number;
+/**
+ * Stores @key:`value` in the map.
+ * @param map - A map
+ * @param key - The key to store in the map
+ * @param value - The value to store for @key
+ */
 export declare const mapSet: (map: MapT, key: number, value: number) => void;
+/**
+ * Add the contents of `other` to @map.
+ * @param map - A map
+ * @param other - Another map
+ */
 export declare const mapUpdate: (map: MapT, other: MapT) => void;
+/**
+ * Add the values of `map` to @values.
+ * @param map - A map
+ * @param values - A set
+ */
 export declare const mapValues: (map: MapT, values: SetT) => void;
+/**
+ * Fetches a list of all color layers for the specified glyph index in the specified
+ * face. The list returned will begin at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param glyph - The glyph index to query
+ * @param startOffset - offset of the first layer to retrieve
+ * @param layerCount - Input = the maximum number of layers to return;
+ * @param layers - The array of layers found
+ */
 export declare const otColorGlyphGetLayers: (face: FaceT, glyph: number, startOffset: number, layerCount?: Ref<number> | null, layers?: Ref<number[]> | null) => number;
+/**
+ * Tests where a face includes COLRv1 paint
+ * data for @glyph.
+ * @param face - #hb_face_t to work upon
+ * @param glyph - The glyph index to query
+ */
 export declare const otColorGlyphHasPaint: (face: FaceT, glyph: number) => number;
+/**
+ * Fetches the PNG image for a glyph. This function takes a font object, not a face object,
+ * as input. To get an optimally sized PNG blob, the PPEM values must be set on the `font` object. If PPEM is unset, the blob returned will be the largest PNG available.
+ *
+ * If the glyph has no PNG image, the singleton empty blob is returned.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - a glyph index
+ */
 export declare const otColorGlyphReferencePng: (font: FontT, glyph: number) => BlobT;
+/**
+ * Fetches the SVG document for a glyph. The blob may be either plain text or gzip-encoded.
+ *
+ * If the glyph has no SVG document, the singleton empty blob is returned.
+ * @param face - #hb_face_t to work upon
+ * @param glyph - a svg glyph index
+ */
 export declare const otColorGlyphReferenceSvg: (face: FaceT, glyph: number) => BlobT;
+/**
+ * Tests whether a face includes a `COLR` table
+ * with data according to COLRv0.
+ * @param face - #hb_face_t to work upon
+ */
 export declare const otColorHasLayers: (face: FaceT) => number;
+/**
+ * Tests where a face includes a `COLR` table
+ * with data according to COLRv1.
+ * @param face - #hb_face_t to work upon
+ */
 export declare const otColorHasPaint: (face: FaceT) => number;
+/**
+ * Tests whether a face includes a `CPAL` color-palette table.
+ * @param face - #hb_face_t to work upon
+ */
 export declare const otColorHasPalettes: (face: FaceT) => number;
+/**
+ * Tests whether a face has PNG glyph images (either in `CBDT` or `sbix` tables).
+ * @param face - #hb_face_t to work upon
+ */
 export declare const otColorHasPng: (face: FaceT) => number;
+/**
+ * Tests whether a face includes any `SVG` glyph images.
+ * @param face - #hb_face_t to work upon.
+ */
 export declare const otColorHasSvg: (face: FaceT) => number;
+/**
+ * Fetches the `name` table Name ID that provides display names for
+ * the specified color in a face's `CPAL` color palette.
+ *
+ * Display names can be generic (e.g., "Background") or specific
+ * (e.g., "Eye color").
+ * @param face - #hb_face_t to work upon
+ * @param colorIndex - The index of the color
+ */
 export declare const otColorPaletteColorGetNameId: (face: FaceT, colorIndex: number) => number;
+/**
+ * Fetches a list of the colors in a color palette.
+ *
+ * After calling this function, `colors` will be filled with the palette
+ * colors. If `colors` is NULL, the function will just return the number
+ * of total colors without storing any actual colors; this can be used
+ * for allocating a buffer of suitable size before calling
+ * hb_ot_color_palette_get_colors() a second time.
+ *
+ * The RGBA values in the palette are unpremultiplied. See the
+ * OpenType spec [CPAL](https://learn.microsoft.com/en-us/typography/opentype/spec/cpal)
+ * section for details.
+ * @param face - #hb_face_t to work upon
+ * @param paletteIndex - the index of the color palette to query
+ * @param startOffset - offset of the first color to retrieve
+ * @param colorCount - Input = the maximum number of colors to return;
+ * @param colors - The array of #hb_color_t records found
+ */
 export declare const otColorPaletteGetColors: (face: FaceT, paletteIndex: number, startOffset: number, colorCount?: Ref<number> | null, colors?: Ref<number[]> | null) => number;
+/**
+ * Fetches the number of color palettes in a face.
+ * @param face - #hb_face_t to work upon
+ */
 export declare const otColorPaletteGetCount: (face: FaceT) => number;
+/**
+ * Fetches the flags defined for a color palette.
+ * @param face - #hb_face_t to work upon
+ * @param paletteIndex - The index of the color palette
+ */
 export declare const otColorPaletteGetFlags: (face: FaceT, paletteIndex: number) => OtColorPaletteFlagsT;
+/**
+ * Fetches the `name` table Name ID that provides display names for
+ * a `CPAL` color palette.
+ *
+ * Palette display names can be generic (e.g., "Default") or provide
+ * specific, themed names (e.g., "Spring", "Summer", "Fall", and "Winter").
+ * @param face - #hb_face_t to work upon
+ * @param paletteIndex - The index of the color palette
+ */
 export declare const otColorPaletteGetNameId: (face: FaceT, paletteIndex: number) => number;
+/**
+ * Sets the font functions to use when working with `font` to
+ * the HarfBuzz's native implementation. This is the default
+ * for fonts newly created.
+ * @param font - #hb_font_t to work upon
+ */
 export declare const otFontSetFuncs: (font: FontT) => void;
+/**
+ * Fetches a list of all feature indexes in the specified face's GSUB table
+ * or GPOS table, underneath the specified scripts, languages, and features.
+ * If no list of scripts is provided, all scripts will be queried. If no list
+ * of languages is provided, all languages will be queried. If no list of
+ * features is provided, all features will be queried.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scripts - The array of scripts to collect features for,
+ * @param languages - The array of languages to collect features for,
+ * @param features - The array of features to collect,
+ * @param featureIndexes - The set of feature indexes found for the query
+ */
 export declare const otLayoutCollectFeatures: (face: FaceT, tableTag: number, featureIndexes: Ref<SetT>, scripts?: number[] | null, languages?: number[] | null, features?: number[] | null) => void;
+/**
+ * Fetches the mapping from feature tags to feature indexes for
+ * the specified script and language.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageIndex - The index of the requested language tag
+ * @param featureMap - The map of feature tag to feature index.
+ */
 export declare const otLayoutCollectFeaturesMap: (face: FaceT, tableTag: number, scriptIndex: number, languageIndex: number, featureMap: Ref<MapT>) => void;
+/**
+ * Fetches a list of all feature-lookup indexes in the specified face's GSUB
+ * table or GPOS table, underneath the specified scripts, languages, and
+ * features. If no list of scripts is provided, all scripts will be queried.
+ * If no list of languages is provided, all languages will be queried. If no
+ * list of features is provided, all features will be queried.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scripts - The array of scripts to collect lookups for,
+ * @param languages - The array of languages to collect lookups for,
+ * @param features - The array of features to collect lookups for,
+ * @param lookupIndexes - The array of lookup indexes found for the query
+ */
 export declare const otLayoutCollectLookups: (face: FaceT, tableTag: number, lookupIndexes: Ref<SetT>, scripts?: number[] | null, languages?: number[] | null, features?: number[] | null) => void;
+/**
+ * Fetches a list of the characters defined as having a variant under the specified
+ * "Character Variant" ("cvXX") feature tag.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - table tag to query, "GSUB" or "GPOS".
+ * @param featureIndex - index of feature to query.
+ * @param startOffset - offset of the first character to retrieve
+ * @param charCount - Input = the maximum number of characters to return;
+ * @param characters - A buffer pointer.
+ */
 export declare const otLayoutFeatureGetCharacters: (face: FaceT, tableTag: number, featureIndex: number, startOffset: number, characters: Ref<number[]>, charCount?: Ref<number> | null) => number;
+/**
+ * Fetches a list of all lookups enumerated for the specified feature, in
+ * the specified face's GSUB table or GPOS table. The list returned will
+ * begin at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param featureIndex - The index of the requested feature
+ * @param startOffset - offset of the first lookup to retrieve
+ * @param lookupCount - Input = the maximum number of lookups to return;
+ * @param lookupIndexes - The array of lookup indexes found for the query
+ */
 export declare const otLayoutFeatureGetLookups: (face: FaceT, tableTag: number, featureIndex: number, startOffset: number, lookupIndexes: Ref<number[]>, lookupCount?: Ref<number> | null) => number;
+/**
+ * Fetches name indices from feature parameters for "Stylistic Set" ('ssXX') or
+ * "Character Variant" ('cvXX') features.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - table tag to query, "GSUB" or "GPOS".
+ * @param featureIndex - index of feature to query.
+ * @param labelId - The ‘name’ table name ID that specifies a string
+ * @param tooltipId - The ‘name’ table name ID that specifies a string
+ * @param sampleId - The ‘name’ table name ID that specifies sample text
+ * @param numNamedParameters - Number of named parameters.
+ * @param firstParamId - The first ‘name’ table name ID used to specify
+ */
 export declare const otLayoutFeatureGetNameIds: (face: FaceT, tableTag: number, featureIndex: number, labelId?: Ref<number> | null, tooltipId?: Ref<number> | null, sampleId?: Ref<number> | null, numNamedParameters?: Ref<number> | null, firstParamId?: Ref<number> | null) => number;
+/**
+ * Fetches a list of all lookups enumerated for the specified feature, in
+ * the specified face's GSUB table or GPOS table, enabled at the specified
+ * variations index. The list returned will begin at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param featureIndex - The index of the feature to query
+ * @param variationsIndex - The index of the feature variation to query
+ * @param startOffset - offset of the first lookup to retrieve
+ * @param lookupCount - Input = the maximum number of lookups to return;
+ * @param lookupIndexes - The array of lookups found for the query
+ */
 export declare const otLayoutFeatureWithVariationsGetLookups: (face: FaceT, tableTag: number, featureIndex: number, variationsIndex: number, startOffset: number, lookupIndexes: Ref<number[]>, lookupCount?: Ref<number> | null) => number;
+/**
+ * Fetches a list of all attachment points for the specified glyph in the GDEF
+ * table of the face. The list returned will begin at the offset provided.
+ *
+ * Useful if the client program wishes to cache the list.
+ * @param face - The #hb_face_t to work on
+ * @param glyph - The #hb_codepoint_t code point to query
+ * @param startOffset - offset of the first attachment point to retrieve
+ * @param pointCount - Input = the maximum number of attachment points to return;
+ * @param pointArray - The array of attachment points found for the query
+ */
 export declare const otLayoutGetAttachPoints: (face: FaceT, glyph: number, startOffset: number, pointArray: Ref<number[]>, pointCount?: Ref<number> | null) => number;
+/**
+ * Fetches a baseline value from the face.
+ * @param font - a font
+ * @param baselineTag - a baseline tag
+ * @param direction - text direction.
+ * @param scriptTag - script tag.
+ * @param languageTag - language tag, currently unused.
+ * @param coord - baseline value if found.
+ */
 export declare const otLayoutGetBaseline: (font: FontT, baselineTag: OtLayoutBaselineTagT, direction: DirectionT, scriptTag: number, languageTag: number, coord?: Ref<number> | null) => number;
+/**
+ * Fetches a baseline value from the face.
+ *
+ * This function is like hb_ot_layout_get_baseline() but takes
+ * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
+ * @param font - a font
+ * @param baselineTag - a baseline tag
+ * @param direction - text direction.
+ * @param script - script.
+ * @param language - language, currently unused.
+ * @param coord - baseline value if found.
+ */
 export declare const otLayoutGetBaseline2: (font: FontT, baselineTag: OtLayoutBaselineTagT, direction: DirectionT, script: ScriptT, language?: number | null, coord?: Ref<number> | null) => number;
+/**
+ * Fetches a baseline value from the face, and synthesizes
+ * it if the font does not have it.
+ * @param font - a font
+ * @param baselineTag - a baseline tag
+ * @param direction - text direction.
+ * @param scriptTag - script tag.
+ * @param languageTag - language tag, currently unused.
+ * @param coord - baseline value if found.
+ */
 export declare const otLayoutGetBaselineWithFallback: (font: FontT, baselineTag: OtLayoutBaselineTagT, direction: DirectionT, scriptTag: number, languageTag: number, coord: Ref<number>) => void;
+/**
+ * Fetches a baseline value from the face, and synthesizes
+ * it if the font does not have it.
+ *
+ * This function is like hb_ot_layout_get_baseline_with_fallback() but takes
+ * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
+ * @param font - a font
+ * @param baselineTag - a baseline tag
+ * @param direction - text direction.
+ * @param script - script.
+ * @param language - language, currently unused.
+ * @param coord - baseline value if found.
+ */
 export declare const otLayoutGetBaselineWithFallback2: (font: FontT, baselineTag: OtLayoutBaselineTagT, direction: DirectionT, script: ScriptT, coord: Ref<number>, language?: number | null) => void;
+/**
+ * Fetches script/language-specific font extents.  These values are
+ * looked up in the `BASE` table's `MinMax` records.
+ *
+ * If no such extents are found, the default extents for the font are
+ * fetched. As such, the return value of this function can for the
+ * most part be ignored.  Note that the per-script/language extents
+ * do not have a line-gap value, and the line-gap is set to zero in
+ * that case.
+ * @param font - a font
+ * @param direction - text direction.
+ * @param scriptTag - script tag.
+ * @param languageTag - language tag.
+ * @param extents - font extents if found.
+ */
 export declare const otLayoutGetFontExtents: (font: FontT, direction: DirectionT, scriptTag: number, languageTag: number, extents?: Ref<number> | null) => number;
+/**
+ * Fetches script/language-specific font extents.  These values are
+ * looked up in the `BASE` table's `MinMax` records.
+ *
+ * If no such extents are found, the default extents for the font are
+ * fetched. As such, the return value of this function can for the
+ * most part be ignored.  Note that the per-script/language extents
+ * do not have a line-gap value, and the line-gap is set to zero in
+ * that case.
+ *
+ * This function is like hb_ot_layout_get_font_extents() but takes
+ * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
+ * @param font - a font
+ * @param direction - text direction.
+ * @param script - script.
+ * @param language - language.
+ * @param extents - font extents if found.
+ */
 export declare const otLayoutGetFontExtents2: (font: FontT, direction: DirectionT, script: ScriptT, language?: number | null, extents?: Ref<number> | null) => number;
+/**
+ * Fetches the GDEF class of the requested glyph in the specified face.
+ * @param face - The #hb_face_t to work on
+ * @param glyph - The #hb_codepoint_t code point to query
+ */
 export declare const otLayoutGetGlyphClass: (face: FaceT, glyph: number) => OtLayoutGlyphClassT;
+/**
+ * Retrieves the set of all glyphs from the face that belong to the requested
+ * glyph class in the face's GDEF table.
+ * @param face - The #hb_face_t to work on
+ * @param klass - The #hb_ot_layout_glyph_class_t GDEF class to retrieve
+ * @param glyphs - The #hb_set_t set of all glyphs belonging to the requested
+ */
 export declare const otLayoutGetGlyphsInClass: (face: FaceT, klass: OtLayoutGlyphClassT, glyphs: Ref<SetT>) => void;
+/**
+ * Fetches the dominant horizontal baseline tag used by @script.
+ * @param script - a script tag.
+ */
 export declare const otLayoutGetHorizontalBaselineTagForScript: (script: ScriptT) => OtLayoutBaselineTagT;
+/**
+ * Fetches a list of the caret positions defined for a ligature glyph in the GDEF
+ * table of the font. The list returned will begin at the offset provided.
+ *
+ * Note that a ligature that is formed from n characters will have n-1
+ * caret positions. The first character is not represented in the array,
+ * since its caret position is the glyph position.
+ *
+ * The positions returned by this function are 'unshaped', and will have to
+ * be fixed up for kerning that may be applied to the ligature glyph.
+ * @param font - The #hb_font_t to work on
+ * @param direction - The #hb_direction_t text direction to use
+ * @param glyph - The #hb_codepoint_t code point to query
+ * @param startOffset - offset of the first caret position to retrieve
+ * @param caretCount - Input = the maximum number of caret positions to return;
+ * @param caretArray - The array of caret positions found for the query
+ */
 export declare const otLayoutGetLigatureCarets: (font: FontT, direction: DirectionT, glyph: number, startOffset: number, caretArray: Ref<number[]>, caretCount?: Ref<number> | null) => number;
+/**
+ * Fetches optical-size feature data (i.e., the `size` feature from GPOS). Note that
+ * the subfamily_id and the subfamily name string (accessible via the subfamily_name_id)
+ * as used here are defined as pertaining only to fonts within a font family that differ
+ * specifically in their respective size ranges; other ways to differentiate fonts within
+ * a subfamily are not covered by the `size` feature.
+ *
+ * For more information on this distinction, see the [`size` feature documentation](
+ * https://docs.microsoft.com/en-us/typography/opentype/spec/features_pt#tag-size).
+ * @param face - #hb_face_t to work upon
+ * @param designSize - The design size of the face
+ * @param subfamilyId - The identifier of the face within the font subfamily
+ * @param subfamilyNameId - The ‘name’ table name ID of the face within the font subfamily
+ * @param rangeStart - The minimum size of the recommended size range for the face
+ * @param rangeEnd - The maximum size of the recommended size range for the face
+ */
 export declare const otLayoutGetSizeParams: (face: FaceT, designSize: Ref<number>, subfamilyId: Ref<number>, subfamilyNameId: Ref<number>, rangeStart: Ref<number>, rangeEnd: Ref<number>) => number;
+/**
+ * Tests whether a face has any glyph classes defined in its GDEF table.
+ * @param face - #hb_face_t to work upon
+ */
 export declare const otLayoutHasGlyphClasses: (face: FaceT) => number;
+/**
+ * Tests whether the specified face includes any GPOS positioning.
+ * @param face - #hb_face_t to work upon
+ */
 export declare const otLayoutHasPositioning: (face: FaceT) => number;
+/**
+ * Tests whether the specified face includes any GSUB substitutions.
+ * @param face - #hb_face_t to work upon
+ */
 export declare const otLayoutHasSubstitution: (face: FaceT) => number;
+/**
+ * Fetches the index of a given feature tag in the specified face's GSUB table
+ * or GPOS table, underneath the specified script and language.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageIndex - The index of the requested language tag
+ * @param featureTag - #hb_tag_t of the feature tag requested
+ * @param featureIndex - The index of the requested feature
+ */
 export declare const otLayoutLanguageFindFeature: (face: FaceT, tableTag: number, scriptIndex: number, languageIndex: number, featureTag: number, featureIndex: Ref<number>) => number;
+/**
+ * Fetches a list of all features in the specified face's GSUB table
+ * or GPOS table, underneath the specified script and language. The list
+ * returned will begin at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageIndex - The index of the requested language tag
+ * @param startOffset - offset of the first feature tag to retrieve
+ * @param featureCount - Input = the maximum number of feature tags to return;
+ * @param featureIndexes - The array of feature indexes found for the query
+ */
 export declare const otLayoutLanguageGetFeatureIndexes: (face: FaceT, tableTag: number, scriptIndex: number, languageIndex: number, startOffset: number, featureIndexes: Ref<number[]>, featureCount?: Ref<number> | null) => number;
+/**
+ * Fetches a list of all features in the specified face's GSUB table
+ * or GPOS table, underneath the specified script and language. The list
+ * returned will begin at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageIndex - The index of the requested language tag
+ * @param startOffset - offset of the first feature tag to retrieve
+ * @param featureCount - Input = the maximum number of feature tags to return;
+ * @param featureTags - The array of #hb_tag_t feature tags found for the query
+ */
 export declare const otLayoutLanguageGetFeatureTags: (face: FaceT, tableTag: number, scriptIndex: number, languageIndex: number, startOffset: number, featureTags: Ref<number[]>, featureCount?: Ref<number> | null) => number;
+/**
+ * Fetches the tag of a requested feature index in the given face's GSUB or GPOS table,
+ * underneath the specified script and language.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageIndex - The index of the requested language tag
+ * @param featureIndex - The index of the requested feature
+ * @param featureTag - The #hb_tag_t of the requested feature
+ */
 export declare const otLayoutLanguageGetRequiredFeature: (face: FaceT, tableTag: number, scriptIndex: number, languageIndex: number, featureIndex: Ref<number>, featureTag: Ref<number>) => number;
+/**
+ * Fetches the index of a requested feature in the given face's GSUB or GPOS table,
+ * underneath the specified script and language.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageIndex - The index of the requested language tag
+ * @param featureIndex - The index of the requested feature
+ */
 export declare const otLayoutLanguageGetRequiredFeatureIndex: (face: FaceT, tableTag: number, scriptIndex: number, languageIndex: number, featureIndex: Ref<number>) => number;
+/**
+ * Fetches a list of all glyphs affected by the specified lookup in the
+ * specified face's GSUB table or GPOS table.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param lookupIndex - The index of the feature lookup to query
+ * @param glyphsBefore - Array of glyphs preceding the substitution range
+ * @param glyphsInput - Array of input glyphs that would be substituted by the lookup
+ * @param glyphsAfter - Array of glyphs following the substitution range
+ * @param glyphsOutput - Array of glyphs that would be the substituted output of the lookup
+ */
 export declare const otLayoutLookupCollectGlyphs: (face: FaceT, tableTag: number, lookupIndex: number, glyphsBefore?: Ref<SetT> | null, glyphsInput?: Ref<SetT> | null, glyphsAfter?: Ref<SetT> | null, glyphsOutput?: Ref<SetT> | null) => void;
+/**
+ * Fetches alternates of a glyph from a given GSUB lookup index. Note that for one-to-one GSUB
+ * glyph substitutions, this function fetches the substituted glyph.
+ * @param face - a face.
+ * @param lookupIndex - index of the feature lookup to query.
+ * @param glyph - a glyph id.
+ * @param startOffset - starting offset.
+ * @param alternateCount - Input = the maximum number of alternate glyphs to return;
+ * @param alternateGlyphs - A glyphs buffer.
+ */
 export declare const otLayoutLookupGetGlyphAlternates: (face: FaceT, lookupIndex: number, glyph: number, startOffset: number, alternateGlyphs: Ref<number[]>, alternateCount?: Ref<number> | null) => number;
+/**
+ * Fetches the optical bound of a glyph positioned at the margin of text.
+ * The direction identifies which edge of the glyph to query.
+ * @param font - a font.
+ * @param lookupIndex - index of the feature lookup to query.
+ * @param direction - edge of the glyph to query.
+ * @param glyph - a glyph id.
+ */
 export declare const otLayoutLookupGetOpticalBound: (font: FontT, lookupIndex: number, direction: DirectionT, glyph: number) => number;
+/**
+ * Compute the transitive closure of glyphs needed for a
+ * specified lookup.
+ * @param face - #hb_face_t to work upon
+ * @param lookupIndex - index of the feature lookup to query
+ * @param glyphs - Array of glyphs comprising the transitive closure of the lookup
+ */
 export declare const otLayoutLookupSubstituteClosure: (face: FaceT, lookupIndex: number, glyphs: Ref<SetT>) => void;
+/**
+ * Tests whether a specified lookup in the specified face would
+ * trigger a substitution on the given glyph sequence.
+ * @param face - #hb_face_t to work upon
+ * @param lookupIndex - The index of the lookup to query
+ * @param glyphs - The sequence of glyphs to query for substitution
+ * @param glyphsLength - The length of the glyph sequence
+ * @param zeroContext - #hb_bool_t indicating whether pre-/post-context are disallowed
+ */
 export declare const otLayoutLookupWouldSubstitute: (face: FaceT, lookupIndex: number, glyphs: number, glyphsLength: number, zeroContext: number) => number;
+/**
+ * Compute the transitive closure of glyphs needed for all of the
+ * provided lookups.
+ * @param face - #hb_face_t to work upon
+ * @param lookups - The set of lookups to query
+ * @param glyphs - Array of glyphs comprising the transitive closure of the lookups
+ */
 export declare const otLayoutLookupsSubstituteClosure: (face: FaceT, lookups: SetT, glyphs: Ref<SetT>) => void;
+/**
+ * Fetches the index of a given language tag in the specified face's GSUB table
+ * or GPOS table, underneath the specified script tag.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageTag - The #hb_tag_t of the requested language
+ * @param languageIndex - The index of the requested language
+ */
 export declare const otLayoutScriptFindLanguage: (face: FaceT, tableTag: number, scriptIndex: number, languageTag: number, languageIndex: number) => number;
+/**
+ * Fetches a list of language tags in the given face's GSUB or GPOS table, underneath
+ * the specified script index. The list returned will begin at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param startOffset - offset of the first language tag to retrieve
+ * @param languageCount - Input = the maximum number of language tags to return;
+ * @param languageTags - Array of language tags found in the table
+ */
 export declare const otLayoutScriptGetLanguageTags: (face: FaceT, tableTag: number, scriptIndex: number, startOffset: number, languageTags: Ref<number[]>, languageCount?: Ref<number> | null) => number;
+/**
+ * Fetches the index of the first language tag fom `language_tags` that is present
+ * in the specified face's GSUB or GPOS table, underneath the specified script
+ * index.
+ *
+ * If none of the given language tags is found, `false` is returned and
+ * `language_index` is set to the default language index.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageCount - The number of languages in the specified script
+ * @param languageTags - The array of language tags
+ * @param languageIndex - The index of the requested language
+ */
 export declare const otLayoutScriptSelectLanguage: (face: FaceT, tableTag: number, scriptIndex: number, languageCount: number, languageTags: number, languageIndex: Ref<number>) => number;
+/**
+ * Fetches the index of the first language tag fom `language_tags` that is present
+ * in the specified face's GSUB or GPOS table, underneath the specified script
+ * index.
+ *
+ * If none of the given language tags is found, `false` is returned and
+ * `language_index` is set to #HB_OT_LAYOUT_DEFAULT_LANGUAGE_INDEX and
+ * `chosen_language` is set to #HB_TAG_NONE.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptIndex - The index of the requested script tag
+ * @param languageCount - The number of languages in the specified script
+ * @param languageTags - The array of language tags
+ * @param languageIndex - The index of the chosen language
+ * @param chosenLanguage - #hb_tag_t of the chosen language
+ */
 export declare const otLayoutScriptSelectLanguage2: (face: FaceT, tableTag: number, scriptIndex: number, languageCount: number, languageTags: number, languageIndex: Ref<number>, chosenLanguage: Ref<number>) => number;
+/**
+ * Deprecated since 2.0.0
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptTags - Array of #hb_tag_t script tags
+ * @param scriptIndex - The index of the chosen script
+ * @param chosenScript - #hb_tag_t of the chosen script
+ */
 export declare const otLayoutTableChooseScript: (face: FaceT, tableTag: number, scriptTags: number, scriptIndex: Ref<number>, chosenScript: Ref<number>) => number;
+/**
+ * Fetches a list of feature variations in the specified face's GSUB table
+ * or GPOS table, at the specified variation coordinates.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param coords - The variation coordinates to query
+ * @param numCoords - The number of variation coordinates
+ * @param variationsIndex - The array of feature variations found for the query
+ */
 export declare const otLayoutTableFindFeatureVariations: (face: FaceT, tableTag: number, coords: number, numCoords: number, variationsIndex: Ref<number>) => number;
+/**
+ * Fetches the index if a given script tag in the specified face's GSUB table
+ * or GPOS table.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptTag - #hb_tag_t of the script tag requested
+ * @param scriptIndex - The index of the requested script tag
+ */
 export declare const otLayoutTableFindScript: (face: FaceT, tableTag: number, scriptTag: number, scriptIndex: Ref<number>) => number;
+/**
+ * Fetches a list of all feature tags in the given face's GSUB or GPOS table.
+ * Note that there might be duplicate feature tags, belonging to different
+ * script/language-system pairs of the table.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param startOffset - offset of the first feature tag to retrieve
+ * @param featureCount - Input = the maximum number of feature tags to return;
+ * @param featureTags - Array of feature tags found in the table
+ */
 export declare const otLayoutTableGetFeatureTags: (face: FaceT, tableTag: number, startOffset: number, featureTags: Ref<number[]>, featureCount?: Ref<number> | null) => number;
+/**
+ * Fetches the total number of lookups enumerated in the specified
+ * face's GSUB table or GPOS table.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ */
 export declare const otLayoutTableGetLookupCount: (face: FaceT, tableTag: number) => number;
+/**
+ * Fetches a list of all scripts enumerated in the specified face's GSUB table
+ * or GPOS table. The list returned will begin at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param startOffset - offset of the first script tag to retrieve
+ * @param scriptCount - Input = the maximum number of script tags to return;
+ * @param scriptTags - The array of #hb_tag_t script tags found for the query
+ */
 export declare const otLayoutTableGetScriptTags: (face: FaceT, tableTag: number, startOffset: number, scriptTags: Ref<number[]>, scriptCount?: Ref<number> | null) => number;
+/**
+ * Selects an OpenType script for `table_tag` from the `script_tags` array.
+ *
+ * If the table does not have any of the requested scripts, then `DFLT`,
+ * `dflt`, and `latn` tags are tried in that order. If the table still does not
+ * have any of these scripts, `script_index` is set to
+ * #HB_OT_LAYOUT_NO_SCRIPT_INDEX and `chosen_script` is set to #HB_TAG_NONE.
+ * @param face - #hb_face_t to work upon
+ * @param tableTag - #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+ * @param scriptCount - Number of script tags in the array
+ * @param scriptTags - Array of #hb_tag_t script tags
+ * @param scriptIndex - The index of the requested script
+ * @param chosenScript - #hb_tag_t of the requested script
+ */
 export declare const otLayoutTableSelectScript: (face: FaceT, tableTag: number, scriptCount: number, scriptTags: number, scriptIndex?: Ref<number> | null, chosenScript?: Ref<number> | null) => number;
+/**
+ * Fetches the specified math constant. For most constants, the value returned
+ * is an #hb_position_t.
+ *
+ * However, if the requested constant is #HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN,
+ * #HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN or
+ * #HB_OT_MATH_CONSTANT_RADICAL_DEGREE_BOTTOM_RAISE_PERCENT, then the return value is
+ * an integer between 0 and 100 representing that percentage.
+ * @param font - #hb_font_t to work upon
+ * @param constant - #hb_ot_math_constant_t the constant to retrieve
+ */
 export declare const otMathGetConstant: (font: FontT, constant: OtMathConstantT) => number;
+/**
+ * Fetches the GlyphAssembly for the specified font, glyph index, and direction.
+ * Returned are a list of #hb_ot_math_glyph_part_t glyph parts that can be
+ * used to draw the glyph and an italics-correction value (if one is defined
+ * in the font).
+ *
+ * <note>The `direction` parameter is only used to select between horizontal
+ * or vertical directions for the construction. Even though all #hb_direction_t
+ * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
+ * considered.</note>
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The index of the glyph to stretch
+ * @param direction - direction of the stretching (horizontal or vertical)
+ * @param startOffset - offset of the first glyph part to retrieve
+ * @param partsCount - Input = maximum number of glyph parts to return;
+ * @param parts - the glyph parts returned
+ * @param italicsCorrection - italics correction of the glyph assembly
+ */
 export declare const otMathGetGlyphAssembly: (font: FontT, glyph: number, direction: DirectionT, startOffset: number, partsCount: Ref<number>, parts: Ref<OtMathGlyphPartT[]>, italicsCorrection: Ref<number>) => number;
+/**
+ * Fetches an italics-correction value (if one exists) for the specified
+ * glyph index.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph index from which to retrieve the value
+ */
 export declare const otMathGetGlyphItalicsCorrection: (font: FontT, glyph: number) => number;
+/**
+ * Fetches the math kerning (cut-ins) value for the specified font, glyph index, and
+ * @kern.
+ *
+ * If the MathKern table is found, the function examines it to find a height
+ * value that is greater or equal to @correction_height. If such a height
+ * value is found, corresponding kerning value from the table is returned. If
+ * no such height value is found, the last kerning value is returned.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph index from which to retrieve the value
+ * @param kern - The #hb_ot_math_kern_t from which to retrieve the value
+ * @param correctionHeight - the correction height to use to determine the kerning.
+ */
 export declare const otMathGetGlyphKerning: (font: FontT, glyph: number, kern: OtMathKernT, correctionHeight: number) => number;
+/**
+ * Fetches the raw MathKern (cut-in) data for the specified font, glyph index,
+ * and @kern. The corresponding list of kern values and correction heights is
+ * returned as a list of #hb_ot_math_kern_entry_t structs.
+ *
+ * See also #hb_ot_math_get_glyph_kerning, which handles selecting the
+ * appropriate kern value for a given correction height.
+ *
+ * <note>For a glyph with `n` defined kern values (where `n` > 0), there are only
+ * @n−1 defined correction heights, as each correction height defines a boundary
+ * past which the next kern value should be selected. Therefore, only the
+ * #hb_ot_math_kern_entry_t.kern_value of the uppermost #hb_ot_math_kern_entry_t
+ * actually comes from the font; its corresponding
+ * #hb_ot_math_kern_entry_t.max_correction_height is always set to
+ * <code>INT32_MAX</code>.</note>
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph index from which to retrieve the kernings
+ * @param kern - The #hb_ot_math_kern_t from which to retrieve the kernings
+ * @param startOffset - offset of the first kern entry to retrieve
+ * @param entriesCount - Input = the maximum number of kern entries to return;
+ * @param kernEntries - array of kern entries returned
+ */
 export declare const otMathGetGlyphKernings: (font: FontT, glyph: number, kern: OtMathKernT, startOffset: number, kernEntries: Ref<number[]>, entriesCount?: Ref<number> | null) => number;
+/**
+ * Fetches a top-accent-attachment value (if one exists) for the specified
+ * glyph index.
+ *
+ * For any glyph that does not have a top-accent-attachment value - that is,
+ * a glyph not covered by the `MathTopAccentAttachment` table (or, when
+ * `font` has no `MathTopAccentAttachment` table or no `MATH` table, any
+ * glyph) - the function synthesizes a value, returning the position at
+ * one-half the glyph's advance width.
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The glyph index from which to retrieve the value
+ */
 export declare const otMathGetGlyphTopAccentAttachment: (font: FontT, glyph: number) => number;
+/**
+ * Fetches the MathGlyphConstruction for the specified font, glyph index, and
+ * direction. The corresponding list of size variants is returned as a list of
+ * #hb_ot_math_glyph_variant_t structs.
+ *
+ * <note>The `direction` parameter is only used to select between horizontal
+ * or vertical directions for the construction. Even though all #hb_direction_t
+ * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
+ * considered.</note>
+ * @param font - #hb_font_t to work upon
+ * @param glyph - The index of the glyph to stretch
+ * @param direction - The direction of the stretching (horizontal or vertical)
+ * @param startOffset - offset of the first variant to retrieve
+ * @param variantsCount - Input = the maximum number of variants to return;
+ * @param variants - array of variants returned
+ */
 export declare const otMathGetGlyphVariants: (font: FontT, glyph: number, direction: DirectionT, startOffset: number, variantsCount: Ref<number>, variants: Ref<OtMathGlyphVariantT[]>) => number;
+/**
+ * Fetches the MathVariants table for the specified font and returns the
+ * minimum overlap of connecting glyphs that are required to draw a glyph
+ * assembly in the specified direction.
+ *
+ * <note>The `direction` parameter is only used to select between horizontal
+ * or vertical directions for the construction. Even though all #hb_direction_t
+ * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
+ * considered.</note>
+ * @param font - #hb_font_t to work upon
+ * @param direction - direction of the stretching (horizontal or vertical)
+ */
 export declare const otMathGetMinConnectorOverlap: (font: FontT, direction: DirectionT) => number;
+/**
+ * Tests whether a face has a `MATH` table.
+ * @param face - #hb_face_t to test
+ */
 export declare const otMathHasData: (face: FaceT) => number;
+/**
+ * Tests whether the given glyph index is an extended shape in the face.
+ * @param face - #hb_face_t to work upon
+ * @param glyph - The glyph index to test
+ */
 export declare const otMathIsGlyphExtendedShape: (face: FaceT, glyph: number) => number;
+/**
+ * Fetches all available feature types.
+ * @param face - a face object
+ * @param startOffset - iteration's start offset
+ * @param entriesCount - buffer size as input, filled size as output
+ * @param entries - entries tags buffer
+ */
 export declare const otMetaGetEntryTags: (face: FaceT, startOffset: number, entries: Ref<OtMetaTagT[]>, entriesCount?: Ref<number> | null) => number;
+/**
+ * It fetches metadata entry of a given tag from a font.
+ * @param face - a #hb_face_t object.
+ * @param metaTag - tag of metadata you like to have.
+ */
 export declare const otMetaReferenceEntry: (face: FaceT, metaTag: OtMetaTagT) => BlobT;
+/**
+ * Fetches metrics value corresponding to `metrics_tag` from @font.
+ * @param font - an #hb_font_t object.
+ * @param metricsTag - tag of metrics value you like to fetch.
+ * @param position - result of metrics value from the font.
+ */
 export declare const otMetricsGetPosition: (font: FontT, metricsTag: OtMetricsTagT, position?: Ref<number> | null) => number;
+/**
+ * Fetches metrics value corresponding to `metrics_tag` from @font,
+ * and synthesizes a value if it the value is missing in the font.
+ * @param font - an #hb_font_t object.
+ * @param metricsTag - tag of metrics value you like to fetch.
+ * @param position - result of metrics value from the font.
+ */
 export declare const otMetricsGetPositionWithFallback: (font: FontT, metricsTag: OtMetricsTagT, position?: Ref<number> | null) => void;
+/**
+ * Fetches metrics value corresponding to `metrics_tag` from `font` with the
+ * current font variation settings applied.
+ * @param font - an #hb_font_t object.
+ * @param metricsTag - tag of metrics value you like to fetch.
+ */
 export declare const otMetricsGetVariation: (font: FontT, metricsTag: OtMetricsTagT) => number;
+/**
+ * Fetches horizontal metrics value corresponding to `metrics_tag` from `font` with the current font variation settings applied.
+ * @param font - an #hb_font_t object.
+ * @param metricsTag - tag of metrics value you like to fetch.
+ */
 export declare const otMetricsGetXVariation: (font: FontT, metricsTag: OtMetricsTagT) => number;
+/**
+ * Fetches vertical metrics value corresponding to `metrics_tag` from `font` with
+ * the current font variation settings applied.
+ * @param font - an #hb_font_t object.
+ * @param metricsTag - tag of metrics value you like to fetch.
+ */
 export declare const otMetricsGetYVariation: (font: FontT, metricsTag: OtMetricsTagT) => number;
+/**
+ * Fetches a font name from the OpenType 'name' table.
+ * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
+ * Returns string in UTF-16 encoding. A NUL terminator is always written
+ * for convenience, and isn't included in the output @text_size.
+ * @param face - font face.
+ * @param nameId - OpenType name identifier to fetch.
+ * @param language - language to fetch the name for.
+ * @param textSize - input size of `text` buffer, and output size of
+ * @param text - buffer to write fetched name into.
+ */
 export declare const otNameGetUtf16: (face: FaceT, nameId: number, language: number, text: Ref<number[]>, textSize?: Ref<number> | null) => number;
+/**
+ * Fetches a font name from the OpenType 'name' table.
+ * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
+ * Returns string in UTF-32 encoding. A NUL terminator is always written
+ * for convenience, and isn't included in the output @text_size.
+ * @param face - font face.
+ * @param nameId - OpenType name identifier to fetch.
+ * @param language - language to fetch the name for.
+ * @param textSize - input size of `text` buffer, and output size of
+ * @param text - buffer to write fetched name into.
+ */
 export declare const otNameGetUtf32: (face: FaceT, nameId: number, language: number, text: Ref<number[]>, textSize?: Ref<number> | null) => number;
+/**
+ * Fetches a font name from the OpenType 'name' table.
+ * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
+ * Returns string in UTF-8 encoding. A NUL terminator is always written
+ * for convenience, and isn't included in the output @text_size.
+ * @param face - font face.
+ * @param nameId - OpenType name identifier to fetch.
+ * @param language - language to fetch the name for.
+ * @param textSize - input size of `text` buffer, and output size of
+ * @param text - buffer to write fetched name into.
+ */
 export declare const otNameGetUtf8: (face: FaceT, nameId: number, language: number, text: Ref<string[]>, textSize?: Ref<number> | null) => number;
+/**
+ * Enumerates all available name IDs and language combinations. Returned
+ * array is owned by the `face` and should not be modified.  It can be
+ * used as long as `face` is alive.
+ * @param face - font face.
+ * @param numEntries - number of returned entries.
+ */
 export declare const otNameListNames: (face: FaceT, numEntries?: Ref<number> | null) => number[];
+/**
+ * Computes the transitive closure of glyphs needed for a specified
+ * input buffer under the given font and feature list. The closure is
+ * computed as a set, not as a list.
+ * @param font - #hb_font_t to work upon
+ * @param buffer - The input buffer to compute from
+ * @param features - The features enabled on the buffer
+ * @param numFeatures - The number of features enabled on the buffer
+ * @param glyphs - The #hb_set_t set of glyphs comprising the transitive closure of the query
+ */
 export declare const otShapeGlyphsClosure: (font: FontT, buffer: BufferT, features: FeatureT[], numFeatures: number, glyphs: Ref<SetT>) => void;
+/**
+ * Computes the complete set of GSUB or GPOS lookups that are applicable
+ * under a given @shape_plan.
+ * @param shapePlan - #hb_shape_plan_t to query
+ * @param tableTag - GSUB or GPOS
+ * @param lookupIndexes - The #hb_set_t set of lookups returned
+ */
 export declare const otShapePlanCollectLookups: (shapePlan: ShapePlanT, tableTag: number, lookupIndexes: Ref<SetT>) => void;
+/**
+ * Fetches the list of OpenType feature tags enabled for a shaping plan, if possible.
+ * @param shapePlan - A shaping plan
+ * @param startOffset - The index of first feature to retrieve
+ * @param tagCount - Input = the maximum number of features to return;
+ * @param tags - The array of enabled feature
+ */
 export declare const otShapePlanGetFeatureTags: (shapePlan: ShapePlanT, startOffset: number, tagCount: Ref<number>, tags: Ref<number[]>) => number;
+/**
+ * Converts an #hb_language_t to an #hb_tag_t.
+ * @param language - an #hb_language_t to convert.
+ */
 export declare const otTagFromLanguage: (language: number) => number;
+/**
+ * Converts a language tag to an #hb_language_t.
+ * @param tag - an language tag
+ */
 export declare const otTagToLanguage: (tag: number) => number | null;
+/**
+ * Converts a script tag to an #hb_script_t.
+ * @param tag - a script tag
+ */
 export declare const otTagToScript: (tag: number) => ScriptT;
+/**
+ * Converts an #hb_script_t to script tags.
+ * @param script - an #hb_script_t to convert.
+ * @param scriptTag_1 - output #hb_tag_t.
+ * @param scriptTag_2 - output #hb_tag_t.
+ */
 export declare const otTagsFromScript: (script: ScriptT, scriptTag_1: Ref<number>, scriptTag_2: Ref<number>) => void;
+/**
+ * Converts an #hb_script_t and an #hb_language_t to script and language tags.
+ * @param script - an #hb_script_t to convert.
+ * @param language - an #hb_language_t to convert.
+ * @param scriptCount - maximum number of script tags to retrieve (IN)
+ * @param scriptTags - array of size at least `script_count` to store the
+ * @param languageCount - maximum number of language tags to retrieve
+ * @param languageTags - array of size at least `language_count` to store
+ */
 export declare const otTagsFromScriptAndLanguage: (script: ScriptT, scriptCount: Ref<number>, languageCount: Ref<number>, language?: number | null, scriptTags?: Ref<number> | null, languageTags?: Ref<number> | null) => void;
+/**
+ * Converts a script tag and a language tag to an #hb_script_t and an
+ * #hb_language_t.
+ * @param scriptTag - a script tag
+ * @param languageTag - a language tag
+ * @param script - the #hb_script_t corresponding to @script_tag.
+ * @param language - the #hb_language_t corresponding to `script_tag` and
+ */
 export declare const otTagsToScriptAndLanguage: (scriptTag: number, languageTag: number, script?: Ref<ScriptT> | null, language?: Ref<number> | null) => void;
+/**
+ * Fetches the variation-axis information corresponding to the specified axis tag
+ * in the specified face.
+ * @param face - #hb_face_t to work upon
+ * @param axisTag - The #hb_tag_t of the variation axis to query
+ * @param axisIndex - The index of the variation axis
+ * @param axisInfo - The #hb_ot_var_axis_info_t of the axis tag queried
+ */
 export declare const otVarFindAxis: (face: FaceT, axisTag: number, axisIndex: number, axisInfo: Ref<number>) => number;
+/**
+ * Fetches the variation-axis information corresponding to the specified axis tag
+ * in the specified face.
+ * @param face - #hb_face_t to work upon
+ * @param axisTag - The #hb_tag_t of the variation axis to query
+ * @param axisInfo - The #hb_ot_var_axis_info_t of the axis tag queried
+ */
 export declare const otVarFindAxisInfo: (face: FaceT, axisTag: number, axisInfo: Ref<OtVarAxisInfoT>) => number;
+/**
+ * Fetches a list of all variation axes in the specified face. The list returned will begin
+ * at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param startOffset - offset of the first lookup to retrieve
+ * @param axesCount - Input = the maximum number of variation axes to return;
+ * @param axesArray - The array of variation axes found
+ */
 export declare const otVarGetAxes: (face: FaceT, startOffset: number, axesArray: Ref<number[]>, axesCount?: Ref<number> | null) => number;
+/**
+ * Fetches the number of OpenType variation axes included in the face.
+ * @param face - The #hb_face_t to work on
+ */
 export declare const otVarGetAxisCount: (face: FaceT) => number;
+/**
+ * Fetches a list of all variation axes in the specified face. The list returned will begin
+ * at the offset provided.
+ * @param face - #hb_face_t to work upon
+ * @param startOffset - offset of the first lookup to retrieve
+ * @param axesCount - Input = the maximum number of variation axes to return;
+ * @param axesArray - The array of variation axes found
+ */
 export declare const otVarGetAxisInfos: (face: FaceT, startOffset: number, axesArray: Ref<OtVarAxisInfoT[]>, axesCount?: Ref<number> | null) => number;
+/**
+ * Fetches the number of named instances included in the face.
+ * @param face - The #hb_face_t to work on
+ */
 export declare const otVarGetNamedInstanceCount: (face: FaceT) => number;
+/**
+ * Tests whether a face includes any OpenType variation data in the `fvar` table.
+ * @param face - The #hb_face_t to work on
+ */
 export declare const otVarHasData: (face: FaceT) => number;
+/**
+ * Fetches the design-space coordinates corresponding to the given
+ * named instance in the face.
+ * @param face - The #hb_face_t to work on
+ * @param instanceIndex - The index of the named instance to query
+ * @param coordsLength - Input = the maximum number of coordinates to return;
+ * @param coords - The array of coordinates found for the query
+ */
 export declare const otVarNamedInstanceGetDesignCoords: (face: FaceT, instanceIndex: number, coords: Ref<number[]>, coordsLength?: Ref<number> | null) => number;
+/**
+ * Fetches the `name` table Name ID that provides display names for
+ * the "PostScript name" defined for the given named instance in the face.
+ * @param face - The #hb_face_t to work on
+ * @param instanceIndex - The index of the named instance to query
+ */
 export declare const otVarNamedInstanceGetPostscriptNameId: (face: FaceT, instanceIndex: number) => number;
+/**
+ * Fetches the `name` table Name ID that provides display names for
+ * the "Subfamily name" defined for the given named instance in the face.
+ * @param face - The #hb_face_t to work on
+ * @param instanceIndex - The index of the named instance to query
+ */
 export declare const otVarNamedInstanceGetSubfamilyNameId: (face: FaceT, instanceIndex: number) => number;
+/**
+ * Normalizes the given design-space coordinates. The minimum and maximum
+ * values for the axis are mapped to the interval [-1,1], with the default
+ * axis value mapped to 0.
+ *
+ * The normalized values have 14 bits of fixed-point sub-integer precision as per
+ * OpenType specification.
+ *
+ * Any additional scaling defined in the face's `avar` table is also
+ * applied, as described at https://docs.microsoft.com/en-us/typography/opentype/spec/avar
+ *
+ * Note: `coords_length` must be the same as the number of axes in the face, as
+ * for example returned by hb_ot_var_get_axis_count().
+ * Otherwise, the behavior is undefined.
+ * @param face - The #hb_face_t to work on
+ * @param coordsLength - The length of the coordinate array
+ * @param designCoords - The design-space coordinates to normalize
+ * @param normalizedCoords - The normalized coordinates
+ */
 export declare const otVarNormalizeCoords: (face: FaceT, coordsLength: number, designCoords: number, normalizedCoords: Ref<number>) => void;
+/**
+ * Normalizes all of the coordinates in the given list of variation axes.
+ * @param face - The #hb_face_t to work on
+ * @param variations - The array of variations to normalize
+ * @param variationsLength - The number of variations to normalize
+ * @param coords - The array of normalized coordinates
+ * @param coordsLength - The length of the coordinate array
+ */
 export declare const otVarNormalizeVariations: (face: FaceT, variations: number, variationsLength: number, coords: Ref<number[]>, coordsLength: Ref<number>) => void;
+/**
+ * Perform a "color" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param isForeground - whether the color is the foreground
+ * @param color - The color to use
+ */
 export declare const paintColor: (funcs: PaintFuncsT, isForeground: number, color: number, paintData?: number | null) => void;
+/**
+ * Perform a "color-glyph" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param glyph - the glyph ID
+ * @param font - the font
+ */
 export declare const paintColorGlyph: (funcs: PaintFuncsT, glyph: number, font: FontT, paintData?: number | null) => number;
+/**
+ * Gets the custom palette color for @color_index.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param colorIndex - color index
+ * @param color - fetched color
+ */
 export declare const paintCustomPaletteColor: (funcs: PaintFuncsT, colorIndex: number, color: Ref<number>, paintData?: number | null) => number;
+/**
+ * Creates a new #hb_paint_funcs_t structure of paint functions.
+ *
+ * The initial reference count of 1 should be released with hb_paint_funcs_destroy()
+ * when you are done using the #hb_paint_funcs_t. This function never returns
+ * `NULL`. If memory cannot be allocated, a special singleton #hb_paint_funcs_t
+ * object will be returned.
+ */
 export declare const paintFuncsCreate: () => PaintFuncsT;
+/**
+ * Fetches the singleton empty paint-functions structure.
+ */
 export declare const paintFuncsGetEmpty: () => PaintFuncsT;
+/**
+ * Tests whether a paint-functions structure is immutable.
+ * @param funcs - The paint-functions structure
+ */
 export declare const paintFuncsIsImmutable: (funcs: PaintFuncsT) => number;
+/**
+ * Makes a paint-functions structure immutable.
+ *
+ * After this call, all attempts to set one of the callbacks
+ * on `funcs` will fail.
+ * @param funcs - The paint-functions structure
+ */
 export declare const paintFuncsMakeImmutable: (funcs: PaintFuncsT) => void;
+/**
+ * Sets the paint-color callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The paint-color callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetColorFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the color-glyph callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The color-glyph callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetColorGlyphFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the custom-palette-color callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The custom-palette-color callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetCustomPaletteColorFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the paint-image callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The paint-image callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetImageFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the linear-gradient callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The linear-gradient callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetLinearGradientFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the pop-clip callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The pop-clip callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetPopClipFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the pop-group callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The pop-group callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetPopGroupFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the pop-transform callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The pop-transform callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetPopTransformFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the push-clip-glyph callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The push-clip-glyph callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetPushClipGlyphFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the push-clip-rect callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The push-clip-rectangle callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetPushClipRectangleFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the push-group callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The push-group callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetPushGroupFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the push-transform callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The push-transform callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetPushTransformFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the radial-gradient callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The radial-gradient callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetRadialGradientFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the sweep-gradient callback on the paint functions struct.
+ * @param funcs - A paint functions struct
+ * @param func - The sweep-gradient callback
+ * @param userData - Data to pass to @func
+ * @param destroy - Function to call when `user_data` is no longer needed
+ */
 export declare const paintFuncsSetSweepGradientFunc: (funcs: PaintFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Perform a "image" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param image - image data
+ * @param width - width of the raster image in pixels, or 0
+ * @param height - height of the raster image in pixels, or 0
+ * @param format - the image format as a tag
+ * @param slant - Deprecated. set to 0.0
+ * @param extents - the extents of the glyph
+ */
 export declare const paintImage: (funcs: PaintFuncsT, image: BlobT, width: number, height: number, format: number, slant: number, paintData?: number | null, extents?: number | null) => void;
+/**
+ * Perform a "linear-gradient" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param colorLine - Color information for the gradient
+ * @param x0 - X coordinate of the first point
+ * @param y0 - Y coordinate of the first point
+ * @param x1 - X coordinate of the second point
+ * @param y1 - Y coordinate of the second point
+ * @param x2 - X coordinate of the third point
+ * @param y2 - Y coordinate of the third point
+ */
 export declare const paintLinearGradient: (funcs: PaintFuncsT, colorLine: ColorLineT, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, paintData?: number | null) => void;
+/**
+ * Perform a "pop-clip" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ */
 export declare const paintPopClip: (funcs: PaintFuncsT, paintData?: number | null) => void;
+/**
+ * Perform a "pop-group" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param mode - the compositing mode to use
+ */
 export declare const paintPopGroup: (funcs: PaintFuncsT, mode: PaintCompositeModeT, paintData?: number | null) => void;
+/**
+ * Perform a "pop-transform" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ */
 export declare const paintPopTransform: (funcs: PaintFuncsT, paintData?: number | null) => void;
+/**
+ * Perform a "push-clip-glyph" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param glyph - the glyph ID
+ * @param font - the font
+ */
 export declare const paintPushClipGlyph: (funcs: PaintFuncsT, glyph: number, font: FontT, paintData?: number | null) => void;
+/**
+ * Perform a "push-clip-rect" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param xmin - min X for the rectangle
+ * @param ymin - min Y for the rectangle
+ * @param xmax - max X for the rectangle
+ * @param ymax - max Y for the rectangle
+ */
 export declare const paintPushClipRectangle: (funcs: PaintFuncsT, xmin: number, ymin: number, xmax: number, ymax: number, paintData?: number | null) => void;
+/**
+ * Push the transform reflecting the font's scale and slant
+ * settings onto the paint functions.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param font - a font
+ */
 export declare const paintPushFontTransform: (funcs: PaintFuncsT, font: FontT, paintData?: number | null) => void;
+/**
+ * Perform a "push-group" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ */
 export declare const paintPushGroup: (funcs: PaintFuncsT, paintData?: number | null) => void;
+/**
+ * Push the inverse of the transform reflecting the font's
+ * scale and slant settings onto the paint functions.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param font - a font
+ */
 export declare const paintPushInverseFontTransform: (funcs: PaintFuncsT, font: FontT, paintData?: number | null) => void;
+/**
+ * Perform a "push-transform" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param xx - xx component of the transform matrix
+ * @param yx - yx component of the transform matrix
+ * @param xy - xy component of the transform matrix
+ * @param yy - yy component of the transform matrix
+ * @param dx - dx component of the transform matrix
+ * @param dy - dy component of the transform matrix
+ */
 export declare const paintPushTransform: (funcs: PaintFuncsT, xx: number, yx: number, xy: number, yy: number, dx: number, dy: number, paintData?: number | null) => void;
+/**
+ * Perform a "radial-gradient" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param colorLine - Color information for the gradient
+ * @param x0 - X coordinate of the first circle's center
+ * @param y0 - Y coordinate of the first circle's center
+ * @param r0 - radius of the first circle
+ * @param x1 - X coordinate of the second circle's center
+ * @param y1 - Y coordinate of the second circle's center
+ * @param r1 - radius of the second circle
+ */
 export declare const paintRadialGradient: (funcs: PaintFuncsT, colorLine: ColorLineT, x0: number, y0: number, r0: number, x1: number, y1: number, r1: number, paintData?: number | null) => void;
+/**
+ * Perform a "sweep-gradient" paint operation.
+ * @param funcs - paint functions
+ * @param paintData - associated data passed by the caller
+ * @param colorLine - Color information for the gradient
+ * @param x0 - X coordinate of the circle's center
+ * @param y0 - Y coordinate of the circle's center
+ * @param startAngle - the start angle
+ * @param endAngle - the end angle
+ */
 export declare const paintSweepGradient: (funcs: PaintFuncsT, colorLine: ColorLineT, x0: number, y0: number, startAngle: number, endAngle: number, paintData?: number | null) => void;
+/**
+ * Reallocates the memory pointed to by `ptr` to `size` bytes, using the
+ * allocator set at compile-time. Typically just realloc().
+ * @param ptr - The pointer to the memory to reallocate.
+ * @param size - The new size of the memory.
+ */
 export declare const realloc: (size: number, ptr?: number | null) => number | null;
+/**
+ * Converts an ISO 15924 script tag to a corresponding #hb_script_t.
+ * @param tag - an #hb_tag_t representing an ISO 15924 tag.
+ */
 export declare const scriptFromIso15924Tag: (tag: number) => ScriptT;
+/**
+ * Converts a string `str` representing an ISO 15924 script tag to a
+ * corresponding #hb_script_t. Shorthand for hb_tag_from_string() then
+ * hb_script_from_iso15924_tag().
+ * @param str - a string representing an
+ * @param len - length of the @str, or -1 if it is `NULL`-terminated.
+ */
 export declare const scriptFromString: (str: number[], len: number) => ScriptT;
+/**
+ * Fetches the #hb_direction_t of a script when it is
+ * set horizontally. All right-to-left scripts will return
+ * #HB_DIRECTION_RTL. All left-to-right scripts will return
+ * #HB_DIRECTION_LTR.
+ *
+ * Scripts that can be written either right-to-left or
+ * left-to-right will return #HB_DIRECTION_INVALID.
+ *
+ * Unknown scripts will return #HB_DIRECTION_LTR.
+ * @param script - The #hb_script_t to query
+ */
 export declare const scriptGetHorizontalDirection: (script: ScriptT) => DirectionT;
+/**
+ * Converts an #hb_script_t to a corresponding ISO 15924 script tag.
+ * @param script - an #hb_script_t to convert.
+ */
 export declare const scriptToIso15924Tag: (script: ScriptT) => number;
+/**
+ * Checks the equality of two #hb_segment_properties_t's.
+ * @param a - first #hb_segment_properties_t to compare.
+ * @param b - second #hb_segment_properties_t to compare.
+ */
 export declare const segmentPropertiesEqual: (a: SegmentPropertiesT, b: SegmentPropertiesT) => number;
+/**
+ * Creates a hash representing @p.
+ * @param p - #hb_segment_properties_t to hash.
+ */
 export declare const segmentPropertiesHash: (p: SegmentPropertiesT) => number;
+/**
+ * Fills in missing fields of `p` from `src` in a considered manner.
+ *
+ * First, if `p` does not have direction set, direction is copied from @src.
+ *
+ * Next, if `p` and `src` have the same direction (which can be unset), if `p` does not have script set, script is copied from @src.
+ *
+ * Finally, if `p` and `src` have the same direction and script (which either
+ * can be unset), if `p` does not have language set, language is copied from
+ * @src.
+ * @param p - #hb_segment_properties_t to fill in.
+ * @param src - #hb_segment_properties_t to fill in from.
+ */
 export declare const segmentPropertiesOverlay: (p: SegmentPropertiesT, src: SegmentPropertiesT) => void;
+/**
+ * Adds `codepoint` to @set.
+ * @param set - A set
+ * @param codepoint - The element to add to @set
+ */
 export declare const setAdd: (set: SetT, codepoint: number) => void;
+/**
+ * Adds all of the elements from `first` to `last` (inclusive) to @set.
+ * @param set - A set
+ * @param first - The first element to add to @set
+ * @param last - The final element to add to @set
+ */
 export declare const setAddRange: (set: SetT, first: number, last: number) => void;
+/**
+ * Adds `num_codepoints` codepoints to a set at once.
+ * The codepoints array must be in increasing order,
+ * with size at least @num_codepoints.
+ * @param set - A set
+ * @param sortedCodepoints - Array of codepoints to add
+ * @param numCodepoints - Length of @sorted_codepoints
+ */
 export declare const setAddSortedArray: (set: SetT, sortedCodepoints: number[], numCodepoints: number) => void;
+/**
+ * Tests whether memory allocation for a set was successful.
+ * @param set - A set
+ */
 export declare const setAllocationSuccessful: (set: SetT) => number;
+/**
+ * Clears out the contents of a set.
+ * @param set - A set
+ */
 export declare const setClear: (set: SetT) => void;
+/**
+ * Allocate a copy of @set.
+ * @param set - A set
+ */
 export declare const setCopy: (set: SetT) => SetT;
+/**
+ * Creates a new, initially empty set.
+ */
 export declare const setCreate: () => SetT;
+/**
+ * Removes `codepoint` from @set.
+ * @param set - A set
+ * @param codepoint - Removes `codepoint` from @set
+ */
 export declare const setDel: (set: SetT, codepoint: number) => void;
+/**
+ * Removes all of the elements from `first` to `last` (inclusive) from @set.
+ *
+ * If `last` is #HB_SET_VALUE_INVALID, then all values
+ * greater than or equal to `first` are removed.
+ * @param set - A set
+ * @param first - The first element to remove from @set
+ * @param last - The final element to remove from @set
+ */
 export declare const setDelRange: (set: SetT, first: number, last: number) => void;
+/**
+ * Fetches the singleton empty #hb_set_t.
+ */
 export declare const setGetEmpty: () => SetT;
+/**
+ * Finds the largest element in the set.
+ * @param set - A set
+ */
 export declare const setGetMax: (set: SetT) => number;
+/**
+ * Finds the smallest element in the set.
+ * @param set - A set
+ */
 export declare const setGetMin: (set: SetT) => number;
+/**
+ * Returns the number of elements in the set.
+ * @param set - A set
+ */
 export declare const setGetPopulation: (set: SetT) => number;
+/**
+ * Tests whether `codepoint` belongs to @set.
+ * @param set - A set
+ * @param codepoint - The element to query
+ */
 export declare const setHas: (set: SetT, codepoint: number) => number;
+/**
+ * Creates a hash representing @set.
+ * @param set - A set
+ */
 export declare const setHash: (set: SetT) => number;
+/**
+ * Makes `set` the intersection of `set` and @other.
+ * @param set - A set
+ * @param other - Another set
+ */
 export declare const setIntersect: (set: SetT, other: SetT) => void;
+/**
+ * Inverts the contents of @set.
+ * @param set - A set
+ */
 export declare const setInvert: (set: SetT) => void;
+/**
+ * Tests whether a set is empty (contains no elements).
+ * @param set - a set.
+ */
 export declare const setIsEmpty: (set: SetT) => number;
+/**
+ * Tests whether `set` and `other` are equal (contain the same
+ * elements).
+ * @param set - A set
+ * @param other - Another set
+ */
 export declare const setIsEqual: (set: SetT, other: SetT) => number;
+/**
+ * Returns whether the set is inverted.
+ * @param set - A set
+ */
 export declare const setIsInverted: (set: SetT) => number;
+/**
+ * Tests whether `set` is a subset of @larger_set.
+ * @param set - A set
+ * @param largerSet - Another set
+ */
 export declare const setIsSubset: (set: SetT, largerSet: SetT) => number;
+/**
+ * Fetches the next element in `set` that is greater than current value of @codepoint.
+ *
+ * Set `codepoint` to #HB_SET_VALUE_INVALID to get started.
+ * @param set - A set
+ * @param codepoint - Input = Code point to query
+ */
 export declare const setNext: (set: SetT, codepoint: Ref<number>) => number;
+/**
+ * Finds the next element in `set` that is greater than @codepoint. Writes out
+ * codepoints to @out, until either the set runs out of elements, or `size` codepoints are written, whichever comes first.
+ * @param set - A set
+ * @param codepoint - Outputting codepoints starting after this one.
+ * @param out - An array of codepoints to write to.
+ * @param size - The maximum number of codepoints to write out.
+ */
 export declare const setNextMany: (set: SetT, codepoint: number, out: number[], size: number) => number;
+/**
+ * Fetches the next consecutive range of elements in `set` that
+ * are greater than current value of @last.
+ *
+ * Set `last` to #HB_SET_VALUE_INVALID to get started.
+ * @param set - A set
+ * @param first - The first code point in the range
+ * @param last - Input = The current last code point in the range
+ */
 export declare const setNextRange: (set: SetT, first: Ref<number>, last: Ref<number>) => number;
+/**
+ * Fetches the previous element in `set` that is lower than current value of @codepoint.
+ *
+ * Set `codepoint` to #HB_SET_VALUE_INVALID to get started.
+ * @param set - A set
+ * @param codepoint - Input = Code point to query
+ */
 export declare const setPrevious: (set: SetT, codepoint: Ref<number>) => number;
+/**
+ * Fetches the previous consecutive range of elements in `set` that
+ * are greater than current value of @last.
+ *
+ * Set `first` to #HB_SET_VALUE_INVALID to get started.
+ * @param set - A set
+ * @param first - Input = The current first code point in the range
+ * @param last - The last code point in the range
+ */
 export declare const setPreviousRange: (set: SetT, first: Ref<number>, last: Ref<number>) => number;
+/**
+ * Makes the contents of `set` equal to the contents of @other.
+ * @param set - A set
+ * @param other - Another set
+ */
 export declare const setSet: (set: SetT, other: SetT) => void;
+/**
+ * Subtracts the contents of `other` from @set.
+ * @param set - A set
+ * @param other - Another set
+ */
 export declare const setSubtract: (set: SetT, other: SetT) => void;
+/**
+ * Makes `set` the symmetric difference of `set` and @other.
+ * @param set - A set
+ * @param other - Another set
+ */
 export declare const setSymmetricDifference: (set: SetT, other: SetT) => void;
+/**
+ * Makes `set` the union of `set` and @other.
+ * @param set - A set
+ * @param other - Another set
+ */
 export declare const setUnion: (set: SetT, other: SetT) => void;
+/**
+ * Shapes `buffer` using `font` turning its Unicode characters content to
+ * positioned glyphs. If `features` is not `NULL`, it will be used to control the
+ * features applied during shaping. If two `features` have the same tag but
+ * overlapping ranges the value of the feature with the higher index takes
+ * precedence.
+ * @param font - an #hb_font_t to use for shaping
+ * @param buffer - an #hb_buffer_t to shape
+ * @param features - an array of user
+ * @param numFeatures - the length of `features` array
+ */
 export declare const shape: (font: FontT, buffer: BufferT, numFeatures: number, features?: FeatureT[] | null) => void;
+/**
+ * See hb_shape() for details. If `shaper_list` is not `NULL`, the specified
+ * shapers will be used in the given order, otherwise the default shapers list
+ * will be used.
+ * @param font - an #hb_font_t to use for shaping
+ * @param buffer - an #hb_buffer_t to shape
+ * @param features - an array of user
+ * @param numFeatures - the length of `features` array
+ * @param shaperList - a `NULL`-terminated
+ */
 export declare const shapeFull: (font: FontT, buffer: BufferT, numFeatures: number, features?: FeatureT[] | null, shaperList?: string[] | null) => number;
+/**
+ * Retrieves the list of shapers supported by HarfBuzz.
+ */
 export declare const shapeListShapers: () => string[];
+/**
+ * Constructs a shaping plan for a combination of @face, @user_features, @props,
+ * and @shaper_list.
+ * @param face - #hb_face_t to use
+ * @param props - The #hb_segment_properties_t of the segment
+ * @param userFeatures - The list of user-selected features
+ * @param numUserFeatures - The number of user-selected features
+ * @param shaperList - List of shapers to try
+ */
 export declare const shapePlanCreate: (face: FaceT, props: SegmentPropertiesT, userFeatures: FeatureT[], numUserFeatures: number, shaperList: string[]) => ShapePlanT;
+/**
+ * The variable-font version of #hb_shape_plan_create.
+ * Constructs a shaping plan for a combination of @face, @user_features, @props,
+ * and @shaper_list, plus the variation-space coordinates @coords.
+ * @param face - #hb_face_t to use
+ * @param props - The #hb_segment_properties_t of the segment
+ * @param userFeatures - The list of user-selected features
+ * @param numUserFeatures - The number of user-selected features
+ * @param coords - The list of variation-space coordinates
+ * @param numCoords - The number of variation-space coordinates
+ * @param shaperList - List of shapers to try
+ */
 export declare const shapePlanCreate2: (face: FaceT, props: SegmentPropertiesT, userFeatures: FeatureT[], numUserFeatures: number, coords: number[], numCoords: number, shaperList: string[]) => ShapePlanT;
+/**
+ * Creates a cached shaping plan suitable for reuse, for a combination
+ * of @face, @user_features, @props, and @shaper_list.
+ * @param face - #hb_face_t to use
+ * @param props - The #hb_segment_properties_t of the segment
+ * @param userFeatures - The list of user-selected features
+ * @param numUserFeatures - The number of user-selected features
+ * @param shaperList - List of shapers to try
+ */
 export declare const shapePlanCreateCached: (face: FaceT, props: SegmentPropertiesT, userFeatures: FeatureT[], numUserFeatures: number, shaperList: string[]) => ShapePlanT;
+/**
+ * The variable-font version of #hb_shape_plan_create_cached.
+ * Creates a cached shaping plan suitable for reuse, for a combination
+ * of @face, @user_features, @props, and @shaper_list, plus the
+ * variation-space coordinates @coords.
+ * @param face - #hb_face_t to use
+ * @param props - The #hb_segment_properties_t of the segment
+ * @param userFeatures - The list of user-selected features
+ * @param numUserFeatures - The number of user-selected features
+ * @param coords - The list of variation-space coordinates
+ * @param numCoords - The number of variation-space coordinates
+ * @param shaperList - List of shapers to try
+ */
 export declare const shapePlanCreateCached2: (face: FaceT, props: SegmentPropertiesT, userFeatures: FeatureT[], numUserFeatures: number, coords: number[], numCoords: number, shaperList: string[]) => ShapePlanT;
+/**
+ * Executes the given shaping plan on the specified buffer, using
+ * the given `font` and @features.
+ * @param shapePlan - A shaping plan
+ * @param font - The #hb_font_t to use
+ * @param buffer - The #hb_buffer_t to work upon
+ * @param features - Features to enable
+ * @param numFeatures - The number of features to enable
+ */
 export declare const shapePlanExecute: (shapePlan: ShapePlanT, font: FontT, buffer: BufferT, features: FeatureT[], numFeatures: number) => number;
+/**
+ * Fetches the singleton empty shaping plan.
+ */
 export declare const shapePlanGetEmpty: () => ShapePlanT;
+/**
+ * Fetches the shaper from a given shaping plan.
+ * @param shapePlan - A shaping plan
+ */
 export declare const shapePlanGetShaper: (shapePlan: ShapePlanT) => string;
+/**
+ * Searches variation axes of a #hb_font_t object for a specific axis first,
+ * if not set, first tries to get default style values in `STAT` table
+ * then tries to polyfill from different tables of the font.
+ * @param font - a #hb_font_t object.
+ * @param styleTag - a style tag.
+ */
 export declare const styleGetValue: (font: FontT, styleTag: StyleTagT) => number;
+/**
+ * Converts a string into an #hb_tag_t. Valid tags
+ * are four characters. Shorter input strings will be
+ * padded with spaces. Longer input strings will be
+ * truncated.
+ * @param str - String to convert
+ * @param len - Length of @str, or -1 if it is `NULL`-terminated
+ */
 export declare const tagFromString: (str: number[], len: number) => number;
+/**
+ * Converts an #hb_tag_t to a string and returns it in @buf.
+ * Strings will be four characters long.
+ * @param tag - #hb_tag_t to convert
+ * @param buf - Converted string
+ */
 export declare const tagToString: (tag: number, buf: Ref<number[]>) => void;
+/**
+ * Retrieves the Canonical Combining Class (ccc) property
+ * of code point @unicode.
+ * @param ufuncs - The Unicode-functions structure
+ * @param unicode - The code point to query
+ */
 export declare const unicodeCombiningClass: (ufuncs: UnicodeFuncsT, unicode: number) => UnicodeCombiningClassT;
+/**
+ * Fetches the composition of a sequence of two Unicode
+ * code points.
+ *
+ * Calls the composition function of the specified
+ * Unicode-functions structure @ufuncs.
+ * @param ufuncs - The Unicode-functions structure
+ * @param a - The first Unicode code point to compose
+ * @param b - The second Unicode code point to compose
+ * @param ab - The composition of @a, @b
+ */
 export declare const unicodeCompose: (ufuncs: UnicodeFuncsT, a: number, b: number, ab: Ref<number>) => number;
+/**
+ * Fetches the decomposition of a Unicode code point.
+ *
+ * Calls the decomposition function of the specified
+ * Unicode-functions structure @ufuncs.
+ * @param ufuncs - The Unicode-functions structure
+ * @param ab - Unicode code point to decompose
+ * @param a - The first code point of the decomposition of @ab
+ * @param b - The second code point of the decomposition of @ab
+ */
 export declare const unicodeDecompose: (ufuncs: UnicodeFuncsT, ab: number, a: Ref<number>, b: Ref<number>) => number;
+/**
+ * Fetches the compatibility decomposition of a Unicode
+ * code point. Deprecated.
+ * @param ufuncs - The Unicode-functions structure
+ * @param u - Code point to decompose
+ * @param decomposed - Compatibility decomposition of @u
+ */
 export declare const unicodeDecomposeCompatibility: (ufuncs: UnicodeFuncsT, u: number, decomposed: Ref<number>) => number;
+/**
+ * Don't use. Not used by HarfBuzz.
+ * @param ufuncs - a Unicode-function structure
+ * @param unicode - The code point to query
+ */
 export declare const unicodeEastasianWidth: (ufuncs: UnicodeFuncsT, unicode: number) => number;
+/**
+ * Creates a new #hb_unicode_funcs_t structure of Unicode functions.
+ * @param parent - Parent Unicode-functions structure
+ */
 export declare const unicodeFuncsCreate: (parent?: UnicodeFuncsT | null) => UnicodeFuncsT;
+/**
+ * Fetches a pointer to the default Unicode-functions structure that is used
+ * when no functions are explicitly set on #hb_buffer_t.
+ */
 export declare const unicodeFuncsGetDefault: () => UnicodeFuncsT;
+/**
+ * Fetches the singleton empty Unicode-functions structure.
+ */
 export declare const unicodeFuncsGetEmpty: () => UnicodeFuncsT;
+/**
+ * Fetches the parent of the Unicode-functions structure
+ * @ufuncs.
+ * @param ufuncs - The Unicode-functions structure
+ */
 export declare const unicodeFuncsGetParent: (ufuncs: UnicodeFuncsT) => UnicodeFuncsT;
+/**
+ * Tests whether the specified Unicode-functions structure
+ * is immutable.
+ * @param ufuncs - The Unicode-functions structure
+ */
 export declare const unicodeFuncsIsImmutable: (ufuncs: UnicodeFuncsT) => number;
+/**
+ * Makes the specified Unicode-functions structure
+ * immutable.
+ * @param ufuncs - The Unicode-functions structure
+ */
 export declare const unicodeFuncsMakeImmutable: (ufuncs: UnicodeFuncsT) => void;
+/**
+ * Sets the implementation function for #hb_unicode_combining_class_func_t.
+ * @param ufuncs - A Unicode-functions structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const unicodeFuncsSetCombiningClassFunc: (ufuncs: UnicodeFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_unicode_compose_func_t.
+ * @param ufuncs - A Unicode-functions structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const unicodeFuncsSetComposeFunc: (ufuncs: UnicodeFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_unicode_decompose_compatibility_func_t.
+ * @param ufuncs - A Unicode-functions structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const unicodeFuncsSetDecomposeCompatibilityFunc: (ufuncs: UnicodeFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_unicode_decompose_func_t.
+ * @param ufuncs - A Unicode-functions structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const unicodeFuncsSetDecomposeFunc: (ufuncs: UnicodeFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_unicode_eastasian_width_func_t.
+ * @param ufuncs - a Unicode-function structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const unicodeFuncsSetEastasianWidthFunc: (ufuncs: UnicodeFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_unicode_general_category_func_t.
+ * @param ufuncs - A Unicode-functions structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const unicodeFuncsSetGeneralCategoryFunc: (ufuncs: UnicodeFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_unicode_mirroring_func_t.
+ * @param ufuncs - A Unicode-functions structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const unicodeFuncsSetMirroringFunc: (ufuncs: UnicodeFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Sets the implementation function for #hb_unicode_script_func_t.
+ * @param ufuncs - A Unicode-functions structure
+ * @param func - The callback function to assign
+ * @param userData - Data to pass to @func
+ * @param destroy - The function to call when `user_data` is not needed anymore
+ */
 export declare const unicodeFuncsSetScriptFunc: (ufuncs: UnicodeFuncsT, func: (...args: unknown[]) => unknown, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null) => void;
+/**
+ * Retrieves the General Category (gc) property
+ * of code point @unicode.
+ * @param ufuncs - The Unicode-functions structure
+ * @param unicode - The code point to query
+ */
 export declare const unicodeGeneralCategory: (ufuncs: UnicodeFuncsT, unicode: number) => UnicodeGeneralCategoryT;
+/**
+ * Retrieves the Bi-directional Mirroring Glyph code
+ * point defined for code point @unicode.
+ * @param ufuncs - The Unicode-functions structure
+ * @param unicode - The code point to query
+ */
 export declare const unicodeMirroring: (ufuncs: UnicodeFuncsT, unicode: number) => number;
+/**
+ * Retrieves the #hb_script_t script to which code
+ * point `unicode` belongs.
+ * @param ufuncs - The Unicode-functions structure
+ * @param unicode - The code point to query
+ */
 export declare const unicodeScript: (ufuncs: UnicodeFuncsT, unicode: number) => ScriptT;
+/**
+ * Parses a string into a #hb_variation_t.
+ *
+ * The format for specifying variation settings follows. All valid CSS
+ * font-variation-settings values other than 'normal' and 'inherited' are also
+ * accepted, though, not documented below.
+ *
+ * The format is a tag, optionally followed by an equals sign, followed by a
+ * number. For example `wght=500`, or `slnt=-7.5`.
+ * @param str - a string to parse
+ * @param len - length of @str, or -1 if string is `NULL` terminated
+ * @param variation - the #hb_variation_t to initialize with the parsed values
+ */
 export declare const variationFromString: (str: number[], len: number, variation: Ref<number>) => number;
+/**
+ * Converts an #hb_variation_t into a `NULL`-terminated string in the format
+ * understood by hb_variation_from_string(). The client in responsible for
+ * allocating big enough size for @buf, 128 bytes is more than enough.
+ *
+ * Note that the string won't include any whitespace.
+ * @param variation - an #hb_variation_t to convert
+ * @param buf - output string
+ * @param size - the allocated size of @buf
+ */
 export declare const variationToString: (variation: number, buf: Ref<string[]>, size: Ref<number>) => void;