toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp

   1 // Generated by uniffi-bindgen-gecko-js.  DO NOT EDIT.
   2
   3 #include "nsString.h"
   4 #include "nsPrintfCString.h"
   5 #include "mozilla/Logging.h"
   6 #include "mozilla/Maybe.h"
   7 #include "mozilla/StaticPtr.h"
   8 #include "mozilla/UniquePtr.h"
   9 #include "mozilla/dom/Promise.h"
  10 #include "mozilla/dom/ScaffoldingConverter.h"
  11 #include "mozilla/dom/UniFFICall.h"
  12 #include "mozilla/dom/UniFFICallbacks.h"
  13 #include "mozilla/dom/UniFFIPointerType.h"
  14 #include "mozilla/dom/UniFFIScaffolding.h"
  15 #include "mozilla/dom/UniFFIRust.h"
  16
  17 namespace mozilla::uniffi {
  18
  19 using dom::ArrayBuffer;
  20 using dom::AutoEntryScript;
  21 using dom::GlobalObject;
  22 using dom::RootedDictionary;
  23 using dom::Promise;
  24 using dom::UniFFIScaffoldingValue;
  25 using dom::Sequence;
  26 using dom::UniFFICallbackHandler;
  27 using dom::UniFFIPointer;
  28 using dom::UniFFIScaffoldingCallResult;
  29
  30 // Define scaffolding functions from UniFFI
  31 extern "C" {
  32   uint64_t uniffi_arithmetical_fn_func_add(uint64_t, uint64_t, RustCallStatus*);
  33   uint64_t uniffi_arithmetical_fn_func_div(uint64_t, uint64_t, RustCallStatus*);
  34   int8_t uniffi_arithmetical_fn_func_equal(uint64_t, uint64_t, RustCallStatus*);
  35   uint64_t uniffi_arithmetical_fn_func_sub(uint64_t, uint64_t, RustCallStatus*);
  36   RustBuffer uniffi_uniffi_custom_types_fn_func_get_custom_types_demo(RustBuffer, RustCallStatus*);
  37   double uniffi_uniffi_fixture_external_types_fn_func_gradient(RustBuffer, RustCallStatus*);
  38   RustBuffer uniffi_uniffi_fixture_external_types_fn_func_intersection(RustBuffer, RustBuffer, RustCallStatus*);
  39   void* uniffi_uniffi_fixture_refcounts_fn_clone_singletonobject(void*, RustCallStatus*);
  40   void uniffi_uniffi_fixture_refcounts_fn_free_singletonobject(void*, RustCallStatus*);
  41   void uniffi_uniffi_fixture_refcounts_fn_method_singletonobject_method(void*, RustCallStatus*);
  42   int32_t uniffi_uniffi_fixture_refcounts_fn_func_get_js_refcount(RustCallStatus*);
  43   void* uniffi_uniffi_fixture_refcounts_fn_func_get_singleton(RustCallStatus*);
  44   double uniffi_uniffi_geometry_fn_func_gradient(RustBuffer, RustCallStatus*);
  45   RustBuffer uniffi_uniffi_geometry_fn_func_intersection(RustBuffer, RustBuffer, RustCallStatus*);
  46   void* uniffi_uniffi_rondpoint_fn_clone_optionneur(void*, RustCallStatus*);
  47   void uniffi_uniffi_rondpoint_fn_free_optionneur(void*, RustCallStatus*);
  48   void* uniffi_uniffi_rondpoint_fn_constructor_optionneur_new(RustCallStatus*);
  49   int8_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_boolean(void*, int8_t, RustCallStatus*);
  50   RustBuffer uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_enum(void*, RustBuffer, RustCallStatus*);
  51   float uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_f32(void*, float, RustCallStatus*);
  52   double uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_f64(void*, double, RustCallStatus*);
  53   int16_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i16_dec(void*, int16_t, RustCallStatus*);
  54   int16_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i16_hex(void*, int16_t, RustCallStatus*);
  55   int32_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i32_dec(void*, int32_t, RustCallStatus*);
  56   int32_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i32_hex(void*, int32_t, RustCallStatus*);
  57   int64_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i64_dec(void*, int64_t, RustCallStatus*);
  58   int64_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i64_hex(void*, int64_t, RustCallStatus*);
  59   int8_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i8_dec(void*, int8_t, RustCallStatus*);
  60   int8_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i8_hex(void*, int8_t, RustCallStatus*);
  61   RustBuffer uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_null(void*, RustBuffer, RustCallStatus*);
  62   RustBuffer uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_sequence(void*, RustBuffer, RustCallStatus*);
  63   RustBuffer uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_string(void*, RustBuffer, RustCallStatus*);
  64   uint16_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u16_dec(void*, uint16_t, RustCallStatus*);
  65   uint16_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u16_hex(void*, uint16_t, RustCallStatus*);
  66   uint32_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_dec(void*, uint32_t, RustCallStatus*);
  67   uint32_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_hex(void*, uint32_t, RustCallStatus*);
  68   uint32_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_oct(void*, uint32_t, RustCallStatus*);
  69   uint64_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u64_dec(void*, uint64_t, RustCallStatus*);
  70   uint64_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u64_hex(void*, uint64_t, RustCallStatus*);
  71   uint8_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u8_dec(void*, uint8_t, RustCallStatus*);
  72   uint8_t uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u8_hex(void*, uint8_t, RustCallStatus*);
  73   RustBuffer uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_zero(void*, RustBuffer, RustCallStatus*);
  74   void* uniffi_uniffi_rondpoint_fn_clone_retourneur(void*, RustCallStatus*);
  75   void uniffi_uniffi_rondpoint_fn_free_retourneur(void*, RustCallStatus*);
  76   void* uniffi_uniffi_rondpoint_fn_constructor_retourneur_new(RustCallStatus*);
  77   int8_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_boolean(void*, int8_t, RustCallStatus*);
  78   double uniffi_uniffi_rondpoint_fn_method_retourneur_identique_double(void*, double, RustCallStatus*);
  79   float uniffi_uniffi_rondpoint_fn_method_retourneur_identique_float(void*, float, RustCallStatus*);
  80   int16_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i16(void*, int16_t, RustCallStatus*);
  81   int32_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i32(void*, int32_t, RustCallStatus*);
  82   int64_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i64(void*, int64_t, RustCallStatus*);
  83   int8_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i8(void*, int8_t, RustCallStatus*);
  84   RustBuffer uniffi_uniffi_rondpoint_fn_method_retourneur_identique_nombres(void*, RustBuffer, RustCallStatus*);
  85   RustBuffer uniffi_uniffi_rondpoint_fn_method_retourneur_identique_nombres_signes(void*, RustBuffer, RustCallStatus*);
  86   RustBuffer uniffi_uniffi_rondpoint_fn_method_retourneur_identique_optionneur_dictionnaire(void*, RustBuffer, RustCallStatus*);
  87   RustBuffer uniffi_uniffi_rondpoint_fn_method_retourneur_identique_string(void*, RustBuffer, RustCallStatus*);
  88   uint16_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u16(void*, uint16_t, RustCallStatus*);
  89   uint32_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u32(void*, uint32_t, RustCallStatus*);
  90   uint64_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u64(void*, uint64_t, RustCallStatus*);
  91   uint8_t uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u8(void*, uint8_t, RustCallStatus*);
  92   void* uniffi_uniffi_rondpoint_fn_clone_stringifier(void*, RustCallStatus*);
  93   void uniffi_uniffi_rondpoint_fn_free_stringifier(void*, RustCallStatus*);
  94   void* uniffi_uniffi_rondpoint_fn_constructor_stringifier_new(RustCallStatus*);
  95   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_boolean(void*, int8_t, RustCallStatus*);
  96   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_double(void*, double, RustCallStatus*);
  97   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_float(void*, float, RustCallStatus*);
  98   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i16(void*, int16_t, RustCallStatus*);
  99   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i32(void*, int32_t, RustCallStatus*);
 100   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i64(void*, int64_t, RustCallStatus*);
 101   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i8(void*, int8_t, RustCallStatus*);
 102   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u16(void*, uint16_t, RustCallStatus*);
 103   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u32(void*, uint32_t, RustCallStatus*);
 104   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u64(void*, uint64_t, RustCallStatus*);
 105   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u8(void*, uint8_t, RustCallStatus*);
 106   RustBuffer uniffi_uniffi_rondpoint_fn_method_stringifier_well_known_string(void*, RustBuffer, RustCallStatus*);
 107   RustBuffer uniffi_uniffi_rondpoint_fn_func_copie_carte(RustBuffer, RustCallStatus*);
 108   RustBuffer uniffi_uniffi_rondpoint_fn_func_copie_dictionnaire(RustBuffer, RustCallStatus*);
 109   RustBuffer uniffi_uniffi_rondpoint_fn_func_copie_enumeration(RustBuffer, RustCallStatus*);
 110   RustBuffer uniffi_uniffi_rondpoint_fn_func_copie_enumerations(RustBuffer, RustCallStatus*);
 111   int8_t uniffi_uniffi_rondpoint_fn_func_switcheroo(int8_t, RustCallStatus*);
 112   void* uniffi_uniffi_sprites_fn_clone_sprite(void*, RustCallStatus*);
 113   void uniffi_uniffi_sprites_fn_free_sprite(void*, RustCallStatus*);
 114   void* uniffi_uniffi_sprites_fn_constructor_sprite_new(RustBuffer, RustCallStatus*);
 115   void* uniffi_uniffi_sprites_fn_constructor_sprite_new_relative_to(RustBuffer, RustBuffer, RustCallStatus*);
 116   RustBuffer uniffi_uniffi_sprites_fn_method_sprite_get_position(void*, RustCallStatus*);
 117   void uniffi_uniffi_sprites_fn_method_sprite_move_by(void*, RustBuffer, RustCallStatus*);
 118   void uniffi_uniffi_sprites_fn_method_sprite_move_to(void*, RustBuffer, RustCallStatus*);
 119   RustBuffer uniffi_uniffi_sprites_fn_func_translate(RustBuffer, RustBuffer, RustCallStatus*);
 120   void* uniffi_uniffi_todolist_fn_clone_todolist(void*, RustCallStatus*);
 121   void uniffi_uniffi_todolist_fn_free_todolist(void*, RustCallStatus*);
 122   void* uniffi_uniffi_todolist_fn_constructor_todolist_new(RustCallStatus*);
 123   void uniffi_uniffi_todolist_fn_method_todolist_add_entries(void*, RustBuffer, RustCallStatus*);
 124   void uniffi_uniffi_todolist_fn_method_todolist_add_entry(void*, RustBuffer, RustCallStatus*);
 125   void uniffi_uniffi_todolist_fn_method_todolist_add_item(void*, RustBuffer, RustCallStatus*);
 126   void uniffi_uniffi_todolist_fn_method_todolist_add_items(void*, RustBuffer, RustCallStatus*);
 127   void uniffi_uniffi_todolist_fn_method_todolist_clear_item(void*, RustBuffer, RustCallStatus*);
 128   RustBuffer uniffi_uniffi_todolist_fn_method_todolist_get_entries(void*, RustCallStatus*);
 129   RustBuffer uniffi_uniffi_todolist_fn_method_todolist_get_first(void*, RustCallStatus*);
 130   RustBuffer uniffi_uniffi_todolist_fn_method_todolist_get_items(void*, RustCallStatus*);
 131   RustBuffer uniffi_uniffi_todolist_fn_method_todolist_get_last(void*, RustCallStatus*);
 132   RustBuffer uniffi_uniffi_todolist_fn_method_todolist_get_last_entry(void*, RustCallStatus*);
 133   void uniffi_uniffi_todolist_fn_method_todolist_make_default(void*, RustCallStatus*);
 134   RustBuffer uniffi_uniffi_todolist_fn_func_create_entry_with(RustBuffer, RustCallStatus*);
 135   RustBuffer uniffi_uniffi_todolist_fn_func_get_default_list(RustCallStatus*);
 136   void uniffi_uniffi_todolist_fn_func_set_default_list(void*, RustCallStatus*);
 137 }
 138
 139 // Define pointer types
 140 const static mozilla::uniffi::UniFFIPointerType kRefcountsSingletonObjectPointerType {
 141   "refcounts::SingletonObject"_ns,
 142   uniffi_uniffi_fixture_refcounts_fn_clone_singletonobject,
 143   uniffi_uniffi_fixture_refcounts_fn_free_singletonobject,
 144 };
 145 const static mozilla::uniffi::UniFFIPointerType kRondpointOptionneurPointerType {
 146   "rondpoint::Optionneur"_ns,
 147   uniffi_uniffi_rondpoint_fn_clone_optionneur,
 148   uniffi_uniffi_rondpoint_fn_free_optionneur,
 149 };
 150 const static mozilla::uniffi::UniFFIPointerType kRondpointRetourneurPointerType {
 151   "rondpoint::Retourneur"_ns,
 152   uniffi_uniffi_rondpoint_fn_clone_retourneur,
 153   uniffi_uniffi_rondpoint_fn_free_retourneur,
 154 };
 155 const static mozilla::uniffi::UniFFIPointerType kRondpointStringifierPointerType {
 156   "rondpoint::Stringifier"_ns,
 157   uniffi_uniffi_rondpoint_fn_clone_stringifier,
 158   uniffi_uniffi_rondpoint_fn_free_stringifier,
 159 };
 160 const static mozilla::uniffi::UniFFIPointerType kSpritesSpritePointerType {
 161   "sprites::Sprite"_ns,
 162   uniffi_uniffi_sprites_fn_clone_sprite,
 163   uniffi_uniffi_sprites_fn_free_sprite,
 164 };
 165 const static mozilla::uniffi::UniFFIPointerType kTodolistTodoListPointerType {
 166   "todolist::TodoList"_ns,
 167   uniffi_uniffi_todolist_fn_clone_todolist,
 168   uniffi_uniffi_todolist_fn_free_todolist,
 169 };
 170
 171 // Define the data we need per-callback interface
 172
 173 // Define a lookup function for our callback interface info
 174 Maybe<CallbackInterfaceInfo> UniFFIFixturesGetCallbackInterfaceInfo(uint64_t aInterfaceId) {
 175     switch(aInterfaceId) {
 176
 177         default:
 178             return Nothing();
 179     }
 180 }
 181
 182 // Define scaffolding call classes for each combination of return/argument types
 183 class ScaffoldingCallHandlerUniFFIFixturesUniffiArithmeticalFnFuncAdd : public UniffiHandlerBase {
 184 private:
 185     // PrepareRustArgs stores the resulting arguments in these fields
 186     typename ScaffoldingConverter<uint64_t>::IntermediateType mA;
 187     typename ScaffoldingConverter<uint64_t>::IntermediateType mB;
 188
 189     // MakeRustCall stores the result of the call in these fields
 190     typename ScaffoldingConverter<uint64_t>::IntermediateType mUniffiReturnValue;
 191
 192 public:
 193     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 194         ScaffoldingConverter<uint64_t>::FromJs(aArgs[0], &mA, aError);
 195         if (aError.Failed()) {
 196             return;
 197         }
 198         ScaffoldingConverter<uint64_t>::FromJs(aArgs[1], &mB, aError);
 199         if (aError.Failed()) {
 200             return;
 201         }
 202     }
 203
 204     void MakeRustCall() override {
 205         RustCallStatus callStatus{};
 206         mUniffiReturnValue = ScaffoldingConverter<uint64_t>::FromRust(
 207             uniffi_arithmetical_fn_func_add(
 208                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mA)),
 209                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mB)),
 210                 &callStatus
 211             )
 212         );
 213
 214         mUniffiCallStatusCode = callStatus.code;
 215         if (callStatus.error_buf.data) {
 216             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 217         }
 218     }
 219
 220     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 221         ScaffoldingConverter<uint64_t>::IntoJs(
 222           aCx,
 223           std::move(mUniffiReturnValue),
 224           aDest,
 225           aError
 226         );
 227     }
 228 };
 229 class ScaffoldingCallHandlerUniFFIFixturesUniffiArithmeticalFnFuncDiv : public UniffiHandlerBase {
 230 private:
 231     // PrepareRustArgs stores the resulting arguments in these fields
 232     typename ScaffoldingConverter<uint64_t>::IntermediateType mDividend;
 233     typename ScaffoldingConverter<uint64_t>::IntermediateType mDivisor;
 234
 235     // MakeRustCall stores the result of the call in these fields
 236     typename ScaffoldingConverter<uint64_t>::IntermediateType mUniffiReturnValue;
 237
 238 public:
 239     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 240         ScaffoldingConverter<uint64_t>::FromJs(aArgs[0], &mDividend, aError);
 241         if (aError.Failed()) {
 242             return;
 243         }
 244         ScaffoldingConverter<uint64_t>::FromJs(aArgs[1], &mDivisor, aError);
 245         if (aError.Failed()) {
 246             return;
 247         }
 248     }
 249
 250     void MakeRustCall() override {
 251         RustCallStatus callStatus{};
 252         mUniffiReturnValue = ScaffoldingConverter<uint64_t>::FromRust(
 253             uniffi_arithmetical_fn_func_div(
 254                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mDividend)),
 255                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mDivisor)),
 256                 &callStatus
 257             )
 258         );
 259
 260         mUniffiCallStatusCode = callStatus.code;
 261         if (callStatus.error_buf.data) {
 262             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 263         }
 264     }
 265
 266     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 267         ScaffoldingConverter<uint64_t>::IntoJs(
 268           aCx,
 269           std::move(mUniffiReturnValue),
 270           aDest,
 271           aError
 272         );
 273     }
 274 };
 275 class ScaffoldingCallHandlerUniFFIFixturesUniffiArithmeticalFnFuncEqual : public UniffiHandlerBase {
 276 private:
 277     // PrepareRustArgs stores the resulting arguments in these fields
 278     typename ScaffoldingConverter<uint64_t>::IntermediateType mA;
 279     typename ScaffoldingConverter<uint64_t>::IntermediateType mB;
 280
 281     // MakeRustCall stores the result of the call in these fields
 282     typename ScaffoldingConverter<int8_t>::IntermediateType mUniffiReturnValue;
 283
 284 public:
 285     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 286         ScaffoldingConverter<uint64_t>::FromJs(aArgs[0], &mA, aError);
 287         if (aError.Failed()) {
 288             return;
 289         }
 290         ScaffoldingConverter<uint64_t>::FromJs(aArgs[1], &mB, aError);
 291         if (aError.Failed()) {
 292             return;
 293         }
 294     }
 295
 296     void MakeRustCall() override {
 297         RustCallStatus callStatus{};
 298         mUniffiReturnValue = ScaffoldingConverter<int8_t>::FromRust(
 299             uniffi_arithmetical_fn_func_equal(
 300                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mA)),
 301                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mB)),
 302                 &callStatus
 303             )
 304         );
 305
 306         mUniffiCallStatusCode = callStatus.code;
 307         if (callStatus.error_buf.data) {
 308             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 309         }
 310     }
 311
 312     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 313         ScaffoldingConverter<int8_t>::IntoJs(
 314           aCx,
 315           std::move(mUniffiReturnValue),
 316           aDest,
 317           aError
 318         );
 319     }
 320 };
 321 class ScaffoldingCallHandlerUniFFIFixturesUniffiArithmeticalFnFuncSub : public UniffiHandlerBase {
 322 private:
 323     // PrepareRustArgs stores the resulting arguments in these fields
 324     typename ScaffoldingConverter<uint64_t>::IntermediateType mA;
 325     typename ScaffoldingConverter<uint64_t>::IntermediateType mB;
 326
 327     // MakeRustCall stores the result of the call in these fields
 328     typename ScaffoldingConverter<uint64_t>::IntermediateType mUniffiReturnValue;
 329
 330 public:
 331     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 332         ScaffoldingConverter<uint64_t>::FromJs(aArgs[0], &mA, aError);
 333         if (aError.Failed()) {
 334             return;
 335         }
 336         ScaffoldingConverter<uint64_t>::FromJs(aArgs[1], &mB, aError);
 337         if (aError.Failed()) {
 338             return;
 339         }
 340     }
 341
 342     void MakeRustCall() override {
 343         RustCallStatus callStatus{};
 344         mUniffiReturnValue = ScaffoldingConverter<uint64_t>::FromRust(
 345             uniffi_arithmetical_fn_func_sub(
 346                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mA)),
 347                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mB)),
 348                 &callStatus
 349             )
 350         );
 351
 352         mUniffiCallStatusCode = callStatus.code;
 353         if (callStatus.error_buf.data) {
 354             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 355         }
 356     }
 357
 358     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 359         ScaffoldingConverter<uint64_t>::IntoJs(
 360           aCx,
 361           std::move(mUniffiReturnValue),
 362           aDest,
 363           aError
 364         );
 365     }
 366 };
 367 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiCustomTypesFnFuncGetCustomTypesDemo : public UniffiHandlerBase {
 368 private:
 369     // PrepareRustArgs stores the resulting arguments in these fields
 370     typename ScaffoldingConverter<RustBuffer>::IntermediateType mDemo;
 371
 372     // MakeRustCall stores the result of the call in these fields
 373     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
 374
 375 public:
 376     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 377         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mDemo, aError);
 378         if (aError.Failed()) {
 379             return;
 380         }
 381     }
 382
 383     void MakeRustCall() override {
 384         RustCallStatus callStatus{};
 385         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
 386             uniffi_uniffi_custom_types_fn_func_get_custom_types_demo(
 387                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mDemo)),
 388                 &callStatus
 389             )
 390         );
 391
 392         mUniffiCallStatusCode = callStatus.code;
 393         if (callStatus.error_buf.data) {
 394             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 395         }
 396     }
 397
 398     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 399         ScaffoldingConverter<RustBuffer>::IntoJs(
 400           aCx,
 401           std::move(mUniffiReturnValue),
 402           aDest,
 403           aError
 404         );
 405     }
 406 };
 407 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureExternalTypesFnFuncGradient : public UniffiHandlerBase {
 408 private:
 409     // PrepareRustArgs stores the resulting arguments in these fields
 410     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
 411
 412     // MakeRustCall stores the result of the call in these fields
 413     typename ScaffoldingConverter<double>::IntermediateType mUniffiReturnValue;
 414
 415 public:
 416     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 417         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mValue, aError);
 418         if (aError.Failed()) {
 419             return;
 420         }
 421     }
 422
 423     void MakeRustCall() override {
 424         RustCallStatus callStatus{};
 425         mUniffiReturnValue = ScaffoldingConverter<double>::FromRust(
 426             uniffi_uniffi_fixture_external_types_fn_func_gradient(
 427                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
 428                 &callStatus
 429             )
 430         );
 431
 432         mUniffiCallStatusCode = callStatus.code;
 433         if (callStatus.error_buf.data) {
 434             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 435         }
 436     }
 437
 438     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 439         ScaffoldingConverter<double>::IntoJs(
 440           aCx,
 441           std::move(mUniffiReturnValue),
 442           aDest,
 443           aError
 444         );
 445     }
 446 };
 447 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureExternalTypesFnFuncIntersection : public UniffiHandlerBase {
 448 private:
 449     // PrepareRustArgs stores the resulting arguments in these fields
 450     typename ScaffoldingConverter<RustBuffer>::IntermediateType mLn1;
 451     typename ScaffoldingConverter<RustBuffer>::IntermediateType mLn2;
 452
 453     // MakeRustCall stores the result of the call in these fields
 454     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
 455
 456 public:
 457     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 458         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mLn1, aError);
 459         if (aError.Failed()) {
 460             return;
 461         }
 462         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mLn2, aError);
 463         if (aError.Failed()) {
 464             return;
 465         }
 466     }
 467
 468     void MakeRustCall() override {
 469         RustCallStatus callStatus{};
 470         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
 471             uniffi_uniffi_fixture_external_types_fn_func_intersection(
 472                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mLn1)),
 473                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mLn2)),
 474                 &callStatus
 475             )
 476         );
 477
 478         mUniffiCallStatusCode = callStatus.code;
 479         if (callStatus.error_buf.data) {
 480             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 481         }
 482     }
 483
 484     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 485         ScaffoldingConverter<RustBuffer>::IntoJs(
 486           aCx,
 487           std::move(mUniffiReturnValue),
 488           aDest,
 489           aError
 490         );
 491     }
 492 };
 493 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureRefcountsFnMethodSingletonobjectMethod : public UniffiHandlerBase {
 494 private:
 495     // PrepareRustArgs stores the resulting arguments in these fields
 496     typename ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntermediateType mPtr;
 497
 498     // MakeRustCall stores the result of the call in these fields
 499
 500 public:
 501     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 502         ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::FromJs(aArgs[0], &mPtr, aError);
 503         if (aError.Failed()) {
 504             return;
 505         }
 506     }
 507
 508     void MakeRustCall() override {
 509         RustCallStatus callStatus{};
 510         uniffi_uniffi_fixture_refcounts_fn_method_singletonobject_method(
 511             ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntoRust(std::move(mPtr)),
 512             &callStatus
 513         );
 514
 515         mUniffiCallStatusCode = callStatus.code;
 516         if (callStatus.error_buf.data) {
 517             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 518         }
 519     }
 520
 521     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 522     }
 523 };
 524 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureRefcountsFnFuncGetJsRefcount : public UniffiHandlerBase {
 525 private:
 526     // PrepareRustArgs stores the resulting arguments in these fields
 527
 528     // MakeRustCall stores the result of the call in these fields
 529     typename ScaffoldingConverter<int32_t>::IntermediateType mUniffiReturnValue;
 530
 531 public:
 532     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 533     }
 534
 535     void MakeRustCall() override {
 536         RustCallStatus callStatus{};
 537         mUniffiReturnValue = ScaffoldingConverter<int32_t>::FromRust(
 538             uniffi_uniffi_fixture_refcounts_fn_func_get_js_refcount(
 539                 &callStatus
 540             )
 541         );
 542
 543         mUniffiCallStatusCode = callStatus.code;
 544         if (callStatus.error_buf.data) {
 545             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 546         }
 547     }
 548
 549     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 550         ScaffoldingConverter<int32_t>::IntoJs(
 551           aCx,
 552           std::move(mUniffiReturnValue),
 553           aDest,
 554           aError
 555         );
 556     }
 557 };
 558 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureRefcountsFnFuncGetSingleton : public UniffiHandlerBase {
 559 private:
 560     // PrepareRustArgs stores the resulting arguments in these fields
 561
 562     // MakeRustCall stores the result of the call in these fields
 563     typename ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntermediateType mUniffiReturnValue;
 564
 565 public:
 566     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 567     }
 568
 569     void MakeRustCall() override {
 570         RustCallStatus callStatus{};
 571         mUniffiReturnValue = ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::FromRust(
 572             uniffi_uniffi_fixture_refcounts_fn_func_get_singleton(
 573                 &callStatus
 574             )
 575         );
 576
 577         mUniffiCallStatusCode = callStatus.code;
 578         if (callStatus.error_buf.data) {
 579             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 580         }
 581     }
 582
 583     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 584         ScaffoldingObjectConverter<&kRefcountsSingletonObjectPointerType>::IntoJs(
 585           aCx,
 586           std::move(mUniffiReturnValue),
 587           aDest,
 588           aError
 589         );
 590     }
 591 };
 592 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiGeometryFnFuncGradient : public UniffiHandlerBase {
 593 private:
 594     // PrepareRustArgs stores the resulting arguments in these fields
 595     typename ScaffoldingConverter<RustBuffer>::IntermediateType mLn;
 596
 597     // MakeRustCall stores the result of the call in these fields
 598     typename ScaffoldingConverter<double>::IntermediateType mUniffiReturnValue;
 599
 600 public:
 601     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 602         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mLn, aError);
 603         if (aError.Failed()) {
 604             return;
 605         }
 606     }
 607
 608     void MakeRustCall() override {
 609         RustCallStatus callStatus{};
 610         mUniffiReturnValue = ScaffoldingConverter<double>::FromRust(
 611             uniffi_uniffi_geometry_fn_func_gradient(
 612                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mLn)),
 613                 &callStatus
 614             )
 615         );
 616
 617         mUniffiCallStatusCode = callStatus.code;
 618         if (callStatus.error_buf.data) {
 619             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 620         }
 621     }
 622
 623     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 624         ScaffoldingConverter<double>::IntoJs(
 625           aCx,
 626           std::move(mUniffiReturnValue),
 627           aDest,
 628           aError
 629         );
 630     }
 631 };
 632 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiGeometryFnFuncIntersection : public UniffiHandlerBase {
 633 private:
 634     // PrepareRustArgs stores the resulting arguments in these fields
 635     typename ScaffoldingConverter<RustBuffer>::IntermediateType mLn1;
 636     typename ScaffoldingConverter<RustBuffer>::IntermediateType mLn2;
 637
 638     // MakeRustCall stores the result of the call in these fields
 639     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
 640
 641 public:
 642     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 643         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mLn1, aError);
 644         if (aError.Failed()) {
 645             return;
 646         }
 647         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mLn2, aError);
 648         if (aError.Failed()) {
 649             return;
 650         }
 651     }
 652
 653     void MakeRustCall() override {
 654         RustCallStatus callStatus{};
 655         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
 656             uniffi_uniffi_geometry_fn_func_intersection(
 657                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mLn1)),
 658                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mLn2)),
 659                 &callStatus
 660             )
 661         );
 662
 663         mUniffiCallStatusCode = callStatus.code;
 664         if (callStatus.error_buf.data) {
 665             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 666         }
 667     }
 668
 669     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 670         ScaffoldingConverter<RustBuffer>::IntoJs(
 671           aCx,
 672           std::move(mUniffiReturnValue),
 673           aDest,
 674           aError
 675         );
 676     }
 677 };
 678 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnConstructorOptionneurNew : public UniffiHandlerBase {
 679 private:
 680     // PrepareRustArgs stores the resulting arguments in these fields
 681
 682     // MakeRustCall stores the result of the call in these fields
 683     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mUniffiReturnValue;
 684
 685 public:
 686     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 687     }
 688
 689     void MakeRustCall() override {
 690         RustCallStatus callStatus{};
 691         mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromRust(
 692             uniffi_uniffi_rondpoint_fn_constructor_optionneur_new(
 693                 &callStatus
 694             )
 695         );
 696
 697         mUniffiCallStatusCode = callStatus.code;
 698         if (callStatus.error_buf.data) {
 699             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 700         }
 701     }
 702
 703     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 704         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoJs(
 705           aCx,
 706           std::move(mUniffiReturnValue),
 707           aDest,
 708           aError
 709         );
 710     }
 711 };
 712 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonBoolean : public UniffiHandlerBase {
 713 private:
 714     // PrepareRustArgs stores the resulting arguments in these fields
 715     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
 716     typename ScaffoldingConverter<int8_t>::IntermediateType mValue;
 717
 718     // MakeRustCall stores the result of the call in these fields
 719     typename ScaffoldingConverter<int8_t>::IntermediateType mUniffiReturnValue;
 720
 721 public:
 722     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 723         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
 724         if (aError.Failed()) {
 725             return;
 726         }
 727         ScaffoldingConverter<int8_t>::FromJs(aArgs[1], &mValue, aError);
 728         if (aError.Failed()) {
 729             return;
 730         }
 731     }
 732
 733     void MakeRustCall() override {
 734         RustCallStatus callStatus{};
 735         mUniffiReturnValue = ScaffoldingConverter<int8_t>::FromRust(
 736             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_boolean(
 737                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
 738                 ScaffoldingConverter<int8_t>::IntoRust(std::move(mValue)),
 739                 &callStatus
 740             )
 741         );
 742
 743         mUniffiCallStatusCode = callStatus.code;
 744         if (callStatus.error_buf.data) {
 745             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 746         }
 747     }
 748
 749     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 750         ScaffoldingConverter<int8_t>::IntoJs(
 751           aCx,
 752           std::move(mUniffiReturnValue),
 753           aDest,
 754           aError
 755         );
 756     }
 757 };
 758 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonEnum : public UniffiHandlerBase {
 759 private:
 760     // PrepareRustArgs stores the resulting arguments in these fields
 761     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
 762     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
 763
 764     // MakeRustCall stores the result of the call in these fields
 765     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
 766
 767 public:
 768     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 769         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
 770         if (aError.Failed()) {
 771             return;
 772         }
 773         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
 774         if (aError.Failed()) {
 775             return;
 776         }
 777     }
 778
 779     void MakeRustCall() override {
 780         RustCallStatus callStatus{};
 781         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
 782             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_enum(
 783                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
 784                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
 785                 &callStatus
 786             )
 787         );
 788
 789         mUniffiCallStatusCode = callStatus.code;
 790         if (callStatus.error_buf.data) {
 791             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 792         }
 793     }
 794
 795     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 796         ScaffoldingConverter<RustBuffer>::IntoJs(
 797           aCx,
 798           std::move(mUniffiReturnValue),
 799           aDest,
 800           aError
 801         );
 802     }
 803 };
 804 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonF32 : public UniffiHandlerBase {
 805 private:
 806     // PrepareRustArgs stores the resulting arguments in these fields
 807     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
 808     typename ScaffoldingConverter<float>::IntermediateType mValue;
 809
 810     // MakeRustCall stores the result of the call in these fields
 811     typename ScaffoldingConverter<float>::IntermediateType mUniffiReturnValue;
 812
 813 public:
 814     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 815         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
 816         if (aError.Failed()) {
 817             return;
 818         }
 819         ScaffoldingConverter<float>::FromJs(aArgs[1], &mValue, aError);
 820         if (aError.Failed()) {
 821             return;
 822         }
 823     }
 824
 825     void MakeRustCall() override {
 826         RustCallStatus callStatus{};
 827         mUniffiReturnValue = ScaffoldingConverter<float>::FromRust(
 828             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_f32(
 829                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
 830                 ScaffoldingConverter<float>::IntoRust(std::move(mValue)),
 831                 &callStatus
 832             )
 833         );
 834
 835         mUniffiCallStatusCode = callStatus.code;
 836         if (callStatus.error_buf.data) {
 837             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 838         }
 839     }
 840
 841     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 842         ScaffoldingConverter<float>::IntoJs(
 843           aCx,
 844           std::move(mUniffiReturnValue),
 845           aDest,
 846           aError
 847         );
 848     }
 849 };
 850 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonF64 : public UniffiHandlerBase {
 851 private:
 852     // PrepareRustArgs stores the resulting arguments in these fields
 853     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
 854     typename ScaffoldingConverter<double>::IntermediateType mValue;
 855
 856     // MakeRustCall stores the result of the call in these fields
 857     typename ScaffoldingConverter<double>::IntermediateType mUniffiReturnValue;
 858
 859 public:
 860     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 861         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
 862         if (aError.Failed()) {
 863             return;
 864         }
 865         ScaffoldingConverter<double>::FromJs(aArgs[1], &mValue, aError);
 866         if (aError.Failed()) {
 867             return;
 868         }
 869     }
 870
 871     void MakeRustCall() override {
 872         RustCallStatus callStatus{};
 873         mUniffiReturnValue = ScaffoldingConverter<double>::FromRust(
 874             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_f64(
 875                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
 876                 ScaffoldingConverter<double>::IntoRust(std::move(mValue)),
 877                 &callStatus
 878             )
 879         );
 880
 881         mUniffiCallStatusCode = callStatus.code;
 882         if (callStatus.error_buf.data) {
 883             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 884         }
 885     }
 886
 887     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 888         ScaffoldingConverter<double>::IntoJs(
 889           aCx,
 890           std::move(mUniffiReturnValue),
 891           aDest,
 892           aError
 893         );
 894     }
 895 };
 896 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI16Dec : public UniffiHandlerBase {
 897 private:
 898     // PrepareRustArgs stores the resulting arguments in these fields
 899     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
 900     typename ScaffoldingConverter<int16_t>::IntermediateType mValue;
 901
 902     // MakeRustCall stores the result of the call in these fields
 903     typename ScaffoldingConverter<int16_t>::IntermediateType mUniffiReturnValue;
 904
 905 public:
 906     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 907         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
 908         if (aError.Failed()) {
 909             return;
 910         }
 911         ScaffoldingConverter<int16_t>::FromJs(aArgs[1], &mValue, aError);
 912         if (aError.Failed()) {
 913             return;
 914         }
 915     }
 916
 917     void MakeRustCall() override {
 918         RustCallStatus callStatus{};
 919         mUniffiReturnValue = ScaffoldingConverter<int16_t>::FromRust(
 920             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i16_dec(
 921                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
 922                 ScaffoldingConverter<int16_t>::IntoRust(std::move(mValue)),
 923                 &callStatus
 924             )
 925         );
 926
 927         mUniffiCallStatusCode = callStatus.code;
 928         if (callStatus.error_buf.data) {
 929             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 930         }
 931     }
 932
 933     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 934         ScaffoldingConverter<int16_t>::IntoJs(
 935           aCx,
 936           std::move(mUniffiReturnValue),
 937           aDest,
 938           aError
 939         );
 940     }
 941 };
 942 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI16Hex : public UniffiHandlerBase {
 943 private:
 944     // PrepareRustArgs stores the resulting arguments in these fields
 945     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
 946     typename ScaffoldingConverter<int16_t>::IntermediateType mValue;
 947
 948     // MakeRustCall stores the result of the call in these fields
 949     typename ScaffoldingConverter<int16_t>::IntermediateType mUniffiReturnValue;
 950
 951 public:
 952     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 953         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
 954         if (aError.Failed()) {
 955             return;
 956         }
 957         ScaffoldingConverter<int16_t>::FromJs(aArgs[1], &mValue, aError);
 958         if (aError.Failed()) {
 959             return;
 960         }
 961     }
 962
 963     void MakeRustCall() override {
 964         RustCallStatus callStatus{};
 965         mUniffiReturnValue = ScaffoldingConverter<int16_t>::FromRust(
 966             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i16_hex(
 967                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
 968                 ScaffoldingConverter<int16_t>::IntoRust(std::move(mValue)),
 969                 &callStatus
 970             )
 971         );
 972
 973         mUniffiCallStatusCode = callStatus.code;
 974         if (callStatus.error_buf.data) {
 975             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
 976         }
 977     }
 978
 979     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
 980         ScaffoldingConverter<int16_t>::IntoJs(
 981           aCx,
 982           std::move(mUniffiReturnValue),
 983           aDest,
 984           aError
 985         );
 986     }
 987 };
 988 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI32Dec : public UniffiHandlerBase {
 989 private:
 990     // PrepareRustArgs stores the resulting arguments in these fields
 991     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
 992     typename ScaffoldingConverter<int32_t>::IntermediateType mValue;
 993
 994     // MakeRustCall stores the result of the call in these fields
 995     typename ScaffoldingConverter<int32_t>::IntermediateType mUniffiReturnValue;
 996
 997 public:
 998     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
 999         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1000         if (aError.Failed()) {
1001             return;
1002         }
1003         ScaffoldingConverter<int32_t>::FromJs(aArgs[1], &mValue, aError);
1004         if (aError.Failed()) {
1005             return;
1006         }
1007     }
1008
1009     void MakeRustCall() override {
1010         RustCallStatus callStatus{};
1011         mUniffiReturnValue = ScaffoldingConverter<int32_t>::FromRust(
1012             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i32_dec(
1013                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1014                 ScaffoldingConverter<int32_t>::IntoRust(std::move(mValue)),
1015                 &callStatus
1016             )
1017         );
1018
1019         mUniffiCallStatusCode = callStatus.code;
1020         if (callStatus.error_buf.data) {
1021             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1022         }
1023     }
1024
1025     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1026         ScaffoldingConverter<int32_t>::IntoJs(
1027           aCx,
1028           std::move(mUniffiReturnValue),
1029           aDest,
1030           aError
1031         );
1032     }
1033 };
1034 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI32Hex : public UniffiHandlerBase {
1035 private:
1036     // PrepareRustArgs stores the resulting arguments in these fields
1037     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1038     typename ScaffoldingConverter<int32_t>::IntermediateType mValue;
1039
1040     // MakeRustCall stores the result of the call in these fields
1041     typename ScaffoldingConverter<int32_t>::IntermediateType mUniffiReturnValue;
1042
1043 public:
1044     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1045         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1046         if (aError.Failed()) {
1047             return;
1048         }
1049         ScaffoldingConverter<int32_t>::FromJs(aArgs[1], &mValue, aError);
1050         if (aError.Failed()) {
1051             return;
1052         }
1053     }
1054
1055     void MakeRustCall() override {
1056         RustCallStatus callStatus{};
1057         mUniffiReturnValue = ScaffoldingConverter<int32_t>::FromRust(
1058             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i32_hex(
1059                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1060                 ScaffoldingConverter<int32_t>::IntoRust(std::move(mValue)),
1061                 &callStatus
1062             )
1063         );
1064
1065         mUniffiCallStatusCode = callStatus.code;
1066         if (callStatus.error_buf.data) {
1067             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1068         }
1069     }
1070
1071     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1072         ScaffoldingConverter<int32_t>::IntoJs(
1073           aCx,
1074           std::move(mUniffiReturnValue),
1075           aDest,
1076           aError
1077         );
1078     }
1079 };
1080 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI64Dec : public UniffiHandlerBase {
1081 private:
1082     // PrepareRustArgs stores the resulting arguments in these fields
1083     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1084     typename ScaffoldingConverter<int64_t>::IntermediateType mValue;
1085
1086     // MakeRustCall stores the result of the call in these fields
1087     typename ScaffoldingConverter<int64_t>::IntermediateType mUniffiReturnValue;
1088
1089 public:
1090     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1091         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1092         if (aError.Failed()) {
1093             return;
1094         }
1095         ScaffoldingConverter<int64_t>::FromJs(aArgs[1], &mValue, aError);
1096         if (aError.Failed()) {
1097             return;
1098         }
1099     }
1100
1101     void MakeRustCall() override {
1102         RustCallStatus callStatus{};
1103         mUniffiReturnValue = ScaffoldingConverter<int64_t>::FromRust(
1104             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i64_dec(
1105                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1106                 ScaffoldingConverter<int64_t>::IntoRust(std::move(mValue)),
1107                 &callStatus
1108             )
1109         );
1110
1111         mUniffiCallStatusCode = callStatus.code;
1112         if (callStatus.error_buf.data) {
1113             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1114         }
1115     }
1116
1117     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1118         ScaffoldingConverter<int64_t>::IntoJs(
1119           aCx,
1120           std::move(mUniffiReturnValue),
1121           aDest,
1122           aError
1123         );
1124     }
1125 };
1126 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI64Hex : public UniffiHandlerBase {
1127 private:
1128     // PrepareRustArgs stores the resulting arguments in these fields
1129     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1130     typename ScaffoldingConverter<int64_t>::IntermediateType mValue;
1131
1132     // MakeRustCall stores the result of the call in these fields
1133     typename ScaffoldingConverter<int64_t>::IntermediateType mUniffiReturnValue;
1134
1135 public:
1136     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1137         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1138         if (aError.Failed()) {
1139             return;
1140         }
1141         ScaffoldingConverter<int64_t>::FromJs(aArgs[1], &mValue, aError);
1142         if (aError.Failed()) {
1143             return;
1144         }
1145     }
1146
1147     void MakeRustCall() override {
1148         RustCallStatus callStatus{};
1149         mUniffiReturnValue = ScaffoldingConverter<int64_t>::FromRust(
1150             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i64_hex(
1151                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1152                 ScaffoldingConverter<int64_t>::IntoRust(std::move(mValue)),
1153                 &callStatus
1154             )
1155         );
1156
1157         mUniffiCallStatusCode = callStatus.code;
1158         if (callStatus.error_buf.data) {
1159             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1160         }
1161     }
1162
1163     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1164         ScaffoldingConverter<int64_t>::IntoJs(
1165           aCx,
1166           std::move(mUniffiReturnValue),
1167           aDest,
1168           aError
1169         );
1170     }
1171 };
1172 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI8Dec : public UniffiHandlerBase {
1173 private:
1174     // PrepareRustArgs stores the resulting arguments in these fields
1175     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1176     typename ScaffoldingConverter<int8_t>::IntermediateType mValue;
1177
1178     // MakeRustCall stores the result of the call in these fields
1179     typename ScaffoldingConverter<int8_t>::IntermediateType mUniffiReturnValue;
1180
1181 public:
1182     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1183         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1184         if (aError.Failed()) {
1185             return;
1186         }
1187         ScaffoldingConverter<int8_t>::FromJs(aArgs[1], &mValue, aError);
1188         if (aError.Failed()) {
1189             return;
1190         }
1191     }
1192
1193     void MakeRustCall() override {
1194         RustCallStatus callStatus{};
1195         mUniffiReturnValue = ScaffoldingConverter<int8_t>::FromRust(
1196             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i8_dec(
1197                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1198                 ScaffoldingConverter<int8_t>::IntoRust(std::move(mValue)),
1199                 &callStatus
1200             )
1201         );
1202
1203         mUniffiCallStatusCode = callStatus.code;
1204         if (callStatus.error_buf.data) {
1205             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1206         }
1207     }
1208
1209     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1210         ScaffoldingConverter<int8_t>::IntoJs(
1211           aCx,
1212           std::move(mUniffiReturnValue),
1213           aDest,
1214           aError
1215         );
1216     }
1217 };
1218 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI8Hex : public UniffiHandlerBase {
1219 private:
1220     // PrepareRustArgs stores the resulting arguments in these fields
1221     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1222     typename ScaffoldingConverter<int8_t>::IntermediateType mValue;
1223
1224     // MakeRustCall stores the result of the call in these fields
1225     typename ScaffoldingConverter<int8_t>::IntermediateType mUniffiReturnValue;
1226
1227 public:
1228     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1229         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1230         if (aError.Failed()) {
1231             return;
1232         }
1233         ScaffoldingConverter<int8_t>::FromJs(aArgs[1], &mValue, aError);
1234         if (aError.Failed()) {
1235             return;
1236         }
1237     }
1238
1239     void MakeRustCall() override {
1240         RustCallStatus callStatus{};
1241         mUniffiReturnValue = ScaffoldingConverter<int8_t>::FromRust(
1242             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_i8_hex(
1243                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1244                 ScaffoldingConverter<int8_t>::IntoRust(std::move(mValue)),
1245                 &callStatus
1246             )
1247         );
1248
1249         mUniffiCallStatusCode = callStatus.code;
1250         if (callStatus.error_buf.data) {
1251             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1252         }
1253     }
1254
1255     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1256         ScaffoldingConverter<int8_t>::IntoJs(
1257           aCx,
1258           std::move(mUniffiReturnValue),
1259           aDest,
1260           aError
1261         );
1262     }
1263 };
1264 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonNull : public UniffiHandlerBase {
1265 private:
1266     // PrepareRustArgs stores the resulting arguments in these fields
1267     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1268     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
1269
1270     // MakeRustCall stores the result of the call in these fields
1271     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
1272
1273 public:
1274     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1275         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1276         if (aError.Failed()) {
1277             return;
1278         }
1279         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
1280         if (aError.Failed()) {
1281             return;
1282         }
1283     }
1284
1285     void MakeRustCall() override {
1286         RustCallStatus callStatus{};
1287         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
1288             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_null(
1289                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1290                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
1291                 &callStatus
1292             )
1293         );
1294
1295         mUniffiCallStatusCode = callStatus.code;
1296         if (callStatus.error_buf.data) {
1297             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1298         }
1299     }
1300
1301     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1302         ScaffoldingConverter<RustBuffer>::IntoJs(
1303           aCx,
1304           std::move(mUniffiReturnValue),
1305           aDest,
1306           aError
1307         );
1308     }
1309 };
1310 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonSequence : public UniffiHandlerBase {
1311 private:
1312     // PrepareRustArgs stores the resulting arguments in these fields
1313     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1314     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
1315
1316     // MakeRustCall stores the result of the call in these fields
1317     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
1318
1319 public:
1320     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1321         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1322         if (aError.Failed()) {
1323             return;
1324         }
1325         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
1326         if (aError.Failed()) {
1327             return;
1328         }
1329     }
1330
1331     void MakeRustCall() override {
1332         RustCallStatus callStatus{};
1333         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
1334             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_sequence(
1335                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1336                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
1337                 &callStatus
1338             )
1339         );
1340
1341         mUniffiCallStatusCode = callStatus.code;
1342         if (callStatus.error_buf.data) {
1343             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1344         }
1345     }
1346
1347     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1348         ScaffoldingConverter<RustBuffer>::IntoJs(
1349           aCx,
1350           std::move(mUniffiReturnValue),
1351           aDest,
1352           aError
1353         );
1354     }
1355 };
1356 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonString : public UniffiHandlerBase {
1357 private:
1358     // PrepareRustArgs stores the resulting arguments in these fields
1359     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1360     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
1361
1362     // MakeRustCall stores the result of the call in these fields
1363     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
1364
1365 public:
1366     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1367         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1368         if (aError.Failed()) {
1369             return;
1370         }
1371         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
1372         if (aError.Failed()) {
1373             return;
1374         }
1375     }
1376
1377     void MakeRustCall() override {
1378         RustCallStatus callStatus{};
1379         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
1380             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_string(
1381                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1382                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
1383                 &callStatus
1384             )
1385         );
1386
1387         mUniffiCallStatusCode = callStatus.code;
1388         if (callStatus.error_buf.data) {
1389             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1390         }
1391     }
1392
1393     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1394         ScaffoldingConverter<RustBuffer>::IntoJs(
1395           aCx,
1396           std::move(mUniffiReturnValue),
1397           aDest,
1398           aError
1399         );
1400     }
1401 };
1402 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU16Dec : public UniffiHandlerBase {
1403 private:
1404     // PrepareRustArgs stores the resulting arguments in these fields
1405     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1406     typename ScaffoldingConverter<uint16_t>::IntermediateType mValue;
1407
1408     // MakeRustCall stores the result of the call in these fields
1409     typename ScaffoldingConverter<uint16_t>::IntermediateType mUniffiReturnValue;
1410
1411 public:
1412     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1413         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1414         if (aError.Failed()) {
1415             return;
1416         }
1417         ScaffoldingConverter<uint16_t>::FromJs(aArgs[1], &mValue, aError);
1418         if (aError.Failed()) {
1419             return;
1420         }
1421     }
1422
1423     void MakeRustCall() override {
1424         RustCallStatus callStatus{};
1425         mUniffiReturnValue = ScaffoldingConverter<uint16_t>::FromRust(
1426             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u16_dec(
1427                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1428                 ScaffoldingConverter<uint16_t>::IntoRust(std::move(mValue)),
1429                 &callStatus
1430             )
1431         );
1432
1433         mUniffiCallStatusCode = callStatus.code;
1434         if (callStatus.error_buf.data) {
1435             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1436         }
1437     }
1438
1439     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1440         ScaffoldingConverter<uint16_t>::IntoJs(
1441           aCx,
1442           std::move(mUniffiReturnValue),
1443           aDest,
1444           aError
1445         );
1446     }
1447 };
1448 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU16Hex : public UniffiHandlerBase {
1449 private:
1450     // PrepareRustArgs stores the resulting arguments in these fields
1451     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1452     typename ScaffoldingConverter<uint16_t>::IntermediateType mValue;
1453
1454     // MakeRustCall stores the result of the call in these fields
1455     typename ScaffoldingConverter<uint16_t>::IntermediateType mUniffiReturnValue;
1456
1457 public:
1458     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1459         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1460         if (aError.Failed()) {
1461             return;
1462         }
1463         ScaffoldingConverter<uint16_t>::FromJs(aArgs[1], &mValue, aError);
1464         if (aError.Failed()) {
1465             return;
1466         }
1467     }
1468
1469     void MakeRustCall() override {
1470         RustCallStatus callStatus{};
1471         mUniffiReturnValue = ScaffoldingConverter<uint16_t>::FromRust(
1472             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u16_hex(
1473                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1474                 ScaffoldingConverter<uint16_t>::IntoRust(std::move(mValue)),
1475                 &callStatus
1476             )
1477         );
1478
1479         mUniffiCallStatusCode = callStatus.code;
1480         if (callStatus.error_buf.data) {
1481             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1482         }
1483     }
1484
1485     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1486         ScaffoldingConverter<uint16_t>::IntoJs(
1487           aCx,
1488           std::move(mUniffiReturnValue),
1489           aDest,
1490           aError
1491         );
1492     }
1493 };
1494 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU32Dec : public UniffiHandlerBase {
1495 private:
1496     // PrepareRustArgs stores the resulting arguments in these fields
1497     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1498     typename ScaffoldingConverter<uint32_t>::IntermediateType mValue;
1499
1500     // MakeRustCall stores the result of the call in these fields
1501     typename ScaffoldingConverter<uint32_t>::IntermediateType mUniffiReturnValue;
1502
1503 public:
1504     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1505         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1506         if (aError.Failed()) {
1507             return;
1508         }
1509         ScaffoldingConverter<uint32_t>::FromJs(aArgs[1], &mValue, aError);
1510         if (aError.Failed()) {
1511             return;
1512         }
1513     }
1514
1515     void MakeRustCall() override {
1516         RustCallStatus callStatus{};
1517         mUniffiReturnValue = ScaffoldingConverter<uint32_t>::FromRust(
1518             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_dec(
1519                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1520                 ScaffoldingConverter<uint32_t>::IntoRust(std::move(mValue)),
1521                 &callStatus
1522             )
1523         );
1524
1525         mUniffiCallStatusCode = callStatus.code;
1526         if (callStatus.error_buf.data) {
1527             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1528         }
1529     }
1530
1531     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1532         ScaffoldingConverter<uint32_t>::IntoJs(
1533           aCx,
1534           std::move(mUniffiReturnValue),
1535           aDest,
1536           aError
1537         );
1538     }
1539 };
1540 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU32Hex : public UniffiHandlerBase {
1541 private:
1542     // PrepareRustArgs stores the resulting arguments in these fields
1543     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1544     typename ScaffoldingConverter<uint32_t>::IntermediateType mValue;
1545
1546     // MakeRustCall stores the result of the call in these fields
1547     typename ScaffoldingConverter<uint32_t>::IntermediateType mUniffiReturnValue;
1548
1549 public:
1550     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1551         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1552         if (aError.Failed()) {
1553             return;
1554         }
1555         ScaffoldingConverter<uint32_t>::FromJs(aArgs[1], &mValue, aError);
1556         if (aError.Failed()) {
1557             return;
1558         }
1559     }
1560
1561     void MakeRustCall() override {
1562         RustCallStatus callStatus{};
1563         mUniffiReturnValue = ScaffoldingConverter<uint32_t>::FromRust(
1564             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_hex(
1565                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1566                 ScaffoldingConverter<uint32_t>::IntoRust(std::move(mValue)),
1567                 &callStatus
1568             )
1569         );
1570
1571         mUniffiCallStatusCode = callStatus.code;
1572         if (callStatus.error_buf.data) {
1573             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1574         }
1575     }
1576
1577     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1578         ScaffoldingConverter<uint32_t>::IntoJs(
1579           aCx,
1580           std::move(mUniffiReturnValue),
1581           aDest,
1582           aError
1583         );
1584     }
1585 };
1586 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU32Oct : public UniffiHandlerBase {
1587 private:
1588     // PrepareRustArgs stores the resulting arguments in these fields
1589     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1590     typename ScaffoldingConverter<uint32_t>::IntermediateType mValue;
1591
1592     // MakeRustCall stores the result of the call in these fields
1593     typename ScaffoldingConverter<uint32_t>::IntermediateType mUniffiReturnValue;
1594
1595 public:
1596     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1597         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1598         if (aError.Failed()) {
1599             return;
1600         }
1601         ScaffoldingConverter<uint32_t>::FromJs(aArgs[1], &mValue, aError);
1602         if (aError.Failed()) {
1603             return;
1604         }
1605     }
1606
1607     void MakeRustCall() override {
1608         RustCallStatus callStatus{};
1609         mUniffiReturnValue = ScaffoldingConverter<uint32_t>::FromRust(
1610             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u32_oct(
1611                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1612                 ScaffoldingConverter<uint32_t>::IntoRust(std::move(mValue)),
1613                 &callStatus
1614             )
1615         );
1616
1617         mUniffiCallStatusCode = callStatus.code;
1618         if (callStatus.error_buf.data) {
1619             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1620         }
1621     }
1622
1623     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1624         ScaffoldingConverter<uint32_t>::IntoJs(
1625           aCx,
1626           std::move(mUniffiReturnValue),
1627           aDest,
1628           aError
1629         );
1630     }
1631 };
1632 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU64Dec : public UniffiHandlerBase {
1633 private:
1634     // PrepareRustArgs stores the resulting arguments in these fields
1635     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1636     typename ScaffoldingConverter<uint64_t>::IntermediateType mValue;
1637
1638     // MakeRustCall stores the result of the call in these fields
1639     typename ScaffoldingConverter<uint64_t>::IntermediateType mUniffiReturnValue;
1640
1641 public:
1642     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1643         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1644         if (aError.Failed()) {
1645             return;
1646         }
1647         ScaffoldingConverter<uint64_t>::FromJs(aArgs[1], &mValue, aError);
1648         if (aError.Failed()) {
1649             return;
1650         }
1651     }
1652
1653     void MakeRustCall() override {
1654         RustCallStatus callStatus{};
1655         mUniffiReturnValue = ScaffoldingConverter<uint64_t>::FromRust(
1656             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u64_dec(
1657                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1658                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mValue)),
1659                 &callStatus
1660             )
1661         );
1662
1663         mUniffiCallStatusCode = callStatus.code;
1664         if (callStatus.error_buf.data) {
1665             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1666         }
1667     }
1668
1669     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1670         ScaffoldingConverter<uint64_t>::IntoJs(
1671           aCx,
1672           std::move(mUniffiReturnValue),
1673           aDest,
1674           aError
1675         );
1676     }
1677 };
1678 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU64Hex : public UniffiHandlerBase {
1679 private:
1680     // PrepareRustArgs stores the resulting arguments in these fields
1681     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1682     typename ScaffoldingConverter<uint64_t>::IntermediateType mValue;
1683
1684     // MakeRustCall stores the result of the call in these fields
1685     typename ScaffoldingConverter<uint64_t>::IntermediateType mUniffiReturnValue;
1686
1687 public:
1688     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1689         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1690         if (aError.Failed()) {
1691             return;
1692         }
1693         ScaffoldingConverter<uint64_t>::FromJs(aArgs[1], &mValue, aError);
1694         if (aError.Failed()) {
1695             return;
1696         }
1697     }
1698
1699     void MakeRustCall() override {
1700         RustCallStatus callStatus{};
1701         mUniffiReturnValue = ScaffoldingConverter<uint64_t>::FromRust(
1702             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u64_hex(
1703                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1704                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mValue)),
1705                 &callStatus
1706             )
1707         );
1708
1709         mUniffiCallStatusCode = callStatus.code;
1710         if (callStatus.error_buf.data) {
1711             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1712         }
1713     }
1714
1715     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1716         ScaffoldingConverter<uint64_t>::IntoJs(
1717           aCx,
1718           std::move(mUniffiReturnValue),
1719           aDest,
1720           aError
1721         );
1722     }
1723 };
1724 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU8Dec : public UniffiHandlerBase {
1725 private:
1726     // PrepareRustArgs stores the resulting arguments in these fields
1727     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1728     typename ScaffoldingConverter<uint8_t>::IntermediateType mValue;
1729
1730     // MakeRustCall stores the result of the call in these fields
1731     typename ScaffoldingConverter<uint8_t>::IntermediateType mUniffiReturnValue;
1732
1733 public:
1734     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1735         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1736         if (aError.Failed()) {
1737             return;
1738         }
1739         ScaffoldingConverter<uint8_t>::FromJs(aArgs[1], &mValue, aError);
1740         if (aError.Failed()) {
1741             return;
1742         }
1743     }
1744
1745     void MakeRustCall() override {
1746         RustCallStatus callStatus{};
1747         mUniffiReturnValue = ScaffoldingConverter<uint8_t>::FromRust(
1748             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u8_dec(
1749                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1750                 ScaffoldingConverter<uint8_t>::IntoRust(std::move(mValue)),
1751                 &callStatus
1752             )
1753         );
1754
1755         mUniffiCallStatusCode = callStatus.code;
1756         if (callStatus.error_buf.data) {
1757             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1758         }
1759     }
1760
1761     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1762         ScaffoldingConverter<uint8_t>::IntoJs(
1763           aCx,
1764           std::move(mUniffiReturnValue),
1765           aDest,
1766           aError
1767         );
1768     }
1769 };
1770 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU8Hex : public UniffiHandlerBase {
1771 private:
1772     // PrepareRustArgs stores the resulting arguments in these fields
1773     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1774     typename ScaffoldingConverter<uint8_t>::IntermediateType mValue;
1775
1776     // MakeRustCall stores the result of the call in these fields
1777     typename ScaffoldingConverter<uint8_t>::IntermediateType mUniffiReturnValue;
1778
1779 public:
1780     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1781         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1782         if (aError.Failed()) {
1783             return;
1784         }
1785         ScaffoldingConverter<uint8_t>::FromJs(aArgs[1], &mValue, aError);
1786         if (aError.Failed()) {
1787             return;
1788         }
1789     }
1790
1791     void MakeRustCall() override {
1792         RustCallStatus callStatus{};
1793         mUniffiReturnValue = ScaffoldingConverter<uint8_t>::FromRust(
1794             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_u8_hex(
1795                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1796                 ScaffoldingConverter<uint8_t>::IntoRust(std::move(mValue)),
1797                 &callStatus
1798             )
1799         );
1800
1801         mUniffiCallStatusCode = callStatus.code;
1802         if (callStatus.error_buf.data) {
1803             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1804         }
1805     }
1806
1807     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1808         ScaffoldingConverter<uint8_t>::IntoJs(
1809           aCx,
1810           std::move(mUniffiReturnValue),
1811           aDest,
1812           aError
1813         );
1814     }
1815 };
1816 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonZero : public UniffiHandlerBase {
1817 private:
1818     // PrepareRustArgs stores the resulting arguments in these fields
1819     typename ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntermediateType mPtr;
1820     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
1821
1822     // MakeRustCall stores the result of the call in these fields
1823     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
1824
1825 public:
1826     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1827         ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1828         if (aError.Failed()) {
1829             return;
1830         }
1831         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
1832         if (aError.Failed()) {
1833             return;
1834         }
1835     }
1836
1837     void MakeRustCall() override {
1838         RustCallStatus callStatus{};
1839         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
1840             uniffi_uniffi_rondpoint_fn_method_optionneur_sinon_zero(
1841                 ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>::IntoRust(std::move(mPtr)),
1842                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
1843                 &callStatus
1844             )
1845         );
1846
1847         mUniffiCallStatusCode = callStatus.code;
1848         if (callStatus.error_buf.data) {
1849             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1850         }
1851     }
1852
1853     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1854         ScaffoldingConverter<RustBuffer>::IntoJs(
1855           aCx,
1856           std::move(mUniffiReturnValue),
1857           aDest,
1858           aError
1859         );
1860     }
1861 };
1862 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnConstructorRetourneurNew : public UniffiHandlerBase {
1863 private:
1864     // PrepareRustArgs stores the resulting arguments in these fields
1865
1866     // MakeRustCall stores the result of the call in these fields
1867     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mUniffiReturnValue;
1868
1869 public:
1870     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1871     }
1872
1873     void MakeRustCall() override {
1874         RustCallStatus callStatus{};
1875         mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromRust(
1876             uniffi_uniffi_rondpoint_fn_constructor_retourneur_new(
1877                 &callStatus
1878             )
1879         );
1880
1881         mUniffiCallStatusCode = callStatus.code;
1882         if (callStatus.error_buf.data) {
1883             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1884         }
1885     }
1886
1887     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1888         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoJs(
1889           aCx,
1890           std::move(mUniffiReturnValue),
1891           aDest,
1892           aError
1893         );
1894     }
1895 };
1896 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueBoolean : public UniffiHandlerBase {
1897 private:
1898     // PrepareRustArgs stores the resulting arguments in these fields
1899     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
1900     typename ScaffoldingConverter<int8_t>::IntermediateType mValue;
1901
1902     // MakeRustCall stores the result of the call in these fields
1903     typename ScaffoldingConverter<int8_t>::IntermediateType mUniffiReturnValue;
1904
1905 public:
1906     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1907         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1908         if (aError.Failed()) {
1909             return;
1910         }
1911         ScaffoldingConverter<int8_t>::FromJs(aArgs[1], &mValue, aError);
1912         if (aError.Failed()) {
1913             return;
1914         }
1915     }
1916
1917     void MakeRustCall() override {
1918         RustCallStatus callStatus{};
1919         mUniffiReturnValue = ScaffoldingConverter<int8_t>::FromRust(
1920             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_boolean(
1921                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
1922                 ScaffoldingConverter<int8_t>::IntoRust(std::move(mValue)),
1923                 &callStatus
1924             )
1925         );
1926
1927         mUniffiCallStatusCode = callStatus.code;
1928         if (callStatus.error_buf.data) {
1929             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1930         }
1931     }
1932
1933     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1934         ScaffoldingConverter<int8_t>::IntoJs(
1935           aCx,
1936           std::move(mUniffiReturnValue),
1937           aDest,
1938           aError
1939         );
1940     }
1941 };
1942 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueDouble : public UniffiHandlerBase {
1943 private:
1944     // PrepareRustArgs stores the resulting arguments in these fields
1945     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
1946     typename ScaffoldingConverter<double>::IntermediateType mValue;
1947
1948     // MakeRustCall stores the result of the call in these fields
1949     typename ScaffoldingConverter<double>::IntermediateType mUniffiReturnValue;
1950
1951 public:
1952     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1953         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
1954         if (aError.Failed()) {
1955             return;
1956         }
1957         ScaffoldingConverter<double>::FromJs(aArgs[1], &mValue, aError);
1958         if (aError.Failed()) {
1959             return;
1960         }
1961     }
1962
1963     void MakeRustCall() override {
1964         RustCallStatus callStatus{};
1965         mUniffiReturnValue = ScaffoldingConverter<double>::FromRust(
1966             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_double(
1967                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
1968                 ScaffoldingConverter<double>::IntoRust(std::move(mValue)),
1969                 &callStatus
1970             )
1971         );
1972
1973         mUniffiCallStatusCode = callStatus.code;
1974         if (callStatus.error_buf.data) {
1975             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
1976         }
1977     }
1978
1979     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
1980         ScaffoldingConverter<double>::IntoJs(
1981           aCx,
1982           std::move(mUniffiReturnValue),
1983           aDest,
1984           aError
1985         );
1986     }
1987 };
1988 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueFloat : public UniffiHandlerBase {
1989 private:
1990     // PrepareRustArgs stores the resulting arguments in these fields
1991     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
1992     typename ScaffoldingConverter<float>::IntermediateType mValue;
1993
1994     // MakeRustCall stores the result of the call in these fields
1995     typename ScaffoldingConverter<float>::IntermediateType mUniffiReturnValue;
1996
1997 public:
1998     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
1999         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2000         if (aError.Failed()) {
2001             return;
2002         }
2003         ScaffoldingConverter<float>::FromJs(aArgs[1], &mValue, aError);
2004         if (aError.Failed()) {
2005             return;
2006         }
2007     }
2008
2009     void MakeRustCall() override {
2010         RustCallStatus callStatus{};
2011         mUniffiReturnValue = ScaffoldingConverter<float>::FromRust(
2012             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_float(
2013                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2014                 ScaffoldingConverter<float>::IntoRust(std::move(mValue)),
2015                 &callStatus
2016             )
2017         );
2018
2019         mUniffiCallStatusCode = callStatus.code;
2020         if (callStatus.error_buf.data) {
2021             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2022         }
2023     }
2024
2025     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2026         ScaffoldingConverter<float>::IntoJs(
2027           aCx,
2028           std::move(mUniffiReturnValue),
2029           aDest,
2030           aError
2031         );
2032     }
2033 };
2034 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueI16 : public UniffiHandlerBase {
2035 private:
2036     // PrepareRustArgs stores the resulting arguments in these fields
2037     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2038     typename ScaffoldingConverter<int16_t>::IntermediateType mValue;
2039
2040     // MakeRustCall stores the result of the call in these fields
2041     typename ScaffoldingConverter<int16_t>::IntermediateType mUniffiReturnValue;
2042
2043 public:
2044     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2045         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2046         if (aError.Failed()) {
2047             return;
2048         }
2049         ScaffoldingConverter<int16_t>::FromJs(aArgs[1], &mValue, aError);
2050         if (aError.Failed()) {
2051             return;
2052         }
2053     }
2054
2055     void MakeRustCall() override {
2056         RustCallStatus callStatus{};
2057         mUniffiReturnValue = ScaffoldingConverter<int16_t>::FromRust(
2058             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i16(
2059                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2060                 ScaffoldingConverter<int16_t>::IntoRust(std::move(mValue)),
2061                 &callStatus
2062             )
2063         );
2064
2065         mUniffiCallStatusCode = callStatus.code;
2066         if (callStatus.error_buf.data) {
2067             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2068         }
2069     }
2070
2071     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2072         ScaffoldingConverter<int16_t>::IntoJs(
2073           aCx,
2074           std::move(mUniffiReturnValue),
2075           aDest,
2076           aError
2077         );
2078     }
2079 };
2080 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueI32 : public UniffiHandlerBase {
2081 private:
2082     // PrepareRustArgs stores the resulting arguments in these fields
2083     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2084     typename ScaffoldingConverter<int32_t>::IntermediateType mValue;
2085
2086     // MakeRustCall stores the result of the call in these fields
2087     typename ScaffoldingConverter<int32_t>::IntermediateType mUniffiReturnValue;
2088
2089 public:
2090     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2091         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2092         if (aError.Failed()) {
2093             return;
2094         }
2095         ScaffoldingConverter<int32_t>::FromJs(aArgs[1], &mValue, aError);
2096         if (aError.Failed()) {
2097             return;
2098         }
2099     }
2100
2101     void MakeRustCall() override {
2102         RustCallStatus callStatus{};
2103         mUniffiReturnValue = ScaffoldingConverter<int32_t>::FromRust(
2104             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i32(
2105                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2106                 ScaffoldingConverter<int32_t>::IntoRust(std::move(mValue)),
2107                 &callStatus
2108             )
2109         );
2110
2111         mUniffiCallStatusCode = callStatus.code;
2112         if (callStatus.error_buf.data) {
2113             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2114         }
2115     }
2116
2117     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2118         ScaffoldingConverter<int32_t>::IntoJs(
2119           aCx,
2120           std::move(mUniffiReturnValue),
2121           aDest,
2122           aError
2123         );
2124     }
2125 };
2126 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueI64 : public UniffiHandlerBase {
2127 private:
2128     // PrepareRustArgs stores the resulting arguments in these fields
2129     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2130     typename ScaffoldingConverter<int64_t>::IntermediateType mValue;
2131
2132     // MakeRustCall stores the result of the call in these fields
2133     typename ScaffoldingConverter<int64_t>::IntermediateType mUniffiReturnValue;
2134
2135 public:
2136     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2137         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2138         if (aError.Failed()) {
2139             return;
2140         }
2141         ScaffoldingConverter<int64_t>::FromJs(aArgs[1], &mValue, aError);
2142         if (aError.Failed()) {
2143             return;
2144         }
2145     }
2146
2147     void MakeRustCall() override {
2148         RustCallStatus callStatus{};
2149         mUniffiReturnValue = ScaffoldingConverter<int64_t>::FromRust(
2150             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i64(
2151                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2152                 ScaffoldingConverter<int64_t>::IntoRust(std::move(mValue)),
2153                 &callStatus
2154             )
2155         );
2156
2157         mUniffiCallStatusCode = callStatus.code;
2158         if (callStatus.error_buf.data) {
2159             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2160         }
2161     }
2162
2163     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2164         ScaffoldingConverter<int64_t>::IntoJs(
2165           aCx,
2166           std::move(mUniffiReturnValue),
2167           aDest,
2168           aError
2169         );
2170     }
2171 };
2172 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueI8 : public UniffiHandlerBase {
2173 private:
2174     // PrepareRustArgs stores the resulting arguments in these fields
2175     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2176     typename ScaffoldingConverter<int8_t>::IntermediateType mValue;
2177
2178     // MakeRustCall stores the result of the call in these fields
2179     typename ScaffoldingConverter<int8_t>::IntermediateType mUniffiReturnValue;
2180
2181 public:
2182     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2183         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2184         if (aError.Failed()) {
2185             return;
2186         }
2187         ScaffoldingConverter<int8_t>::FromJs(aArgs[1], &mValue, aError);
2188         if (aError.Failed()) {
2189             return;
2190         }
2191     }
2192
2193     void MakeRustCall() override {
2194         RustCallStatus callStatus{};
2195         mUniffiReturnValue = ScaffoldingConverter<int8_t>::FromRust(
2196             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_i8(
2197                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2198                 ScaffoldingConverter<int8_t>::IntoRust(std::move(mValue)),
2199                 &callStatus
2200             )
2201         );
2202
2203         mUniffiCallStatusCode = callStatus.code;
2204         if (callStatus.error_buf.data) {
2205             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2206         }
2207     }
2208
2209     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2210         ScaffoldingConverter<int8_t>::IntoJs(
2211           aCx,
2212           std::move(mUniffiReturnValue),
2213           aDest,
2214           aError
2215         );
2216     }
2217 };
2218 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueNombres : public UniffiHandlerBase {
2219 private:
2220     // PrepareRustArgs stores the resulting arguments in these fields
2221     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2222     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
2223
2224     // MakeRustCall stores the result of the call in these fields
2225     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2226
2227 public:
2228     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2229         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2230         if (aError.Failed()) {
2231             return;
2232         }
2233         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
2234         if (aError.Failed()) {
2235             return;
2236         }
2237     }
2238
2239     void MakeRustCall() override {
2240         RustCallStatus callStatus{};
2241         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2242             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_nombres(
2243                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2244                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
2245                 &callStatus
2246             )
2247         );
2248
2249         mUniffiCallStatusCode = callStatus.code;
2250         if (callStatus.error_buf.data) {
2251             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2252         }
2253     }
2254
2255     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2256         ScaffoldingConverter<RustBuffer>::IntoJs(
2257           aCx,
2258           std::move(mUniffiReturnValue),
2259           aDest,
2260           aError
2261         );
2262     }
2263 };
2264 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueNombresSignes : public UniffiHandlerBase {
2265 private:
2266     // PrepareRustArgs stores the resulting arguments in these fields
2267     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2268     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
2269
2270     // MakeRustCall stores the result of the call in these fields
2271     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2272
2273 public:
2274     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2275         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2276         if (aError.Failed()) {
2277             return;
2278         }
2279         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
2280         if (aError.Failed()) {
2281             return;
2282         }
2283     }
2284
2285     void MakeRustCall() override {
2286         RustCallStatus callStatus{};
2287         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2288             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_nombres_signes(
2289                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2290                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
2291                 &callStatus
2292             )
2293         );
2294
2295         mUniffiCallStatusCode = callStatus.code;
2296         if (callStatus.error_buf.data) {
2297             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2298         }
2299     }
2300
2301     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2302         ScaffoldingConverter<RustBuffer>::IntoJs(
2303           aCx,
2304           std::move(mUniffiReturnValue),
2305           aDest,
2306           aError
2307         );
2308     }
2309 };
2310 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueOptionneurDictionnaire : public UniffiHandlerBase {
2311 private:
2312     // PrepareRustArgs stores the resulting arguments in these fields
2313     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2314     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
2315
2316     // MakeRustCall stores the result of the call in these fields
2317     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2318
2319 public:
2320     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2321         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2322         if (aError.Failed()) {
2323             return;
2324         }
2325         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
2326         if (aError.Failed()) {
2327             return;
2328         }
2329     }
2330
2331     void MakeRustCall() override {
2332         RustCallStatus callStatus{};
2333         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2334             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_optionneur_dictionnaire(
2335                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2336                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
2337                 &callStatus
2338             )
2339         );
2340
2341         mUniffiCallStatusCode = callStatus.code;
2342         if (callStatus.error_buf.data) {
2343             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2344         }
2345     }
2346
2347     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2348         ScaffoldingConverter<RustBuffer>::IntoJs(
2349           aCx,
2350           std::move(mUniffiReturnValue),
2351           aDest,
2352           aError
2353         );
2354     }
2355 };
2356 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueString : public UniffiHandlerBase {
2357 private:
2358     // PrepareRustArgs stores the resulting arguments in these fields
2359     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2360     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
2361
2362     // MakeRustCall stores the result of the call in these fields
2363     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2364
2365 public:
2366     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2367         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2368         if (aError.Failed()) {
2369             return;
2370         }
2371         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
2372         if (aError.Failed()) {
2373             return;
2374         }
2375     }
2376
2377     void MakeRustCall() override {
2378         RustCallStatus callStatus{};
2379         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2380             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_string(
2381                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2382                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
2383                 &callStatus
2384             )
2385         );
2386
2387         mUniffiCallStatusCode = callStatus.code;
2388         if (callStatus.error_buf.data) {
2389             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2390         }
2391     }
2392
2393     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2394         ScaffoldingConverter<RustBuffer>::IntoJs(
2395           aCx,
2396           std::move(mUniffiReturnValue),
2397           aDest,
2398           aError
2399         );
2400     }
2401 };
2402 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueU16 : public UniffiHandlerBase {
2403 private:
2404     // PrepareRustArgs stores the resulting arguments in these fields
2405     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2406     typename ScaffoldingConverter<uint16_t>::IntermediateType mValue;
2407
2408     // MakeRustCall stores the result of the call in these fields
2409     typename ScaffoldingConverter<uint16_t>::IntermediateType mUniffiReturnValue;
2410
2411 public:
2412     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2413         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2414         if (aError.Failed()) {
2415             return;
2416         }
2417         ScaffoldingConverter<uint16_t>::FromJs(aArgs[1], &mValue, aError);
2418         if (aError.Failed()) {
2419             return;
2420         }
2421     }
2422
2423     void MakeRustCall() override {
2424         RustCallStatus callStatus{};
2425         mUniffiReturnValue = ScaffoldingConverter<uint16_t>::FromRust(
2426             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u16(
2427                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2428                 ScaffoldingConverter<uint16_t>::IntoRust(std::move(mValue)),
2429                 &callStatus
2430             )
2431         );
2432
2433         mUniffiCallStatusCode = callStatus.code;
2434         if (callStatus.error_buf.data) {
2435             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2436         }
2437     }
2438
2439     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2440         ScaffoldingConverter<uint16_t>::IntoJs(
2441           aCx,
2442           std::move(mUniffiReturnValue),
2443           aDest,
2444           aError
2445         );
2446     }
2447 };
2448 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueU32 : public UniffiHandlerBase {
2449 private:
2450     // PrepareRustArgs stores the resulting arguments in these fields
2451     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2452     typename ScaffoldingConverter<uint32_t>::IntermediateType mValue;
2453
2454     // MakeRustCall stores the result of the call in these fields
2455     typename ScaffoldingConverter<uint32_t>::IntermediateType mUniffiReturnValue;
2456
2457 public:
2458     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2459         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2460         if (aError.Failed()) {
2461             return;
2462         }
2463         ScaffoldingConverter<uint32_t>::FromJs(aArgs[1], &mValue, aError);
2464         if (aError.Failed()) {
2465             return;
2466         }
2467     }
2468
2469     void MakeRustCall() override {
2470         RustCallStatus callStatus{};
2471         mUniffiReturnValue = ScaffoldingConverter<uint32_t>::FromRust(
2472             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u32(
2473                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2474                 ScaffoldingConverter<uint32_t>::IntoRust(std::move(mValue)),
2475                 &callStatus
2476             )
2477         );
2478
2479         mUniffiCallStatusCode = callStatus.code;
2480         if (callStatus.error_buf.data) {
2481             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2482         }
2483     }
2484
2485     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2486         ScaffoldingConverter<uint32_t>::IntoJs(
2487           aCx,
2488           std::move(mUniffiReturnValue),
2489           aDest,
2490           aError
2491         );
2492     }
2493 };
2494 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueU64 : public UniffiHandlerBase {
2495 private:
2496     // PrepareRustArgs stores the resulting arguments in these fields
2497     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2498     typename ScaffoldingConverter<uint64_t>::IntermediateType mValue;
2499
2500     // MakeRustCall stores the result of the call in these fields
2501     typename ScaffoldingConverter<uint64_t>::IntermediateType mUniffiReturnValue;
2502
2503 public:
2504     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2505         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2506         if (aError.Failed()) {
2507             return;
2508         }
2509         ScaffoldingConverter<uint64_t>::FromJs(aArgs[1], &mValue, aError);
2510         if (aError.Failed()) {
2511             return;
2512         }
2513     }
2514
2515     void MakeRustCall() override {
2516         RustCallStatus callStatus{};
2517         mUniffiReturnValue = ScaffoldingConverter<uint64_t>::FromRust(
2518             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u64(
2519                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2520                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mValue)),
2521                 &callStatus
2522             )
2523         );
2524
2525         mUniffiCallStatusCode = callStatus.code;
2526         if (callStatus.error_buf.data) {
2527             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2528         }
2529     }
2530
2531     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2532         ScaffoldingConverter<uint64_t>::IntoJs(
2533           aCx,
2534           std::move(mUniffiReturnValue),
2535           aDest,
2536           aError
2537         );
2538     }
2539 };
2540 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueU8 : public UniffiHandlerBase {
2541 private:
2542     // PrepareRustArgs stores the resulting arguments in these fields
2543     typename ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntermediateType mPtr;
2544     typename ScaffoldingConverter<uint8_t>::IntermediateType mValue;
2545
2546     // MakeRustCall stores the result of the call in these fields
2547     typename ScaffoldingConverter<uint8_t>::IntermediateType mUniffiReturnValue;
2548
2549 public:
2550     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2551         ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::FromJs(aArgs[0], &mPtr, aError);
2552         if (aError.Failed()) {
2553             return;
2554         }
2555         ScaffoldingConverter<uint8_t>::FromJs(aArgs[1], &mValue, aError);
2556         if (aError.Failed()) {
2557             return;
2558         }
2559     }
2560
2561     void MakeRustCall() override {
2562         RustCallStatus callStatus{};
2563         mUniffiReturnValue = ScaffoldingConverter<uint8_t>::FromRust(
2564             uniffi_uniffi_rondpoint_fn_method_retourneur_identique_u8(
2565                 ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>::IntoRust(std::move(mPtr)),
2566                 ScaffoldingConverter<uint8_t>::IntoRust(std::move(mValue)),
2567                 &callStatus
2568             )
2569         );
2570
2571         mUniffiCallStatusCode = callStatus.code;
2572         if (callStatus.error_buf.data) {
2573             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2574         }
2575     }
2576
2577     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2578         ScaffoldingConverter<uint8_t>::IntoJs(
2579           aCx,
2580           std::move(mUniffiReturnValue),
2581           aDest,
2582           aError
2583         );
2584     }
2585 };
2586 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnConstructorStringifierNew : public UniffiHandlerBase {
2587 private:
2588     // PrepareRustArgs stores the resulting arguments in these fields
2589
2590     // MakeRustCall stores the result of the call in these fields
2591     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mUniffiReturnValue;
2592
2593 public:
2594     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2595     }
2596
2597     void MakeRustCall() override {
2598         RustCallStatus callStatus{};
2599         mUniffiReturnValue = ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromRust(
2600             uniffi_uniffi_rondpoint_fn_constructor_stringifier_new(
2601                 &callStatus
2602             )
2603         );
2604
2605         mUniffiCallStatusCode = callStatus.code;
2606         if (callStatus.error_buf.data) {
2607             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2608         }
2609     }
2610
2611     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2612         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoJs(
2613           aCx,
2614           std::move(mUniffiReturnValue),
2615           aDest,
2616           aError
2617         );
2618     }
2619 };
2620 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringBoolean : public UniffiHandlerBase {
2621 private:
2622     // PrepareRustArgs stores the resulting arguments in these fields
2623     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2624     typename ScaffoldingConverter<int8_t>::IntermediateType mValue;
2625
2626     // MakeRustCall stores the result of the call in these fields
2627     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2628
2629 public:
2630     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2631         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
2632         if (aError.Failed()) {
2633             return;
2634         }
2635         ScaffoldingConverter<int8_t>::FromJs(aArgs[1], &mValue, aError);
2636         if (aError.Failed()) {
2637             return;
2638         }
2639     }
2640
2641     void MakeRustCall() override {
2642         RustCallStatus callStatus{};
2643         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2644             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_boolean(
2645                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
2646                 ScaffoldingConverter<int8_t>::IntoRust(std::move(mValue)),
2647                 &callStatus
2648             )
2649         );
2650
2651         mUniffiCallStatusCode = callStatus.code;
2652         if (callStatus.error_buf.data) {
2653             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2654         }
2655     }
2656
2657     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2658         ScaffoldingConverter<RustBuffer>::IntoJs(
2659           aCx,
2660           std::move(mUniffiReturnValue),
2661           aDest,
2662           aError
2663         );
2664     }
2665 };
2666 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringDouble : public UniffiHandlerBase {
2667 private:
2668     // PrepareRustArgs stores the resulting arguments in these fields
2669     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2670     typename ScaffoldingConverter<double>::IntermediateType mValue;
2671
2672     // MakeRustCall stores the result of the call in these fields
2673     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2674
2675 public:
2676     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2677         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
2678         if (aError.Failed()) {
2679             return;
2680         }
2681         ScaffoldingConverter<double>::FromJs(aArgs[1], &mValue, aError);
2682         if (aError.Failed()) {
2683             return;
2684         }
2685     }
2686
2687     void MakeRustCall() override {
2688         RustCallStatus callStatus{};
2689         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2690             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_double(
2691                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
2692                 ScaffoldingConverter<double>::IntoRust(std::move(mValue)),
2693                 &callStatus
2694             )
2695         );
2696
2697         mUniffiCallStatusCode = callStatus.code;
2698         if (callStatus.error_buf.data) {
2699             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2700         }
2701     }
2702
2703     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2704         ScaffoldingConverter<RustBuffer>::IntoJs(
2705           aCx,
2706           std::move(mUniffiReturnValue),
2707           aDest,
2708           aError
2709         );
2710     }
2711 };
2712 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringFloat : public UniffiHandlerBase {
2713 private:
2714     // PrepareRustArgs stores the resulting arguments in these fields
2715     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2716     typename ScaffoldingConverter<float>::IntermediateType mValue;
2717
2718     // MakeRustCall stores the result of the call in these fields
2719     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2720
2721 public:
2722     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2723         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
2724         if (aError.Failed()) {
2725             return;
2726         }
2727         ScaffoldingConverter<float>::FromJs(aArgs[1], &mValue, aError);
2728         if (aError.Failed()) {
2729             return;
2730         }
2731     }
2732
2733     void MakeRustCall() override {
2734         RustCallStatus callStatus{};
2735         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2736             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_float(
2737                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
2738                 ScaffoldingConverter<float>::IntoRust(std::move(mValue)),
2739                 &callStatus
2740             )
2741         );
2742
2743         mUniffiCallStatusCode = callStatus.code;
2744         if (callStatus.error_buf.data) {
2745             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2746         }
2747     }
2748
2749     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2750         ScaffoldingConverter<RustBuffer>::IntoJs(
2751           aCx,
2752           std::move(mUniffiReturnValue),
2753           aDest,
2754           aError
2755         );
2756     }
2757 };
2758 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringI16 : public UniffiHandlerBase {
2759 private:
2760     // PrepareRustArgs stores the resulting arguments in these fields
2761     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2762     typename ScaffoldingConverter<int16_t>::IntermediateType mValue;
2763
2764     // MakeRustCall stores the result of the call in these fields
2765     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2766
2767 public:
2768     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2769         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
2770         if (aError.Failed()) {
2771             return;
2772         }
2773         ScaffoldingConverter<int16_t>::FromJs(aArgs[1], &mValue, aError);
2774         if (aError.Failed()) {
2775             return;
2776         }
2777     }
2778
2779     void MakeRustCall() override {
2780         RustCallStatus callStatus{};
2781         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2782             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i16(
2783                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
2784                 ScaffoldingConverter<int16_t>::IntoRust(std::move(mValue)),
2785                 &callStatus
2786             )
2787         );
2788
2789         mUniffiCallStatusCode = callStatus.code;
2790         if (callStatus.error_buf.data) {
2791             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2792         }
2793     }
2794
2795     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2796         ScaffoldingConverter<RustBuffer>::IntoJs(
2797           aCx,
2798           std::move(mUniffiReturnValue),
2799           aDest,
2800           aError
2801         );
2802     }
2803 };
2804 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringI32 : public UniffiHandlerBase {
2805 private:
2806     // PrepareRustArgs stores the resulting arguments in these fields
2807     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2808     typename ScaffoldingConverter<int32_t>::IntermediateType mValue;
2809
2810     // MakeRustCall stores the result of the call in these fields
2811     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2812
2813 public:
2814     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2815         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
2816         if (aError.Failed()) {
2817             return;
2818         }
2819         ScaffoldingConverter<int32_t>::FromJs(aArgs[1], &mValue, aError);
2820         if (aError.Failed()) {
2821             return;
2822         }
2823     }
2824
2825     void MakeRustCall() override {
2826         RustCallStatus callStatus{};
2827         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2828             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i32(
2829                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
2830                 ScaffoldingConverter<int32_t>::IntoRust(std::move(mValue)),
2831                 &callStatus
2832             )
2833         );
2834
2835         mUniffiCallStatusCode = callStatus.code;
2836         if (callStatus.error_buf.data) {
2837             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2838         }
2839     }
2840
2841     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2842         ScaffoldingConverter<RustBuffer>::IntoJs(
2843           aCx,
2844           std::move(mUniffiReturnValue),
2845           aDest,
2846           aError
2847         );
2848     }
2849 };
2850 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringI64 : public UniffiHandlerBase {
2851 private:
2852     // PrepareRustArgs stores the resulting arguments in these fields
2853     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2854     typename ScaffoldingConverter<int64_t>::IntermediateType mValue;
2855
2856     // MakeRustCall stores the result of the call in these fields
2857     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2858
2859 public:
2860     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2861         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
2862         if (aError.Failed()) {
2863             return;
2864         }
2865         ScaffoldingConverter<int64_t>::FromJs(aArgs[1], &mValue, aError);
2866         if (aError.Failed()) {
2867             return;
2868         }
2869     }
2870
2871     void MakeRustCall() override {
2872         RustCallStatus callStatus{};
2873         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2874             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i64(
2875                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
2876                 ScaffoldingConverter<int64_t>::IntoRust(std::move(mValue)),
2877                 &callStatus
2878             )
2879         );
2880
2881         mUniffiCallStatusCode = callStatus.code;
2882         if (callStatus.error_buf.data) {
2883             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2884         }
2885     }
2886
2887     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2888         ScaffoldingConverter<RustBuffer>::IntoJs(
2889           aCx,
2890           std::move(mUniffiReturnValue),
2891           aDest,
2892           aError
2893         );
2894     }
2895 };
2896 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringI8 : public UniffiHandlerBase {
2897 private:
2898     // PrepareRustArgs stores the resulting arguments in these fields
2899     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2900     typename ScaffoldingConverter<int8_t>::IntermediateType mValue;
2901
2902     // MakeRustCall stores the result of the call in these fields
2903     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2904
2905 public:
2906     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2907         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
2908         if (aError.Failed()) {
2909             return;
2910         }
2911         ScaffoldingConverter<int8_t>::FromJs(aArgs[1], &mValue, aError);
2912         if (aError.Failed()) {
2913             return;
2914         }
2915     }
2916
2917     void MakeRustCall() override {
2918         RustCallStatus callStatus{};
2919         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2920             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_i8(
2921                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
2922                 ScaffoldingConverter<int8_t>::IntoRust(std::move(mValue)),
2923                 &callStatus
2924             )
2925         );
2926
2927         mUniffiCallStatusCode = callStatus.code;
2928         if (callStatus.error_buf.data) {
2929             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2930         }
2931     }
2932
2933     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2934         ScaffoldingConverter<RustBuffer>::IntoJs(
2935           aCx,
2936           std::move(mUniffiReturnValue),
2937           aDest,
2938           aError
2939         );
2940     }
2941 };
2942 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringU16 : public UniffiHandlerBase {
2943 private:
2944     // PrepareRustArgs stores the resulting arguments in these fields
2945     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2946     typename ScaffoldingConverter<uint16_t>::IntermediateType mValue;
2947
2948     // MakeRustCall stores the result of the call in these fields
2949     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2950
2951 public:
2952     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2953         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
2954         if (aError.Failed()) {
2955             return;
2956         }
2957         ScaffoldingConverter<uint16_t>::FromJs(aArgs[1], &mValue, aError);
2958         if (aError.Failed()) {
2959             return;
2960         }
2961     }
2962
2963     void MakeRustCall() override {
2964         RustCallStatus callStatus{};
2965         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
2966             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u16(
2967                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
2968                 ScaffoldingConverter<uint16_t>::IntoRust(std::move(mValue)),
2969                 &callStatus
2970             )
2971         );
2972
2973         mUniffiCallStatusCode = callStatus.code;
2974         if (callStatus.error_buf.data) {
2975             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
2976         }
2977     }
2978
2979     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
2980         ScaffoldingConverter<RustBuffer>::IntoJs(
2981           aCx,
2982           std::move(mUniffiReturnValue),
2983           aDest,
2984           aError
2985         );
2986     }
2987 };
2988 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringU32 : public UniffiHandlerBase {
2989 private:
2990     // PrepareRustArgs stores the resulting arguments in these fields
2991     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
2992     typename ScaffoldingConverter<uint32_t>::IntermediateType mValue;
2993
2994     // MakeRustCall stores the result of the call in these fields
2995     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
2996
2997 public:
2998     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
2999         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
3000         if (aError.Failed()) {
3001             return;
3002         }
3003         ScaffoldingConverter<uint32_t>::FromJs(aArgs[1], &mValue, aError);
3004         if (aError.Failed()) {
3005             return;
3006         }
3007     }
3008
3009     void MakeRustCall() override {
3010         RustCallStatus callStatus{};
3011         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3012             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u32(
3013                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
3014                 ScaffoldingConverter<uint32_t>::IntoRust(std::move(mValue)),
3015                 &callStatus
3016             )
3017         );
3018
3019         mUniffiCallStatusCode = callStatus.code;
3020         if (callStatus.error_buf.data) {
3021             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3022         }
3023     }
3024
3025     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3026         ScaffoldingConverter<RustBuffer>::IntoJs(
3027           aCx,
3028           std::move(mUniffiReturnValue),
3029           aDest,
3030           aError
3031         );
3032     }
3033 };
3034 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringU64 : public UniffiHandlerBase {
3035 private:
3036     // PrepareRustArgs stores the resulting arguments in these fields
3037     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
3038     typename ScaffoldingConverter<uint64_t>::IntermediateType mValue;
3039
3040     // MakeRustCall stores the result of the call in these fields
3041     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3042
3043 public:
3044     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3045         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
3046         if (aError.Failed()) {
3047             return;
3048         }
3049         ScaffoldingConverter<uint64_t>::FromJs(aArgs[1], &mValue, aError);
3050         if (aError.Failed()) {
3051             return;
3052         }
3053     }
3054
3055     void MakeRustCall() override {
3056         RustCallStatus callStatus{};
3057         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3058             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u64(
3059                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
3060                 ScaffoldingConverter<uint64_t>::IntoRust(std::move(mValue)),
3061                 &callStatus
3062             )
3063         );
3064
3065         mUniffiCallStatusCode = callStatus.code;
3066         if (callStatus.error_buf.data) {
3067             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3068         }
3069     }
3070
3071     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3072         ScaffoldingConverter<RustBuffer>::IntoJs(
3073           aCx,
3074           std::move(mUniffiReturnValue),
3075           aDest,
3076           aError
3077         );
3078     }
3079 };
3080 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringU8 : public UniffiHandlerBase {
3081 private:
3082     // PrepareRustArgs stores the resulting arguments in these fields
3083     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
3084     typename ScaffoldingConverter<uint8_t>::IntermediateType mValue;
3085
3086     // MakeRustCall stores the result of the call in these fields
3087     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3088
3089 public:
3090     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3091         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
3092         if (aError.Failed()) {
3093             return;
3094         }
3095         ScaffoldingConverter<uint8_t>::FromJs(aArgs[1], &mValue, aError);
3096         if (aError.Failed()) {
3097             return;
3098         }
3099     }
3100
3101     void MakeRustCall() override {
3102         RustCallStatus callStatus{};
3103         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3104             uniffi_uniffi_rondpoint_fn_method_stringifier_to_string_u8(
3105                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
3106                 ScaffoldingConverter<uint8_t>::IntoRust(std::move(mValue)),
3107                 &callStatus
3108             )
3109         );
3110
3111         mUniffiCallStatusCode = callStatus.code;
3112         if (callStatus.error_buf.data) {
3113             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3114         }
3115     }
3116
3117     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3118         ScaffoldingConverter<RustBuffer>::IntoJs(
3119           aCx,
3120           std::move(mUniffiReturnValue),
3121           aDest,
3122           aError
3123         );
3124     }
3125 };
3126 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierWellKnownString : public UniffiHandlerBase {
3127 private:
3128     // PrepareRustArgs stores the resulting arguments in these fields
3129     typename ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntermediateType mPtr;
3130     typename ScaffoldingConverter<RustBuffer>::IntermediateType mValue;
3131
3132     // MakeRustCall stores the result of the call in these fields
3133     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3134
3135 public:
3136     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3137         ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::FromJs(aArgs[0], &mPtr, aError);
3138         if (aError.Failed()) {
3139             return;
3140         }
3141         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mValue, aError);
3142         if (aError.Failed()) {
3143             return;
3144         }
3145     }
3146
3147     void MakeRustCall() override {
3148         RustCallStatus callStatus{};
3149         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3150             uniffi_uniffi_rondpoint_fn_method_stringifier_well_known_string(
3151                 ScaffoldingObjectConverter<&kRondpointStringifierPointerType>::IntoRust(std::move(mPtr)),
3152                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mValue)),
3153                 &callStatus
3154             )
3155         );
3156
3157         mUniffiCallStatusCode = callStatus.code;
3158         if (callStatus.error_buf.data) {
3159             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3160         }
3161     }
3162
3163     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3164         ScaffoldingConverter<RustBuffer>::IntoJs(
3165           aCx,
3166           std::move(mUniffiReturnValue),
3167           aDest,
3168           aError
3169         );
3170     }
3171 };
3172 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncCopieCarte : public UniffiHandlerBase {
3173 private:
3174     // PrepareRustArgs stores the resulting arguments in these fields
3175     typename ScaffoldingConverter<RustBuffer>::IntermediateType mC;
3176
3177     // MakeRustCall stores the result of the call in these fields
3178     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3179
3180 public:
3181     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3182         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mC, aError);
3183         if (aError.Failed()) {
3184             return;
3185         }
3186     }
3187
3188     void MakeRustCall() override {
3189         RustCallStatus callStatus{};
3190         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3191             uniffi_uniffi_rondpoint_fn_func_copie_carte(
3192                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mC)),
3193                 &callStatus
3194             )
3195         );
3196
3197         mUniffiCallStatusCode = callStatus.code;
3198         if (callStatus.error_buf.data) {
3199             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3200         }
3201     }
3202
3203     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3204         ScaffoldingConverter<RustBuffer>::IntoJs(
3205           aCx,
3206           std::move(mUniffiReturnValue),
3207           aDest,
3208           aError
3209         );
3210     }
3211 };
3212 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncCopieDictionnaire : public UniffiHandlerBase {
3213 private:
3214     // PrepareRustArgs stores the resulting arguments in these fields
3215     typename ScaffoldingConverter<RustBuffer>::IntermediateType mD;
3216
3217     // MakeRustCall stores the result of the call in these fields
3218     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3219
3220 public:
3221     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3222         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mD, aError);
3223         if (aError.Failed()) {
3224             return;
3225         }
3226     }
3227
3228     void MakeRustCall() override {
3229         RustCallStatus callStatus{};
3230         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3231             uniffi_uniffi_rondpoint_fn_func_copie_dictionnaire(
3232                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mD)),
3233                 &callStatus
3234             )
3235         );
3236
3237         mUniffiCallStatusCode = callStatus.code;
3238         if (callStatus.error_buf.data) {
3239             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3240         }
3241     }
3242
3243     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3244         ScaffoldingConverter<RustBuffer>::IntoJs(
3245           aCx,
3246           std::move(mUniffiReturnValue),
3247           aDest,
3248           aError
3249         );
3250     }
3251 };
3252 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncCopieEnumeration : public UniffiHandlerBase {
3253 private:
3254     // PrepareRustArgs stores the resulting arguments in these fields
3255     typename ScaffoldingConverter<RustBuffer>::IntermediateType mE;
3256
3257     // MakeRustCall stores the result of the call in these fields
3258     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3259
3260 public:
3261     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3262         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mE, aError);
3263         if (aError.Failed()) {
3264             return;
3265         }
3266     }
3267
3268     void MakeRustCall() override {
3269         RustCallStatus callStatus{};
3270         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3271             uniffi_uniffi_rondpoint_fn_func_copie_enumeration(
3272                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mE)),
3273                 &callStatus
3274             )
3275         );
3276
3277         mUniffiCallStatusCode = callStatus.code;
3278         if (callStatus.error_buf.data) {
3279             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3280         }
3281     }
3282
3283     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3284         ScaffoldingConverter<RustBuffer>::IntoJs(
3285           aCx,
3286           std::move(mUniffiReturnValue),
3287           aDest,
3288           aError
3289         );
3290     }
3291 };
3292 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncCopieEnumerations : public UniffiHandlerBase {
3293 private:
3294     // PrepareRustArgs stores the resulting arguments in these fields
3295     typename ScaffoldingConverter<RustBuffer>::IntermediateType mE;
3296
3297     // MakeRustCall stores the result of the call in these fields
3298     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3299
3300 public:
3301     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3302         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mE, aError);
3303         if (aError.Failed()) {
3304             return;
3305         }
3306     }
3307
3308     void MakeRustCall() override {
3309         RustCallStatus callStatus{};
3310         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3311             uniffi_uniffi_rondpoint_fn_func_copie_enumerations(
3312                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mE)),
3313                 &callStatus
3314             )
3315         );
3316
3317         mUniffiCallStatusCode = callStatus.code;
3318         if (callStatus.error_buf.data) {
3319             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3320         }
3321     }
3322
3323     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3324         ScaffoldingConverter<RustBuffer>::IntoJs(
3325           aCx,
3326           std::move(mUniffiReturnValue),
3327           aDest,
3328           aError
3329         );
3330     }
3331 };
3332 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncSwitcheroo : public UniffiHandlerBase {
3333 private:
3334     // PrepareRustArgs stores the resulting arguments in these fields
3335     typename ScaffoldingConverter<int8_t>::IntermediateType mB;
3336
3337     // MakeRustCall stores the result of the call in these fields
3338     typename ScaffoldingConverter<int8_t>::IntermediateType mUniffiReturnValue;
3339
3340 public:
3341     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3342         ScaffoldingConverter<int8_t>::FromJs(aArgs[0], &mB, aError);
3343         if (aError.Failed()) {
3344             return;
3345         }
3346     }
3347
3348     void MakeRustCall() override {
3349         RustCallStatus callStatus{};
3350         mUniffiReturnValue = ScaffoldingConverter<int8_t>::FromRust(
3351             uniffi_uniffi_rondpoint_fn_func_switcheroo(
3352                 ScaffoldingConverter<int8_t>::IntoRust(std::move(mB)),
3353                 &callStatus
3354             )
3355         );
3356
3357         mUniffiCallStatusCode = callStatus.code;
3358         if (callStatus.error_buf.data) {
3359             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3360         }
3361     }
3362
3363     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3364         ScaffoldingConverter<int8_t>::IntoJs(
3365           aCx,
3366           std::move(mUniffiReturnValue),
3367           aDest,
3368           aError
3369         );
3370     }
3371 };
3372 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnConstructorSpriteNew : public UniffiHandlerBase {
3373 private:
3374     // PrepareRustArgs stores the resulting arguments in these fields
3375     typename ScaffoldingConverter<RustBuffer>::IntermediateType mInitialPosition;
3376
3377     // MakeRustCall stores the result of the call in these fields
3378     typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mUniffiReturnValue;
3379
3380 public:
3381     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3382         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mInitialPosition, aError);
3383         if (aError.Failed()) {
3384             return;
3385         }
3386     }
3387
3388     void MakeRustCall() override {
3389         RustCallStatus callStatus{};
3390         mUniffiReturnValue = ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromRust(
3391             uniffi_uniffi_sprites_fn_constructor_sprite_new(
3392                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mInitialPosition)),
3393                 &callStatus
3394             )
3395         );
3396
3397         mUniffiCallStatusCode = callStatus.code;
3398         if (callStatus.error_buf.data) {
3399             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3400         }
3401     }
3402
3403     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3404         ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoJs(
3405           aCx,
3406           std::move(mUniffiReturnValue),
3407           aDest,
3408           aError
3409         );
3410     }
3411 };
3412 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnConstructorSpriteNewRelativeTo : public UniffiHandlerBase {
3413 private:
3414     // PrepareRustArgs stores the resulting arguments in these fields
3415     typename ScaffoldingConverter<RustBuffer>::IntermediateType mReference;
3416     typename ScaffoldingConverter<RustBuffer>::IntermediateType mDirection;
3417
3418     // MakeRustCall stores the result of the call in these fields
3419     typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mUniffiReturnValue;
3420
3421 public:
3422     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3423         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mReference, aError);
3424         if (aError.Failed()) {
3425             return;
3426         }
3427         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mDirection, aError);
3428         if (aError.Failed()) {
3429             return;
3430         }
3431     }
3432
3433     void MakeRustCall() override {
3434         RustCallStatus callStatus{};
3435         mUniffiReturnValue = ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromRust(
3436             uniffi_uniffi_sprites_fn_constructor_sprite_new_relative_to(
3437                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mReference)),
3438                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mDirection)),
3439                 &callStatus
3440             )
3441         );
3442
3443         mUniffiCallStatusCode = callStatus.code;
3444         if (callStatus.error_buf.data) {
3445             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3446         }
3447     }
3448
3449     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3450         ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoJs(
3451           aCx,
3452           std::move(mUniffiReturnValue),
3453           aDest,
3454           aError
3455         );
3456     }
3457 };
3458 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnMethodSpriteGetPosition : public UniffiHandlerBase {
3459 private:
3460     // PrepareRustArgs stores the resulting arguments in these fields
3461     typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr;
3462
3463     // MakeRustCall stores the result of the call in these fields
3464     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3465
3466 public:
3467     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3468         ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError);
3469         if (aError.Failed()) {
3470             return;
3471         }
3472     }
3473
3474     void MakeRustCall() override {
3475         RustCallStatus callStatus{};
3476         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3477             uniffi_uniffi_sprites_fn_method_sprite_get_position(
3478                 ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)),
3479                 &callStatus
3480             )
3481         );
3482
3483         mUniffiCallStatusCode = callStatus.code;
3484         if (callStatus.error_buf.data) {
3485             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3486         }
3487     }
3488
3489     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3490         ScaffoldingConverter<RustBuffer>::IntoJs(
3491           aCx,
3492           std::move(mUniffiReturnValue),
3493           aDest,
3494           aError
3495         );
3496     }
3497 };
3498 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnMethodSpriteMoveBy : public UniffiHandlerBase {
3499 private:
3500     // PrepareRustArgs stores the resulting arguments in these fields
3501     typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr;
3502     typename ScaffoldingConverter<RustBuffer>::IntermediateType mDirection;
3503
3504     // MakeRustCall stores the result of the call in these fields
3505
3506 public:
3507     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3508         ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError);
3509         if (aError.Failed()) {
3510             return;
3511         }
3512         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mDirection, aError);
3513         if (aError.Failed()) {
3514             return;
3515         }
3516     }
3517
3518     void MakeRustCall() override {
3519         RustCallStatus callStatus{};
3520         uniffi_uniffi_sprites_fn_method_sprite_move_by(
3521             ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)),
3522             ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mDirection)),
3523             &callStatus
3524         );
3525
3526         mUniffiCallStatusCode = callStatus.code;
3527         if (callStatus.error_buf.data) {
3528             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3529         }
3530     }
3531
3532     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3533     }
3534 };
3535 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnMethodSpriteMoveTo : public UniffiHandlerBase {
3536 private:
3537     // PrepareRustArgs stores the resulting arguments in these fields
3538     typename ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntermediateType mPtr;
3539     typename ScaffoldingConverter<RustBuffer>::IntermediateType mPosition;
3540
3541     // MakeRustCall stores the result of the call in these fields
3542
3543 public:
3544     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3545         ScaffoldingObjectConverter<&kSpritesSpritePointerType>::FromJs(aArgs[0], &mPtr, aError);
3546         if (aError.Failed()) {
3547             return;
3548         }
3549         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mPosition, aError);
3550         if (aError.Failed()) {
3551             return;
3552         }
3553     }
3554
3555     void MakeRustCall() override {
3556         RustCallStatus callStatus{};
3557         uniffi_uniffi_sprites_fn_method_sprite_move_to(
3558             ScaffoldingObjectConverter<&kSpritesSpritePointerType>::IntoRust(std::move(mPtr)),
3559             ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mPosition)),
3560             &callStatus
3561         );
3562
3563         mUniffiCallStatusCode = callStatus.code;
3564         if (callStatus.error_buf.data) {
3565             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3566         }
3567     }
3568
3569     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3570     }
3571 };
3572 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnFuncTranslate : public UniffiHandlerBase {
3573 private:
3574     // PrepareRustArgs stores the resulting arguments in these fields
3575     typename ScaffoldingConverter<RustBuffer>::IntermediateType mPosition;
3576     typename ScaffoldingConverter<RustBuffer>::IntermediateType mDirection;
3577
3578     // MakeRustCall stores the result of the call in these fields
3579     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3580
3581 public:
3582     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3583         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mPosition, aError);
3584         if (aError.Failed()) {
3585             return;
3586         }
3587         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mDirection, aError);
3588         if (aError.Failed()) {
3589             return;
3590         }
3591     }
3592
3593     void MakeRustCall() override {
3594         RustCallStatus callStatus{};
3595         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3596             uniffi_uniffi_sprites_fn_func_translate(
3597                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mPosition)),
3598                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mDirection)),
3599                 &callStatus
3600             )
3601         );
3602
3603         mUniffiCallStatusCode = callStatus.code;
3604         if (callStatus.error_buf.data) {
3605             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3606         }
3607     }
3608
3609     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3610         ScaffoldingConverter<RustBuffer>::IntoJs(
3611           aCx,
3612           std::move(mUniffiReturnValue),
3613           aDest,
3614           aError
3615         );
3616     }
3617 };
3618 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnConstructorTodolistNew : public UniffiHandlerBase {
3619 private:
3620     // PrepareRustArgs stores the resulting arguments in these fields
3621
3622     // MakeRustCall stores the result of the call in these fields
3623     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mUniffiReturnValue;
3624
3625 public:
3626     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3627     }
3628
3629     void MakeRustCall() override {
3630         RustCallStatus callStatus{};
3631         mUniffiReturnValue = ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromRust(
3632             uniffi_uniffi_todolist_fn_constructor_todolist_new(
3633                 &callStatus
3634             )
3635         );
3636
3637         mUniffiCallStatusCode = callStatus.code;
3638         if (callStatus.error_buf.data) {
3639             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3640         }
3641     }
3642
3643     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3644         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoJs(
3645           aCx,
3646           std::move(mUniffiReturnValue),
3647           aDest,
3648           aError
3649         );
3650     }
3651 };
3652 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistAddEntries : public UniffiHandlerBase {
3653 private:
3654     // PrepareRustArgs stores the resulting arguments in these fields
3655     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3656     typename ScaffoldingConverter<RustBuffer>::IntermediateType mEntries;
3657
3658     // MakeRustCall stores the result of the call in these fields
3659
3660 public:
3661     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3662         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3663         if (aError.Failed()) {
3664             return;
3665         }
3666         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mEntries, aError);
3667         if (aError.Failed()) {
3668             return;
3669         }
3670     }
3671
3672     void MakeRustCall() override {
3673         RustCallStatus callStatus{};
3674         uniffi_uniffi_todolist_fn_method_todolist_add_entries(
3675             ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3676             ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mEntries)),
3677             &callStatus
3678         );
3679
3680         mUniffiCallStatusCode = callStatus.code;
3681         if (callStatus.error_buf.data) {
3682             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3683         }
3684     }
3685
3686     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3687     }
3688 };
3689 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistAddEntry : public UniffiHandlerBase {
3690 private:
3691     // PrepareRustArgs stores the resulting arguments in these fields
3692     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3693     typename ScaffoldingConverter<RustBuffer>::IntermediateType mEntry;
3694
3695     // MakeRustCall stores the result of the call in these fields
3696
3697 public:
3698     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3699         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3700         if (aError.Failed()) {
3701             return;
3702         }
3703         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mEntry, aError);
3704         if (aError.Failed()) {
3705             return;
3706         }
3707     }
3708
3709     void MakeRustCall() override {
3710         RustCallStatus callStatus{};
3711         uniffi_uniffi_todolist_fn_method_todolist_add_entry(
3712             ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3713             ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mEntry)),
3714             &callStatus
3715         );
3716
3717         mUniffiCallStatusCode = callStatus.code;
3718         if (callStatus.error_buf.data) {
3719             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3720         }
3721     }
3722
3723     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3724     }
3725 };
3726 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistAddItem : public UniffiHandlerBase {
3727 private:
3728     // PrepareRustArgs stores the resulting arguments in these fields
3729     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3730     typename ScaffoldingConverter<RustBuffer>::IntermediateType mTodo;
3731
3732     // MakeRustCall stores the result of the call in these fields
3733
3734 public:
3735     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3736         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3737         if (aError.Failed()) {
3738             return;
3739         }
3740         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mTodo, aError);
3741         if (aError.Failed()) {
3742             return;
3743         }
3744     }
3745
3746     void MakeRustCall() override {
3747         RustCallStatus callStatus{};
3748         uniffi_uniffi_todolist_fn_method_todolist_add_item(
3749             ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3750             ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mTodo)),
3751             &callStatus
3752         );
3753
3754         mUniffiCallStatusCode = callStatus.code;
3755         if (callStatus.error_buf.data) {
3756             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3757         }
3758     }
3759
3760     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3761     }
3762 };
3763 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistAddItems : public UniffiHandlerBase {
3764 private:
3765     // PrepareRustArgs stores the resulting arguments in these fields
3766     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3767     typename ScaffoldingConverter<RustBuffer>::IntermediateType mItems;
3768
3769     // MakeRustCall stores the result of the call in these fields
3770
3771 public:
3772     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3773         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3774         if (aError.Failed()) {
3775             return;
3776         }
3777         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mItems, aError);
3778         if (aError.Failed()) {
3779             return;
3780         }
3781     }
3782
3783     void MakeRustCall() override {
3784         RustCallStatus callStatus{};
3785         uniffi_uniffi_todolist_fn_method_todolist_add_items(
3786             ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3787             ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mItems)),
3788             &callStatus
3789         );
3790
3791         mUniffiCallStatusCode = callStatus.code;
3792         if (callStatus.error_buf.data) {
3793             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3794         }
3795     }
3796
3797     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3798     }
3799 };
3800 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistClearItem : public UniffiHandlerBase {
3801 private:
3802     // PrepareRustArgs stores the resulting arguments in these fields
3803     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3804     typename ScaffoldingConverter<RustBuffer>::IntermediateType mTodo;
3805
3806     // MakeRustCall stores the result of the call in these fields
3807
3808 public:
3809     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3810         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3811         if (aError.Failed()) {
3812             return;
3813         }
3814         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[1], &mTodo, aError);
3815         if (aError.Failed()) {
3816             return;
3817         }
3818     }
3819
3820     void MakeRustCall() override {
3821         RustCallStatus callStatus{};
3822         uniffi_uniffi_todolist_fn_method_todolist_clear_item(
3823             ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3824             ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mTodo)),
3825             &callStatus
3826         );
3827
3828         mUniffiCallStatusCode = callStatus.code;
3829         if (callStatus.error_buf.data) {
3830             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3831         }
3832     }
3833
3834     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3835     }
3836 };
3837 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetEntries : public UniffiHandlerBase {
3838 private:
3839     // PrepareRustArgs stores the resulting arguments in these fields
3840     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3841
3842     // MakeRustCall stores the result of the call in these fields
3843     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3844
3845 public:
3846     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3847         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3848         if (aError.Failed()) {
3849             return;
3850         }
3851     }
3852
3853     void MakeRustCall() override {
3854         RustCallStatus callStatus{};
3855         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3856             uniffi_uniffi_todolist_fn_method_todolist_get_entries(
3857                 ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3858                 &callStatus
3859             )
3860         );
3861
3862         mUniffiCallStatusCode = callStatus.code;
3863         if (callStatus.error_buf.data) {
3864             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3865         }
3866     }
3867
3868     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3869         ScaffoldingConverter<RustBuffer>::IntoJs(
3870           aCx,
3871           std::move(mUniffiReturnValue),
3872           aDest,
3873           aError
3874         );
3875     }
3876 };
3877 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetFirst : public UniffiHandlerBase {
3878 private:
3879     // PrepareRustArgs stores the resulting arguments in these fields
3880     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3881
3882     // MakeRustCall stores the result of the call in these fields
3883     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3884
3885 public:
3886     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3887         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3888         if (aError.Failed()) {
3889             return;
3890         }
3891     }
3892
3893     void MakeRustCall() override {
3894         RustCallStatus callStatus{};
3895         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3896             uniffi_uniffi_todolist_fn_method_todolist_get_first(
3897                 ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3898                 &callStatus
3899             )
3900         );
3901
3902         mUniffiCallStatusCode = callStatus.code;
3903         if (callStatus.error_buf.data) {
3904             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3905         }
3906     }
3907
3908     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3909         ScaffoldingConverter<RustBuffer>::IntoJs(
3910           aCx,
3911           std::move(mUniffiReturnValue),
3912           aDest,
3913           aError
3914         );
3915     }
3916 };
3917 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetItems : public UniffiHandlerBase {
3918 private:
3919     // PrepareRustArgs stores the resulting arguments in these fields
3920     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3921
3922     // MakeRustCall stores the result of the call in these fields
3923     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3924
3925 public:
3926     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3927         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3928         if (aError.Failed()) {
3929             return;
3930         }
3931     }
3932
3933     void MakeRustCall() override {
3934         RustCallStatus callStatus{};
3935         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3936             uniffi_uniffi_todolist_fn_method_todolist_get_items(
3937                 ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3938                 &callStatus
3939             )
3940         );
3941
3942         mUniffiCallStatusCode = callStatus.code;
3943         if (callStatus.error_buf.data) {
3944             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3945         }
3946     }
3947
3948     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3949         ScaffoldingConverter<RustBuffer>::IntoJs(
3950           aCx,
3951           std::move(mUniffiReturnValue),
3952           aDest,
3953           aError
3954         );
3955     }
3956 };
3957 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetLast : public UniffiHandlerBase {
3958 private:
3959     // PrepareRustArgs stores the resulting arguments in these fields
3960     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
3961
3962     // MakeRustCall stores the result of the call in these fields
3963     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
3964
3965 public:
3966     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
3967         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
3968         if (aError.Failed()) {
3969             return;
3970         }
3971     }
3972
3973     void MakeRustCall() override {
3974         RustCallStatus callStatus{};
3975         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
3976             uniffi_uniffi_todolist_fn_method_todolist_get_last(
3977                 ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
3978                 &callStatus
3979             )
3980         );
3981
3982         mUniffiCallStatusCode = callStatus.code;
3983         if (callStatus.error_buf.data) {
3984             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
3985         }
3986     }
3987
3988     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
3989         ScaffoldingConverter<RustBuffer>::IntoJs(
3990           aCx,
3991           std::move(mUniffiReturnValue),
3992           aDest,
3993           aError
3994         );
3995     }
3996 };
3997 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetLastEntry : public UniffiHandlerBase {
3998 private:
3999     // PrepareRustArgs stores the resulting arguments in these fields
4000     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
4001
4002     // MakeRustCall stores the result of the call in these fields
4003     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
4004
4005 public:
4006     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
4007         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
4008         if (aError.Failed()) {
4009             return;
4010         }
4011     }
4012
4013     void MakeRustCall() override {
4014         RustCallStatus callStatus{};
4015         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
4016             uniffi_uniffi_todolist_fn_method_todolist_get_last_entry(
4017                 ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
4018                 &callStatus
4019             )
4020         );
4021
4022         mUniffiCallStatusCode = callStatus.code;
4023         if (callStatus.error_buf.data) {
4024             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
4025         }
4026     }
4027
4028     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
4029         ScaffoldingConverter<RustBuffer>::IntoJs(
4030           aCx,
4031           std::move(mUniffiReturnValue),
4032           aDest,
4033           aError
4034         );
4035     }
4036 };
4037 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistMakeDefault : public UniffiHandlerBase {
4038 private:
4039     // PrepareRustArgs stores the resulting arguments in these fields
4040     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mPtr;
4041
4042     // MakeRustCall stores the result of the call in these fields
4043
4044 public:
4045     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
4046         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mPtr, aError);
4047         if (aError.Failed()) {
4048             return;
4049         }
4050     }
4051
4052     void MakeRustCall() override {
4053         RustCallStatus callStatus{};
4054         uniffi_uniffi_todolist_fn_method_todolist_make_default(
4055             ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mPtr)),
4056             &callStatus
4057         );
4058
4059         mUniffiCallStatusCode = callStatus.code;
4060         if (callStatus.error_buf.data) {
4061             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
4062         }
4063     }
4064
4065     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
4066     }
4067 };
4068 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnFuncCreateEntryWith : public UniffiHandlerBase {
4069 private:
4070     // PrepareRustArgs stores the resulting arguments in these fields
4071     typename ScaffoldingConverter<RustBuffer>::IntermediateType mTodo;
4072
4073     // MakeRustCall stores the result of the call in these fields
4074     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
4075
4076 public:
4077     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
4078         ScaffoldingConverter<RustBuffer>::FromJs(aArgs[0], &mTodo, aError);
4079         if (aError.Failed()) {
4080             return;
4081         }
4082     }
4083
4084     void MakeRustCall() override {
4085         RustCallStatus callStatus{};
4086         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
4087             uniffi_uniffi_todolist_fn_func_create_entry_with(
4088                 ScaffoldingConverter<RustBuffer>::IntoRust(std::move(mTodo)),
4089                 &callStatus
4090             )
4091         );
4092
4093         mUniffiCallStatusCode = callStatus.code;
4094         if (callStatus.error_buf.data) {
4095             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
4096         }
4097     }
4098
4099     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
4100         ScaffoldingConverter<RustBuffer>::IntoJs(
4101           aCx,
4102           std::move(mUniffiReturnValue),
4103           aDest,
4104           aError
4105         );
4106     }
4107 };
4108 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnFuncGetDefaultList : public UniffiHandlerBase {
4109 private:
4110     // PrepareRustArgs stores the resulting arguments in these fields
4111
4112     // MakeRustCall stores the result of the call in these fields
4113     typename ScaffoldingConverter<RustBuffer>::IntermediateType mUniffiReturnValue;
4114
4115 public:
4116     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
4117     }
4118
4119     void MakeRustCall() override {
4120         RustCallStatus callStatus{};
4121         mUniffiReturnValue = ScaffoldingConverter<RustBuffer>::FromRust(
4122             uniffi_uniffi_todolist_fn_func_get_default_list(
4123                 &callStatus
4124             )
4125         );
4126
4127         mUniffiCallStatusCode = callStatus.code;
4128         if (callStatus.error_buf.data) {
4129             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
4130         }
4131     }
4132
4133     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
4134         ScaffoldingConverter<RustBuffer>::IntoJs(
4135           aCx,
4136           std::move(mUniffiReturnValue),
4137           aDest,
4138           aError
4139         );
4140     }
4141 };
4142 class ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnFuncSetDefaultList : public UniffiHandlerBase {
4143 private:
4144     // PrepareRustArgs stores the resulting arguments in these fields
4145     typename ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntermediateType mList;
4146
4147     // MakeRustCall stores the result of the call in these fields
4148
4149 public:
4150     void PrepareRustArgs(const dom::Sequence<dom::UniFFIScaffoldingValue>& aArgs, ErrorResult& aError) override {
4151         ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::FromJs(aArgs[0], &mList, aError);
4152         if (aError.Failed()) {
4153             return;
4154         }
4155     }
4156
4157     void MakeRustCall() override {
4158         RustCallStatus callStatus{};
4159         uniffi_uniffi_todolist_fn_func_set_default_list(
4160             ScaffoldingObjectConverter<&kTodolistTodoListPointerType>::IntoRust(std::move(mList)),
4161             &callStatus
4162         );
4163
4164         mUniffiCallStatusCode = callStatus.code;
4165         if (callStatus.error_buf.data) {
4166             mUniffiCallStatusErrorBuf = OwnedRustBuffer(callStatus.error_buf);
4167         }
4168     }
4169
4170     virtual void ExtractSuccessfulCallResult(JSContext* aCx, dom::Optional<dom::UniFFIScaffoldingValue>& aDest, ErrorResult& aError) override {
4171     }
4172 };
4173
4174 UniquePtr<UniffiHandlerBase> UniFFIFixturesGetHandler(uint64_t aId) {
4175   switch (aId) {
4176     case 59: {
4177         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiArithmeticalFnFuncAdd>();
4178     }
4179     case 60: {
4180         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiArithmeticalFnFuncDiv>();
4181     }
4182     case 61: {
4183         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiArithmeticalFnFuncEqual>();
4184     }
4185     case 62: {
4186         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiArithmeticalFnFuncSub>();
4187     }
4188     case 63: {
4189         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiCustomTypesFnFuncGetCustomTypesDemo>();
4190     }
4191     case 64: {
4192         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureExternalTypesFnFuncGradient>();
4193     }
4194     case 65: {
4195         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureExternalTypesFnFuncIntersection>();
4196     }
4197     case 67: {
4198         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureRefcountsFnMethodSingletonobjectMethod>();
4199     }
4200     case 68: {
4201         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureRefcountsFnFuncGetJsRefcount>();
4202     }
4203     case 69: {
4204         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiFixtureRefcountsFnFuncGetSingleton>();
4205     }
4206     case 70: {
4207         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiGeometryFnFuncGradient>();
4208     }
4209     case 71: {
4210         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiGeometryFnFuncIntersection>();
4211     }
4212     case 73: {
4213         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnConstructorOptionneurNew>();
4214     }
4215     case 74: {
4216         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonBoolean>();
4217     }
4218     case 75: {
4219         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonEnum>();
4220     }
4221     case 76: {
4222         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonF32>();
4223     }
4224     case 77: {
4225         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonF64>();
4226     }
4227     case 78: {
4228         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI16Dec>();
4229     }
4230     case 79: {
4231         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI16Hex>();
4232     }
4233     case 80: {
4234         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI32Dec>();
4235     }
4236     case 81: {
4237         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI32Hex>();
4238     }
4239     case 82: {
4240         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI64Dec>();
4241     }
4242     case 83: {
4243         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI64Hex>();
4244     }
4245     case 84: {
4246         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI8Dec>();
4247     }
4248     case 85: {
4249         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonI8Hex>();
4250     }
4251     case 86: {
4252         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonNull>();
4253     }
4254     case 87: {
4255         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonSequence>();
4256     }
4257     case 88: {
4258         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonString>();
4259     }
4260     case 89: {
4261         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU16Dec>();
4262     }
4263     case 90: {
4264         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU16Hex>();
4265     }
4266     case 91: {
4267         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU32Dec>();
4268     }
4269     case 92: {
4270         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU32Hex>();
4271     }
4272     case 93: {
4273         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU32Oct>();
4274     }
4275     case 94: {
4276         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU64Dec>();
4277     }
4278     case 95: {
4279         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU64Hex>();
4280     }
4281     case 96: {
4282         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU8Dec>();
4283     }
4284     case 97: {
4285         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonU8Hex>();
4286     }
4287     case 98: {
4288         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodOptionneurSinonZero>();
4289     }
4290     case 100: {
4291         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnConstructorRetourneurNew>();
4292     }
4293     case 101: {
4294         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueBoolean>();
4295     }
4296     case 102: {
4297         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueDouble>();
4298     }
4299     case 103: {
4300         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueFloat>();
4301     }
4302     case 104: {
4303         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueI16>();
4304     }
4305     case 105: {
4306         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueI32>();
4307     }
4308     case 106: {
4309         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueI64>();
4310     }
4311     case 107: {
4312         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueI8>();
4313     }
4314     case 108: {
4315         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueNombres>();
4316     }
4317     case 109: {
4318         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueNombresSignes>();
4319     }
4320     case 110: {
4321         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueOptionneurDictionnaire>();
4322     }
4323     case 111: {
4324         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueString>();
4325     }
4326     case 112: {
4327         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueU16>();
4328     }
4329     case 113: {
4330         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueU32>();
4331     }
4332     case 114: {
4333         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueU64>();
4334     }
4335     case 115: {
4336         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodRetourneurIdentiqueU8>();
4337     }
4338     case 117: {
4339         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnConstructorStringifierNew>();
4340     }
4341     case 118: {
4342         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringBoolean>();
4343     }
4344     case 119: {
4345         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringDouble>();
4346     }
4347     case 120: {
4348         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringFloat>();
4349     }
4350     case 121: {
4351         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringI16>();
4352     }
4353     case 122: {
4354         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringI32>();
4355     }
4356     case 123: {
4357         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringI64>();
4358     }
4359     case 124: {
4360         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringI8>();
4361     }
4362     case 125: {
4363         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringU16>();
4364     }
4365     case 126: {
4366         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringU32>();
4367     }
4368     case 127: {
4369         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringU64>();
4370     }
4371     case 128: {
4372         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierToStringU8>();
4373     }
4374     case 129: {
4375         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnMethodStringifierWellKnownString>();
4376     }
4377     case 130: {
4378         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncCopieCarte>();
4379     }
4380     case 131: {
4381         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncCopieDictionnaire>();
4382     }
4383     case 132: {
4384         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncCopieEnumeration>();
4385     }
4386     case 133: {
4387         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncCopieEnumerations>();
4388     }
4389     case 134: {
4390         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiRondpointFnFuncSwitcheroo>();
4391     }
4392     case 136: {
4393         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnConstructorSpriteNew>();
4394     }
4395     case 137: {
4396         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnConstructorSpriteNewRelativeTo>();
4397     }
4398     case 138: {
4399         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnMethodSpriteGetPosition>();
4400     }
4401     case 139: {
4402         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnMethodSpriteMoveBy>();
4403     }
4404     case 140: {
4405         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnMethodSpriteMoveTo>();
4406     }
4407     case 141: {
4408         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiSpritesFnFuncTranslate>();
4409     }
4410     case 143: {
4411         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnConstructorTodolistNew>();
4412     }
4413     case 144: {
4414         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistAddEntries>();
4415     }
4416     case 145: {
4417         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistAddEntry>();
4418     }
4419     case 146: {
4420         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistAddItem>();
4421     }
4422     case 147: {
4423         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistAddItems>();
4424     }
4425     case 148: {
4426         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistClearItem>();
4427     }
4428     case 149: {
4429         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetEntries>();
4430     }
4431     case 150: {
4432         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetFirst>();
4433     }
4434     case 151: {
4435         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetItems>();
4436     }
4437     case 152: {
4438         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetLast>();
4439     }
4440     case 153: {
4441         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistGetLastEntry>();
4442     }
4443     case 154: {
4444         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnMethodTodolistMakeDefault>();
4445     }
4446     case 155: {
4447         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnFuncCreateEntryWith>();
4448     }
4449     case 156: {
4450         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnFuncGetDefaultList>();
4451     }
4452     case 157: {
4453         return MakeUnique<ScaffoldingCallHandlerUniFFIFixturesUniffiUniffiTodolistFnFuncSetDefaultList>();
4454     }
4455
4456     default:
4457       return nullptr;
4458   }
4459 }
4460
4461 Maybe<already_AddRefed<UniFFIPointer>> UniFFIFixturesReadPointer(const GlobalObject& aGlobal, uint64_t aId, const ArrayBuffer& aArrayBuff, long aPosition, ErrorResult& aError) {
4462   const UniFFIPointerType* type;
4463   switch (aId) {
4464     case 7: { // refcounts:SingletonObject
4465       type = &kRefcountsSingletonObjectPointerType;
4466       break;
4467     }
4468     case 8: { // rondpoint:Optionneur
4469       type = &kRondpointOptionneurPointerType;
4470       break;
4471     }
4472     case 9: { // rondpoint:Retourneur
4473       type = &kRondpointRetourneurPointerType;
4474       break;
4475     }
4476     case 10: { // rondpoint:Stringifier
4477       type = &kRondpointStringifierPointerType;
4478       break;
4479     }
4480     case 11: { // sprites:Sprite
4481       type = &kSpritesSpritePointerType;
4482       break;
4483     }
4484     case 12: { // todolist:TodoList
4485       type = &kTodolistTodoListPointerType;
4486       break;
4487     }
4488     default:
4489       return Nothing();
4490   }
4491   return Some(UniFFIPointer::Read(aArrayBuff, aPosition, type, aError));
4492 }
4493
4494 bool UniFFIFixturesWritePointer(const GlobalObject& aGlobal, uint64_t aId, const UniFFIPointer& aPtr, const ArrayBuffer& aArrayBuff, long aPosition, ErrorResult& aError) {
4495   const UniFFIPointerType* type;
4496   switch (aId) {
4497     case 7: { // refcounts:SingletonObject
4498       type = &kRefcountsSingletonObjectPointerType;
4499       break;
4500     }
4501     case 8: { // rondpoint:Optionneur
4502       type = &kRondpointOptionneurPointerType;
4503       break;
4504     }
4505     case 9: { // rondpoint:Retourneur
4506       type = &kRondpointRetourneurPointerType;
4507       break;
4508     }
4509     case 10: { // rondpoint:Stringifier
4510       type = &kRondpointStringifierPointerType;
4511       break;
4512     }
4513     case 11: { // sprites:Sprite
4514       type = &kSpritesSpritePointerType;
4515       break;
4516     }
4517     case 12: { // todolist:TodoList
4518       type = &kTodolistTodoListPointerType;
4519       break;
4520     }
4521     default:
4522       return false;
4523   }
4524   aPtr.Write(aArrayBuff, aPosition, type, aError);
4525   return true;
4526 }
4527
4528 }  // namespace mozilla::uniffi