chromium/out/Default/gen/third_party/skia/src/ports/fontations/src/ffi.rs.h

#pragma once
#include "src/ports/fontations/src/skpath_bridge.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <iterator>
#include <new>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#if defined(_WIN32)
#include <basetsd.h>
#else
#include <sys/types.h>
#endif

namespace rust {
inline namespace cxxbridge1 {
// #include "rust/cxx.h"

#ifndef CXXBRIDGE1_PANIC
#define CXXBRIDGE1_PANIC
template <typename Exception>
void panic [[noreturn]] (const char *msg);
#endif // CXXBRIDGE1_PANIC

struct unsafe_bitcopy_t;

namespace {
template <typename T>
class impl;
} // namespace

template <typename T>
::std::size_t size_of();
template <typename T>
::std::size_t align_of();

#ifndef CXXBRIDGE1_RUST_STRING
#define CXXBRIDGE1_RUST_STRING
class String final { … };
#endif // CXXBRIDGE1_RUST_STRING

#ifndef CXXBRIDGE1_RUST_SLICE
#define CXXBRIDGE1_RUST_SLICE
namespace detail {
template <bool>
struct copy_assignable_if { … };

template <>
struct copy_assignable_if<false> { … };
} // namespace detail

template <typename T>
class Slice final
    : private detail::copy_assignable_if<std::is_const<T>::value> { … };

template <typename T>
class Slice<T>::iterator final { … };

template <typename T>
Slice<T>::Slice() noexcept { … }

template <typename T>
Slice<T>::Slice(T *s, std::size_t count) noexcept { … }

template <typename T>
T *Slice<T>::data() const noexcept { … }

template <typename T>
std::size_t Slice<T>::size() const noexcept { … }

template <typename T>
std::size_t Slice<T>::length() const noexcept { … }

template <typename T>
bool Slice<T>::empty() const noexcept { … }

template <typename T>
T &Slice<T>::operator[](std::size_t n) const noexcept { … }

template <typename T>
T &Slice<T>::at(std::size_t n) const { … }

template <typename T>
T &Slice<T>::front() const noexcept { … }

template <typename T>
T &Slice<T>::back() const noexcept { … }

template <typename T>
typename Slice<T>::iterator::reference
Slice<T>::iterator::operator*() const noexcept { … }

template <typename T>
typename Slice<T>::iterator::pointer
Slice<T>::iterator::operator->() const noexcept { … }

template <typename T>
typename Slice<T>::iterator::reference Slice<T>::iterator::operator[](
    typename Slice<T>::iterator::difference_type n) const noexcept { … }

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator++() noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator++(int) noexcept { … }

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator--() noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator--(int) noexcept { … }

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator+=(
    typename Slice<T>::iterator::difference_type n) noexcept { … }

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator-=(
    typename Slice<T>::iterator::difference_type n) noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator+(
    typename Slice<T>::iterator::difference_type n) const noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator-(
    typename Slice<T>::iterator::difference_type n) const noexcept { … }

template <typename T>
typename Slice<T>::iterator::difference_type
Slice<T>::iterator::operator-(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator==(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator<(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator>(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::begin() const noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::end() const noexcept { … }

template <typename T>
void Slice<T>::swap(Slice &rhs) noexcept { … }
#endif // CXXBRIDGE1_RUST_SLICE

#ifndef CXXBRIDGE1_RUST_BOX
#define CXXBRIDGE1_RUST_BOX
template <typename T>
class Box final { … };

template <typename T>
class Box<T>::uninit { … };

template <typename T>
class Box<T>::allocation { … };

template <typename T>
Box<T>::Box(Box &&other) noexcept : … { … }

template <typename T>
Box<T>::Box(const T &val) { … }

template <typename T>
Box<T>::Box(T &&val) { … }

template <typename T>
Box<T>::~Box() noexcept { … }

template <typename T>
Box<T> &Box<T>::operator=(Box &&other) &noexcept { … }

template <typename T>
const T *Box<T>::operator->() const noexcept { … }

template <typename T>
const T &Box<T>::operator*() const noexcept { … }

template <typename T>
T *Box<T>::operator->() noexcept { … }

template <typename T>
T &Box<T>::operator*() noexcept { … }

template <typename T>
template <typename... Fields>
Box<T> Box<T>::in_place(Fields &&...fields) { … }

template <typename T>
void Box<T>::swap(Box &rhs) noexcept { … }

template <typename T>
Box<T> Box<T>::from_raw(T *raw) noexcept { … }

template <typename T>
T *Box<T>::into_raw() noexcept { … }

template <typename T>
Box<T>::Box(uninit) noexcept { … }
#endif // CXXBRIDGE1_RUST_BOX

#ifndef CXXBRIDGE1_RUST_BITCOPY_T
#define CXXBRIDGE1_RUST_BITCOPY_T
struct unsafe_bitcopy_t final { … };
#endif // CXXBRIDGE1_RUST_BITCOPY_T

#ifndef CXXBRIDGE1_RUST_VEC
#define CXXBRIDGE1_RUST_VEC
template <typename T>
class Vec final { … };

template <typename T>
Vec<T>::Vec(std::initializer_list<T> init) : … { … }

template <typename T>
Vec<T>::Vec(const Vec &other) : … { … }

template <typename T>
Vec<T>::Vec(Vec &&other) noexcept : … { … }

template <typename T>
Vec<T>::~Vec() noexcept { … }

template <typename T>
Vec<T> &Vec<T>::operator=(Vec &&other) &noexcept { … }

template <typename T>
Vec<T> &Vec<T>::operator=(const Vec &other) & { … }

template <typename T>
bool Vec<T>::empty() const noexcept { … }

template <typename T>
T *Vec<T>::data() noexcept { … }

template <typename T>
const T &Vec<T>::operator[](std::size_t n) const noexcept { … }

template <typename T>
const T &Vec<T>::at(std::size_t n) const { … }

template <typename T>
const T &Vec<T>::front() const noexcept { … }

template <typename T>
const T &Vec<T>::back() const noexcept { … }

template <typename T>
T &Vec<T>::operator[](std::size_t n) noexcept { … }

template <typename T>
T &Vec<T>::at(std::size_t n) { … }

template <typename T>
T &Vec<T>::front() noexcept { … }

template <typename T>
T &Vec<T>::back() noexcept { … }

template <typename T>
void Vec<T>::reserve(std::size_t new_cap) { … }

template <typename T>
void Vec<T>::push_back(const T &value) { … }

template <typename T>
void Vec<T>::push_back(T &&value) { … }

template <typename T>
template <typename... Args>
void Vec<T>::emplace_back(Args &&...args) { … }

template <typename T>
void Vec<T>::clear() { … }

template <typename T>
typename Vec<T>::iterator Vec<T>::begin() noexcept { … }

template <typename T>
typename Vec<T>::iterator Vec<T>::end() noexcept { … }

template <typename T>
typename Vec<T>::const_iterator Vec<T>::begin() const noexcept { … }

template <typename T>
typename Vec<T>::const_iterator Vec<T>::end() const noexcept { … }

template <typename T>
typename Vec<T>::const_iterator Vec<T>::cbegin() const noexcept { … }

template <typename T>
typename Vec<T>::const_iterator Vec<T>::cend() const noexcept { … }

template <typename T>
void Vec<T>::swap(Vec &rhs) noexcept { … }

template <typename T>
Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : … { … }
#endif // CXXBRIDGE1_RUST_VEC

#ifndef CXXBRIDGE1_RUST_ISIZE
#define CXXBRIDGE1_RUST_ISIZE
#if defined(_WIN32)
using isize = SSIZE_T;
#else
isize;
#endif
#endif // CXXBRIDGE1_RUST_ISIZE

#ifndef CXXBRIDGE1_RUST_OPAQUE
#define CXXBRIDGE1_RUST_OPAQUE
class Opaque { … };
#endif // CXXBRIDGE1_RUST_OPAQUE

#ifndef CXXBRIDGE1_IS_COMPLETE
#define CXXBRIDGE1_IS_COMPLETE
namespace detail {
namespace {
template <typename T, typename = std::size_t>
struct is_complete : std::false_type { … };
is_complete<T, decltype(sizeof(T))>;
} // namespace
} // namespace detail
#endif // CXXBRIDGE1_IS_COMPLETE

#ifndef CXXBRIDGE1_LAYOUT
#define CXXBRIDGE1_LAYOUT
class layout { … };

template <typename T>
std::size_t size_of() { … }

template <typename T>
std::size_t align_of() { … }
#endif // CXXBRIDGE1_LAYOUT
} // namespace cxxbridge1
} // namespace rust

namespace fontations_ffi {
  struct ColorStop;
  struct Metrics;
  struct BridgeLocalizedName;
  struct SkiaDesignCoordinate;
  struct BridgeScalerMetrics;
  struct PaletteOverride;
  struct ClipBox;
  struct Transform;
  struct FillLinearParams;
  struct FillRadialParams;
  struct FillSweepParams;
  struct BridgeFontStyle;
  struct BitmapMetrics;
  struct BridgeFontRef;
  struct BridgeOutlineCollection;
  struct BridgeMappingIndex;
  struct BridgeHintingInstance;
  struct BridgeBitmapGlyph;
  struct BridgeLocalizedStrings;
  struct BridgeNormalizedCoords;
  struct BridgeColorStops;
  PathWrapper;
  AxisWrapper;
  ColorPainterWrapper;
}

namespace fontations_ffi {
#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$ColorStop
#define CXXBRIDGE1_STRUCT_fontations_ffi$ColorStop
struct ColorStop final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$ColorStop

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$Metrics
#define CXXBRIDGE1_STRUCT_fontations_ffi$Metrics
struct Metrics final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$Metrics

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeLocalizedName
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeLocalizedName
struct BridgeLocalizedName final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeLocalizedName

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$SkiaDesignCoordinate
#define CXXBRIDGE1_STRUCT_fontations_ffi$SkiaDesignCoordinate
struct SkiaDesignCoordinate final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$SkiaDesignCoordinate

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeScalerMetrics
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeScalerMetrics
struct BridgeScalerMetrics final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeScalerMetrics

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$PaletteOverride
#define CXXBRIDGE1_STRUCT_fontations_ffi$PaletteOverride
struct PaletteOverride final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$PaletteOverride

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$ClipBox
#define CXXBRIDGE1_STRUCT_fontations_ffi$ClipBox
struct ClipBox final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$ClipBox

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$Transform
#define CXXBRIDGE1_STRUCT_fontations_ffi$Transform
struct Transform final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$Transform

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$FillLinearParams
#define CXXBRIDGE1_STRUCT_fontations_ffi$FillLinearParams
struct FillLinearParams final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$FillLinearParams

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$FillRadialParams
#define CXXBRIDGE1_STRUCT_fontations_ffi$FillRadialParams
struct FillRadialParams final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$FillRadialParams

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$FillSweepParams
#define CXXBRIDGE1_STRUCT_fontations_ffi$FillSweepParams
struct FillSweepParams final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$FillSweepParams

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeFontStyle
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeFontStyle
struct BridgeFontStyle final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeFontStyle

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BitmapMetrics
#define CXXBRIDGE1_STRUCT_fontations_ffi$BitmapMetrics
struct BitmapMetrics final { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BitmapMetrics

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeFontRef
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeFontRef
struct BridgeFontRef final : public ::rust::Opaque { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeFontRef

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeOutlineCollection
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeOutlineCollection
struct BridgeOutlineCollection final : public ::rust::Opaque { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeOutlineCollection

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeMappingIndex
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeMappingIndex
struct BridgeMappingIndex final : public ::rust::Opaque { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeMappingIndex

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeHintingInstance
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeHintingInstance
struct BridgeHintingInstance final : public ::rust::Opaque { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeHintingInstance

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeBitmapGlyph
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeBitmapGlyph
struct BridgeBitmapGlyph final : public ::rust::Opaque { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeBitmapGlyph

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeLocalizedStrings
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeLocalizedStrings
struct BridgeLocalizedStrings final : public ::rust::Opaque { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeLocalizedStrings

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeNormalizedCoords
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeNormalizedCoords
struct BridgeNormalizedCoords final : public ::rust::Opaque { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeNormalizedCoords

#ifndef CXXBRIDGE1_STRUCT_fontations_ffi$BridgeColorStops
#define CXXBRIDGE1_STRUCT_fontations_ffi$BridgeColorStops
struct BridgeColorStops final : public ::rust::Opaque { … };
#endif // CXXBRIDGE1_STRUCT_fontations_ffi$BridgeColorStops

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeFontRef> make_font_ref(::rust::Slice<::std::uint8_t const> font_data, ::std::uint32_t index) noexcept;

__attribute__((visibility("default"))) bool font_ref_is_valid(::fontations_ffi::BridgeFontRef const &bridge_font_ref) noexcept;

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeOutlineCollection> get_outline_collection(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

// Returns true on a font or collection, sets `num_fonts``
// to 0 if single font file, and to > 0 for a TrueType collection.
// Returns false if the data cannot be interpreted as a font or collection.
__attribute__((visibility("default"))) bool font_or_collection(::rust::Slice<::std::uint8_t const> font_data, ::std::uint32_t &num_fonts) noexcept;

__attribute__((visibility("default"))) ::std::size_t num_named_instances(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeMappingIndex> make_mapping_index(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeHintingInstance> make_hinting_instance(::fontations_ffi::BridgeOutlineCollection const &outlines, float size, ::fontations_ffi::BridgeNormalizedCoords const &coords, bool do_lcd_antialiasing, bool lcd_orientation_vertical, bool preserve_linear_metrics) noexcept;

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeHintingInstance> make_mono_hinting_instance(::fontations_ffi::BridgeOutlineCollection const &outlines, float size, ::fontations_ffi::BridgeNormalizedCoords const &coords) noexcept;

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeHintingInstance> no_hinting_instance() noexcept;

__attribute__((visibility("default"))) ::std::uint16_t lookup_glyph_or_zero(::fontations_ffi::BridgeFontRef const &font_ref, ::fontations_ffi::BridgeMappingIndex const &map, ::std::uint32_t codepoint) noexcept;

__attribute__((visibility("default"))) bool get_path(::fontations_ffi::BridgeOutlineCollection const &outlines, ::std::uint16_t glyph_id, float size, ::fontations_ffi::BridgeNormalizedCoords const &coords, ::fontations_ffi::BridgeHintingInstance const &hinting_instance, ::fontations_ffi::PathWrapper &path_wrapper, ::fontations_ffi::BridgeScalerMetrics &scaler_metrics) noexcept;

__attribute__((visibility("default"))) float unhinted_advance_width_or_zero(::fontations_ffi::BridgeFontRef const &font_ref, float size, ::fontations_ffi::BridgeNormalizedCoords const &coords, ::std::uint16_t glyph_id) noexcept;

__attribute__((visibility("default"))) bool scaler_hinted_advance_width(::fontations_ffi::BridgeOutlineCollection const &outlines, ::fontations_ffi::BridgeHintingInstance const &hinting_instance, ::std::uint16_t glyph_id, float &out_advance_width) noexcept;

__attribute__((visibility("default"))) ::std::uint16_t units_per_em_or_zero(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) ::fontations_ffi::Metrics get_skia_metrics(::fontations_ffi::BridgeFontRef const &font_ref, float size, ::fontations_ffi::BridgeNormalizedCoords const &coords) noexcept;

__attribute__((visibility("default"))) ::fontations_ffi::Metrics get_unscaled_metrics(::fontations_ffi::BridgeFontRef const &font_ref, ::fontations_ffi::BridgeNormalizedCoords const &coords) noexcept;

__attribute__((visibility("default"))) ::std::uint16_t num_glyphs(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) void fill_glyph_to_unicode_map(::fontations_ffi::BridgeFontRef const &font_ref, ::rust::Slice<::std::uint32_t > map) noexcept;

__attribute__((visibility("default"))) ::rust::String family_name(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) bool postscript_name(::fontations_ffi::BridgeFontRef const &font_ref, ::rust::String &out_string) noexcept;

// Receives a slice of palette overrides that will be merged
// with the specified base palette of the font. The result is a
// palette of RGBA, 8-bit per component, colors, consisting of
// palette entries merged with overrides.
__attribute__((visibility("default"))) ::rust::Vec<::std::uint32_t> resolve_palette(::fontations_ffi::BridgeFontRef const &font_ref, ::std::uint16_t base_palette, ::rust::Slice<::fontations_ffi::PaletteOverride const> palette_overrides) noexcept;

__attribute__((visibility("default"))) bool has_colrv1_glyph(::fontations_ffi::BridgeFontRef const &font_ref, ::std::uint16_t glyph_id) noexcept;

__attribute__((visibility("default"))) bool has_colrv0_glyph(::fontations_ffi::BridgeFontRef const &font_ref, ::std::uint16_t glyph_id) noexcept;

__attribute__((visibility("default"))) bool get_colrv1_clip_box(::fontations_ffi::BridgeFontRef const &font_ref, ::fontations_ffi::BridgeNormalizedCoords const &coords, ::std::uint16_t glyph_id, float size, ::fontations_ffi::ClipBox &clip_box) noexcept;

__attribute__((visibility("default"))) bool has_bitmap_glyph(::fontations_ffi::BridgeFontRef const &font_ref, ::std::uint16_t glyph_id) noexcept;

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeBitmapGlyph> bitmap_glyph(::fontations_ffi::BridgeFontRef const &font_ref, ::std::uint16_t glyph_id, float font_size) noexcept;

__attribute__((visibility("default"))) ::rust::Slice<::std::uint8_t const> png_data(::fontations_ffi::BridgeBitmapGlyph const &bitmap_glyph) noexcept;

__attribute__((visibility("default"))) ::fontations_ffi::BitmapMetrics const &bitmap_metrics(::fontations_ffi::BridgeBitmapGlyph const &bitmap_glyph) noexcept;

__attribute__((visibility("default"))) ::std::size_t table_data(::fontations_ffi::BridgeFontRef const &font_ref, ::std::uint32_t tag, ::std::size_t offset, ::rust::Slice<::std::uint8_t > data) noexcept;

__attribute__((visibility("default"))) ::std::uint16_t table_tags(::fontations_ffi::BridgeFontRef const &font_ref, ::rust::Slice<::std::uint32_t > tags) noexcept;

__attribute__((visibility("default"))) ::rust::isize variation_position(::fontations_ffi::BridgeNormalizedCoords const &coords, ::rust::Slice<::fontations_ffi::SkiaDesignCoordinate > coordinates) noexcept;

__attribute__((visibility("default"))) ::rust::isize coordinates_for_shifted_named_instance_index(::fontations_ffi::BridgeFontRef const &font_ref, ::std::uint32_t shifted_index, ::rust::Slice<::fontations_ffi::SkiaDesignCoordinate > coords) noexcept;

__attribute__((visibility("default"))) ::std::size_t num_axes(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) ::rust::isize populate_axes(::fontations_ffi::BridgeFontRef const &font_ref, ::fontations_ffi::AxisWrapper &axis_wrapper) noexcept;

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeLocalizedStrings> get_localized_strings(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) bool localized_name_next(::fontations_ffi::BridgeLocalizedStrings &bridge_localized_strings, ::fontations_ffi::BridgeLocalizedName &out_localized_name) noexcept;

__attribute__((visibility("default"))) ::rust::Box<::fontations_ffi::BridgeNormalizedCoords> resolve_into_normalized_coords(::fontations_ffi::BridgeFontRef const &font_ref, ::rust::Slice<::fontations_ffi::SkiaDesignCoordinate const> design_coords) noexcept;

__attribute__((visibility("default"))) bool normalized_coords_equal(::fontations_ffi::BridgeNormalizedCoords const &a, ::fontations_ffi::BridgeNormalizedCoords const &b) noexcept;

__attribute__((visibility("default"))) bool draw_colr_glyph(::fontations_ffi::BridgeFontRef const &font_ref, ::fontations_ffi::BridgeNormalizedCoords const &coords, ::std::uint16_t glyph_id, ::fontations_ffi::ColorPainterWrapper &color_painter) noexcept;

__attribute__((visibility("default"))) bool next_color_stop(::fontations_ffi::BridgeColorStops &color_stops, ::fontations_ffi::ColorStop &stop) noexcept;

__attribute__((visibility("default"))) ::std::size_t num_color_stops(::fontations_ffi::BridgeColorStops const &color_stops) noexcept;

__attribute__((visibility("default"))) bool get_font_style(::fontations_ffi::BridgeFontRef const &font_ref, ::fontations_ffi::BridgeNormalizedCoords const &coords, ::fontations_ffi::BridgeFontStyle &font_style) noexcept;

__attribute__((visibility("default"))) bool is_embeddable(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) bool is_subsettable(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) bool is_fixed_pitch(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) bool is_serif_style(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) bool is_script_style(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;

__attribute__((visibility("default"))) ::std::int32_t italic_angle(::fontations_ffi::BridgeFontRef const &font_ref) noexcept;
} // namespace fontations_ffi