occt-wasm 3.0.1

// AUTO-GENERATED by cargo xtask codegen -- DO NOT EDIT
// Rust host API for occt-wasm WASI module via wasmtime

use wasmtime::TypedFunc;

use crate::error::OcctResult;
use crate::types::{
    BoundingBox, EdgeData, EvolutionData, LabelInfo, Mesh, MeshBatch, NurbsCurveData,
    ProjectionData, ShapeHandle,
};

/// Cached WASM function handles for kernel methods.
///
/// Include this in the `OcctKernel` struct definition:
/// ```ignore
/// pub struct OcctKernel {
///     // ... core fields ...
///     #[doc(hidden)]
///     generated: GeneratedFuncs,
/// }
/// ```
#[allow(
    clippy::type_complexity,
    clippy::redundant_pub_crate,
    clippy::struct_field_names
)]
pub(crate) struct GeneratedFuncs {
    fn_make_box: TypedFunc<(f64, f64, f64), u32>,
    fn_make_box_from_corners: TypedFunc<(f64, f64, f64, f64, f64, f64), u32>,
    fn_make_cylinder: TypedFunc<(f64, f64), u32>,
    fn_make_sphere: TypedFunc<(f64,), u32>,
    fn_make_cone: TypedFunc<(f64, f64, f64), u32>,
    fn_make_torus: TypedFunc<(f64, f64), u32>,
    fn_make_ellipsoid: TypedFunc<(f64, f64, f64), u32>,
    fn_make_rectangle: TypedFunc<(f64, f64), u32>,
    fn_fuse: TypedFunc<(u32, u32), u32>,
    fn_cut: TypedFunc<(u32, u32), u32>,
    fn_common: TypedFunc<(u32, u32), u32>,
    fn_section: TypedFunc<(u32, u32), u32>,
    fn_intersect: TypedFunc<(u32, u32), u32>,
    fn_fuse_all: TypedFunc<(i32, i32), u32>,
    fn_cut_all: TypedFunc<(u32, i32, i32), u32>,
    fn_boolean_pipeline: TypedFunc<(u32, i32, i32, i32, i32), u32>,
    fn_split: TypedFunc<(u32, i32, i32), u32>,
    fn_extrude: TypedFunc<(u32, f64, f64, f64), u32>,
    fn_revolve: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_fillet: TypedFunc<(u32, i32, i32, f64), u32>,
    fn_chamfer: TypedFunc<(u32, i32, i32, f64), u32>,
    fn_chamfer_dist_angle: TypedFunc<(u32, i32, i32, f64, f64), u32>,
    fn_shell: TypedFunc<(u32, i32, i32, f64, f64), u32>,
    fn_offset: TypedFunc<(u32, f64, f64), u32>,
    fn_draft: TypedFunc<(u32, u32, f64, f64, f64, f64), u32>,
    fn_thicken: TypedFunc<(u32, f64, f64), u32>,
    fn_defeature: TypedFunc<(u32, i32, i32, f64), u32>,
    fn_reverse_shape: TypedFunc<(u32,), u32>,
    fn_simplify: TypedFunc<(u32,), u32>,
    fn_fillet_variable: TypedFunc<(u32, u32, f64, f64), u32>,
    fn_fillet_batch: TypedFunc<(i32, i32, i32, i32, i32, i32, i32, i32), i32>,
    fn_offset_wire2_d: TypedFunc<(u32, f64, i32), u32>,
    fn_translate: TypedFunc<(u32, f64, f64, f64), u32>,
    fn_rotate: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_scale: TypedFunc<(u32, f64, f64, f64, f64), u32>,
    fn_mirror: TypedFunc<(u32, f64, f64, f64, f64, f64, f64), u32>,
    fn_copy: TypedFunc<(u32,), u32>,
    fn_linear_pattern: TypedFunc<(u32, f64, f64, f64, f64, i32), u32>,
    fn_circular_pattern: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64, i32), u32>,
    fn_transform: TypedFunc<(u32, i32, i32), u32>,
    fn_general_transform: TypedFunc<(u32, i32, i32), u32>,
    fn_translate_batch: TypedFunc<(i32, i32, i32, i32), i32>,
    fn_compose_transform: TypedFunc<(i32, i32, i32, i32), i32>,
    fn_transform_batch: TypedFunc<(i32, i32, i32, i32), i32>,
    fn_rotate_batch: TypedFunc<(i32, i32, i32, i32), i32>,
    fn_scale_batch: TypedFunc<(i32, i32, i32, i32), i32>,
    fn_mirror_batch: TypedFunc<(i32, i32, i32, i32), i32>,
    fn_make_vertex: TypedFunc<(f64, f64, f64), u32>,
    fn_make_edge: TypedFunc<(u32, u32), u32>,
    fn_make_wire: TypedFunc<(i32, i32), u32>,
    fn_make_face: TypedFunc<(u32,), u32>,
    fn_make_face_on_surface: TypedFunc<(u32, u32), u32>,
    fn_make_solid: TypedFunc<(u32,), u32>,
    fn_sew: TypedFunc<(i32, i32, f64), u32>,
    fn_make_compound: TypedFunc<(i32, i32), u32>,
    fn_make_line_edge: TypedFunc<(f64, f64, f64, f64, f64, f64), u32>,
    fn_make_circle_edge: TypedFunc<(f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_make_circle_arc: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_make_arc_edge: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_make_ellipse_edge: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_make_bezier_edge: TypedFunc<(i32, i32), u32>,
    fn_make_ellipse_arc: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_make_helix_wire: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_make_non_planar_face: TypedFunc<(u32,), u32>,
    fn_add_holes_in_face: TypedFunc<(u32, i32, i32), u32>,
    fn_remove_holes_from_face: TypedFunc<(u32, i32, i32), u32>,
    fn_solid_from_shell: TypedFunc<(u32,), u32>,
    fn_build_solid_from_faces: TypedFunc<(i32, i32, f64), u32>,
    fn_sew_and_solidify: TypedFunc<(i32, i32, f64), u32>,
    fn_build_tri_face: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_make_tangent_arc: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_bspline_surface: TypedFunc<(i32, i32, i32, i32), u32>,
    fn_get_shape_type: TypedFunc<(u32,), i32>,
    fn_get_sub_shapes: TypedFunc<(u32, i32, i32), i32>,
    fn_distance_between: TypedFunc<(u32, u32), f64>,
    fn_is_same: TypedFunc<(u32, u32), i32>,
    fn_is_equal: TypedFunc<(u32, u32), i32>,
    fn_is_null: TypedFunc<(u32,), i32>,
    fn_hash_code: TypedFunc<(u32, i32), i32>,
    fn_shape_orientation: TypedFunc<(u32,), i32>,
    fn_iter_shapes: TypedFunc<(u32,), i32>,
    fn_edge_to_face_map: TypedFunc<(u32, i32), i32>,
    fn_downcast: TypedFunc<(u32, i32, i32), u32>,
    fn_adjacent_faces: TypedFunc<(u32, u32), i32>,
    fn_shared_edges: TypedFunc<(u32, u32), i32>,
    fn_get_bounding_box: TypedFunc<(u32, i32), i32>,
    fn_get_volume: TypedFunc<(u32,), f64>,
    fn_get_surface_area: TypedFunc<(u32,), f64>,
    fn_get_length: TypedFunc<(u32,), f64>,
    fn_get_center_of_mass: TypedFunc<(u32,), i32>,
    fn_get_surface_center_of_mass: TypedFunc<(u32,), i32>,
    fn_vertex_position: TypedFunc<(u32,), i32>,
    fn_surface_type: TypedFunc<(u32,), i32>,
    fn_surface_normal: TypedFunc<(u32, f64, f64), i32>,
    fn_point_on_surface: TypedFunc<(u32, f64, f64), i32>,
    fn_outer_wire: TypedFunc<(u32,), u32>,
    fn_get_linear_center_of_mass: TypedFunc<(u32,), i32>,
    fn_surface_curvature: TypedFunc<(u32, f64, f64), i32>,
    fn_uv_bounds: TypedFunc<(u32,), i32>,
    fn_get_face_cylinder_data: TypedFunc<(u32,), i32>,
    fn_uv_from_point: TypedFunc<(u32, f64, f64, f64), i32>,
    fn_project_point_on_face: TypedFunc<(u32, f64, f64, f64), i32>,
    fn_classify_point_on_face: TypedFunc<(u32, f64, f64), i32>,
    fn_curve_type: TypedFunc<(u32,), i32>,
    fn_curve_point_at_param: TypedFunc<(u32, f64), i32>,
    fn_curve_tangent: TypedFunc<(u32, f64), i32>,
    fn_curve_parameters: TypedFunc<(u32,), i32>,
    fn_curve_is_closed: TypedFunc<(u32,), i32>,
    fn_curve_length: TypedFunc<(u32,), f64>,
    fn_interpolate_points: TypedFunc<(i32, i32, i32), u32>,
    fn_curve_is_periodic: TypedFunc<(u32,), i32>,
    fn_approximate_points: TypedFunc<(i32, i32, f64), u32>,
    fn_lift_curve2d_to_plane:
        TypedFunc<(i32, i32, f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_get_nurbs_curve_data: TypedFunc<(u32,), i32>,
    fn_has_triangulation: TypedFunc<(u32,), i32>,
    fn_query_batch: TypedFunc<(i32, i32), i32>,
    fn_pipe: TypedFunc<(u32, u32), u32>,
    fn_simple_pipe: TypedFunc<(u32, u32), u32>,
    fn_revolve_vec: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64), u32>,
    fn_loft: TypedFunc<(i32, i32, i32, i32), u32>,
    fn_loft_with_vertices: TypedFunc<(i32, i32, i32, i32, u32, u32), u32>,
    fn_sweep: TypedFunc<(u32, u32, i32), u32>,
    fn_sweep_pipe_shell: TypedFunc<(u32, u32, i32, i32), u32>,
    fn_draft_prism: TypedFunc<(u32, f64, f64, f64, f64), u32>,
    fn_fix_shape: TypedFunc<(u32,), u32>,
    fn_unify_same_domain: TypedFunc<(u32,), u32>,
    fn_is_valid: TypedFunc<(u32,), i32>,
    fn_heal_solid: TypedFunc<(u32, f64), u32>,
    fn_heal_face: TypedFunc<(u32, f64), u32>,
    fn_heal_wire: TypedFunc<(u32, f64), u32>,
    fn_fix_face_orientations: TypedFunc<(u32,), u32>,
    fn_build_curves3d: TypedFunc<(u32,), i32>,
    fn_fix_wire_on_face: TypedFunc<(u32, u32, f64), u32>,
    fn_remove_degenerate_edges: TypedFunc<(u32,), u32>,
    fn_import_step: TypedFunc<(i32, i32), u32>,
    fn_export_step: TypedFunc<(u32,), i32>,
    fn_export_stl: TypedFunc<(u32, f64, i32), i32>,
    fn_import_stl: TypedFunc<(i32, i32), u32>,
    fn_to_brep: TypedFunc<(u32,), i32>,
    fn_from_brep: TypedFunc<(i32, i32), u32>,
    fn_translate_with_history: TypedFunc<(u32, f64, f64, f64, i32, i32, i32), i32>,
    fn_fuse_with_history: TypedFunc<(u32, u32, i32, i32, i32), i32>,
    fn_cut_with_history: TypedFunc<(u32, u32, i32, i32, i32), i32>,
    fn_fillet_with_history: TypedFunc<(u32, i32, i32, f64, i32, i32, i32), i32>,
    fn_rotate_with_history: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64, i32, i32, i32), i32>,
    fn_mirror_with_history: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, i32, i32, i32), i32>,
    fn_scale_with_history: TypedFunc<(u32, f64, f64, f64, f64, i32, i32, i32), i32>,
    fn_intersect_with_history: TypedFunc<(u32, u32, i32, i32, i32), i32>,
    fn_chamfer_with_history: TypedFunc<(u32, i32, i32, f64, i32, i32, i32), i32>,
    fn_shell_with_history: TypedFunc<(u32, i32, i32, f64, f64, i32, i32, i32), i32>,
    fn_offset_with_history: TypedFunc<(u32, f64, f64, i32, i32, i32), i32>,
    fn_thicken_with_history: TypedFunc<(u32, f64, f64, i32, i32, i32), i32>,
    fn_tessellate: TypedFunc<(u32, f64, f64), i32>,
    fn_mesh_shape: TypedFunc<(u32, f64, f64), i32>,
    fn_mesh_batch: TypedFunc<(i32, i32, f64, f64), i32>,
    fn_wireframe: TypedFunc<(u32, f64), i32>,
    fn_project_edges: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64, f64, f64, i32), i32>,
    fn_release: TypedFunc<(u32,), i32>,
    fn_release_all: TypedFunc<(), i32>,
    fn_get_shape_count: TypedFunc<(), u32>,
    fn_make_null_shape: TypedFunc<(), u32>,
    fn_xcaf_new_document: TypedFunc<(), u32>,
    fn_xcaf_close: TypedFunc<(u32,), i32>,
    fn_xcaf_add_shape: TypedFunc<(u32, u32), i32>,
    fn_xcaf_add_component: TypedFunc<(u32, i32, u32, f64, f64, f64, f64, f64, f64), i32>,
    fn_xcaf_set_color: TypedFunc<(u32, i32, f64, f64, f64), i32>,
    fn_xcaf_set_name: TypedFunc<(u32, i32, i32, i32), i32>,
    fn_xcaf_get_label_info: TypedFunc<(u32, i32), i32>,
    fn_xcaf_get_child_labels: TypedFunc<(u32, i32), i32>,
    fn_xcaf_get_root_labels: TypedFunc<(u32,), i32>,
    fn_xcaf_export_step: TypedFunc<(u32,), i32>,
    fn_xcaf_import_step: TypedFunc<(i32, i32), u32>,
    fn_xcaf_export_gltf: TypedFunc<(u32, f64, f64), i32>,
}

impl GeneratedFuncs {
    #[allow(clippy::too_many_lines)]
    pub(crate) fn resolve(
        instance: &wasmtime::Instance,
        mut store: &mut wasmtime::Store<()>,
    ) -> OcctResult<Self> {
        Ok(Self {
            fn_make_box: instance.get_typed_func(&mut store, "occt_make_box")?,
            fn_make_box_from_corners: instance
                .get_typed_func(&mut store, "occt_make_box_from_corners")?,
            fn_make_cylinder: instance.get_typed_func(&mut store, "occt_make_cylinder")?,
            fn_make_sphere: instance.get_typed_func(&mut store, "occt_make_sphere")?,
            fn_make_cone: instance.get_typed_func(&mut store, "occt_make_cone")?,
            fn_make_torus: instance.get_typed_func(&mut store, "occt_make_torus")?,
            fn_make_ellipsoid: instance.get_typed_func(&mut store, "occt_make_ellipsoid")?,
            fn_make_rectangle: instance.get_typed_func(&mut store, "occt_make_rectangle")?,
            fn_fuse: instance.get_typed_func(&mut store, "occt_fuse")?,
            fn_cut: instance.get_typed_func(&mut store, "occt_cut")?,
            fn_common: instance.get_typed_func(&mut store, "occt_common")?,
            fn_section: instance.get_typed_func(&mut store, "occt_section")?,
            fn_intersect: instance.get_typed_func(&mut store, "occt_intersect")?,
            fn_fuse_all: instance.get_typed_func(&mut store, "occt_fuse_all")?,
            fn_cut_all: instance.get_typed_func(&mut store, "occt_cut_all")?,
            fn_boolean_pipeline: instance.get_typed_func(&mut store, "occt_boolean_pipeline")?,
            fn_split: instance.get_typed_func(&mut store, "occt_split")?,
            fn_extrude: instance.get_typed_func(&mut store, "occt_extrude")?,
            fn_revolve: instance.get_typed_func(&mut store, "occt_revolve")?,
            fn_fillet: instance.get_typed_func(&mut store, "occt_fillet")?,
            fn_chamfer: instance.get_typed_func(&mut store, "occt_chamfer")?,
            fn_chamfer_dist_angle: instance
                .get_typed_func(&mut store, "occt_chamfer_dist_angle")?,
            fn_shell: instance.get_typed_func(&mut store, "occt_shell")?,
            fn_offset: instance.get_typed_func(&mut store, "occt_offset")?,
            fn_draft: instance.get_typed_func(&mut store, "occt_draft")?,
            fn_thicken: instance.get_typed_func(&mut store, "occt_thicken")?,
            fn_defeature: instance.get_typed_func(&mut store, "occt_defeature")?,
            fn_reverse_shape: instance.get_typed_func(&mut store, "occt_reverse_shape")?,
            fn_simplify: instance.get_typed_func(&mut store, "occt_simplify")?,
            fn_fillet_variable: instance.get_typed_func(&mut store, "occt_fillet_variable")?,
            fn_fillet_batch: instance.get_typed_func(&mut store, "occt_fillet_batch")?,
            fn_offset_wire2_d: instance.get_typed_func(&mut store, "occt_offset_wire2_d")?,
            fn_translate: instance.get_typed_func(&mut store, "occt_translate")?,
            fn_rotate: instance.get_typed_func(&mut store, "occt_rotate")?,
            fn_scale: instance.get_typed_func(&mut store, "occt_scale")?,
            fn_mirror: instance.get_typed_func(&mut store, "occt_mirror")?,
            fn_copy: instance.get_typed_func(&mut store, "occt_copy")?,
            fn_linear_pattern: instance.get_typed_func(&mut store, "occt_linear_pattern")?,
            fn_circular_pattern: instance.get_typed_func(&mut store, "occt_circular_pattern")?,
            fn_transform: instance.get_typed_func(&mut store, "occt_transform")?,
            fn_general_transform: instance.get_typed_func(&mut store, "occt_general_transform")?,
            fn_translate_batch: instance.get_typed_func(&mut store, "occt_translate_batch")?,
            fn_compose_transform: instance.get_typed_func(&mut store, "occt_compose_transform")?,
            fn_transform_batch: instance.get_typed_func(&mut store, "occt_transform_batch")?,
            fn_rotate_batch: instance.get_typed_func(&mut store, "occt_rotate_batch")?,
            fn_scale_batch: instance.get_typed_func(&mut store, "occt_scale_batch")?,
            fn_mirror_batch: instance.get_typed_func(&mut store, "occt_mirror_batch")?,
            fn_make_vertex: instance.get_typed_func(&mut store, "occt_make_vertex")?,
            fn_make_edge: instance.get_typed_func(&mut store, "occt_make_edge")?,
            fn_make_wire: instance.get_typed_func(&mut store, "occt_make_wire")?,
            fn_make_face: instance.get_typed_func(&mut store, "occt_make_face")?,
            fn_make_face_on_surface: instance
                .get_typed_func(&mut store, "occt_make_face_on_surface")?,
            fn_make_solid: instance.get_typed_func(&mut store, "occt_make_solid")?,
            fn_sew: instance.get_typed_func(&mut store, "occt_sew")?,
            fn_make_compound: instance.get_typed_func(&mut store, "occt_make_compound")?,
            fn_make_line_edge: instance.get_typed_func(&mut store, "occt_make_line_edge")?,
            fn_make_circle_edge: instance.get_typed_func(&mut store, "occt_make_circle_edge")?,
            fn_make_circle_arc: instance.get_typed_func(&mut store, "occt_make_circle_arc")?,
            fn_make_arc_edge: instance.get_typed_func(&mut store, "occt_make_arc_edge")?,
            fn_make_ellipse_edge: instance.get_typed_func(&mut store, "occt_make_ellipse_edge")?,
            fn_make_bezier_edge: instance.get_typed_func(&mut store, "occt_make_bezier_edge")?,
            fn_make_ellipse_arc: instance.get_typed_func(&mut store, "occt_make_ellipse_arc")?,
            fn_make_helix_wire: instance.get_typed_func(&mut store, "occt_make_helix_wire")?,
            fn_make_non_planar_face: instance
                .get_typed_func(&mut store, "occt_make_non_planar_face")?,
            fn_add_holes_in_face: instance.get_typed_func(&mut store, "occt_add_holes_in_face")?,
            fn_remove_holes_from_face: instance
                .get_typed_func(&mut store, "occt_remove_holes_from_face")?,
            fn_solid_from_shell: instance.get_typed_func(&mut store, "occt_solid_from_shell")?,
            fn_build_solid_from_faces: instance
                .get_typed_func(&mut store, "occt_build_solid_from_faces")?,
            fn_sew_and_solidify: instance.get_typed_func(&mut store, "occt_sew_and_solidify")?,
            fn_build_tri_face: instance.get_typed_func(&mut store, "occt_build_tri_face")?,
            fn_make_tangent_arc: instance.get_typed_func(&mut store, "occt_make_tangent_arc")?,
            fn_bspline_surface: instance.get_typed_func(&mut store, "occt_bspline_surface")?,
            fn_get_shape_type: instance.get_typed_func(&mut store, "occt_get_shape_type")?,
            fn_get_sub_shapes: instance.get_typed_func(&mut store, "occt_get_sub_shapes")?,
            fn_distance_between: instance.get_typed_func(&mut store, "occt_distance_between")?,
            fn_is_same: instance.get_typed_func(&mut store, "occt_is_same")?,
            fn_is_equal: instance.get_typed_func(&mut store, "occt_is_equal")?,
            fn_is_null: instance.get_typed_func(&mut store, "occt_is_null")?,
            fn_hash_code: instance.get_typed_func(&mut store, "occt_hash_code")?,
            fn_shape_orientation: instance.get_typed_func(&mut store, "occt_shape_orientation")?,
            fn_iter_shapes: instance.get_typed_func(&mut store, "occt_iter_shapes")?,
            fn_edge_to_face_map: instance.get_typed_func(&mut store, "occt_edge_to_face_map")?,
            fn_downcast: instance.get_typed_func(&mut store, "occt_downcast")?,
            fn_adjacent_faces: instance.get_typed_func(&mut store, "occt_adjacent_faces")?,
            fn_shared_edges: instance.get_typed_func(&mut store, "occt_shared_edges")?,
            fn_get_bounding_box: instance.get_typed_func(&mut store, "occt_get_bounding_box")?,
            fn_get_volume: instance.get_typed_func(&mut store, "occt_get_volume")?,
            fn_get_surface_area: instance.get_typed_func(&mut store, "occt_get_surface_area")?,
            fn_get_length: instance.get_typed_func(&mut store, "occt_get_length")?,
            fn_get_center_of_mass: instance
                .get_typed_func(&mut store, "occt_get_center_of_mass")?,
            fn_get_surface_center_of_mass: instance
                .get_typed_func(&mut store, "occt_get_surface_center_of_mass")?,
            fn_vertex_position: instance.get_typed_func(&mut store, "occt_vertex_position")?,
            fn_surface_type: instance.get_typed_func(&mut store, "occt_surface_type")?,
            fn_surface_normal: instance.get_typed_func(&mut store, "occt_surface_normal")?,
            fn_point_on_surface: instance.get_typed_func(&mut store, "occt_point_on_surface")?,
            fn_outer_wire: instance.get_typed_func(&mut store, "occt_outer_wire")?,
            fn_get_linear_center_of_mass: instance
                .get_typed_func(&mut store, "occt_get_linear_center_of_mass")?,
            fn_surface_curvature: instance.get_typed_func(&mut store, "occt_surface_curvature")?,
            fn_uv_bounds: instance.get_typed_func(&mut store, "occt_uv_bounds")?,
            fn_get_face_cylinder_data: instance
                .get_typed_func(&mut store, "occt_get_face_cylinder_data")?,
            fn_uv_from_point: instance.get_typed_func(&mut store, "occt_uv_from_point")?,
            fn_project_point_on_face: instance
                .get_typed_func(&mut store, "occt_project_point_on_face")?,
            fn_classify_point_on_face: instance
                .get_typed_func(&mut store, "occt_classify_point_on_face")?,
            fn_curve_type: instance.get_typed_func(&mut store, "occt_curve_type")?,
            fn_curve_point_at_param: instance
                .get_typed_func(&mut store, "occt_curve_point_at_param")?,
            fn_curve_tangent: instance.get_typed_func(&mut store, "occt_curve_tangent")?,
            fn_curve_parameters: instance.get_typed_func(&mut store, "occt_curve_parameters")?,
            fn_curve_is_closed: instance.get_typed_func(&mut store, "occt_curve_is_closed")?,
            fn_curve_length: instance.get_typed_func(&mut store, "occt_curve_length")?,
            fn_interpolate_points: instance
                .get_typed_func(&mut store, "occt_interpolate_points")?,
            fn_curve_is_periodic: instance.get_typed_func(&mut store, "occt_curve_is_periodic")?,
            fn_approximate_points: instance
                .get_typed_func(&mut store, "occt_approximate_points")?,
            fn_lift_curve2d_to_plane: instance
                .get_typed_func(&mut store, "occt_lift_curve2d_to_plane")?,
            fn_get_nurbs_curve_data: instance
                .get_typed_func(&mut store, "occt_get_nurbs_curve_data")?,
            fn_has_triangulation: instance.get_typed_func(&mut store, "occt_has_triangulation")?,
            fn_query_batch: instance.get_typed_func(&mut store, "occt_query_batch")?,
            fn_pipe: instance.get_typed_func(&mut store, "occt_pipe")?,
            fn_simple_pipe: instance.get_typed_func(&mut store, "occt_simple_pipe")?,
            fn_revolve_vec: instance.get_typed_func(&mut store, "occt_revolve_vec")?,
            fn_loft: instance.get_typed_func(&mut store, "occt_loft")?,
            fn_loft_with_vertices: instance
                .get_typed_func(&mut store, "occt_loft_with_vertices")?,
            fn_sweep: instance.get_typed_func(&mut store, "occt_sweep")?,
            fn_sweep_pipe_shell: instance.get_typed_func(&mut store, "occt_sweep_pipe_shell")?,
            fn_draft_prism: instance.get_typed_func(&mut store, "occt_draft_prism")?,
            fn_fix_shape: instance.get_typed_func(&mut store, "occt_fix_shape")?,
            fn_unify_same_domain: instance.get_typed_func(&mut store, "occt_unify_same_domain")?,
            fn_is_valid: instance.get_typed_func(&mut store, "occt_is_valid")?,
            fn_heal_solid: instance.get_typed_func(&mut store, "occt_heal_solid")?,
            fn_heal_face: instance.get_typed_func(&mut store, "occt_heal_face")?,
            fn_heal_wire: instance.get_typed_func(&mut store, "occt_heal_wire")?,
            fn_fix_face_orientations: instance
                .get_typed_func(&mut store, "occt_fix_face_orientations")?,
            fn_build_curves3d: instance.get_typed_func(&mut store, "occt_build_curves3d")?,
            fn_fix_wire_on_face: instance.get_typed_func(&mut store, "occt_fix_wire_on_face")?,
            fn_remove_degenerate_edges: instance
                .get_typed_func(&mut store, "occt_remove_degenerate_edges")?,
            fn_import_step: instance.get_typed_func(&mut store, "occt_import_step")?,
            fn_export_step: instance.get_typed_func(&mut store, "occt_export_step")?,
            fn_export_stl: instance.get_typed_func(&mut store, "occt_export_stl")?,
            fn_import_stl: instance.get_typed_func(&mut store, "occt_import_stl")?,
            fn_to_brep: instance.get_typed_func(&mut store, "occt_to_brep")?,
            fn_from_brep: instance.get_typed_func(&mut store, "occt_from_brep")?,
            fn_translate_with_history: instance
                .get_typed_func(&mut store, "occt_translate_with_history")?,
            fn_fuse_with_history: instance.get_typed_func(&mut store, "occt_fuse_with_history")?,
            fn_cut_with_history: instance.get_typed_func(&mut store, "occt_cut_with_history")?,
            fn_fillet_with_history: instance
                .get_typed_func(&mut store, "occt_fillet_with_history")?,
            fn_rotate_with_history: instance
                .get_typed_func(&mut store, "occt_rotate_with_history")?,
            fn_mirror_with_history: instance
                .get_typed_func(&mut store, "occt_mirror_with_history")?,
            fn_scale_with_history: instance
                .get_typed_func(&mut store, "occt_scale_with_history")?,
            fn_intersect_with_history: instance
                .get_typed_func(&mut store, "occt_intersect_with_history")?,
            fn_chamfer_with_history: instance
                .get_typed_func(&mut store, "occt_chamfer_with_history")?,
            fn_shell_with_history: instance
                .get_typed_func(&mut store, "occt_shell_with_history")?,
            fn_offset_with_history: instance
                .get_typed_func(&mut store, "occt_offset_with_history")?,
            fn_thicken_with_history: instance
                .get_typed_func(&mut store, "occt_thicken_with_history")?,
            fn_tessellate: instance.get_typed_func(&mut store, "occt_tessellate")?,
            fn_mesh_shape: instance.get_typed_func(&mut store, "occt_mesh_shape")?,
            fn_mesh_batch: instance.get_typed_func(&mut store, "occt_mesh_batch")?,
            fn_wireframe: instance.get_typed_func(&mut store, "occt_wireframe")?,
            fn_project_edges: instance.get_typed_func(&mut store, "occt_project_edges")?,
            fn_release: instance.get_typed_func(&mut store, "occt_release")?,
            fn_release_all: instance.get_typed_func(&mut store, "occt_release_all")?,
            fn_get_shape_count: instance.get_typed_func(&mut store, "occt_get_shape_count")?,
            fn_make_null_shape: instance.get_typed_func(&mut store, "occt_make_null_shape")?,
            fn_xcaf_new_document: instance.get_typed_func(&mut store, "occt_xcaf_new_document")?,
            fn_xcaf_close: instance.get_typed_func(&mut store, "occt_xcaf_close")?,
            fn_xcaf_add_shape: instance.get_typed_func(&mut store, "occt_xcaf_add_shape")?,
            fn_xcaf_add_component: instance
                .get_typed_func(&mut store, "occt_xcaf_add_component")?,
            fn_xcaf_set_color: instance.get_typed_func(&mut store, "occt_xcaf_set_color")?,
            fn_xcaf_set_name: instance.get_typed_func(&mut store, "occt_xcaf_set_name")?,
            fn_xcaf_get_label_info: instance
                .get_typed_func(&mut store, "occt_xcaf_get_label_info")?,
            fn_xcaf_get_child_labels: instance
                .get_typed_func(&mut store, "occt_xcaf_get_child_labels")?,
            fn_xcaf_get_root_labels: instance
                .get_typed_func(&mut store, "occt_xcaf_get_root_labels")?,
            fn_xcaf_export_step: instance.get_typed_func(&mut store, "occt_xcaf_export_step")?,
            fn_xcaf_import_step: instance.get_typed_func(&mut store, "occt_xcaf_import_step")?,
            fn_xcaf_export_gltf: instance.get_typed_func(&mut store, "occt_xcaf_export_gltf")?,
        })
    }
}

/// Generated kernel methods.
///
/// All facade methods wrapped as safe Rust functions.
#[allow(missing_docs, clippy::too_many_arguments)]
impl crate::kernel::OcctKernel {
    pub fn make_box(&mut self, dx: f64, dy: f64, dz: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_box
            .call(&mut self.store, (dx, dy, dz))?;
        self.check_error("make_box")?;
        if result == 0 {
            return Err(self.read_last_error("make_box"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_box_from_corners(
        &mut self,
        x1: f64,
        y1: f64,
        z1: f64,
        x2: f64,
        y2: f64,
        z2: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_box_from_corners
            .call(&mut self.store, (x1, y1, z1, x2, y2, z2))?;
        self.check_error("make_box_from_corners")?;
        if result == 0 {
            return Err(self.read_last_error("make_box_from_corners"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_cylinder(&mut self, radius: f64, height: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_cylinder
            .call(&mut self.store, (radius, height))?;
        self.check_error("make_cylinder")?;
        if result == 0 {
            return Err(self.read_last_error("make_cylinder"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_sphere(&mut self, radius: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_sphere
            .call(&mut self.store, (radius,))?;
        self.check_error("make_sphere")?;
        if result == 0 {
            return Err(self.read_last_error("make_sphere"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_cone(&mut self, r1: f64, r2: f64, height: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_cone
            .call(&mut self.store, (r1, r2, height))?;
        self.check_error("make_cone")?;
        if result == 0 {
            return Err(self.read_last_error("make_cone"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_torus(&mut self, major_radius: f64, minor_radius: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_torus
            .call(&mut self.store, (major_radius, minor_radius))?;
        self.check_error("make_torus")?;
        if result == 0 {
            return Err(self.read_last_error("make_torus"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_ellipsoid(&mut self, rx: f64, ry: f64, rz: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_ellipsoid
            .call(&mut self.store, (rx, ry, rz))?;
        self.check_error("make_ellipsoid")?;
        if result == 0 {
            return Err(self.read_last_error("make_ellipsoid"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_rectangle(&mut self, width: f64, height: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_rectangle
            .call(&mut self.store, (width, height))?;
        self.check_error("make_rectangle")?;
        if result == 0 {
            return Err(self.read_last_error("make_rectangle"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn fuse(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_fuse.call(&mut self.store, (a.0, b.0))?;
        self.check_error("fuse")?;
        if result == 0 {
            return Err(self.read_last_error("fuse"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn cut(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_cut.call(&mut self.store, (a.0, b.0))?;
        self.check_error("cut")?;
        if result == 0 {
            return Err(self.read_last_error("cut"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn common(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_common.call(&mut self.store, (a.0, b.0))?;
        self.check_error("common")?;
        if result == 0 {
            return Err(self.read_last_error("common"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn section(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_section
            .call(&mut self.store, (a.0, b.0))?;
        self.check_error("section")?;
        if result == 0 {
            return Err(self.read_last_error("section"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn intersect(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_intersect
            .call(&mut self.store, (a.0, b.0))?;
        self.check_error("intersect")?;
        if result == 0 {
            return Err(self.read_last_error("intersect"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn fuse_all(&mut self, shape_ids: &[ShapeHandle]) -> OcctResult<ShapeHandle> {
        let shape_ids_bytes: Vec<u8> = shape_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let shape_ids_ptr = self.write_bytes(&shape_ids_bytes)?;
        let shape_ids_len = shape_ids.len() as u32;
        let result = self.generated.fn_fuse_all.call(
            &mut self.store,
            (shape_ids_ptr as i32, shape_ids_len as i32),
        );
        self.free_bytes(shape_ids_ptr)?;
        let result = result?;
        self.check_error("fuse_all")?;
        if result == 0 {
            return Err(self.read_last_error("fuse_all"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn cut_all(
        &mut self,
        shape_id: ShapeHandle,
        tool_ids: &[ShapeHandle],
    ) -> OcctResult<ShapeHandle> {
        let tool_ids_bytes: Vec<u8> = tool_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let tool_ids_ptr = self.write_bytes(&tool_ids_bytes)?;
        let tool_ids_len = tool_ids.len() as u32;
        let result = self.generated.fn_cut_all.call(
            &mut self.store,
            (shape_id.0, tool_ids_ptr as i32, tool_ids_len as i32),
        );
        self.free_bytes(tool_ids_ptr)?;
        let result = result?;
        self.check_error("cut_all")?;
        if result == 0 {
            return Err(self.read_last_error("cut_all"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn boolean_pipeline(
        &mut self,
        base_id: ShapeHandle,
        op_codes: &[i32],
        tool_ids: &[ShapeHandle],
    ) -> OcctResult<ShapeHandle> {
        let op_codes_bytes: Vec<u8> = op_codes.iter().flat_map(|v| v.to_le_bytes()).collect();
        let op_codes_ptr = self.write_bytes(&op_codes_bytes)?;
        let op_codes_len = op_codes.len() as u32;
        let tool_ids_bytes: Vec<u8> = tool_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let tool_ids_ptr = match self.write_bytes(&tool_ids_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(op_codes_ptr);
                return Err(e);
            }
        };
        let tool_ids_len = tool_ids.len() as u32;
        let result = self.generated.fn_boolean_pipeline.call(
            &mut self.store,
            (
                base_id.0,
                op_codes_ptr as i32,
                op_codes_len as i32,
                tool_ids_ptr as i32,
                tool_ids_len as i32,
            ),
        );
        self.free_bytes(op_codes_ptr)?;
        self.free_bytes(tool_ids_ptr)?;
        let result = result?;
        self.check_error("boolean_pipeline")?;
        if result == 0 {
            return Err(self.read_last_error("boolean_pipeline"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn split(
        &mut self,
        shape_id: ShapeHandle,
        tool_ids: &[ShapeHandle],
    ) -> OcctResult<ShapeHandle> {
        let tool_ids_bytes: Vec<u8> = tool_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let tool_ids_ptr = self.write_bytes(&tool_ids_bytes)?;
        let tool_ids_len = tool_ids.len() as u32;
        let result = self.generated.fn_split.call(
            &mut self.store,
            (shape_id.0, tool_ids_ptr as i32, tool_ids_len as i32),
        );
        self.free_bytes(tool_ids_ptr)?;
        let result = result?;
        self.check_error("split")?;
        if result == 0 {
            return Err(self.read_last_error("split"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn extrude(
        &mut self,
        shape_id: ShapeHandle,
        dx: f64,
        dy: f64,
        dz: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_extrude
            .call(&mut self.store, (shape_id.0, dx, dy, dz))?;
        self.check_error("extrude")?;
        if result == 0 {
            return Err(self.read_last_error("extrude"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn revolve(
        &mut self,
        shape_id: ShapeHandle,
        px: f64,
        py: f64,
        pz: f64,
        dx: f64,
        dy: f64,
        dz: f64,
        angle_rad: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_revolve.call(
            &mut self.store,
            (shape_id.0, px, py, pz, dx, dy, dz, angle_rad),
        )?;
        self.check_error("revolve")?;
        if result == 0 {
            return Err(self.read_last_error("revolve"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn fillet(
        &mut self,
        solid_id: ShapeHandle,
        edge_ids: &[ShapeHandle],
        radius: f64,
    ) -> OcctResult<ShapeHandle> {
        let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
        let edge_ids_len = edge_ids.len() as u32;
        let result = self.generated.fn_fillet.call(
            &mut self.store,
            (solid_id.0, edge_ids_ptr as i32, edge_ids_len as i32, radius),
        );
        self.free_bytes(edge_ids_ptr)?;
        let result = result?;
        self.check_error("fillet")?;
        if result == 0 {
            return Err(self.read_last_error("fillet"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn chamfer(
        &mut self,
        solid_id: ShapeHandle,
        edge_ids: &[ShapeHandle],
        distance: f64,
    ) -> OcctResult<ShapeHandle> {
        let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
        let edge_ids_len = edge_ids.len() as u32;
        let result = self.generated.fn_chamfer.call(
            &mut self.store,
            (
                solid_id.0,
                edge_ids_ptr as i32,
                edge_ids_len as i32,
                distance,
            ),
        );
        self.free_bytes(edge_ids_ptr)?;
        let result = result?;
        self.check_error("chamfer")?;
        if result == 0 {
            return Err(self.read_last_error("chamfer"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn chamfer_dist_angle(
        &mut self,
        solid_id: ShapeHandle,
        edge_ids: &[ShapeHandle],
        distance: f64,
        angle_deg: f64,
    ) -> OcctResult<ShapeHandle> {
        let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
        let edge_ids_len = edge_ids.len() as u32;
        let result = self.generated.fn_chamfer_dist_angle.call(
            &mut self.store,
            (
                solid_id.0,
                edge_ids_ptr as i32,
                edge_ids_len as i32,
                distance,
                angle_deg,
            ),
        );
        self.free_bytes(edge_ids_ptr)?;
        let result = result?;
        self.check_error("chamfer_dist_angle")?;
        if result == 0 {
            return Err(self.read_last_error("chamfer_dist_angle"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn shell(
        &mut self,
        solid_id: ShapeHandle,
        face_ids: &[ShapeHandle],
        thickness: f64,
        tolerance: f64,
    ) -> OcctResult<ShapeHandle> {
        let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
        let face_ids_len = face_ids.len() as u32;
        let result = self.generated.fn_shell.call(
            &mut self.store,
            (
                solid_id.0,
                face_ids_ptr as i32,
                face_ids_len as i32,
                thickness,
                tolerance,
            ),
        );
        self.free_bytes(face_ids_ptr)?;
        let result = result?;
        self.check_error("shell")?;
        if result == 0 {
            return Err(self.read_last_error("shell"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn offset(
        &mut self,
        solid_id: ShapeHandle,
        distance: f64,
        tolerance: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_offset
            .call(&mut self.store, (solid_id.0, distance, tolerance))?;
        self.check_error("offset")?;
        if result == 0 {
            return Err(self.read_last_error("offset"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn draft(
        &mut self,
        shape_id: ShapeHandle,
        face_id: ShapeHandle,
        angle_rad: f64,
        dx: f64,
        dy: f64,
        dz: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_draft.call(
            &mut self.store,
            (shape_id.0, face_id.0, angle_rad, dx, dy, dz),
        )?;
        self.check_error("draft")?;
        if result == 0 {
            return Err(self.read_last_error("draft"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn thicken(
        &mut self,
        shape_id: ShapeHandle,
        thickness: f64,
        tolerance: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_thicken
            .call(&mut self.store, (shape_id.0, thickness, tolerance))?;
        self.check_error("thicken")?;
        if result == 0 {
            return Err(self.read_last_error("thicken"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn defeature(
        &mut self,
        shape_id: ShapeHandle,
        face_ids: &[ShapeHandle],
        tolerance: f64,
    ) -> OcctResult<ShapeHandle> {
        let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
        let face_ids_len = face_ids.len() as u32;
        let result = self.generated.fn_defeature.call(
            &mut self.store,
            (
                shape_id.0,
                face_ids_ptr as i32,
                face_ids_len as i32,
                tolerance,
            ),
        );
        self.free_bytes(face_ids_ptr)?;
        let result = result?;
        self.check_error("defeature")?;
        if result == 0 {
            return Err(self.read_last_error("defeature"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn reverse_shape(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_reverse_shape
            .call(&mut self.store, (id.0,))?;
        self.check_error("reverse_shape")?;
        if result == 0 {
            return Err(self.read_last_error("reverse_shape"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn simplify(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_simplify.call(&mut self.store, (id.0,))?;
        self.check_error("simplify")?;
        if result == 0 {
            return Err(self.read_last_error("simplify"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn fillet_variable(
        &mut self,
        solid_id: ShapeHandle,
        edge_id: ShapeHandle,
        start_radius: f64,
        end_radius: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_fillet_variable.call(
            &mut self.store,
            (solid_id.0, edge_id.0, start_radius, end_radius),
        )?;
        self.check_error("fillet_variable")?;
        if result == 0 {
            return Err(self.read_last_error("fillet_variable"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn fillet_batch(
        &mut self,
        solid_ids: &[ShapeHandle],
        edge_counts: &[i32],
        flat_edge_ids: &[ShapeHandle],
        radii: &[f64],
    ) -> OcctResult<Vec<u32>> {
        let solid_ids_bytes: Vec<u8> = solid_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let solid_ids_ptr = self.write_bytes(&solid_ids_bytes)?;
        let solid_ids_len = solid_ids.len() as u32;
        let edge_counts_bytes: Vec<u8> = edge_counts.iter().flat_map(|v| v.to_le_bytes()).collect();
        let edge_counts_ptr = match self.write_bytes(&edge_counts_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(solid_ids_ptr);
                return Err(e);
            }
        };
        let edge_counts_len = edge_counts.len() as u32;
        let flat_edge_ids_bytes: Vec<u8> = flat_edge_ids
            .iter()
            .flat_map(|h| h.0.to_le_bytes())
            .collect();
        let flat_edge_ids_ptr = match self.write_bytes(&flat_edge_ids_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(solid_ids_ptr);
                let _ = self.free_bytes(edge_counts_ptr);
                return Err(e);
            }
        };
        let flat_edge_ids_len = flat_edge_ids.len() as u32;
        let radii_bytes: Vec<u8> = radii.iter().flat_map(|v| v.to_le_bytes()).collect();
        let radii_ptr = match self.write_bytes(&radii_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(solid_ids_ptr);
                let _ = self.free_bytes(edge_counts_ptr);
                let _ = self.free_bytes(flat_edge_ids_ptr);
                return Err(e);
            }
        };
        let radii_len = radii.len() as u32;
        let len = self.generated.fn_fillet_batch.call(
            &mut self.store,
            (
                solid_ids_ptr as i32,
                solid_ids_len as i32,
                edge_counts_ptr as i32,
                edge_counts_len as i32,
                flat_edge_ids_ptr as i32,
                flat_edge_ids_len as i32,
                radii_ptr as i32,
                radii_len as i32,
            ),
        );
        self.free_bytes(solid_ids_ptr)?;
        self.free_bytes(edge_counts_ptr)?;
        self.free_bytes(flat_edge_ids_ptr)?;
        self.free_bytes(radii_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("fillet_batch"));
        }
        self.read_vec_u32_result()
    }

    pub fn offset_wire2_d(
        &mut self,
        wire_id: ShapeHandle,
        offset: f64,
        join_type: i32,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_offset_wire2_d
            .call(&mut self.store, (wire_id.0, offset, join_type))?;
        self.check_error("offset_wire2_d")?;
        if result == 0 {
            return Err(self.read_last_error("offset_wire2_d"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn translate(
        &mut self,
        id: ShapeHandle,
        dx: f64,
        dy: f64,
        dz: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_translate
            .call(&mut self.store, (id.0, dx, dy, dz))?;
        self.check_error("translate")?;
        if result == 0 {
            return Err(self.read_last_error("translate"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn rotate(
        &mut self,
        id: ShapeHandle,
        px: f64,
        py: f64,
        pz: f64,
        dx: f64,
        dy: f64,
        dz: f64,
        angle_rad: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_rotate
            .call(&mut self.store, (id.0, px, py, pz, dx, dy, dz, angle_rad))?;
        self.check_error("rotate")?;
        if result == 0 {
            return Err(self.read_last_error("rotate"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn scale(
        &mut self,
        id: ShapeHandle,
        px: f64,
        py: f64,
        pz: f64,
        factor: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_scale
            .call(&mut self.store, (id.0, px, py, pz, factor))?;
        self.check_error("scale")?;
        if result == 0 {
            return Err(self.read_last_error("scale"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn mirror(
        &mut self,
        id: ShapeHandle,
        px: f64,
        py: f64,
        pz: f64,
        nx: f64,
        ny: f64,
        nz: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_mirror
            .call(&mut self.store, (id.0, px, py, pz, nx, ny, nz))?;
        self.check_error("mirror")?;
        if result == 0 {
            return Err(self.read_last_error("mirror"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn copy(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_copy.call(&mut self.store, (id.0,))?;
        self.check_error("copy")?;
        if result == 0 {
            return Err(self.read_last_error("copy"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn linear_pattern(
        &mut self,
        id: ShapeHandle,
        dx: f64,
        dy: f64,
        dz: f64,
        spacing: f64,
        count: i32,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_linear_pattern
            .call(&mut self.store, (id.0, dx, dy, dz, spacing, count))?;
        self.check_error("linear_pattern")?;
        if result == 0 {
            return Err(self.read_last_error("linear_pattern"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn circular_pattern(
        &mut self,
        id: ShapeHandle,
        cx: f64,
        cy: f64,
        cz: f64,
        ax: f64,
        ay: f64,
        az: f64,
        angle: f64,
        count: i32,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_circular_pattern.call(
            &mut self.store,
            (id.0, cx, cy, cz, ax, ay, az, angle, count),
        )?;
        self.check_error("circular_pattern")?;
        if result == 0 {
            return Err(self.read_last_error("circular_pattern"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn transform(&mut self, id: ShapeHandle, matrix: &[f64]) -> OcctResult<ShapeHandle> {
        let matrix_bytes: Vec<u8> = matrix.iter().flat_map(|v| v.to_le_bytes()).collect();
        let matrix_ptr = self.write_bytes(&matrix_bytes)?;
        let matrix_len = matrix.len() as u32;
        let result = self.generated.fn_transform.call(
            &mut self.store,
            (id.0, matrix_ptr as i32, matrix_len as i32),
        );
        self.free_bytes(matrix_ptr)?;
        let result = result?;
        self.check_error("transform")?;
        if result == 0 {
            return Err(self.read_last_error("transform"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn general_transform(
        &mut self,
        id: ShapeHandle,
        matrix: &[f64],
    ) -> OcctResult<ShapeHandle> {
        let matrix_bytes: Vec<u8> = matrix.iter().flat_map(|v| v.to_le_bytes()).collect();
        let matrix_ptr = self.write_bytes(&matrix_bytes)?;
        let matrix_len = matrix.len() as u32;
        let result = self.generated.fn_general_transform.call(
            &mut self.store,
            (id.0, matrix_ptr as i32, matrix_len as i32),
        );
        self.free_bytes(matrix_ptr)?;
        let result = result?;
        self.check_error("general_transform")?;
        if result == 0 {
            return Err(self.read_last_error("general_transform"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn translate_batch(
        &mut self,
        ids: &[ShapeHandle],
        offsets: &[f64],
    ) -> OcctResult<Vec<u32>> {
        let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let ids_ptr = self.write_bytes(&ids_bytes)?;
        let ids_len = ids.len() as u32;
        let offsets_bytes: Vec<u8> = offsets.iter().flat_map(|v| v.to_le_bytes()).collect();
        let offsets_ptr = match self.write_bytes(&offsets_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(ids_ptr);
                return Err(e);
            }
        };
        let offsets_len = offsets.len() as u32;
        let len = self.generated.fn_translate_batch.call(
            &mut self.store,
            (
                ids_ptr as i32,
                ids_len as i32,
                offsets_ptr as i32,
                offsets_len as i32,
            ),
        );
        self.free_bytes(ids_ptr)?;
        self.free_bytes(offsets_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("translate_batch"));
        }
        self.read_vec_u32_result()
    }

    pub fn compose_transform(&mut self, m1: &[f64], m2: &[f64]) -> OcctResult<Vec<f64>> {
        let m1_bytes: Vec<u8> = m1.iter().flat_map(|v| v.to_le_bytes()).collect();
        let m1_ptr = self.write_bytes(&m1_bytes)?;
        let m1_len = m1.len() as u32;
        let m2_bytes: Vec<u8> = m2.iter().flat_map(|v| v.to_le_bytes()).collect();
        let m2_ptr = match self.write_bytes(&m2_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(m1_ptr);
                return Err(e);
            }
        };
        let m2_len = m2.len() as u32;
        let len = self.generated.fn_compose_transform.call(
            &mut self.store,
            (m1_ptr as i32, m1_len as i32, m2_ptr as i32, m2_len as i32),
        );
        self.free_bytes(m1_ptr)?;
        self.free_bytes(m2_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("compose_transform"));
        }
        self.read_vec_f64_result()
    }

    pub fn transform_batch(
        &mut self,
        ids: &[ShapeHandle],
        matrices: &[f64],
    ) -> OcctResult<Vec<u32>> {
        let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let ids_ptr = self.write_bytes(&ids_bytes)?;
        let ids_len = ids.len() as u32;
        let matrices_bytes: Vec<u8> = matrices.iter().flat_map(|v| v.to_le_bytes()).collect();
        let matrices_ptr = match self.write_bytes(&matrices_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(ids_ptr);
                return Err(e);
            }
        };
        let matrices_len = matrices.len() as u32;
        let len = self.generated.fn_transform_batch.call(
            &mut self.store,
            (
                ids_ptr as i32,
                ids_len as i32,
                matrices_ptr as i32,
                matrices_len as i32,
            ),
        );
        self.free_bytes(ids_ptr)?;
        self.free_bytes(matrices_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("transform_batch"));
        }
        self.read_vec_u32_result()
    }

    pub fn rotate_batch(&mut self, ids: &[ShapeHandle], params: &[f64]) -> OcctResult<Vec<u32>> {
        let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let ids_ptr = self.write_bytes(&ids_bytes)?;
        let ids_len = ids.len() as u32;
        let params_bytes: Vec<u8> = params.iter().flat_map(|v| v.to_le_bytes()).collect();
        let params_ptr = match self.write_bytes(&params_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(ids_ptr);
                return Err(e);
            }
        };
        let params_len = params.len() as u32;
        let len = self.generated.fn_rotate_batch.call(
            &mut self.store,
            (
                ids_ptr as i32,
                ids_len as i32,
                params_ptr as i32,
                params_len as i32,
            ),
        );
        self.free_bytes(ids_ptr)?;
        self.free_bytes(params_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("rotate_batch"));
        }
        self.read_vec_u32_result()
    }

    pub fn scale_batch(&mut self, ids: &[ShapeHandle], params: &[f64]) -> OcctResult<Vec<u32>> {
        let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let ids_ptr = self.write_bytes(&ids_bytes)?;
        let ids_len = ids.len() as u32;
        let params_bytes: Vec<u8> = params.iter().flat_map(|v| v.to_le_bytes()).collect();
        let params_ptr = match self.write_bytes(&params_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(ids_ptr);
                return Err(e);
            }
        };
        let params_len = params.len() as u32;
        let len = self.generated.fn_scale_batch.call(
            &mut self.store,
            (
                ids_ptr as i32,
                ids_len as i32,
                params_ptr as i32,
                params_len as i32,
            ),
        );
        self.free_bytes(ids_ptr)?;
        self.free_bytes(params_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("scale_batch"));
        }
        self.read_vec_u32_result()
    }

    pub fn mirror_batch(&mut self, ids: &[ShapeHandle], params: &[f64]) -> OcctResult<Vec<u32>> {
        let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let ids_ptr = self.write_bytes(&ids_bytes)?;
        let ids_len = ids.len() as u32;
        let params_bytes: Vec<u8> = params.iter().flat_map(|v| v.to_le_bytes()).collect();
        let params_ptr = match self.write_bytes(&params_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(ids_ptr);
                return Err(e);
            }
        };
        let params_len = params.len() as u32;
        let len = self.generated.fn_mirror_batch.call(
            &mut self.store,
            (
                ids_ptr as i32,
                ids_len as i32,
                params_ptr as i32,
                params_len as i32,
            ),
        );
        self.free_bytes(ids_ptr)?;
        self.free_bytes(params_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("mirror_batch"));
        }
        self.read_vec_u32_result()
    }

    pub fn make_vertex(&mut self, x: f64, y: f64, z: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_vertex
            .call(&mut self.store, (x, y, z))?;
        self.check_error("make_vertex")?;
        if result == 0 {
            return Err(self.read_last_error("make_vertex"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_edge(&mut self, v1: ShapeHandle, v2: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_edge
            .call(&mut self.store, (v1.0, v2.0))?;
        self.check_error("make_edge")?;
        if result == 0 {
            return Err(self.read_last_error("make_edge"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_wire(&mut self, edge_ids: &[ShapeHandle]) -> OcctResult<ShapeHandle> {
        let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
        let edge_ids_len = edge_ids.len() as u32;
        let result = self
            .generated
            .fn_make_wire
            .call(&mut self.store, (edge_ids_ptr as i32, edge_ids_len as i32));
        self.free_bytes(edge_ids_ptr)?;
        let result = result?;
        self.check_error("make_wire")?;
        if result == 0 {
            return Err(self.read_last_error("make_wire"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_face(&mut self, wire_id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_face
            .call(&mut self.store, (wire_id.0,))?;
        self.check_error("make_face")?;
        if result == 0 {
            return Err(self.read_last_error("make_face"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_face_on_surface(
        &mut self,
        face_id: ShapeHandle,
        wire_id: ShapeHandle,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_face_on_surface
            .call(&mut self.store, (face_id.0, wire_id.0))?;
        self.check_error("make_face_on_surface")?;
        if result == 0 {
            return Err(self.read_last_error("make_face_on_surface"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_solid(&mut self, shell_id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_solid
            .call(&mut self.store, (shell_id.0,))?;
        self.check_error("make_solid")?;
        if result == 0 {
            return Err(self.read_last_error("make_solid"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn sew(&mut self, shape_ids: &[ShapeHandle], tolerance: f64) -> OcctResult<ShapeHandle> {
        let shape_ids_bytes: Vec<u8> = shape_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let shape_ids_ptr = self.write_bytes(&shape_ids_bytes)?;
        let shape_ids_len = shape_ids.len() as u32;
        let result = self.generated.fn_sew.call(
            &mut self.store,
            (shape_ids_ptr as i32, shape_ids_len as i32, tolerance),
        );
        self.free_bytes(shape_ids_ptr)?;
        let result = result?;
        self.check_error("sew")?;
        if result == 0 {
            return Err(self.read_last_error("sew"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_compound(&mut self, shape_ids: &[ShapeHandle]) -> OcctResult<ShapeHandle> {
        let shape_ids_bytes: Vec<u8> = shape_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let shape_ids_ptr = self.write_bytes(&shape_ids_bytes)?;
        let shape_ids_len = shape_ids.len() as u32;
        let result = self.generated.fn_make_compound.call(
            &mut self.store,
            (shape_ids_ptr as i32, shape_ids_len as i32),
        );
        self.free_bytes(shape_ids_ptr)?;
        let result = result?;
        self.check_error("make_compound")?;
        if result == 0 {
            return Err(self.read_last_error("make_compound"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_line_edge(
        &mut self,
        x1: f64,
        y1: f64,
        z1: f64,
        x2: f64,
        y2: f64,
        z2: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_line_edge
            .call(&mut self.store, (x1, y1, z1, x2, y2, z2))?;
        self.check_error("make_line_edge")?;
        if result == 0 {
            return Err(self.read_last_error("make_line_edge"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_circle_edge(
        &mut self,
        cx: f64,
        cy: f64,
        cz: f64,
        nx: f64,
        ny: f64,
        nz: f64,
        radius: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_circle_edge
            .call(&mut self.store, (cx, cy, cz, nx, ny, nz, radius))?;
        self.check_error("make_circle_edge")?;
        if result == 0 {
            return Err(self.read_last_error("make_circle_edge"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_circle_arc(
        &mut self,
        cx: f64,
        cy: f64,
        cz: f64,
        nx: f64,
        ny: f64,
        nz: f64,
        radius: f64,
        start_angle: f64,
        end_angle: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_make_circle_arc.call(
            &mut self.store,
            (cx, cy, cz, nx, ny, nz, radius, start_angle, end_angle),
        )?;
        self.check_error("make_circle_arc")?;
        if result == 0 {
            return Err(self.read_last_error("make_circle_arc"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_arc_edge(
        &mut self,
        x1: f64,
        y1: f64,
        z1: f64,
        x2: f64,
        y2: f64,
        z2: f64,
        x3: f64,
        y3: f64,
        z3: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_arc_edge
            .call(&mut self.store, (x1, y1, z1, x2, y2, z2, x3, y3, z3))?;
        self.check_error("make_arc_edge")?;
        if result == 0 {
            return Err(self.read_last_error("make_arc_edge"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_ellipse_edge(
        &mut self,
        cx: f64,
        cy: f64,
        cz: f64,
        nx: f64,
        ny: f64,
        nz: f64,
        major_radius: f64,
        minor_radius: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_make_ellipse_edge.call(
            &mut self.store,
            (cx, cy, cz, nx, ny, nz, major_radius, minor_radius),
        )?;
        self.check_error("make_ellipse_edge")?;
        if result == 0 {
            return Err(self.read_last_error("make_ellipse_edge"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_bezier_edge(&mut self, flat_points: &[f64]) -> OcctResult<ShapeHandle> {
        let flat_points_bytes: Vec<u8> = flat_points.iter().flat_map(|v| v.to_le_bytes()).collect();
        let flat_points_ptr = self.write_bytes(&flat_points_bytes)?;
        let flat_points_len = flat_points.len() as u32;
        let result = self.generated.fn_make_bezier_edge.call(
            &mut self.store,
            (flat_points_ptr as i32, flat_points_len as i32),
        );
        self.free_bytes(flat_points_ptr)?;
        let result = result?;
        self.check_error("make_bezier_edge")?;
        if result == 0 {
            return Err(self.read_last_error("make_bezier_edge"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_ellipse_arc(
        &mut self,
        cx: f64,
        cy: f64,
        cz: f64,
        nx: f64,
        ny: f64,
        nz: f64,
        major_radius: f64,
        minor_radius: f64,
        start_angle: f64,
        end_angle: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_make_ellipse_arc.call(
            &mut self.store,
            (
                cx,
                cy,
                cz,
                nx,
                ny,
                nz,
                major_radius,
                minor_radius,
                start_angle,
                end_angle,
            ),
        )?;
        self.check_error("make_ellipse_arc")?;
        if result == 0 {
            return Err(self.read_last_error("make_ellipse_arc"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_helix_wire(
        &mut self,
        px: f64,
        py: f64,
        pz: f64,
        dx: f64,
        dy: f64,
        dz: f64,
        pitch: f64,
        height: f64,
        radius: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_make_helix_wire.call(
            &mut self.store,
            (px, py, pz, dx, dy, dz, pitch, height, radius),
        )?;
        self.check_error("make_helix_wire")?;
        if result == 0 {
            return Err(self.read_last_error("make_helix_wire"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_non_planar_face(&mut self, wire_id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_non_planar_face
            .call(&mut self.store, (wire_id.0,))?;
        self.check_error("make_non_planar_face")?;
        if result == 0 {
            return Err(self.read_last_error("make_non_planar_face"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn add_holes_in_face(
        &mut self,
        face_id: ShapeHandle,
        hole_wire_ids: &[ShapeHandle],
    ) -> OcctResult<ShapeHandle> {
        let hole_wire_ids_bytes: Vec<u8> = hole_wire_ids
            .iter()
            .flat_map(|h| h.0.to_le_bytes())
            .collect();
        let hole_wire_ids_ptr = self.write_bytes(&hole_wire_ids_bytes)?;
        let hole_wire_ids_len = hole_wire_ids.len() as u32;
        let result = self.generated.fn_add_holes_in_face.call(
            &mut self.store,
            (
                face_id.0,
                hole_wire_ids_ptr as i32,
                hole_wire_ids_len as i32,
            ),
        );
        self.free_bytes(hole_wire_ids_ptr)?;
        let result = result?;
        self.check_error("add_holes_in_face")?;
        if result == 0 {
            return Err(self.read_last_error("add_holes_in_face"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn remove_holes_from_face(
        &mut self,
        face_id: ShapeHandle,
        hole_indices: &[i32],
    ) -> OcctResult<ShapeHandle> {
        let hole_indices_bytes: Vec<u8> =
            hole_indices.iter().flat_map(|v| v.to_le_bytes()).collect();
        let hole_indices_ptr = self.write_bytes(&hole_indices_bytes)?;
        let hole_indices_len = hole_indices.len() as u32;
        let result = self.generated.fn_remove_holes_from_face.call(
            &mut self.store,
            (face_id.0, hole_indices_ptr as i32, hole_indices_len as i32),
        );
        self.free_bytes(hole_indices_ptr)?;
        let result = result?;
        self.check_error("remove_holes_from_face")?;
        if result == 0 {
            return Err(self.read_last_error("remove_holes_from_face"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn solid_from_shell(&mut self, shell_id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_solid_from_shell
            .call(&mut self.store, (shell_id.0,))?;
        self.check_error("solid_from_shell")?;
        if result == 0 {
            return Err(self.read_last_error("solid_from_shell"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn build_solid_from_faces(
        &mut self,
        face_ids: &[ShapeHandle],
        tolerance: f64,
    ) -> OcctResult<ShapeHandle> {
        let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
        let face_ids_len = face_ids.len() as u32;
        let result = self.generated.fn_build_solid_from_faces.call(
            &mut self.store,
            (face_ids_ptr as i32, face_ids_len as i32, tolerance),
        );
        self.free_bytes(face_ids_ptr)?;
        let result = result?;
        self.check_error("build_solid_from_faces")?;
        if result == 0 {
            return Err(self.read_last_error("build_solid_from_faces"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn sew_and_solidify(
        &mut self,
        face_ids: &[ShapeHandle],
        tolerance: f64,
    ) -> OcctResult<ShapeHandle> {
        let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
        let face_ids_len = face_ids.len() as u32;
        let result = self.generated.fn_sew_and_solidify.call(
            &mut self.store,
            (face_ids_ptr as i32, face_ids_len as i32, tolerance),
        );
        self.free_bytes(face_ids_ptr)?;
        let result = result?;
        self.check_error("sew_and_solidify")?;
        if result == 0 {
            return Err(self.read_last_error("sew_and_solidify"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn build_tri_face(
        &mut self,
        ax: f64,
        ay: f64,
        az: f64,
        bx: f64,
        by: f64,
        bz: f64,
        cx2: f64,
        cy2: f64,
        cz2: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_build_tri_face
            .call(&mut self.store, (ax, ay, az, bx, by, bz, cx2, cy2, cz2))?;
        self.check_error("build_tri_face")?;
        if result == 0 {
            return Err(self.read_last_error("build_tri_face"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn make_tangent_arc(
        &mut self,
        x1: f64,
        y1: f64,
        z1: f64,
        tx: f64,
        ty: f64,
        tz: f64,
        x2: f64,
        y2: f64,
        z2: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_tangent_arc
            .call(&mut self.store, (x1, y1, z1, tx, ty, tz, x2, y2, z2))?;
        self.check_error("make_tangent_arc")?;
        if result == 0 {
            return Err(self.read_last_error("make_tangent_arc"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn bspline_surface(
        &mut self,
        flat_points: &[f64],
        rows: i32,
        cols: i32,
    ) -> OcctResult<ShapeHandle> {
        let flat_points_bytes: Vec<u8> = flat_points.iter().flat_map(|v| v.to_le_bytes()).collect();
        let flat_points_ptr = self.write_bytes(&flat_points_bytes)?;
        let flat_points_len = flat_points.len() as u32;
        let result = self.generated.fn_bspline_surface.call(
            &mut self.store,
            (flat_points_ptr as i32, flat_points_len as i32, rows, cols),
        );
        self.free_bytes(flat_points_ptr)?;
        let result = result?;
        self.check_error("bspline_surface")?;
        if result == 0 {
            return Err(self.read_last_error("bspline_surface"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn get_shape_type(&mut self, id: ShapeHandle) -> OcctResult<String> {
        let len = self
            .generated
            .fn_get_shape_type
            .call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("get_shape_type"));
        }
        self.read_string_result()
    }

    pub fn get_sub_shapes(&mut self, id: ShapeHandle, shape_type: &str) -> OcctResult<Vec<u32>> {
        let shape_type_ptr = self.write_bytes(shape_type.as_bytes())?;
        let shape_type_len = shape_type.len() as u32;
        let len = self.generated.fn_get_sub_shapes.call(
            &mut self.store,
            (id.0, shape_type_ptr as i32, shape_type_len as i32),
        );
        self.free_bytes(shape_type_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("get_sub_shapes"));
        }
        self.read_vec_u32_result()
    }

    pub fn distance_between(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<f64> {
        let result = self
            .generated
            .fn_distance_between
            .call(&mut self.store, (a.0, b.0))?;
        self.check_error("distance_between")?;
        Ok(result)
    }

    pub fn is_same(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<bool> {
        let result = self
            .generated
            .fn_is_same
            .call(&mut self.store, (a.0, b.0))?;
        if result < 0 {
            return Err(self.read_last_error("is_same"));
        }
        Ok(result != 0)
    }

    pub fn is_equal(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<bool> {
        let result = self
            .generated
            .fn_is_equal
            .call(&mut self.store, (a.0, b.0))?;
        if result < 0 {
            return Err(self.read_last_error("is_equal"));
        }
        Ok(result != 0)
    }

    pub fn is_null(&mut self, id: ShapeHandle) -> OcctResult<bool> {
        let result = self.generated.fn_is_null.call(&mut self.store, (id.0,))?;
        if result < 0 {
            return Err(self.read_last_error("is_null"));
        }
        Ok(result != 0)
    }

    pub fn hash_code(&mut self, id: ShapeHandle, upper_bound: i32) -> OcctResult<i32> {
        let result = self
            .generated
            .fn_hash_code
            .call(&mut self.store, (id.0, upper_bound))?;
        self.check_error("hash_code")?;
        Ok(result)
    }

    pub fn shape_orientation(&mut self, id: ShapeHandle) -> OcctResult<String> {
        let len = self
            .generated
            .fn_shape_orientation
            .call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("shape_orientation"));
        }
        self.read_string_result()
    }

    pub fn iter_shapes(&mut self, id: ShapeHandle) -> OcctResult<Vec<u32>> {
        let len = self
            .generated
            .fn_iter_shapes
            .call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("iter_shapes"));
        }
        self.read_vec_u32_result()
    }

    pub fn edge_to_face_map(
        &mut self,
        id: ShapeHandle,
        hash_upper_bound: i32,
    ) -> OcctResult<Vec<i32>> {
        let len = self
            .generated
            .fn_edge_to_face_map
            .call(&mut self.store, (id.0, hash_upper_bound))?;
        if len < 0 {
            return Err(self.read_last_error("edge_to_face_map"));
        }
        self.read_vec_i32_result()
    }

    pub fn downcast(&mut self, id: ShapeHandle, target_type: &str) -> OcctResult<ShapeHandle> {
        let target_type_ptr = self.write_bytes(target_type.as_bytes())?;
        let target_type_len = target_type.len() as u32;
        let result = self.generated.fn_downcast.call(
            &mut self.store,
            (id.0, target_type_ptr as i32, target_type_len as i32),
        );
        self.free_bytes(target_type_ptr)?;
        let result = result?;
        self.check_error("downcast")?;
        if result == 0 {
            return Err(self.read_last_error("downcast"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn adjacent_faces(
        &mut self,
        shape_id: ShapeHandle,
        face_id: ShapeHandle,
    ) -> OcctResult<Vec<u32>> {
        let len = self
            .generated
            .fn_adjacent_faces
            .call(&mut self.store, (shape_id.0, face_id.0))?;
        if len < 0 {
            return Err(self.read_last_error("adjacent_faces"));
        }
        self.read_vec_u32_result()
    }

    pub fn shared_edges(
        &mut self,
        face_a: ShapeHandle,
        face_b: ShapeHandle,
    ) -> OcctResult<Vec<u32>> {
        let len = self
            .generated
            .fn_shared_edges
            .call(&mut self.store, (face_a.0, face_b.0))?;
        if len < 0 {
            return Err(self.read_last_error("shared_edges"));
        }
        self.read_vec_u32_result()
    }

    pub fn get_bounding_box(
        &mut self,
        id: ShapeHandle,
        use_triangulation: bool,
    ) -> OcctResult<BoundingBox> {
        let status = self
            .generated
            .fn_get_bounding_box
            .call(&mut self.store, (id.0, i32::from(use_triangulation)))?;
        if status < 0 {
            return Err(self.read_last_error("get_bounding_box"));
        }
        self.read_bbox_result()
    }

    pub fn get_volume(&mut self, id: ShapeHandle) -> OcctResult<f64> {
        let result = self
            .generated
            .fn_get_volume
            .call(&mut self.store, (id.0,))?;
        self.check_error("get_volume")?;
        Ok(result)
    }

    pub fn get_surface_area(&mut self, id: ShapeHandle) -> OcctResult<f64> {
        let result = self
            .generated
            .fn_get_surface_area
            .call(&mut self.store, (id.0,))?;
        self.check_error("get_surface_area")?;
        Ok(result)
    }

    pub fn get_length(&mut self, id: ShapeHandle) -> OcctResult<f64> {
        let result = self
            .generated
            .fn_get_length
            .call(&mut self.store, (id.0,))?;
        self.check_error("get_length")?;
        Ok(result)
    }

    pub fn get_center_of_mass(&mut self, id: ShapeHandle) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_get_center_of_mass
            .call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("get_center_of_mass"));
        }
        self.read_vec_f64_result()
    }

    pub fn get_surface_center_of_mass(&mut self, face_id: ShapeHandle) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_get_surface_center_of_mass
            .call(&mut self.store, (face_id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("get_surface_center_of_mass"));
        }
        self.read_vec_f64_result()
    }

    pub fn vertex_position(&mut self, vertex_id: ShapeHandle) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_vertex_position
            .call(&mut self.store, (vertex_id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("vertex_position"));
        }
        self.read_vec_f64_result()
    }

    pub fn surface_type(&mut self, face_id: ShapeHandle) -> OcctResult<String> {
        let len = self
            .generated
            .fn_surface_type
            .call(&mut self.store, (face_id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("surface_type"));
        }
        self.read_string_result()
    }

    pub fn surface_normal(&mut self, face_id: ShapeHandle, u: f64, v: f64) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_surface_normal
            .call(&mut self.store, (face_id.0, u, v))?;
        if len < 0 {
            return Err(self.read_last_error("surface_normal"));
        }
        self.read_vec_f64_result()
    }

    pub fn point_on_surface(
        &mut self,
        face_id: ShapeHandle,
        u: f64,
        v: f64,
    ) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_point_on_surface
            .call(&mut self.store, (face_id.0, u, v))?;
        if len < 0 {
            return Err(self.read_last_error("point_on_surface"));
        }
        self.read_vec_f64_result()
    }

    pub fn outer_wire(&mut self, face_id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_outer_wire
            .call(&mut self.store, (face_id.0,))?;
        self.check_error("outer_wire")?;
        if result == 0 {
            return Err(self.read_last_error("outer_wire"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn get_linear_center_of_mass(&mut self, id: ShapeHandle) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_get_linear_center_of_mass
            .call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("get_linear_center_of_mass"));
        }
        self.read_vec_f64_result()
    }

    pub fn surface_curvature(
        &mut self,
        face_id: ShapeHandle,
        u: f64,
        v: f64,
    ) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_surface_curvature
            .call(&mut self.store, (face_id.0, u, v))?;
        if len < 0 {
            return Err(self.read_last_error("surface_curvature"));
        }
        self.read_vec_f64_result()
    }

    pub fn uv_bounds(&mut self, face_id: ShapeHandle) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_uv_bounds
            .call(&mut self.store, (face_id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("uv_bounds"));
        }
        self.read_vec_f64_result()
    }

    pub fn get_face_cylinder_data(&mut self, face_id: ShapeHandle) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_get_face_cylinder_data
            .call(&mut self.store, (face_id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("get_face_cylinder_data"));
        }
        self.read_vec_f64_result()
    }

    pub fn uv_from_point(
        &mut self,
        face_id: ShapeHandle,
        x: f64,
        y: f64,
        z: f64,
    ) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_uv_from_point
            .call(&mut self.store, (face_id.0, x, y, z))?;
        if len < 0 {
            return Err(self.read_last_error("uv_from_point"));
        }
        self.read_vec_f64_result()
    }

    pub fn project_point_on_face(
        &mut self,
        face_id: ShapeHandle,
        x: f64,
        y: f64,
        z: f64,
    ) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_project_point_on_face
            .call(&mut self.store, (face_id.0, x, y, z))?;
        if len < 0 {
            return Err(self.read_last_error("project_point_on_face"));
        }
        self.read_vec_f64_result()
    }

    pub fn classify_point_on_face(
        &mut self,
        face_id: ShapeHandle,
        u: f64,
        v: f64,
    ) -> OcctResult<String> {
        let len = self
            .generated
            .fn_classify_point_on_face
            .call(&mut self.store, (face_id.0, u, v))?;
        if len < 0 {
            return Err(self.read_last_error("classify_point_on_face"));
        }
        self.read_string_result()
    }

    pub fn curve_type(&mut self, id: ShapeHandle) -> OcctResult<String> {
        let len = self
            .generated
            .fn_curve_type
            .call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("curve_type"));
        }
        self.read_string_result()
    }

    pub fn curve_point_at_param(&mut self, id: ShapeHandle, param: f64) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_curve_point_at_param
            .call(&mut self.store, (id.0, param))?;
        if len < 0 {
            return Err(self.read_last_error("curve_point_at_param"));
        }
        self.read_vec_f64_result()
    }

    pub fn curve_tangent(&mut self, id: ShapeHandle, param: f64) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_curve_tangent
            .call(&mut self.store, (id.0, param))?;
        if len < 0 {
            return Err(self.read_last_error("curve_tangent"));
        }
        self.read_vec_f64_result()
    }

    pub fn curve_parameters(&mut self, id: ShapeHandle) -> OcctResult<Vec<f64>> {
        let len = self
            .generated
            .fn_curve_parameters
            .call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("curve_parameters"));
        }
        self.read_vec_f64_result()
    }

    pub fn curve_is_closed(&mut self, id: ShapeHandle) -> OcctResult<bool> {
        let result = self
            .generated
            .fn_curve_is_closed
            .call(&mut self.store, (id.0,))?;
        if result < 0 {
            return Err(self.read_last_error("curve_is_closed"));
        }
        Ok(result != 0)
    }

    pub fn curve_length(&mut self, id: ShapeHandle) -> OcctResult<f64> {
        let result = self
            .generated
            .fn_curve_length
            .call(&mut self.store, (id.0,))?;
        self.check_error("curve_length")?;
        Ok(result)
    }

    pub fn interpolate_points(
        &mut self,
        flat_points: &[f64],
        periodic: bool,
    ) -> OcctResult<ShapeHandle> {
        let flat_points_bytes: Vec<u8> = flat_points.iter().flat_map(|v| v.to_le_bytes()).collect();
        let flat_points_ptr = self.write_bytes(&flat_points_bytes)?;
        let flat_points_len = flat_points.len() as u32;
        let result = self.generated.fn_interpolate_points.call(
            &mut self.store,
            (
                flat_points_ptr as i32,
                flat_points_len as i32,
                i32::from(periodic),
            ),
        );
        self.free_bytes(flat_points_ptr)?;
        let result = result?;
        self.check_error("interpolate_points")?;
        if result == 0 {
            return Err(self.read_last_error("interpolate_points"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn curve_is_periodic(&mut self, id: ShapeHandle) -> OcctResult<bool> {
        let result = self
            .generated
            .fn_curve_is_periodic
            .call(&mut self.store, (id.0,))?;
        if result < 0 {
            return Err(self.read_last_error("curve_is_periodic"));
        }
        Ok(result != 0)
    }

    pub fn approximate_points(
        &mut self,
        flat_points: &[f64],
        tolerance: f64,
    ) -> OcctResult<ShapeHandle> {
        let flat_points_bytes: Vec<u8> = flat_points.iter().flat_map(|v| v.to_le_bytes()).collect();
        let flat_points_ptr = self.write_bytes(&flat_points_bytes)?;
        let flat_points_len = flat_points.len() as u32;
        let result = self.generated.fn_approximate_points.call(
            &mut self.store,
            (flat_points_ptr as i32, flat_points_len as i32, tolerance),
        );
        self.free_bytes(flat_points_ptr)?;
        let result = result?;
        self.check_error("approximate_points")?;
        if result == 0 {
            return Err(self.read_last_error("approximate_points"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn lift_curve2d_to_plane(
        &mut self,
        flat_points2d: &[f64],
        plane_ox: f64,
        plane_oy: f64,
        plane_oz: f64,
        plane_zx: f64,
        plane_zy: f64,
        plane_zz: f64,
        plane_xx: f64,
        plane_xy: f64,
        plane_xz: f64,
    ) -> OcctResult<ShapeHandle> {
        let flat_points2d_bytes: Vec<u8> =
            flat_points2d.iter().flat_map(|v| v.to_le_bytes()).collect();
        let flat_points2d_ptr = self.write_bytes(&flat_points2d_bytes)?;
        let flat_points2d_len = flat_points2d.len() as u32;
        let result = self.generated.fn_lift_curve2d_to_plane.call(
            &mut self.store,
            (
                flat_points2d_ptr as i32,
                flat_points2d_len as i32,
                plane_ox,
                plane_oy,
                plane_oz,
                plane_zx,
                plane_zy,
                plane_zz,
                plane_xx,
                plane_xy,
                plane_xz,
            ),
        );
        self.free_bytes(flat_points2d_ptr)?;
        let result = result?;
        self.check_error("lift_curve2d_to_plane")?;
        if result == 0 {
            return Err(self.read_last_error("lift_curve2d_to_plane"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn get_nurbs_curve_data(&mut self, edge_id: ShapeHandle) -> OcctResult<NurbsCurveData> {
        let status = self
            .generated
            .fn_get_nurbs_curve_data
            .call(&mut self.store, (edge_id.0,))?;
        if status < 0 {
            return Err(self.read_last_error("get_nurbs_curve_data"));
        }
        self.read_nurbs_result()
    }

    pub fn has_triangulation(&mut self, id: ShapeHandle) -> OcctResult<bool> {
        let result = self
            .generated
            .fn_has_triangulation
            .call(&mut self.store, (id.0,))?;
        if result < 0 {
            return Err(self.read_last_error("has_triangulation"));
        }
        Ok(result != 0)
    }

    pub fn query_batch(&mut self, ids: &[ShapeHandle]) -> OcctResult<Vec<f64>> {
        let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let ids_ptr = self.write_bytes(&ids_bytes)?;
        let ids_len = ids.len() as u32;
        let len = self
            .generated
            .fn_query_batch
            .call(&mut self.store, (ids_ptr as i32, ids_len as i32));
        self.free_bytes(ids_ptr)?;
        let len = len?;
        if len < 0 {
            return Err(self.read_last_error("query_batch"));
        }
        self.read_vec_f64_result()
    }

    pub fn pipe(
        &mut self,
        profile_id: ShapeHandle,
        spine_id: ShapeHandle,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_pipe
            .call(&mut self.store, (profile_id.0, spine_id.0))?;
        self.check_error("pipe")?;
        if result == 0 {
            return Err(self.read_last_error("pipe"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn simple_pipe(
        &mut self,
        profile_id: ShapeHandle,
        spine_id: ShapeHandle,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_simple_pipe
            .call(&mut self.store, (profile_id.0, spine_id.0))?;
        self.check_error("simple_pipe")?;
        if result == 0 {
            return Err(self.read_last_error("simple_pipe"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn revolve_vec(
        &mut self,
        shape_id: ShapeHandle,
        cx: f64,
        cy: f64,
        cz: f64,
        dx: f64,
        dy: f64,
        dz: f64,
        angle: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_revolve_vec
            .call(&mut self.store, (shape_id.0, cx, cy, cz, dx, dy, dz, angle))?;
        self.check_error("revolve_vec")?;
        if result == 0 {
            return Err(self.read_last_error("revolve_vec"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn loft(
        &mut self,
        wire_ids: &[ShapeHandle],
        is_solid: bool,
        ruled: bool,
    ) -> OcctResult<ShapeHandle> {
        let wire_ids_bytes: Vec<u8> = wire_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let wire_ids_ptr = self.write_bytes(&wire_ids_bytes)?;
        let wire_ids_len = wire_ids.len() as u32;
        let result = self.generated.fn_loft.call(
            &mut self.store,
            (
                wire_ids_ptr as i32,
                wire_ids_len as i32,
                i32::from(is_solid),
                i32::from(ruled),
            ),
        );
        self.free_bytes(wire_ids_ptr)?;
        let result = result?;
        self.check_error("loft")?;
        if result == 0 {
            return Err(self.read_last_error("loft"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn loft_with_vertices(
        &mut self,
        wire_ids: &[ShapeHandle],
        is_solid: bool,
        ruled: bool,
        start_vertex_id: ShapeHandle,
        end_vertex_id: ShapeHandle,
    ) -> OcctResult<ShapeHandle> {
        let wire_ids_bytes: Vec<u8> = wire_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let wire_ids_ptr = self.write_bytes(&wire_ids_bytes)?;
        let wire_ids_len = wire_ids.len() as u32;
        let result = self.generated.fn_loft_with_vertices.call(
            &mut self.store,
            (
                wire_ids_ptr as i32,
                wire_ids_len as i32,
                i32::from(is_solid),
                i32::from(ruled),
                start_vertex_id.0,
                end_vertex_id.0,
            ),
        );
        self.free_bytes(wire_ids_ptr)?;
        let result = result?;
        self.check_error("loft_with_vertices")?;
        if result == 0 {
            return Err(self.read_last_error("loft_with_vertices"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn sweep(
        &mut self,
        wire_id: ShapeHandle,
        spine_id: ShapeHandle,
        transition_mode: i32,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_sweep
            .call(&mut self.store, (wire_id.0, spine_id.0, transition_mode))?;
        self.check_error("sweep")?;
        if result == 0 {
            return Err(self.read_last_error("sweep"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn sweep_pipe_shell(
        &mut self,
        profile_id: ShapeHandle,
        spine_id: ShapeHandle,
        freenet: bool,
        smooth: bool,
    ) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_sweep_pipe_shell.call(
            &mut self.store,
            (
                profile_id.0,
                spine_id.0,
                i32::from(freenet),
                i32::from(smooth),
            ),
        )?;
        self.check_error("sweep_pipe_shell")?;
        if result == 0 {
            return Err(self.read_last_error("sweep_pipe_shell"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn draft_prism(
        &mut self,
        shape_id: ShapeHandle,
        dx: f64,
        dy: f64,
        dz: f64,
        angle_deg: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_draft_prism
            .call(&mut self.store, (shape_id.0, dx, dy, dz, angle_deg))?;
        self.check_error("draft_prism")?;
        if result == 0 {
            return Err(self.read_last_error("draft_prism"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn fix_shape(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self.generated.fn_fix_shape.call(&mut self.store, (id.0,))?;
        self.check_error("fix_shape")?;
        if result == 0 {
            return Err(self.read_last_error("fix_shape"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn unify_same_domain(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_unify_same_domain
            .call(&mut self.store, (id.0,))?;
        self.check_error("unify_same_domain")?;
        if result == 0 {
            return Err(self.read_last_error("unify_same_domain"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn is_valid(&mut self, id: ShapeHandle) -> OcctResult<bool> {
        let result = self.generated.fn_is_valid.call(&mut self.store, (id.0,))?;
        if result < 0 {
            return Err(self.read_last_error("is_valid"));
        }
        Ok(result != 0)
    }

    pub fn heal_solid(&mut self, id: ShapeHandle, tolerance: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_heal_solid
            .call(&mut self.store, (id.0, tolerance))?;
        self.check_error("heal_solid")?;
        if result == 0 {
            return Err(self.read_last_error("heal_solid"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn heal_face(&mut self, id: ShapeHandle, tolerance: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_heal_face
            .call(&mut self.store, (id.0, tolerance))?;
        self.check_error("heal_face")?;
        if result == 0 {
            return Err(self.read_last_error("heal_face"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn heal_wire(&mut self, id: ShapeHandle, tolerance: f64) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_heal_wire
            .call(&mut self.store, (id.0, tolerance))?;
        self.check_error("heal_wire")?;
        if result == 0 {
            return Err(self.read_last_error("heal_wire"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn fix_face_orientations(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_fix_face_orientations
            .call(&mut self.store, (id.0,))?;
        self.check_error("fix_face_orientations")?;
        if result == 0 {
            return Err(self.read_last_error("fix_face_orientations"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn build_curves3d(&mut self, wire_id: ShapeHandle) -> OcctResult<()> {
        let result = self
            .generated
            .fn_build_curves3d
            .call(&mut self.store, (wire_id.0,))?;
        if result < 0 {
            return Err(self.read_last_error("build_curves3d"));
        }
        Ok(())
    }

    pub fn fix_wire_on_face(
        &mut self,
        wire_id: ShapeHandle,
        face_id: ShapeHandle,
        tolerance: f64,
    ) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_fix_wire_on_face
            .call(&mut self.store, (wire_id.0, face_id.0, tolerance))?;
        self.check_error("fix_wire_on_face")?;
        if result == 0 {
            return Err(self.read_last_error("fix_wire_on_face"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn remove_degenerate_edges(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_remove_degenerate_edges
            .call(&mut self.store, (id.0,))?;
        self.check_error("remove_degenerate_edges")?;
        if result == 0 {
            return Err(self.read_last_error("remove_degenerate_edges"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn import_step(&mut self, data: &str) -> OcctResult<ShapeHandle> {
        let data_ptr = self.write_bytes(data.as_bytes())?;
        let data_len = data.len() as u32;
        let result = self
            .generated
            .fn_import_step
            .call(&mut self.store, (data_ptr as i32, data_len as i32));
        self.free_bytes(data_ptr)?;
        let result = result?;
        self.check_error("import_step")?;
        if result == 0 {
            return Err(self.read_last_error("import_step"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn export_step(&mut self, id: ShapeHandle) -> OcctResult<String> {
        let len = self
            .generated
            .fn_export_step
            .call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("export_step"));
        }
        self.read_string_result()
    }

    pub fn export_stl(
        &mut self,
        id: ShapeHandle,
        linear_deflection: f64,
        ascii: bool,
    ) -> OcctResult<String> {
        let len = self
            .generated
            .fn_export_stl
            .call(&mut self.store, (id.0, linear_deflection, i32::from(ascii)))?;
        if len < 0 {
            return Err(self.read_last_error("export_stl"));
        }
        self.read_string_result()
    }

    pub fn import_stl(&mut self, data: &str) -> OcctResult<ShapeHandle> {
        let data_ptr = self.write_bytes(data.as_bytes())?;
        let data_len = data.len() as u32;
        let result = self
            .generated
            .fn_import_stl
            .call(&mut self.store, (data_ptr as i32, data_len as i32));
        self.free_bytes(data_ptr)?;
        let result = result?;
        self.check_error("import_stl")?;
        if result == 0 {
            return Err(self.read_last_error("import_stl"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn to_brep(&mut self, id: ShapeHandle) -> OcctResult<String> {
        let len = self.generated.fn_to_brep.call(&mut self.store, (id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("to_brep"));
        }
        self.read_string_result()
    }

    pub fn from_brep(&mut self, data: &str) -> OcctResult<ShapeHandle> {
        let data_ptr = self.write_bytes(data.as_bytes())?;
        let data_len = data.len() as u32;
        let result = self
            .generated
            .fn_from_brep
            .call(&mut self.store, (data_ptr as i32, data_len as i32));
        self.free_bytes(data_ptr)?;
        let result = result?;
        self.check_error("from_brep")?;
        if result == 0 {
            return Err(self.read_last_error("from_brep"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn translate_with_history(
        &mut self,
        id: ShapeHandle,
        dx: f64,
        dy: f64,
        dz: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_translate_with_history.call(
            &mut self.store,
            (
                id.0,
                dx,
                dy,
                dz,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("translate_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn fuse_with_history(
        &mut self,
        a: ShapeHandle,
        b: ShapeHandle,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_fuse_with_history.call(
            &mut self.store,
            (
                a.0,
                b.0,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("fuse_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn cut_with_history(
        &mut self,
        a: ShapeHandle,
        b: ShapeHandle,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_cut_with_history.call(
            &mut self.store,
            (
                a.0,
                b.0,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("cut_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn fillet_with_history(
        &mut self,
        solid_id: ShapeHandle,
        edge_ids: &[ShapeHandle],
        radius: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
        let edge_ids_len = edge_ids.len() as u32;
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = match self.write_bytes(&input_face_hashes_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(edge_ids_ptr);
                return Err(e);
            }
        };
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_fillet_with_history.call(
            &mut self.store,
            (
                solid_id.0,
                edge_ids_ptr as i32,
                edge_ids_len as i32,
                radius,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(edge_ids_ptr)?;
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("fillet_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn rotate_with_history(
        &mut self,
        id: ShapeHandle,
        px: f64,
        py: f64,
        pz: f64,
        dx: f64,
        dy: f64,
        dz: f64,
        angle: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_rotate_with_history.call(
            &mut self.store,
            (
                id.0,
                px,
                py,
                pz,
                dx,
                dy,
                dz,
                angle,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("rotate_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn mirror_with_history(
        &mut self,
        id: ShapeHandle,
        px: f64,
        py: f64,
        pz: f64,
        nx: f64,
        ny: f64,
        nz: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_mirror_with_history.call(
            &mut self.store,
            (
                id.0,
                px,
                py,
                pz,
                nx,
                ny,
                nz,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("mirror_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn scale_with_history(
        &mut self,
        id: ShapeHandle,
        cx: f64,
        cy: f64,
        cz: f64,
        factor: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_scale_with_history.call(
            &mut self.store,
            (
                id.0,
                cx,
                cy,
                cz,
                factor,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("scale_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn intersect_with_history(
        &mut self,
        a: ShapeHandle,
        b: ShapeHandle,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_intersect_with_history.call(
            &mut self.store,
            (
                a.0,
                b.0,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("intersect_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn chamfer_with_history(
        &mut self,
        solid_id: ShapeHandle,
        edge_ids: &[ShapeHandle],
        distance: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
        let edge_ids_len = edge_ids.len() as u32;
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = match self.write_bytes(&input_face_hashes_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(edge_ids_ptr);
                return Err(e);
            }
        };
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_chamfer_with_history.call(
            &mut self.store,
            (
                solid_id.0,
                edge_ids_ptr as i32,
                edge_ids_len as i32,
                distance,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(edge_ids_ptr)?;
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("chamfer_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn shell_with_history(
        &mut self,
        solid_id: ShapeHandle,
        face_ids: &[ShapeHandle],
        thickness: f64,
        tolerance: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
        let face_ids_len = face_ids.len() as u32;
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = match self.write_bytes(&input_face_hashes_bytes) {
            Ok(ptr) => ptr,
            Err(e) => {
                let _ = self.free_bytes(face_ids_ptr);
                return Err(e);
            }
        };
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_shell_with_history.call(
            &mut self.store,
            (
                solid_id.0,
                face_ids_ptr as i32,
                face_ids_len as i32,
                thickness,
                tolerance,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(face_ids_ptr)?;
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("shell_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn offset_with_history(
        &mut self,
        solid_id: ShapeHandle,
        distance: f64,
        tolerance: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_offset_with_history.call(
            &mut self.store,
            (
                solid_id.0,
                distance,
                tolerance,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("offset_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn thicken_with_history(
        &mut self,
        shape_id: ShapeHandle,
        thickness: f64,
        tolerance: f64,
        input_face_hashes: &[i32],
        hash_upper_bound: i32,
    ) -> OcctResult<EvolutionData> {
        let input_face_hashes_bytes: Vec<u8> = input_face_hashes
            .iter()
            .flat_map(|v| v.to_le_bytes())
            .collect();
        let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
        let input_face_hashes_len = input_face_hashes.len() as u32;
        let status = self.generated.fn_thicken_with_history.call(
            &mut self.store,
            (
                shape_id.0,
                thickness,
                tolerance,
                input_face_hashes_ptr as i32,
                input_face_hashes_len as i32,
                hash_upper_bound,
            ),
        );
        self.free_bytes(input_face_hashes_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("thicken_with_history"));
        }
        self.read_evolution_result()
    }

    pub fn tessellate(
        &mut self,
        id: ShapeHandle,
        linear_deflection: f64,
        angular_deflection: f64,
    ) -> OcctResult<Mesh> {
        let status = self.generated.fn_tessellate.call(
            &mut self.store,
            (id.0, linear_deflection, angular_deflection),
        )?;
        if status < 0 {
            return Err(self.read_last_error("tessellate"));
        }
        self.read_mesh_result()
    }

    pub fn mesh_shape(
        &mut self,
        id: ShapeHandle,
        linear_deflection: f64,
        angular_deflection: f64,
    ) -> OcctResult<Mesh> {
        let status = self.generated.fn_mesh_shape.call(
            &mut self.store,
            (id.0, linear_deflection, angular_deflection),
        )?;
        if status < 0 {
            return Err(self.read_last_error("mesh_shape"));
        }
        self.read_mesh_result()
    }

    pub fn mesh_batch(
        &mut self,
        ids: &[ShapeHandle],
        linear_deflection: f64,
        angular_deflection: f64,
    ) -> OcctResult<MeshBatch> {
        let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
        let ids_ptr = self.write_bytes(&ids_bytes)?;
        let ids_len = ids.len() as u32;
        let status = self.generated.fn_mesh_batch.call(
            &mut self.store,
            (
                ids_ptr as i32,
                ids_len as i32,
                linear_deflection,
                angular_deflection,
            ),
        );
        self.free_bytes(ids_ptr)?;
        let status = status?;
        if status < 0 {
            return Err(self.read_last_error("mesh_batch"));
        }
        self.read_mesh_batch_result()
    }

    pub fn wireframe(&mut self, id: ShapeHandle, deflection: f64) -> OcctResult<EdgeData> {
        let status = self
            .generated
            .fn_wireframe
            .call(&mut self.store, (id.0, deflection))?;
        if status < 0 {
            return Err(self.read_last_error("wireframe"));
        }
        self.read_edge_result()
    }

    pub fn project_edges(
        &mut self,
        shape_id: ShapeHandle,
        ox: f64,
        oy: f64,
        oz: f64,
        dx: f64,
        dy: f64,
        dz: f64,
        xx: f64,
        xy: f64,
        xz: f64,
        has_x_axis: bool,
    ) -> OcctResult<ProjectionData> {
        let status = self.generated.fn_project_edges.call(
            &mut self.store,
            (
                shape_id.0,
                ox,
                oy,
                oz,
                dx,
                dy,
                dz,
                xx,
                xy,
                xz,
                i32::from(has_x_axis),
            ),
        )?;
        if status < 0 {
            return Err(self.read_last_error("project_edges"));
        }
        self.read_projection_result()
    }

    pub fn release(&mut self, id: ShapeHandle) -> OcctResult<()> {
        let result = self.generated.fn_release.call(&mut self.store, (id.0,))?;
        if result < 0 {
            return Err(self.read_last_error("release"));
        }
        Ok(())
    }

    pub fn release_all(&mut self) -> OcctResult<()> {
        let result = self.generated.fn_release_all.call(&mut self.store, ())?;
        if result < 0 {
            return Err(self.read_last_error("release_all"));
        }
        Ok(())
    }

    pub fn get_shape_count(&mut self) -> OcctResult<u32> {
        let result = self
            .generated
            .fn_get_shape_count
            .call(&mut self.store, ())?;
        self.check_error("get_shape_count")?;
        Ok(result)
    }

    pub fn make_null_shape(&mut self) -> OcctResult<ShapeHandle> {
        let result = self
            .generated
            .fn_make_null_shape
            .call(&mut self.store, ())?;
        self.check_error("make_null_shape")?;
        if result == 0 {
            return Err(self.read_last_error("make_null_shape"));
        }
        Ok(ShapeHandle(result))
    }

    pub fn xcaf_new_document(&mut self) -> OcctResult<u32> {
        let result = self
            .generated
            .fn_xcaf_new_document
            .call(&mut self.store, ())?;
        self.check_error("xcaf_new_document")?;
        Ok(result)
    }

    pub fn xcaf_close(&mut self, doc_id: ShapeHandle) -> OcctResult<()> {
        let result = self
            .generated
            .fn_xcaf_close
            .call(&mut self.store, (doc_id.0,))?;
        if result < 0 {
            return Err(self.read_last_error("xcaf_close"));
        }
        Ok(())
    }

    pub fn xcaf_add_shape(
        &mut self,
        doc_id: ShapeHandle,
        shape_id: ShapeHandle,
    ) -> OcctResult<i32> {
        let result = self
            .generated
            .fn_xcaf_add_shape
            .call(&mut self.store, (doc_id.0, shape_id.0))?;
        self.check_error("xcaf_add_shape")?;
        Ok(result)
    }

    pub fn xcaf_add_component(
        &mut self,
        doc_id: ShapeHandle,
        parent_label_id: i32,
        shape_id: ShapeHandle,
        tx: f64,
        ty: f64,
        tz: f64,
        rx: f64,
        ry: f64,
        rz: f64,
    ) -> OcctResult<i32> {
        let result = self.generated.fn_xcaf_add_component.call(
            &mut self.store,
            (
                doc_id.0,
                parent_label_id,
                shape_id.0,
                tx,
                ty,
                tz,
                rx,
                ry,
                rz,
            ),
        )?;
        self.check_error("xcaf_add_component")?;
        Ok(result)
    }

    pub fn xcaf_set_color(
        &mut self,
        doc_id: ShapeHandle,
        label_id: i32,
        r: f64,
        g: f64,
        b: f64,
    ) -> OcctResult<()> {
        let result = self
            .generated
            .fn_xcaf_set_color
            .call(&mut self.store, (doc_id.0, label_id, r, g, b))?;
        if result < 0 {
            return Err(self.read_last_error("xcaf_set_color"));
        }
        Ok(())
    }

    pub fn xcaf_set_name(
        &mut self,
        doc_id: ShapeHandle,
        label_id: i32,
        name: &str,
    ) -> OcctResult<()> {
        let name_ptr = self.write_bytes(name.as_bytes())?;
        let name_len = name.len() as u32;
        let result = self.generated.fn_xcaf_set_name.call(
            &mut self.store,
            (doc_id.0, label_id, name_ptr as i32, name_len as i32),
        );
        self.free_bytes(name_ptr)?;
        let result = result?;
        if result < 0 {
            return Err(self.read_last_error("xcaf_set_name"));
        }
        Ok(())
    }

    pub fn xcaf_get_label_info(
        &mut self,
        doc_id: ShapeHandle,
        label_id: i32,
    ) -> OcctResult<LabelInfo> {
        let status = self
            .generated
            .fn_xcaf_get_label_info
            .call(&mut self.store, (doc_id.0, label_id))?;
        if status < 0 {
            return Err(self.read_last_error("xcaf_get_label_info"));
        }
        self.read_label_info_result()
    }

    pub fn xcaf_get_child_labels(
        &mut self,
        doc_id: ShapeHandle,
        parent_label_id: i32,
    ) -> OcctResult<Vec<i32>> {
        let len = self
            .generated
            .fn_xcaf_get_child_labels
            .call(&mut self.store, (doc_id.0, parent_label_id))?;
        if len < 0 {
            return Err(self.read_last_error("xcaf_get_child_labels"));
        }
        self.read_vec_i32_result()
    }

    pub fn xcaf_get_root_labels(&mut self, doc_id: ShapeHandle) -> OcctResult<Vec<i32>> {
        let len = self
            .generated
            .fn_xcaf_get_root_labels
            .call(&mut self.store, (doc_id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("xcaf_get_root_labels"));
        }
        self.read_vec_i32_result()
    }

    pub fn xcaf_export_step(&mut self, doc_id: ShapeHandle) -> OcctResult<String> {
        let len = self
            .generated
            .fn_xcaf_export_step
            .call(&mut self.store, (doc_id.0,))?;
        if len < 0 {
            return Err(self.read_last_error("xcaf_export_step"));
        }
        self.read_string_result()
    }

    pub fn xcaf_import_step(&mut self, step_data: &str) -> OcctResult<u32> {
        let step_data_ptr = self.write_bytes(step_data.as_bytes())?;
        let step_data_len = step_data.len() as u32;
        let result = self.generated.fn_xcaf_import_step.call(
            &mut self.store,
            (step_data_ptr as i32, step_data_len as i32),
        );
        self.free_bytes(step_data_ptr)?;
        let result = result?;
        self.check_error("xcaf_import_step")?;
        Ok(result)
    }

    pub fn xcaf_export_gltf(
        &mut self,
        doc_id: ShapeHandle,
        lin_deflection: f64,
        ang_deflection: f64,
    ) -> OcctResult<String> {
        let len = self
            .generated
            .fn_xcaf_export_gltf
            .call(&mut self.store, (doc_id.0, lin_deflection, ang_deflection))?;
        if len < 0 {
            return Err(self.read_last_error("xcaf_export_gltf"));
        }
        self.read_string_result()
    }
}