///
/// One-Swift-Cxx-Bridge.hpp
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © Marc Rousavy @ Margelo
///

#pragma once

// Forward declarations of C++ defined types
// Forward declaration of `AppIntentInvocation` to properly resolve imports.
namespace margelo::nitro::one { struct AppIntentInvocation; }
// Forward declaration of `AppTrackingPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class AppTrackingPermissionStatus; }
// Forward declaration of `AppleAuthCredential` to properly resolve imports.
namespace margelo::nitro::one { struct AppleAuthCredential; }
// Forward declaration of `AppleAuthFullName` to properly resolve imports.
namespace margelo::nitro::one { struct AppleAuthFullName; }
// Forward declaration of `AppleAuthResultType` to properly resolve imports.
namespace margelo::nitro::one { enum class AppleAuthResultType; }
// Forward declaration of `AppleAuthResult` to properly resolve imports.
namespace margelo::nitro::one { struct AppleAuthResult; }
// Forward declaration of `AppleAuthScope` to properly resolve imports.
namespace margelo::nitro::one { enum class AppleAuthScope; }
// Forward declaration of `AppleCredentialState` to properly resolve imports.
namespace margelo::nitro::one { enum class AppleCredentialState; }
// Forward declaration of `AppleRealUserStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class AppleRealUserStatus; }
// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
namespace NitroModules { class ArrayBufferHolder; }
// Forward declaration of `AudioInterruptionEvent` to properly resolve imports.
namespace margelo::nitro::one { struct AudioInterruptionEvent; }
// Forward declaration of `AudioInterruptionType` to properly resolve imports.
namespace margelo::nitro::one { enum class AudioInterruptionType; }
// Forward declaration of `AudioPlaybackState` to properly resolve imports.
namespace margelo::nitro::one { enum class AudioPlaybackState; }
// Forward declaration of `AudioPlaybackStatus` to properly resolve imports.
namespace margelo::nitro::one { struct AudioPlaybackStatus; }
// Forward declaration of `AudioPlayerStatus` to properly resolve imports.
namespace margelo::nitro::one { struct AudioPlayerStatus; }
// Forward declaration of `AudioRecordingPermission` to properly resolve imports.
namespace margelo::nitro::one { enum class AudioRecordingPermission; }
// Forward declaration of `AudioRecordingResult` to properly resolve imports.
namespace margelo::nitro::one { struct AudioRecordingResult; }
// Forward declaration of `AudioRecordingState` to properly resolve imports.
namespace margelo::nitro::one { enum class AudioRecordingState; }
// Forward declaration of `AudioRecordingStatus` to properly resolve imports.
namespace margelo::nitro::one { struct AudioRecordingStatus; }
// Forward declaration of `AudioRemoteCommandEvent` to properly resolve imports.
namespace margelo::nitro::one { struct AudioRemoteCommandEvent; }
// Forward declaration of `AudioRemoteCommandType` to properly resolve imports.
namespace margelo::nitro::one { enum class AudioRemoteCommandType; }
// Forward declaration of `BackgroundTaskInvocation` to properly resolve imports.
namespace margelo::nitro::one { struct BackgroundTaskInvocation; }
// Forward declaration of `BackgroundTaskKind` to properly resolve imports.
namespace margelo::nitro::one { enum class BackgroundTaskKind; }
// Forward declaration of `BarometerMeasurement` to properly resolve imports.
namespace margelo::nitro::one { struct BarometerMeasurement; }
// Forward declaration of `BatteryLevelEvent` to properly resolve imports.
namespace margelo::nitro::one { struct BatteryLevelEvent; }
// Forward declaration of `BatteryPowerModeEvent` to properly resolve imports.
namespace margelo::nitro::one { struct BatteryPowerModeEvent; }
// Forward declaration of `BatteryPowerState` to properly resolve imports.
namespace margelo::nitro::one { struct BatteryPowerState; }
// Forward declaration of `BatteryStateEvent` to properly resolve imports.
namespace margelo::nitro::one { struct BatteryStateEvent; }
// Forward declaration of `BatteryState` to properly resolve imports.
namespace margelo::nitro::one { enum class BatteryState; }
// Forward declaration of `BrightnessEvent` to properly resolve imports.
namespace margelo::nitro::one { struct BrightnessEvent; }
// Forward declaration of `BrightnessMode` to properly resolve imports.
namespace margelo::nitro::one { enum class BrightnessMode; }
// Forward declaration of `BrightnessPermissionResponse` to properly resolve imports.
namespace margelo::nitro::one { struct BrightnessPermissionResponse; }
// Forward declaration of `BrightnessPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class BrightnessPermissionStatus; }
// Forward declaration of `BrowserAuthResultType` to properly resolve imports.
namespace margelo::nitro::one { enum class BrowserAuthResultType; }
// Forward declaration of `BrowserAuthResult` to properly resolve imports.
namespace margelo::nitro::one { struct BrowserAuthResult; }
// Forward declaration of `BrowserColorScheme` to properly resolve imports.
namespace margelo::nitro::one { enum class BrowserColorScheme; }
// Forward declaration of `BrowserPresentationStyle` to properly resolve imports.
namespace margelo::nitro::one { enum class BrowserPresentationStyle; }
// Forward declaration of `BrowserResultType` to properly resolve imports.
namespace margelo::nitro::one { enum class BrowserResultType; }
// Forward declaration of `BrowserResult` to properly resolve imports.
namespace margelo::nitro::one { struct BrowserResult; }
// Forward declaration of `CalendarEvent` to properly resolve imports.
namespace margelo::nitro::one { struct CalendarEvent; }
// Forward declaration of `CalendarInfo` to properly resolve imports.
namespace margelo::nitro::one { struct CalendarInfo; }
// Forward declaration of `CalendarPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class CalendarPermissionStatus; }
// Forward declaration of `CalendarRecurrenceFrequency` to properly resolve imports.
namespace margelo::nitro::one { enum class CalendarRecurrenceFrequency; }
// Forward declaration of `CalendarRecurrence` to properly resolve imports.
namespace margelo::nitro::one { struct CalendarRecurrence; }
// Forward declaration of `CameraPermissionResponse` to properly resolve imports.
namespace margelo::nitro::one { struct CameraPermissionResponse; }
// Forward declaration of `CameraPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class CameraPermissionStatus; }
// Forward declaration of `ClipboardImageResult` to properly resolve imports.
namespace margelo::nitro::one { struct ClipboardImageResult; }
// Forward declaration of `ContactInfo` to properly resolve imports.
namespace margelo::nitro::one { struct ContactInfo; }
// Forward declaration of `ContactPostalAddressInput` to properly resolve imports.
namespace margelo::nitro::one { struct ContactPostalAddressInput; }
// Forward declaration of `ContactPostalAddress` to properly resolve imports.
namespace margelo::nitro::one { struct ContactPostalAddress; }
// Forward declaration of `ContactsPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class ContactsPermissionStatus; }
// Forward declaration of `DataScannerBounds` to properly resolve imports.
namespace margelo::nitro::one { struct DataScannerBounds; }
// Forward declaration of `DataScannerItemType` to properly resolve imports.
namespace margelo::nitro::one { enum class DataScannerItemType; }
// Forward declaration of `DataScannerPoint` to properly resolve imports.
namespace margelo::nitro::one { struct DataScannerPoint; }
// Forward declaration of `DataScannerRecognizedDataType` to properly resolve imports.
namespace margelo::nitro::one { struct DataScannerRecognizedDataType; }
// Forward declaration of `DataScannerRecognizedItem` to properly resolve imports.
namespace margelo::nitro::one { struct DataScannerRecognizedItem; }
// Forward declaration of `DataScannerRect` to properly resolve imports.
namespace margelo::nitro::one { struct DataScannerRect; }
// Forward declaration of `DataScannerScanningUnavailable` to properly resolve imports.
namespace margelo::nitro::one { enum class DataScannerScanningUnavailable; }
// Forward declaration of `DataScannerTextContentType` to properly resolve imports.
namespace margelo::nitro::one { enum class DataScannerTextContentType; }
// Forward declaration of `DetailedDirectoryInfo` to properly resolve imports.
namespace margelo::nitro::one { struct DetailedDirectoryInfo; }
// Forward declaration of `DetailedFileInfo` to properly resolve imports.
namespace margelo::nitro::one { struct DetailedFileInfo; }
// Forward declaration of `DeviceAttestationAvailability` to properly resolve imports.
namespace margelo::nitro::one { struct DeviceAttestationAvailability; }
// Forward declaration of `DeviceInfo` to properly resolve imports.
namespace margelo::nitro::one { struct DeviceInfo; }
// Forward declaration of `DiskSpace` to properly resolve imports.
namespace margelo::nitro::one { struct DiskSpace; }
// Forward declaration of `DocumentCameraError` to properly resolve imports.
namespace margelo::nitro::one { struct DocumentCameraError; }
// Forward declaration of `DocumentPickerAsset` to properly resolve imports.
namespace margelo::nitro::one { struct DocumentPickerAsset; }
// Forward declaration of `DocumentPickerNativeResult` to properly resolve imports.
namespace margelo::nitro::one { struct DocumentPickerNativeResult; }
// Forward declaration of `FetchBlobRef` to properly resolve imports.
namespace margelo::nitro::one { struct FetchBlobRef; }
// Forward declaration of `FetchFormPart` to properly resolve imports.
namespace margelo::nitro::one { struct FetchFormPart; }
// Forward declaration of `FetchHeader` to properly resolve imports.
namespace margelo::nitro::one { struct FetchHeader; }
// Forward declaration of `FetchNativeResponse` to properly resolve imports.
namespace margelo::nitro::one { struct FetchNativeResponse; }
// Forward declaration of `FileDirectories` to properly resolve imports.
namespace margelo::nitro::one { struct FileDirectories; }
// Forward declaration of `FileEntry` to properly resolve imports.
namespace margelo::nitro::one { struct FileEntry; }
// Forward declaration of `FileInfo` to properly resolve imports.
namespace margelo::nitro::one { struct FileInfo; }
// Forward declaration of `HingeState` to properly resolve imports.
namespace margelo::nitro::one { struct HingeState; }
// Forward declaration of `HingeStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class HingeStatus; }
// Forward declaration of `HybridDocumentCameraImageSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridDocumentCameraImageSpec; }
// Forward declaration of `HybridDocumentCameraScanSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridDocumentCameraScanSpec; }
// Forward declaration of `HybridNativeCNContactSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridNativeCNContactSpec; }
// Forward declaration of `HybridNativeCNContactStoreSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridNativeCNContactStoreSpec; }
// Forward declaration of `HybridNativeCNKeyDescriptorSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridNativeCNKeyDescriptorSpec; }
// Forward declaration of `HybridOneAdaptiveSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneAdaptiveSpec; }
// Forward declaration of `HybridOneAppIconSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneAppIconSpec; }
// Forward declaration of `HybridOneAppInfoSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneAppInfoSpec; }
// Forward declaration of `HybridOneAppIntentsSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneAppIntentsSpec; }
// Forward declaration of `HybridOneAppTrackingSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneAppTrackingSpec; }
// Forward declaration of `HybridOneAppleAuthSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneAppleAuthSpec; }
// Forward declaration of `HybridOneAudioSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneAudioSpec; }
// Forward declaration of `HybridOneBackgroundTasksSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneBackgroundTasksSpec; }
// Forward declaration of `HybridOneBarometerSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneBarometerSpec; }
// Forward declaration of `HybridOneBatterySpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneBatterySpec; }
// Forward declaration of `HybridOneBrightnessSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneBrightnessSpec; }
// Forward declaration of `HybridOneBrowserSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneBrowserSpec; }
// Forward declaration of `HybridOneCalendarSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneCalendarSpec; }
// Forward declaration of `HybridOneClipboardSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneClipboardSpec; }
// Forward declaration of `HybridOneContactUISpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneContactUISpec; }
// Forward declaration of `HybridOneContactsSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneContactsSpec; }
// Forward declaration of `HybridOneDataScannerSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneDataScannerSpec; }
// Forward declaration of `HybridOneDeviceAttestationSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneDeviceAttestationSpec; }
// Forward declaration of `HybridOneDeviceSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneDeviceSpec; }
// Forward declaration of `HybridOneDocumentCameraSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneDocumentCameraSpec; }
// Forward declaration of `HybridOneDocumentPickerSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneDocumentPickerSpec; }
// Forward declaration of `HybridOneFetchSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneFetchSpec; }
// Forward declaration of `HybridOneFileSystemSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneFileSystemSpec; }
// Forward declaration of `HybridOneFontsSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneFontsSpec; }
// Forward declaration of `HybridOneHapticsSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneHapticsSpec; }
// Forward declaration of `HybridOneImageManipulatorSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneImageManipulatorSpec; }
// Forward declaration of `HybridOneImagePickerSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneImagePickerSpec; }
// Forward declaration of `HybridOneKeepAwakeSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneKeepAwakeSpec; }
// Forward declaration of `HybridOneLaunchScreenSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneLaunchScreenSpec; }
// Forward declaration of `HybridOneLightSensorSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneLightSensorSpec; }
// Forward declaration of `HybridOneLocalAuthenticationSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneLocalAuthenticationSpec; }
// Forward declaration of `HybridOneLocationSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneLocationSpec; }
// Forward declaration of `HybridOneMailComposeSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneMailComposeSpec; }
// Forward declaration of `HybridOneMapServicesSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneMapServicesSpec; }
// Forward declaration of `HybridOneMessageComposeSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneMessageComposeSpec; }
// Forward declaration of `HybridOneMotionSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneMotionSpec; }
// Forward declaration of `HybridOneNativeModulesSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneNativeModulesSpec; }
// Forward declaration of `HybridOneNetworkSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneNetworkSpec; }
// Forward declaration of `HybridOneNotificationsSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneNotificationsSpec; }
// Forward declaration of `HybridOnePedometerSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOnePedometerSpec; }
// Forward declaration of `HybridOnePhotoLibrarySpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOnePhotoLibrarySpec; }
// Forward declaration of `HybridOnePrintSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOnePrintSpec; }
// Forward declaration of `HybridOneProtectedStoreSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneProtectedStoreSpec; }
// Forward declaration of `HybridOnePurchasesSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOnePurchasesSpec; }
// Forward declaration of `HybridOneQuickActionsSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneQuickActionsSpec; }
// Forward declaration of `HybridOneScreenCaptureSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneScreenCaptureSpec; }
// Forward declaration of `HybridOneScreenOrientationSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneScreenOrientationSpec; }
// Forward declaration of `HybridOneSecureStoreSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneSecureStoreSpec; }
// Forward declaration of `HybridOneShareSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneShareSpec; }
// Forward declaration of `HybridOneSpeechSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneSpeechSpec; }
// Forward declaration of `HybridOneSpeechSynthesisSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneSpeechSynthesisSpec; }
// Forward declaration of `HybridOneStoreReviewSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneStoreReviewSpec; }
// Forward declaration of `HybridOneUpdatesSpec` to properly resolve imports.
namespace margelo::nitro::one { class HybridOneUpdatesSpec; }
// Forward declaration of `ImageCrop` to properly resolve imports.
namespace margelo::nitro::one { struct ImageCrop; }
// Forward declaration of `ImagePickerAssetType` to properly resolve imports.
namespace margelo::nitro::one { enum class ImagePickerAssetType; }
// Forward declaration of `ImagePickerAsset` to properly resolve imports.
namespace margelo::nitro::one { struct ImagePickerAsset; }
// Forward declaration of `ImagePickerCropAspect` to properly resolve imports.
namespace margelo::nitro::one { struct ImagePickerCropAspect; }
// Forward declaration of `ImagePickerMediaType` to properly resolve imports.
namespace margelo::nitro::one { enum class ImagePickerMediaType; }
// Forward declaration of `ImagePickerNativeResult` to properly resolve imports.
namespace margelo::nitro::one { struct ImagePickerNativeResult; }
// Forward declaration of `ImageResize` to properly resolve imports.
namespace margelo::nitro::one { struct ImageResize; }
// Forward declaration of `ImageTransformResult` to properly resolve imports.
namespace margelo::nitro::one { struct ImageTransformResult; }
// Forward declaration of `LightSensorMeasurement` to properly resolve imports.
namespace margelo::nitro::one { struct LightSensorMeasurement; }
// Forward declaration of `ListedEntry` to properly resolve imports.
namespace margelo::nitro::one { struct ListedEntry; }
// Forward declaration of `LocalAuthenticationStatus` to properly resolve imports.
namespace margelo::nitro::one { struct LocalAuthenticationStatus; }
// Forward declaration of `LocaleInfo` to properly resolve imports.
namespace margelo::nitro::one { struct LocaleInfo; }
// Forward declaration of `LocalizationInfo` to properly resolve imports.
namespace margelo::nitro::one { struct LocalizationInfo; }
// Forward declaration of `LocationPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class LocationPermissionStatus; }
// Forward declaration of `LocationPlace` to properly resolve imports.
namespace margelo::nitro::one { struct LocationPlace; }
// Forward declaration of `LocationPosition` to properly resolve imports.
namespace margelo::nitro::one { struct LocationPosition; }
// Forward declaration of `LocationRegion` to properly resolve imports.
namespace margelo::nitro::one { struct LocationRegion; }
// Forward declaration of `MailComposeResult` to properly resolve imports.
namespace margelo::nitro::one { enum class MailComposeResult; }
// Forward declaration of `MapCoordinate` to properly resolve imports.
namespace margelo::nitro::one { struct MapCoordinate; }
// Forward declaration of `MapPlace` to properly resolve imports.
namespace margelo::nitro::one { struct MapPlace; }
// Forward declaration of `MapRouteStep` to properly resolve imports.
namespace margelo::nitro::one { struct MapRouteStep; }
// Forward declaration of `MapRoute` to properly resolve imports.
namespace margelo::nitro::one { struct MapRoute; }
// Forward declaration of `MapSuggestion` to properly resolve imports.
namespace margelo::nitro::one { struct MapSuggestion; }
// Forward declaration of `MessageAttachment` to properly resolve imports.
namespace margelo::nitro::one { struct MessageAttachment; }
// Forward declaration of `MessageComposeResult` to properly resolve imports.
namespace margelo::nitro::one { enum class MessageComposeResult; }
// Forward declaration of `MotionAvailability` to properly resolve imports.
namespace margelo::nitro::one { struct MotionAvailability; }
// Forward declaration of `MotionReading` to properly resolve imports.
namespace margelo::nitro::one { struct MotionReading; }
// Forward declaration of `MotionSensor` to properly resolve imports.
namespace margelo::nitro::one { enum class MotionSensor; }
// Forward declaration of `MotionVector` to properly resolve imports.
namespace margelo::nitro::one { struct MotionVector; }
// Forward declaration of `NativeChannel` to properly resolve imports.
namespace margelo::nitro::one { struct NativeChannel; }
// Forward declaration of `NativeContent` to properly resolve imports.
namespace margelo::nitro::one { struct NativeContent; }
// Forward declaration of `NativeIosPermissionRequest` to properly resolve imports.
namespace margelo::nitro::one { struct NativeIosPermissionRequest; }
// Forward declaration of `NativeIosPermission` to properly resolve imports.
namespace margelo::nitro::one { struct NativeIosPermission; }
// Forward declaration of `NativeNotificationAction` to properly resolve imports.
namespace margelo::nitro::one { struct NativeNotificationAction; }
// Forward declaration of `NativeNotificationCategoryOptions` to properly resolve imports.
namespace margelo::nitro::one { struct NativeNotificationCategoryOptions; }
// Forward declaration of `NativeNotificationCategory` to properly resolve imports.
namespace margelo::nitro::one { struct NativeNotificationCategory; }
// Forward declaration of `NativeNotificationRequest` to properly resolve imports.
namespace margelo::nitro::one { struct NativeNotificationRequest; }
// Forward declaration of `NativeNotificationResponse` to properly resolve imports.
namespace margelo::nitro::one { struct NativeNotificationResponse; }
// Forward declaration of `NativeNotification` to properly resolve imports.
namespace margelo::nitro::one { struct NativeNotification; }
// Forward declaration of `NativePermissionResponse` to properly resolve imports.
namespace margelo::nitro::one { struct NativePermissionResponse; }
// Forward declaration of `NativePushToken` to properly resolve imports.
namespace margelo::nitro::one { struct NativePushToken; }
// Forward declaration of `NativeTriggerInput` to properly resolve imports.
namespace margelo::nitro::one { struct NativeTriggerInput; }
// Forward declaration of `NativeTriggerType` to properly resolve imports.
namespace margelo::nitro::one { enum class NativeTriggerType; }
// Forward declaration of `NativeTrigger` to properly resolve imports.
namespace margelo::nitro::one { struct NativeTrigger; }
// Forward declaration of `NetworkStateType` to properly resolve imports.
namespace margelo::nitro::one { enum class NetworkStateType; }
// Forward declaration of `NetworkState` to properly resolve imports.
namespace margelo::nitro::one { struct NetworkState; }
// Forward declaration of `NotificationPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class NotificationPermissionStatus; }
// Forward declaration of `OneImageFlip` to properly resolve imports.
namespace margelo::nitro::one { enum class OneImageFlip; }
// Forward declaration of `OneUpdatesCheckResult` to properly resolve imports.
namespace margelo::nitro::one { struct OneUpdatesCheckResult; }
// Forward declaration of `OneUpdatesCheckType` to properly resolve imports.
namespace margelo::nitro::one { enum class OneUpdatesCheckType; }
// Forward declaration of `OneUpdatesFetchResult` to properly resolve imports.
namespace margelo::nitro::one { struct OneUpdatesFetchResult; }
// Forward declaration of `OneUpdatesFetchType` to properly resolve imports.
namespace margelo::nitro::one { enum class OneUpdatesFetchType; }
// Forward declaration of `PathStat` to properly resolve imports.
namespace margelo::nitro::one { struct PathStat; }
// Forward declaration of `PedometerPermissionResponse` to properly resolve imports.
namespace margelo::nitro::one { struct PedometerPermissionResponse; }
// Forward declaration of `PedometerPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class PedometerPermissionStatus; }
// Forward declaration of `PedometerResult` to properly resolve imports.
namespace margelo::nitro::one { struct PedometerResult; }
// Forward declaration of `PendingBackgroundTask` to properly resolve imports.
namespace margelo::nitro::one { struct PendingBackgroundTask; }
// Forward declaration of `PhotoLibraryAlbumPage` to properly resolve imports.
namespace margelo::nitro::one { struct PhotoLibraryAlbumPage; }
// Forward declaration of `PhotoLibraryAlbum` to properly resolve imports.
namespace margelo::nitro::one { struct PhotoLibraryAlbum; }
// Forward declaration of `PhotoLibraryAssetPage` to properly resolve imports.
namespace margelo::nitro::one { struct PhotoLibraryAssetPage; }
// Forward declaration of `PhotoLibraryAsset` to properly resolve imports.
namespace margelo::nitro::one { struct PhotoLibraryAsset; }
// Forward declaration of `PhotoLibraryMediaType` to properly resolve imports.
namespace margelo::nitro::one { enum class PhotoLibraryMediaType; }
// Forward declaration of `PhotoLibraryPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class PhotoLibraryPermissionStatus; }
// Forward declaration of `PitchCorrectionQuality` to properly resolve imports.
namespace margelo::nitro::one { enum class PitchCorrectionQuality; }
// Forward declaration of `PrintResult` to properly resolve imports.
namespace margelo::nitro::one { struct PrintResult; }
// Forward declaration of `PurchaseProductType` to properly resolve imports.
namespace margelo::nitro::one { enum class PurchaseProductType; }
// Forward declaration of `PurchaseProduct` to properly resolve imports.
namespace margelo::nitro::one { struct PurchaseProduct; }
// Forward declaration of `PurchaseResult` to properly resolve imports.
namespace margelo::nitro::one { struct PurchaseResult; }
// Forward declaration of `PurchaseStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class PurchaseStatus; }
// Forward declaration of `PurchaseTransaction` to properly resolve imports.
namespace margelo::nitro::one { struct PurchaseTransaction; }
// Forward declaration of `PurchaseUpdateStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class PurchaseUpdateStatus; }
// Forward declaration of `PurchaseUpdate` to properly resolve imports.
namespace margelo::nitro::one { struct PurchaseUpdate; }
// Forward declaration of `QuickActionItem` to properly resolve imports.
namespace margelo::nitro::one { struct QuickActionItem; }
// Forward declaration of `RegionCenter` to properly resolve imports.
namespace margelo::nitro::one { struct RegionCenter; }
// Forward declaration of `RegionState` to properly resolve imports.
namespace margelo::nitro::one { enum class RegionState; }
// Forward declaration of `ReminderInfo` to properly resolve imports.
namespace margelo::nitro::one { struct ReminderInfo; }
// Forward declaration of `ScreenCaptureResult` to properly resolve imports.
namespace margelo::nitro::one { struct ScreenCaptureResult; }
// Forward declaration of `ScreenCaptureState` to properly resolve imports.
namespace margelo::nitro::one { enum class ScreenCaptureState; }
// Forward declaration of `ScreenOrientationValue` to properly resolve imports.
namespace margelo::nitro::one { enum class ScreenOrientationValue; }
// Forward declaration of `SecureStoreAccessibility` to properly resolve imports.
namespace margelo::nitro::one { enum class SecureStoreAccessibility; }
// Forward declaration of `ShareItemType` to properly resolve imports.
namespace margelo::nitro::one { enum class ShareItemType; }
// Forward declaration of `ShareItem` to properly resolve imports.
namespace margelo::nitro::one { struct ShareItem; }
// Forward declaration of `ShareResult` to properly resolve imports.
namespace margelo::nitro::one { struct ShareResult; }
// Forward declaration of `SizeClass` to properly resolve imports.
namespace margelo::nitro::one { struct SizeClass; }
// Forward declaration of `SpeechErrorCode` to properly resolve imports.
namespace margelo::nitro::one { enum class SpeechErrorCode; }
// Forward declaration of `SpeechEventType` to properly resolve imports.
namespace margelo::nitro::one { enum class SpeechEventType; }
// Forward declaration of `SpeechEvent` to properly resolve imports.
namespace margelo::nitro::one { struct SpeechEvent; }
// Forward declaration of `SpeechPermissionResponse` to properly resolve imports.
namespace margelo::nitro::one { struct SpeechPermissionResponse; }
// Forward declaration of `SpeechPermissionStatus` to properly resolve imports.
namespace margelo::nitro::one { enum class SpeechPermissionStatus; }
// Forward declaration of `SpeechSynthesisEventType` to properly resolve imports.
namespace margelo::nitro::one { enum class SpeechSynthesisEventType; }
// Forward declaration of `SpeechSynthesisEvent` to properly resolve imports.
namespace margelo::nitro::one { struct SpeechSynthesisEvent; }
// Forward declaration of `SpeechSynthesisVoiceQuality` to properly resolve imports.
namespace margelo::nitro::one { enum class SpeechSynthesisVoiceQuality; }
// Forward declaration of `SpeechSynthesisVoice` to properly resolve imports.
namespace margelo::nitro::one { struct SpeechSynthesisVoice; }
// Forward declaration of `UserInterfaceSizeClass` to properly resolve imports.
namespace margelo::nitro::one { enum class UserInterfaceSizeClass; }

// Forward declarations of Swift defined types
// Forward declaration of `HybridDocumentCameraImageSpec_cxx` to properly resolve imports.
namespace One { class HybridDocumentCameraImageSpec_cxx; }
// Forward declaration of `HybridDocumentCameraScanSpec_cxx` to properly resolve imports.
namespace One { class HybridDocumentCameraScanSpec_cxx; }
// Forward declaration of `HybridNativeCNContactSpec_cxx` to properly resolve imports.
namespace One { class HybridNativeCNContactSpec_cxx; }
// Forward declaration of `HybridNativeCNContactStoreSpec_cxx` to properly resolve imports.
namespace One { class HybridNativeCNContactStoreSpec_cxx; }
// Forward declaration of `HybridNativeCNKeyDescriptorSpec_cxx` to properly resolve imports.
namespace One { class HybridNativeCNKeyDescriptorSpec_cxx; }
// Forward declaration of `HybridOneAdaptiveSpec_cxx` to properly resolve imports.
namespace One { class HybridOneAdaptiveSpec_cxx; }
// Forward declaration of `HybridOneAppIconSpec_cxx` to properly resolve imports.
namespace One { class HybridOneAppIconSpec_cxx; }
// Forward declaration of `HybridOneAppInfoSpec_cxx` to properly resolve imports.
namespace One { class HybridOneAppInfoSpec_cxx; }
// Forward declaration of `HybridOneAppIntentsSpec_cxx` to properly resolve imports.
namespace One { class HybridOneAppIntentsSpec_cxx; }
// Forward declaration of `HybridOneAppTrackingSpec_cxx` to properly resolve imports.
namespace One { class HybridOneAppTrackingSpec_cxx; }
// Forward declaration of `HybridOneAppleAuthSpec_cxx` to properly resolve imports.
namespace One { class HybridOneAppleAuthSpec_cxx; }
// Forward declaration of `HybridOneAudioSpec_cxx` to properly resolve imports.
namespace One { class HybridOneAudioSpec_cxx; }
// Forward declaration of `HybridOneBackgroundTasksSpec_cxx` to properly resolve imports.
namespace One { class HybridOneBackgroundTasksSpec_cxx; }
// Forward declaration of `HybridOneBarometerSpec_cxx` to properly resolve imports.
namespace One { class HybridOneBarometerSpec_cxx; }
// Forward declaration of `HybridOneBatterySpec_cxx` to properly resolve imports.
namespace One { class HybridOneBatterySpec_cxx; }
// Forward declaration of `HybridOneBrightnessSpec_cxx` to properly resolve imports.
namespace One { class HybridOneBrightnessSpec_cxx; }
// Forward declaration of `HybridOneBrowserSpec_cxx` to properly resolve imports.
namespace One { class HybridOneBrowserSpec_cxx; }
// Forward declaration of `HybridOneCalendarSpec_cxx` to properly resolve imports.
namespace One { class HybridOneCalendarSpec_cxx; }
// Forward declaration of `HybridOneClipboardSpec_cxx` to properly resolve imports.
namespace One { class HybridOneClipboardSpec_cxx; }
// Forward declaration of `HybridOneContactUISpec_cxx` to properly resolve imports.
namespace One { class HybridOneContactUISpec_cxx; }
// Forward declaration of `HybridOneContactsSpec_cxx` to properly resolve imports.
namespace One { class HybridOneContactsSpec_cxx; }
// Forward declaration of `HybridOneDataScannerSpec_cxx` to properly resolve imports.
namespace One { class HybridOneDataScannerSpec_cxx; }
// Forward declaration of `HybridOneDeviceAttestationSpec_cxx` to properly resolve imports.
namespace One { class HybridOneDeviceAttestationSpec_cxx; }
// Forward declaration of `HybridOneDeviceSpec_cxx` to properly resolve imports.
namespace One { class HybridOneDeviceSpec_cxx; }
// Forward declaration of `HybridOneDocumentCameraSpec_cxx` to properly resolve imports.
namespace One { class HybridOneDocumentCameraSpec_cxx; }
// Forward declaration of `HybridOneDocumentPickerSpec_cxx` to properly resolve imports.
namespace One { class HybridOneDocumentPickerSpec_cxx; }
// Forward declaration of `HybridOneFetchSpec_cxx` to properly resolve imports.
namespace One { class HybridOneFetchSpec_cxx; }
// Forward declaration of `HybridOneFileSystemSpec_cxx` to properly resolve imports.
namespace One { class HybridOneFileSystemSpec_cxx; }
// Forward declaration of `HybridOneFontsSpec_cxx` to properly resolve imports.
namespace One { class HybridOneFontsSpec_cxx; }
// Forward declaration of `HybridOneHapticsSpec_cxx` to properly resolve imports.
namespace One { class HybridOneHapticsSpec_cxx; }
// Forward declaration of `HybridOneImageManipulatorSpec_cxx` to properly resolve imports.
namespace One { class HybridOneImageManipulatorSpec_cxx; }
// Forward declaration of `HybridOneImagePickerSpec_cxx` to properly resolve imports.
namespace One { class HybridOneImagePickerSpec_cxx; }
// Forward declaration of `HybridOneKeepAwakeSpec_cxx` to properly resolve imports.
namespace One { class HybridOneKeepAwakeSpec_cxx; }
// Forward declaration of `HybridOneLaunchScreenSpec_cxx` to properly resolve imports.
namespace One { class HybridOneLaunchScreenSpec_cxx; }
// Forward declaration of `HybridOneLightSensorSpec_cxx` to properly resolve imports.
namespace One { class HybridOneLightSensorSpec_cxx; }
// Forward declaration of `HybridOneLocalAuthenticationSpec_cxx` to properly resolve imports.
namespace One { class HybridOneLocalAuthenticationSpec_cxx; }
// Forward declaration of `HybridOneLocationSpec_cxx` to properly resolve imports.
namespace One { class HybridOneLocationSpec_cxx; }
// Forward declaration of `HybridOneMailComposeSpec_cxx` to properly resolve imports.
namespace One { class HybridOneMailComposeSpec_cxx; }
// Forward declaration of `HybridOneMapServicesSpec_cxx` to properly resolve imports.
namespace One { class HybridOneMapServicesSpec_cxx; }
// Forward declaration of `HybridOneMessageComposeSpec_cxx` to properly resolve imports.
namespace One { class HybridOneMessageComposeSpec_cxx; }
// Forward declaration of `HybridOneMotionSpec_cxx` to properly resolve imports.
namespace One { class HybridOneMotionSpec_cxx; }
// Forward declaration of `HybridOneNativeModulesSpec_cxx` to properly resolve imports.
namespace One { class HybridOneNativeModulesSpec_cxx; }
// Forward declaration of `HybridOneNetworkSpec_cxx` to properly resolve imports.
namespace One { class HybridOneNetworkSpec_cxx; }
// Forward declaration of `HybridOneNotificationsSpec_cxx` to properly resolve imports.
namespace One { class HybridOneNotificationsSpec_cxx; }
// Forward declaration of `HybridOnePedometerSpec_cxx` to properly resolve imports.
namespace One { class HybridOnePedometerSpec_cxx; }
// Forward declaration of `HybridOnePhotoLibrarySpec_cxx` to properly resolve imports.
namespace One { class HybridOnePhotoLibrarySpec_cxx; }
// Forward declaration of `HybridOnePrintSpec_cxx` to properly resolve imports.
namespace One { class HybridOnePrintSpec_cxx; }
// Forward declaration of `HybridOneProtectedStoreSpec_cxx` to properly resolve imports.
namespace One { class HybridOneProtectedStoreSpec_cxx; }
// Forward declaration of `HybridOnePurchasesSpec_cxx` to properly resolve imports.
namespace One { class HybridOnePurchasesSpec_cxx; }
// Forward declaration of `HybridOneQuickActionsSpec_cxx` to properly resolve imports.
namespace One { class HybridOneQuickActionsSpec_cxx; }
// Forward declaration of `HybridOneScreenCaptureSpec_cxx` to properly resolve imports.
namespace One { class HybridOneScreenCaptureSpec_cxx; }
// Forward declaration of `HybridOneScreenOrientationSpec_cxx` to properly resolve imports.
namespace One { class HybridOneScreenOrientationSpec_cxx; }
// Forward declaration of `HybridOneSecureStoreSpec_cxx` to properly resolve imports.
namespace One { class HybridOneSecureStoreSpec_cxx; }
// Forward declaration of `HybridOneShareSpec_cxx` to properly resolve imports.
namespace One { class HybridOneShareSpec_cxx; }
// Forward declaration of `HybridOneSpeechSpec_cxx` to properly resolve imports.
namespace One { class HybridOneSpeechSpec_cxx; }
// Forward declaration of `HybridOneSpeechSynthesisSpec_cxx` to properly resolve imports.
namespace One { class HybridOneSpeechSynthesisSpec_cxx; }
// Forward declaration of `HybridOneStoreReviewSpec_cxx` to properly resolve imports.
namespace One { class HybridOneStoreReviewSpec_cxx; }
// Forward declaration of `HybridOneUpdatesSpec_cxx` to properly resolve imports.
namespace One { class HybridOneUpdatesSpec_cxx; }

// Include C++ defined types
#include "AppIntentInvocation.hpp"
#include "AppTrackingPermissionStatus.hpp"
#include "AppleAuthCredential.hpp"
#include "AppleAuthFullName.hpp"
#include "AppleAuthResult.hpp"
#include "AppleAuthResultType.hpp"
#include "AppleAuthScope.hpp"
#include "AppleCredentialState.hpp"
#include "AppleRealUserStatus.hpp"
#include "AudioInterruptionEvent.hpp"
#include "AudioInterruptionType.hpp"
#include "AudioPlaybackState.hpp"
#include "AudioPlaybackStatus.hpp"
#include "AudioPlayerStatus.hpp"
#include "AudioRecordingPermission.hpp"
#include "AudioRecordingResult.hpp"
#include "AudioRecordingState.hpp"
#include "AudioRecordingStatus.hpp"
#include "AudioRemoteCommandEvent.hpp"
#include "AudioRemoteCommandType.hpp"
#include "BackgroundTaskInvocation.hpp"
#include "BackgroundTaskKind.hpp"
#include "BarometerMeasurement.hpp"
#include "BatteryLevelEvent.hpp"
#include "BatteryPowerModeEvent.hpp"
#include "BatteryPowerState.hpp"
#include "BatteryState.hpp"
#include "BatteryStateEvent.hpp"
#include "BrightnessEvent.hpp"
#include "BrightnessMode.hpp"
#include "BrightnessPermissionResponse.hpp"
#include "BrightnessPermissionStatus.hpp"
#include "BrowserAuthResult.hpp"
#include "BrowserAuthResultType.hpp"
#include "BrowserColorScheme.hpp"
#include "BrowserPresentationStyle.hpp"
#include "BrowserResult.hpp"
#include "BrowserResultType.hpp"
#include "CalendarEvent.hpp"
#include "CalendarInfo.hpp"
#include "CalendarPermissionStatus.hpp"
#include "CalendarRecurrence.hpp"
#include "CalendarRecurrenceFrequency.hpp"
#include "CameraPermissionResponse.hpp"
#include "CameraPermissionStatus.hpp"
#include "ClipboardImageResult.hpp"
#include "ContactInfo.hpp"
#include "ContactPostalAddress.hpp"
#include "ContactPostalAddressInput.hpp"
#include "ContactsPermissionStatus.hpp"
#include "DataScannerBounds.hpp"
#include "DataScannerItemType.hpp"
#include "DataScannerPoint.hpp"
#include "DataScannerRecognizedDataType.hpp"
#include "DataScannerRecognizedItem.hpp"
#include "DataScannerRect.hpp"
#include "DataScannerScanningUnavailable.hpp"
#include "DataScannerTextContentType.hpp"
#include "DetailedDirectoryInfo.hpp"
#include "DetailedFileInfo.hpp"
#include "DeviceAttestationAvailability.hpp"
#include "DeviceInfo.hpp"
#include "DiskSpace.hpp"
#include "DocumentCameraError.hpp"
#include "DocumentPickerAsset.hpp"
#include "DocumentPickerNativeResult.hpp"
#include "FetchBlobRef.hpp"
#include "FetchFormPart.hpp"
#include "FetchHeader.hpp"
#include "FetchNativeResponse.hpp"
#include "FileDirectories.hpp"
#include "FileEntry.hpp"
#include "FileInfo.hpp"
#include "HingeState.hpp"
#include "HingeStatus.hpp"
#include "HybridDocumentCameraImageSpec.hpp"
#include "HybridDocumentCameraScanSpec.hpp"
#include "HybridNativeCNContactSpec.hpp"
#include "HybridNativeCNContactStoreSpec.hpp"
#include "HybridNativeCNKeyDescriptorSpec.hpp"
#include "HybridOneAdaptiveSpec.hpp"
#include "HybridOneAppIconSpec.hpp"
#include "HybridOneAppInfoSpec.hpp"
#include "HybridOneAppIntentsSpec.hpp"
#include "HybridOneAppTrackingSpec.hpp"
#include "HybridOneAppleAuthSpec.hpp"
#include "HybridOneAudioSpec.hpp"
#include "HybridOneBackgroundTasksSpec.hpp"
#include "HybridOneBarometerSpec.hpp"
#include "HybridOneBatterySpec.hpp"
#include "HybridOneBrightnessSpec.hpp"
#include "HybridOneBrowserSpec.hpp"
#include "HybridOneCalendarSpec.hpp"
#include "HybridOneClipboardSpec.hpp"
#include "HybridOneContactUISpec.hpp"
#include "HybridOneContactsSpec.hpp"
#include "HybridOneDataScannerSpec.hpp"
#include "HybridOneDeviceAttestationSpec.hpp"
#include "HybridOneDeviceSpec.hpp"
#include "HybridOneDocumentCameraSpec.hpp"
#include "HybridOneDocumentPickerSpec.hpp"
#include "HybridOneFetchSpec.hpp"
#include "HybridOneFileSystemSpec.hpp"
#include "HybridOneFontsSpec.hpp"
#include "HybridOneHapticsSpec.hpp"
#include "HybridOneImageManipulatorSpec.hpp"
#include "HybridOneImagePickerSpec.hpp"
#include "HybridOneKeepAwakeSpec.hpp"
#include "HybridOneLaunchScreenSpec.hpp"
#include "HybridOneLightSensorSpec.hpp"
#include "HybridOneLocalAuthenticationSpec.hpp"
#include "HybridOneLocationSpec.hpp"
#include "HybridOneMailComposeSpec.hpp"
#include "HybridOneMapServicesSpec.hpp"
#include "HybridOneMessageComposeSpec.hpp"
#include "HybridOneMotionSpec.hpp"
#include "HybridOneNativeModulesSpec.hpp"
#include "HybridOneNetworkSpec.hpp"
#include "HybridOneNotificationsSpec.hpp"
#include "HybridOnePedometerSpec.hpp"
#include "HybridOnePhotoLibrarySpec.hpp"
#include "HybridOnePrintSpec.hpp"
#include "HybridOneProtectedStoreSpec.hpp"
#include "HybridOnePurchasesSpec.hpp"
#include "HybridOneQuickActionsSpec.hpp"
#include "HybridOneScreenCaptureSpec.hpp"
#include "HybridOneScreenOrientationSpec.hpp"
#include "HybridOneSecureStoreSpec.hpp"
#include "HybridOneShareSpec.hpp"
#include "HybridOneSpeechSpec.hpp"
#include "HybridOneSpeechSynthesisSpec.hpp"
#include "HybridOneStoreReviewSpec.hpp"
#include "HybridOneUpdatesSpec.hpp"
#include "ImageCrop.hpp"
#include "ImagePickerAsset.hpp"
#include "ImagePickerAssetType.hpp"
#include "ImagePickerCropAspect.hpp"
#include "ImagePickerMediaType.hpp"
#include "ImagePickerNativeResult.hpp"
#include "ImageResize.hpp"
#include "ImageTransformResult.hpp"
#include "LightSensorMeasurement.hpp"
#include "ListedEntry.hpp"
#include "LocalAuthenticationStatus.hpp"
#include "LocaleInfo.hpp"
#include "LocalizationInfo.hpp"
#include "LocationPermissionStatus.hpp"
#include "LocationPlace.hpp"
#include "LocationPosition.hpp"
#include "LocationRegion.hpp"
#include "MailComposeResult.hpp"
#include "MapCoordinate.hpp"
#include "MapPlace.hpp"
#include "MapRoute.hpp"
#include "MapRouteStep.hpp"
#include "MapSuggestion.hpp"
#include "MessageAttachment.hpp"
#include "MessageComposeResult.hpp"
#include "MotionAvailability.hpp"
#include "MotionReading.hpp"
#include "MotionSensor.hpp"
#include "MotionVector.hpp"
#include "NativeChannel.hpp"
#include "NativeContent.hpp"
#include "NativeIosPermission.hpp"
#include "NativeIosPermissionRequest.hpp"
#include "NativeNotification.hpp"
#include "NativeNotificationAction.hpp"
#include "NativeNotificationCategory.hpp"
#include "NativeNotificationCategoryOptions.hpp"
#include "NativeNotificationRequest.hpp"
#include "NativeNotificationResponse.hpp"
#include "NativePermissionResponse.hpp"
#include "NativePushToken.hpp"
#include "NativeTrigger.hpp"
#include "NativeTriggerInput.hpp"
#include "NativeTriggerType.hpp"
#include "NetworkState.hpp"
#include "NetworkStateType.hpp"
#include "NotificationPermissionStatus.hpp"
#include "OneImageFlip.hpp"
#include "OneUpdatesCheckResult.hpp"
#include "OneUpdatesCheckType.hpp"
#include "OneUpdatesFetchResult.hpp"
#include "OneUpdatesFetchType.hpp"
#include "PathStat.hpp"
#include "PedometerPermissionResponse.hpp"
#include "PedometerPermissionStatus.hpp"
#include "PedometerResult.hpp"
#include "PendingBackgroundTask.hpp"
#include "PhotoLibraryAlbum.hpp"
#include "PhotoLibraryAlbumPage.hpp"
#include "PhotoLibraryAsset.hpp"
#include "PhotoLibraryAssetPage.hpp"
#include "PhotoLibraryMediaType.hpp"
#include "PhotoLibraryPermissionStatus.hpp"
#include "PitchCorrectionQuality.hpp"
#include "PrintResult.hpp"
#include "PurchaseProduct.hpp"
#include "PurchaseProductType.hpp"
#include "PurchaseResult.hpp"
#include "PurchaseStatus.hpp"
#include "PurchaseTransaction.hpp"
#include "PurchaseUpdate.hpp"
#include "PurchaseUpdateStatus.hpp"
#include "QuickActionItem.hpp"
#include "RegionCenter.hpp"
#include "RegionState.hpp"
#include "ReminderInfo.hpp"
#include "ScreenCaptureResult.hpp"
#include "ScreenCaptureState.hpp"
#include "ScreenOrientationValue.hpp"
#include "SecureStoreAccessibility.hpp"
#include "ShareItem.hpp"
#include "ShareItemType.hpp"
#include "ShareResult.hpp"
#include "SizeClass.hpp"
#include "SpeechErrorCode.hpp"
#include "SpeechEvent.hpp"
#include "SpeechEventType.hpp"
#include "SpeechPermissionResponse.hpp"
#include "SpeechPermissionStatus.hpp"
#include "SpeechSynthesisEvent.hpp"
#include "SpeechSynthesisEventType.hpp"
#include "SpeechSynthesisVoice.hpp"
#include "SpeechSynthesisVoiceQuality.hpp"
#include "UserInterfaceSizeClass.hpp"
#include <NitroModules/AnyMap.hpp>
#include <NitroModules/ArrayBuffer.hpp>
#include <NitroModules/ArrayBufferHolder.hpp>
#include <NitroModules/Promise.hpp>
#include <NitroModules/PromiseHolder.hpp>
#include <NitroModules/Result.hpp>
#include <exception>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>

/**
 * Contains specialized versions of C++ templated types so they can be accessed from Swift,
 * as well as helper functions to interact with those C++ types from Swift.
 */
namespace margelo::nitro::one::bridge::swift {

  // pragma MARK: std::optional<HingeState>
  /**
   * Specialized version of `std::optional<HingeState>`.
   */
  using std__optional_HingeState_ = std::optional<HingeState>;
  inline std::optional<HingeState> create_std__optional_HingeState_(const HingeState& value) noexcept {
    return std::optional<HingeState>(value);
  }
  inline bool has_value_std__optional_HingeState_(const std::optional<HingeState>& optional) noexcept {
    return optional.has_value();
  }
  inline HingeState get_std__optional_HingeState_(const std::optional<HingeState>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<SizeClass>>
  /**
   * Specialized version of `std::shared_ptr<Promise<SizeClass>>`.
   */
  using std__shared_ptr_Promise_SizeClass__ = std::shared_ptr<Promise<SizeClass>>;
  inline std::shared_ptr<Promise<SizeClass>> create_std__shared_ptr_Promise_SizeClass__() noexcept {
    return Promise<SizeClass>::create();
  }
  inline PromiseHolder<SizeClass> wrap_std__shared_ptr_Promise_SizeClass__(std::shared_ptr<Promise<SizeClass>> promise) noexcept {
    return PromiseHolder<SizeClass>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const SizeClass& /* result */)>
  /**
   * Specialized version of `std::function<void(const SizeClass&)>`.
   */
  using Func_void_SizeClass = std::function<void(const SizeClass& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const SizeClass& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_SizeClass_Wrapper final {
  public:
    explicit Func_void_SizeClass_Wrapper(std::function<void(const SizeClass& /* result */)>&& func): _function(std::make_unique<std::function<void(const SizeClass& /* result */)>>(std::move(func))) {}
    inline void call(SizeClass result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const SizeClass& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_SizeClass create_Func_void_SizeClass(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_SizeClass_Wrapper wrap_Func_void_SizeClass(Func_void_SizeClass value) noexcept {
    return Func_void_SizeClass_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
  /**
   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
   */
  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
  /**
   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
   */
  class Func_void_std__exception_ptr_Wrapper final {
  public:
    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
    inline void call(std::exception_ptr error) const noexcept {
      _function->operator()(error);
    }
  private:
    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
    return Func_void_std__exception_ptr_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::optional<HingeState>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::optional<HingeState>>>`.
   */
  using std__shared_ptr_Promise_std__optional_HingeState___ = std::shared_ptr<Promise<std::optional<HingeState>>>;
  inline std::shared_ptr<Promise<std::optional<HingeState>>> create_std__shared_ptr_Promise_std__optional_HingeState___() noexcept {
    return Promise<std::optional<HingeState>>::create();
  }
  inline PromiseHolder<std::optional<HingeState>> wrap_std__shared_ptr_Promise_std__optional_HingeState___(std::shared_ptr<Promise<std::optional<HingeState>>> promise) noexcept {
    return PromiseHolder<std::optional<HingeState>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::optional<HingeState>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::optional<HingeState>&)>`.
   */
  using Func_void_std__optional_HingeState_ = std::function<void(const std::optional<HingeState>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<HingeState>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_HingeState__Wrapper final {
  public:
    explicit Func_void_std__optional_HingeState__Wrapper(std::function<void(const std::optional<HingeState>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<HingeState>& /* result */)>>(std::move(func))) {}
    inline void call(std::optional<HingeState> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<HingeState>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_HingeState_ create_Func_void_std__optional_HingeState_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_HingeState__Wrapper wrap_Func_void_std__optional_HingeState_(Func_void_std__optional_HingeState_ value) noexcept {
    return Func_void_std__optional_HingeState__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void()>
  /**
   * Specialized version of `std::function<void()>`.
   */
  using Func_void = std::function<void()>;
  /**
   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
   */
  class Func_void_Wrapper final {
  public:
    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
    inline void call() const noexcept {
      _function->operator()();
    }
  private:
    std::unique_ptr<std::function<void()>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
    return Func_void_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAdaptiveSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneAdaptiveSpec>`.
   */
  using std__shared_ptr_HybridOneAdaptiveSpec_ = std::shared_ptr<HybridOneAdaptiveSpec>;
  std::shared_ptr<HybridOneAdaptiveSpec> create_std__shared_ptr_HybridOneAdaptiveSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneAdaptiveSpec_(std__shared_ptr_HybridOneAdaptiveSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneAdaptiveSpec>
  using std__weak_ptr_HybridOneAdaptiveSpec_ = std::weak_ptr<HybridOneAdaptiveSpec>;
  inline std__weak_ptr_HybridOneAdaptiveSpec_ weakify_std__shared_ptr_HybridOneAdaptiveSpec_(const std::shared_ptr<HybridOneAdaptiveSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<SizeClass>
  using Result_SizeClass_ = Result<SizeClass>;
  inline Result_SizeClass_ create_Result_SizeClass_(const SizeClass& value) noexcept {
    return Result<SizeClass>::withValue(value);
  }
  inline Result_SizeClass_ create_Result_SizeClass_(const std::exception_ptr& error) noexcept {
    return Result<SizeClass>::withError(error);
  }
  
  // pragma MARK: Result<std::optional<HingeState>>
  using Result_std__optional_HingeState__ = Result<std::optional<HingeState>>;
  inline Result_std__optional_HingeState__ create_Result_std__optional_HingeState__(const std::optional<HingeState>& value) noexcept {
    return Result<std::optional<HingeState>>::withValue(value);
  }
  inline Result_std__optional_HingeState__ create_Result_std__optional_HingeState__(const std::exception_ptr& error) noexcept {
    return Result<std::optional<HingeState>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<SizeClass>>>
  using Result_std__shared_ptr_Promise_SizeClass___ = Result<std::shared_ptr<Promise<SizeClass>>>;
  inline Result_std__shared_ptr_Promise_SizeClass___ create_Result_std__shared_ptr_Promise_SizeClass___(const std::shared_ptr<Promise<SizeClass>>& value) noexcept {
    return Result<std::shared_ptr<Promise<SizeClass>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_SizeClass___ create_Result_std__shared_ptr_Promise_SizeClass___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<SizeClass>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<HingeState>>>>
  using Result_std__shared_ptr_Promise_std__optional_HingeState____ = Result<std::shared_ptr<Promise<std::optional<HingeState>>>>;
  inline Result_std__shared_ptr_Promise_std__optional_HingeState____ create_Result_std__shared_ptr_Promise_std__optional_HingeState____(const std::shared_ptr<Promise<std::optional<HingeState>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<HingeState>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__optional_HingeState____ create_Result_std__shared_ptr_Promise_std__optional_HingeState____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<HingeState>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::function<void()>>
  using Result_std__function_void____ = Result<std::function<void()>>;
  inline Result_std__function_void____ create_Result_std__function_void____(const std::function<void()>& value) noexcept {
    return Result<std::function<void()>>::withValue(value);
  }
  inline Result_std__function_void____ create_Result_std__function_void____(const std::exception_ptr& error) noexcept {
    return Result<std::function<void()>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<bool>>
  /**
   * Specialized version of `std::shared_ptr<Promise<bool>>`.
   */
  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
    return Promise<bool>::create();
  }
  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
    return PromiseHolder<bool>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(bool /* result */)>
  /**
   * Specialized version of `std::function<void(bool)>`.
   */
  using Func_void_bool = std::function<void(bool /* result */)>;
  /**
   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
   */
  class Func_void_bool_Wrapper final {
  public:
    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
    inline void call(bool result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(bool /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
    return Func_void_bool_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<std::string>
  /**
   * Specialized version of `std::optional<std::string>`.
   */
  using std__optional_std__string_ = std::optional<std::string>;
  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
    return std::optional<std::string>(value);
  }
  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
    return optional.has_value();
  }
  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::optional<std::string>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::optional<std::string>>>`.
   */
  using std__shared_ptr_Promise_std__optional_std__string___ = std::shared_ptr<Promise<std::optional<std::string>>>;
  inline std::shared_ptr<Promise<std::optional<std::string>>> create_std__shared_ptr_Promise_std__optional_std__string___() noexcept {
    return Promise<std::optional<std::string>>::create();
  }
  inline PromiseHolder<std::optional<std::string>> wrap_std__shared_ptr_Promise_std__optional_std__string___(std::shared_ptr<Promise<std::optional<std::string>>> promise) noexcept {
    return PromiseHolder<std::optional<std::string>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::optional<std::string>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::optional<std::string>&)>`.
   */
  using Func_void_std__optional_std__string_ = std::function<void(const std::optional<std::string>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<std::string>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_std__string__Wrapper final {
  public:
    explicit Func_void_std__optional_std__string__Wrapper(std::function<void(const std::optional<std::string>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::string>& /* result */)>>(std::move(func))) {}
    inline void call(std::optional<std::string> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<std::string>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_std__string_ create_Func_void_std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_std__string__Wrapper wrap_Func_void_std__optional_std__string_(Func_void_std__optional_std__string_ value) noexcept {
    return Func_void_std__optional_std__string__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<void>>
  /**
   * Specialized version of `std::shared_ptr<Promise<void>>`.
   */
  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
    return Promise<void>::create();
  }
  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
    return PromiseHolder<void>(std::move(promise));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppIconSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneAppIconSpec>`.
   */
  using std__shared_ptr_HybridOneAppIconSpec_ = std::shared_ptr<HybridOneAppIconSpec>;
  std::shared_ptr<HybridOneAppIconSpec> create_std__shared_ptr_HybridOneAppIconSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneAppIconSpec_(std__shared_ptr_HybridOneAppIconSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneAppIconSpec>
  using std__weak_ptr_HybridOneAppIconSpec_ = std::weak_ptr<HybridOneAppIconSpec>;
  inline std__weak_ptr_HybridOneAppIconSpec_ weakify_std__shared_ptr_HybridOneAppIconSpec_(const std::shared_ptr<HybridOneAppIconSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::string>>>>
  using Result_std__shared_ptr_Promise_std__optional_std__string____ = Result<std::shared_ptr<Promise<std::optional<std::string>>>>;
  inline Result_std__shared_ptr_Promise_std__optional_std__string____ create_Result_std__shared_ptr_Promise_std__optional_std__string____(const std::shared_ptr<Promise<std::optional<std::string>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__optional_std__string____ create_Result_std__shared_ptr_Promise_std__optional_std__string____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<void>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppInfoSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneAppInfoSpec>`.
   */
  using std__shared_ptr_HybridOneAppInfoSpec_ = std::shared_ptr<HybridOneAppInfoSpec>;
  std::shared_ptr<HybridOneAppInfoSpec> create_std__shared_ptr_HybridOneAppInfoSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneAppInfoSpec_(std__shared_ptr_HybridOneAppInfoSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneAppInfoSpec>
  using std__weak_ptr_HybridOneAppInfoSpec_ = std::weak_ptr<HybridOneAppInfoSpec>;
  inline std__weak_ptr_HybridOneAppInfoSpec_ weakify_std__shared_ptr_HybridOneAppInfoSpec_(const std::shared_ptr<HybridOneAppInfoSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::function<void(const AppIntentInvocation& /* invocation */)>
  /**
   * Specialized version of `std::function<void(const AppIntentInvocation&)>`.
   */
  using Func_void_AppIntentInvocation = std::function<void(const AppIntentInvocation& /* invocation */)>;
  /**
   * Wrapper class for a `std::function<void(const AppIntentInvocation& / * invocation * /)>`, this can be used from Swift.
   */
  class Func_void_AppIntentInvocation_Wrapper final {
  public:
    explicit Func_void_AppIntentInvocation_Wrapper(std::function<void(const AppIntentInvocation& /* invocation */)>&& func): _function(std::make_unique<std::function<void(const AppIntentInvocation& /* invocation */)>>(std::move(func))) {}
    inline void call(AppIntentInvocation invocation) const noexcept {
      _function->operator()(invocation);
    }
  private:
    std::unique_ptr<std::function<void(const AppIntentInvocation& /* invocation */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AppIntentInvocation create_Func_void_AppIntentInvocation(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AppIntentInvocation_Wrapper wrap_Func_void_AppIntentInvocation(Func_void_AppIntentInvocation value) noexcept {
    return Func_void_AppIntentInvocation_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<AppIntentInvocation>
  /**
   * Specialized version of `std::vector<AppIntentInvocation>`.
   */
  using std__vector_AppIntentInvocation_ = std::vector<AppIntentInvocation>;
  inline std::vector<AppIntentInvocation> create_std__vector_AppIntentInvocation_(size_t size) noexcept {
    std::vector<AppIntentInvocation> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppIntentsSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneAppIntentsSpec>`.
   */
  using std__shared_ptr_HybridOneAppIntentsSpec_ = std::shared_ptr<HybridOneAppIntentsSpec>;
  std::shared_ptr<HybridOneAppIntentsSpec> create_std__shared_ptr_HybridOneAppIntentsSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneAppIntentsSpec_(std__shared_ptr_HybridOneAppIntentsSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneAppIntentsSpec>
  using std__weak_ptr_HybridOneAppIntentsSpec_ = std::weak_ptr<HybridOneAppIntentsSpec>;
  inline std__weak_ptr_HybridOneAppIntentsSpec_ weakify_std__shared_ptr_HybridOneAppIntentsSpec_(const std::shared_ptr<HybridOneAppIntentsSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::vector<AppIntentInvocation>>
  using Result_std__vector_AppIntentInvocation__ = Result<std::vector<AppIntentInvocation>>;
  inline Result_std__vector_AppIntentInvocation__ create_Result_std__vector_AppIntentInvocation__(const std::vector<AppIntentInvocation>& value) noexcept {
    return Result<std::vector<AppIntentInvocation>>::withValue(value);
  }
  inline Result_std__vector_AppIntentInvocation__ create_Result_std__vector_AppIntentInvocation__(const std::exception_ptr& error) noexcept {
    return Result<std::vector<AppIntentInvocation>>::withError(error);
  }
  
  // pragma MARK: Result<void>
  using Result_void_ = Result<void>;
  inline Result_void_ create_Result_void_() noexcept {
    return Result<void>::withValue();
  }
  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
    return Result<void>::withError(error);
  }
  
  // pragma MARK: std::optional<AppleAuthFullName>
  /**
   * Specialized version of `std::optional<AppleAuthFullName>`.
   */
  using std__optional_AppleAuthFullName_ = std::optional<AppleAuthFullName>;
  inline std::optional<AppleAuthFullName> create_std__optional_AppleAuthFullName_(const AppleAuthFullName& value) noexcept {
    return std::optional<AppleAuthFullName>(value);
  }
  inline bool has_value_std__optional_AppleAuthFullName_(const std::optional<AppleAuthFullName>& optional) noexcept {
    return optional.has_value();
  }
  inline AppleAuthFullName get_std__optional_AppleAuthFullName_(const std::optional<AppleAuthFullName>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<AppleAuthCredential>
  /**
   * Specialized version of `std::optional<AppleAuthCredential>`.
   */
  using std__optional_AppleAuthCredential_ = std::optional<AppleAuthCredential>;
  inline std::optional<AppleAuthCredential> create_std__optional_AppleAuthCredential_(const AppleAuthCredential& value) noexcept {
    return std::optional<AppleAuthCredential>(value);
  }
  inline bool has_value_std__optional_AppleAuthCredential_(const std::optional<AppleAuthCredential>& optional) noexcept {
    return optional.has_value();
  }
  inline AppleAuthCredential get_std__optional_AppleAuthCredential_(const std::optional<AppleAuthCredential>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<AppleAuthResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<AppleAuthResult>>`.
   */
  using std__shared_ptr_Promise_AppleAuthResult__ = std::shared_ptr<Promise<AppleAuthResult>>;
  inline std::shared_ptr<Promise<AppleAuthResult>> create_std__shared_ptr_Promise_AppleAuthResult__() noexcept {
    return Promise<AppleAuthResult>::create();
  }
  inline PromiseHolder<AppleAuthResult> wrap_std__shared_ptr_Promise_AppleAuthResult__(std::shared_ptr<Promise<AppleAuthResult>> promise) noexcept {
    return PromiseHolder<AppleAuthResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const AppleAuthResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const AppleAuthResult&)>`.
   */
  using Func_void_AppleAuthResult = std::function<void(const AppleAuthResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const AppleAuthResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_AppleAuthResult_Wrapper final {
  public:
    explicit Func_void_AppleAuthResult_Wrapper(std::function<void(const AppleAuthResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const AppleAuthResult& /* result */)>>(std::move(func))) {}
    inline void call(AppleAuthResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const AppleAuthResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AppleAuthResult create_Func_void_AppleAuthResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AppleAuthResult_Wrapper wrap_Func_void_AppleAuthResult(Func_void_AppleAuthResult value) noexcept {
    return Func_void_AppleAuthResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<AppleAuthScope>
  /**
   * Specialized version of `std::vector<AppleAuthScope>`.
   */
  using std__vector_AppleAuthScope_ = std::vector<AppleAuthScope>;
  inline std::vector<AppleAuthScope> create_std__vector_AppleAuthScope_(size_t size) noexcept {
    std::vector<AppleAuthScope> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<std::vector<AppleAuthScope>>
  /**
   * Specialized version of `std::optional<std::vector<AppleAuthScope>>`.
   */
  using std__optional_std__vector_AppleAuthScope__ = std::optional<std::vector<AppleAuthScope>>;
  inline std::optional<std::vector<AppleAuthScope>> create_std__optional_std__vector_AppleAuthScope__(const std::vector<AppleAuthScope>& value) noexcept {
    return std::optional<std::vector<AppleAuthScope>>(value);
  }
  inline bool has_value_std__optional_std__vector_AppleAuthScope__(const std::optional<std::vector<AppleAuthScope>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::vector<AppleAuthScope> get_std__optional_std__vector_AppleAuthScope__(const std::optional<std::vector<AppleAuthScope>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<AppleCredentialState>>
  /**
   * Specialized version of `std::shared_ptr<Promise<AppleCredentialState>>`.
   */
  using std__shared_ptr_Promise_AppleCredentialState__ = std::shared_ptr<Promise<AppleCredentialState>>;
  inline std::shared_ptr<Promise<AppleCredentialState>> create_std__shared_ptr_Promise_AppleCredentialState__() noexcept {
    return Promise<AppleCredentialState>::create();
  }
  inline PromiseHolder<AppleCredentialState> wrap_std__shared_ptr_Promise_AppleCredentialState__(std::shared_ptr<Promise<AppleCredentialState>> promise) noexcept {
    return PromiseHolder<AppleCredentialState>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(AppleCredentialState /* result */)>
  /**
   * Specialized version of `std::function<void(AppleCredentialState)>`.
   */
  using Func_void_AppleCredentialState = std::function<void(AppleCredentialState /* result */)>;
  /**
   * Wrapper class for a `std::function<void(AppleCredentialState / * result * /)>`, this can be used from Swift.
   */
  class Func_void_AppleCredentialState_Wrapper final {
  public:
    explicit Func_void_AppleCredentialState_Wrapper(std::function<void(AppleCredentialState /* result */)>&& func): _function(std::make_unique<std::function<void(AppleCredentialState /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<AppleCredentialState>(result));
    }
  private:
    std::unique_ptr<std::function<void(AppleCredentialState /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AppleCredentialState create_Func_void_AppleCredentialState(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AppleCredentialState_Wrapper wrap_Func_void_AppleCredentialState(Func_void_AppleCredentialState value) noexcept {
    return Func_void_AppleCredentialState_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppleAuthSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneAppleAuthSpec>`.
   */
  using std__shared_ptr_HybridOneAppleAuthSpec_ = std::shared_ptr<HybridOneAppleAuthSpec>;
  std::shared_ptr<HybridOneAppleAuthSpec> create_std__shared_ptr_HybridOneAppleAuthSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneAppleAuthSpec_(std__shared_ptr_HybridOneAppleAuthSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneAppleAuthSpec>
  using std__weak_ptr_HybridOneAppleAuthSpec_ = std::weak_ptr<HybridOneAppleAuthSpec>;
  inline std__weak_ptr_HybridOneAppleAuthSpec_ weakify_std__shared_ptr_HybridOneAppleAuthSpec_(const std::shared_ptr<HybridOneAppleAuthSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<bool>
  using Result_bool_ = Result<bool>;
  inline Result_bool_ create_Result_bool_(bool value) noexcept {
    return Result<bool>::withValue(std::move(value));
  }
  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
    return Result<bool>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<AppleAuthResult>>>
  using Result_std__shared_ptr_Promise_AppleAuthResult___ = Result<std::shared_ptr<Promise<AppleAuthResult>>>;
  inline Result_std__shared_ptr_Promise_AppleAuthResult___ create_Result_std__shared_ptr_Promise_AppleAuthResult___(const std::shared_ptr<Promise<AppleAuthResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<AppleAuthResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_AppleAuthResult___ create_Result_std__shared_ptr_Promise_AppleAuthResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<AppleAuthResult>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<AppleCredentialState>>>
  using Result_std__shared_ptr_Promise_AppleCredentialState___ = Result<std::shared_ptr<Promise<AppleCredentialState>>>;
  inline Result_std__shared_ptr_Promise_AppleCredentialState___ create_Result_std__shared_ptr_Promise_AppleCredentialState___(const std::shared_ptr<Promise<AppleCredentialState>>& value) noexcept {
    return Result<std::shared_ptr<Promise<AppleCredentialState>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_AppleCredentialState___ create_Result_std__shared_ptr_Promise_AppleCredentialState___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<AppleCredentialState>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<AppTrackingPermissionStatus>>
  /**
   * Specialized version of `std::shared_ptr<Promise<AppTrackingPermissionStatus>>`.
   */
  using std__shared_ptr_Promise_AppTrackingPermissionStatus__ = std::shared_ptr<Promise<AppTrackingPermissionStatus>>;
  inline std::shared_ptr<Promise<AppTrackingPermissionStatus>> create_std__shared_ptr_Promise_AppTrackingPermissionStatus__() noexcept {
    return Promise<AppTrackingPermissionStatus>::create();
  }
  inline PromiseHolder<AppTrackingPermissionStatus> wrap_std__shared_ptr_Promise_AppTrackingPermissionStatus__(std::shared_ptr<Promise<AppTrackingPermissionStatus>> promise) noexcept {
    return PromiseHolder<AppTrackingPermissionStatus>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(AppTrackingPermissionStatus /* result */)>
  /**
   * Specialized version of `std::function<void(AppTrackingPermissionStatus)>`.
   */
  using Func_void_AppTrackingPermissionStatus = std::function<void(AppTrackingPermissionStatus /* result */)>;
  /**
   * Wrapper class for a `std::function<void(AppTrackingPermissionStatus / * result * /)>`, this can be used from Swift.
   */
  class Func_void_AppTrackingPermissionStatus_Wrapper final {
  public:
    explicit Func_void_AppTrackingPermissionStatus_Wrapper(std::function<void(AppTrackingPermissionStatus /* result */)>&& func): _function(std::make_unique<std::function<void(AppTrackingPermissionStatus /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<AppTrackingPermissionStatus>(result));
    }
  private:
    std::unique_ptr<std::function<void(AppTrackingPermissionStatus /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AppTrackingPermissionStatus create_Func_void_AppTrackingPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AppTrackingPermissionStatus_Wrapper wrap_Func_void_AppTrackingPermissionStatus(Func_void_AppTrackingPermissionStatus value) noexcept {
    return Func_void_AppTrackingPermissionStatus_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAppTrackingSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneAppTrackingSpec>`.
   */
  using std__shared_ptr_HybridOneAppTrackingSpec_ = std::shared_ptr<HybridOneAppTrackingSpec>;
  std::shared_ptr<HybridOneAppTrackingSpec> create_std__shared_ptr_HybridOneAppTrackingSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneAppTrackingSpec_(std__shared_ptr_HybridOneAppTrackingSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneAppTrackingSpec>
  using std__weak_ptr_HybridOneAppTrackingSpec_ = std::weak_ptr<HybridOneAppTrackingSpec>;
  inline std__weak_ptr_HybridOneAppTrackingSpec_ weakify_std__shared_ptr_HybridOneAppTrackingSpec_(const std::shared_ptr<HybridOneAppTrackingSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<AppTrackingPermissionStatus>
  using Result_AppTrackingPermissionStatus_ = Result<AppTrackingPermissionStatus>;
  inline Result_AppTrackingPermissionStatus_ create_Result_AppTrackingPermissionStatus_(AppTrackingPermissionStatus value) noexcept {
    return Result<AppTrackingPermissionStatus>::withValue(std::move(value));
  }
  inline Result_AppTrackingPermissionStatus_ create_Result_AppTrackingPermissionStatus_(const std::exception_ptr& error) noexcept {
    return Result<AppTrackingPermissionStatus>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<AppTrackingPermissionStatus>>>
  using Result_std__shared_ptr_Promise_AppTrackingPermissionStatus___ = Result<std::shared_ptr<Promise<AppTrackingPermissionStatus>>>;
  inline Result_std__shared_ptr_Promise_AppTrackingPermissionStatus___ create_Result_std__shared_ptr_Promise_AppTrackingPermissionStatus___(const std::shared_ptr<Promise<AppTrackingPermissionStatus>>& value) noexcept {
    return Result<std::shared_ptr<Promise<AppTrackingPermissionStatus>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_AppTrackingPermissionStatus___ create_Result_std__shared_ptr_Promise_AppTrackingPermissionStatus___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<AppTrackingPermissionStatus>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<AudioRecordingPermission>>
  /**
   * Specialized version of `std::shared_ptr<Promise<AudioRecordingPermission>>`.
   */
  using std__shared_ptr_Promise_AudioRecordingPermission__ = std::shared_ptr<Promise<AudioRecordingPermission>>;
  inline std::shared_ptr<Promise<AudioRecordingPermission>> create_std__shared_ptr_Promise_AudioRecordingPermission__() noexcept {
    return Promise<AudioRecordingPermission>::create();
  }
  inline PromiseHolder<AudioRecordingPermission> wrap_std__shared_ptr_Promise_AudioRecordingPermission__(std::shared_ptr<Promise<AudioRecordingPermission>> promise) noexcept {
    return PromiseHolder<AudioRecordingPermission>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(AudioRecordingPermission /* result */)>
  /**
   * Specialized version of `std::function<void(AudioRecordingPermission)>`.
   */
  using Func_void_AudioRecordingPermission = std::function<void(AudioRecordingPermission /* result */)>;
  /**
   * Wrapper class for a `std::function<void(AudioRecordingPermission / * result * /)>`, this can be used from Swift.
   */
  class Func_void_AudioRecordingPermission_Wrapper final {
  public:
    explicit Func_void_AudioRecordingPermission_Wrapper(std::function<void(AudioRecordingPermission /* result */)>&& func): _function(std::make_unique<std::function<void(AudioRecordingPermission /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<AudioRecordingPermission>(result));
    }
  private:
    std::unique_ptr<std::function<void(AudioRecordingPermission /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AudioRecordingPermission create_Func_void_AudioRecordingPermission(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AudioRecordingPermission_Wrapper wrap_Func_void_AudioRecordingPermission(Func_void_AudioRecordingPermission value) noexcept {
    return Func_void_AudioRecordingPermission_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<double>
  /**
   * Specialized version of `std::optional<double>`.
   */
  using std__optional_double_ = std::optional<double>;
  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
    return std::optional<double>(value);
  }
  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
    return optional.has_value();
  }
  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<AudioPlaybackStatus>>
  /**
   * Specialized version of `std::shared_ptr<Promise<AudioPlaybackStatus>>`.
   */
  using std__shared_ptr_Promise_AudioPlaybackStatus__ = std::shared_ptr<Promise<AudioPlaybackStatus>>;
  inline std::shared_ptr<Promise<AudioPlaybackStatus>> create_std__shared_ptr_Promise_AudioPlaybackStatus__() noexcept {
    return Promise<AudioPlaybackStatus>::create();
  }
  inline PromiseHolder<AudioPlaybackStatus> wrap_std__shared_ptr_Promise_AudioPlaybackStatus__(std::shared_ptr<Promise<AudioPlaybackStatus>> promise) noexcept {
    return PromiseHolder<AudioPlaybackStatus>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const AudioPlaybackStatus& /* result */)>
  /**
   * Specialized version of `std::function<void(const AudioPlaybackStatus&)>`.
   */
  using Func_void_AudioPlaybackStatus = std::function<void(const AudioPlaybackStatus& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const AudioPlaybackStatus& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_AudioPlaybackStatus_Wrapper final {
  public:
    explicit Func_void_AudioPlaybackStatus_Wrapper(std::function<void(const AudioPlaybackStatus& /* result */)>&& func): _function(std::make_unique<std::function<void(const AudioPlaybackStatus& /* result */)>>(std::move(func))) {}
    inline void call(AudioPlaybackStatus result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const AudioPlaybackStatus& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AudioPlaybackStatus create_Func_void_AudioPlaybackStatus(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AudioPlaybackStatus_Wrapper wrap_Func_void_AudioPlaybackStatus(Func_void_AudioPlaybackStatus value) noexcept {
    return Func_void_AudioPlaybackStatus_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<AudioRecordingStatus>>
  /**
   * Specialized version of `std::shared_ptr<Promise<AudioRecordingStatus>>`.
   */
  using std__shared_ptr_Promise_AudioRecordingStatus__ = std::shared_ptr<Promise<AudioRecordingStatus>>;
  inline std::shared_ptr<Promise<AudioRecordingStatus>> create_std__shared_ptr_Promise_AudioRecordingStatus__() noexcept {
    return Promise<AudioRecordingStatus>::create();
  }
  inline PromiseHolder<AudioRecordingStatus> wrap_std__shared_ptr_Promise_AudioRecordingStatus__(std::shared_ptr<Promise<AudioRecordingStatus>> promise) noexcept {
    return PromiseHolder<AudioRecordingStatus>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const AudioRecordingStatus& /* result */)>
  /**
   * Specialized version of `std::function<void(const AudioRecordingStatus&)>`.
   */
  using Func_void_AudioRecordingStatus = std::function<void(const AudioRecordingStatus& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const AudioRecordingStatus& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_AudioRecordingStatus_Wrapper final {
  public:
    explicit Func_void_AudioRecordingStatus_Wrapper(std::function<void(const AudioRecordingStatus& /* result */)>&& func): _function(std::make_unique<std::function<void(const AudioRecordingStatus& /* result */)>>(std::move(func))) {}
    inline void call(AudioRecordingStatus result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const AudioRecordingStatus& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AudioRecordingStatus create_Func_void_AudioRecordingStatus(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AudioRecordingStatus_Wrapper wrap_Func_void_AudioRecordingStatus(Func_void_AudioRecordingStatus value) noexcept {
    return Func_void_AudioRecordingStatus_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<AudioRecordingResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<AudioRecordingResult>>`.
   */
  using std__shared_ptr_Promise_AudioRecordingResult__ = std::shared_ptr<Promise<AudioRecordingResult>>;
  inline std::shared_ptr<Promise<AudioRecordingResult>> create_std__shared_ptr_Promise_AudioRecordingResult__() noexcept {
    return Promise<AudioRecordingResult>::create();
  }
  inline PromiseHolder<AudioRecordingResult> wrap_std__shared_ptr_Promise_AudioRecordingResult__(std::shared_ptr<Promise<AudioRecordingResult>> promise) noexcept {
    return PromiseHolder<AudioRecordingResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const AudioRecordingResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const AudioRecordingResult&)>`.
   */
  using Func_void_AudioRecordingResult = std::function<void(const AudioRecordingResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const AudioRecordingResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_AudioRecordingResult_Wrapper final {
  public:
    explicit Func_void_AudioRecordingResult_Wrapper(std::function<void(const AudioRecordingResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const AudioRecordingResult& /* result */)>>(std::move(func))) {}
    inline void call(AudioRecordingResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const AudioRecordingResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AudioRecordingResult create_Func_void_AudioRecordingResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AudioRecordingResult_Wrapper wrap_Func_void_AudioRecordingResult(Func_void_AudioRecordingResult value) noexcept {
    return Func_void_AudioRecordingResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const AudioInterruptionEvent& /* event */)>
  /**
   * Specialized version of `std::function<void(const AudioInterruptionEvent&)>`.
   */
  using Func_void_AudioInterruptionEvent = std::function<void(const AudioInterruptionEvent& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const AudioInterruptionEvent& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_AudioInterruptionEvent_Wrapper final {
  public:
    explicit Func_void_AudioInterruptionEvent_Wrapper(std::function<void(const AudioInterruptionEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const AudioInterruptionEvent& /* event */)>>(std::move(func))) {}
    inline void call(AudioInterruptionEvent event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const AudioInterruptionEvent& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AudioInterruptionEvent create_Func_void_AudioInterruptionEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AudioInterruptionEvent_Wrapper wrap_Func_void_AudioInterruptionEvent(Func_void_AudioInterruptionEvent value) noexcept {
    return Func_void_AudioInterruptionEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const AudioRemoteCommandEvent& /* event */)>
  /**
   * Specialized version of `std::function<void(const AudioRemoteCommandEvent&)>`.
   */
  using Func_void_AudioRemoteCommandEvent = std::function<void(const AudioRemoteCommandEvent& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const AudioRemoteCommandEvent& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_AudioRemoteCommandEvent_Wrapper final {
  public:
    explicit Func_void_AudioRemoteCommandEvent_Wrapper(std::function<void(const AudioRemoteCommandEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const AudioRemoteCommandEvent& /* event */)>>(std::move(func))) {}
    inline void call(AudioRemoteCommandEvent event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const AudioRemoteCommandEvent& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_AudioRemoteCommandEvent create_Func_void_AudioRemoteCommandEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_AudioRemoteCommandEvent_Wrapper wrap_Func_void_AudioRemoteCommandEvent(Func_void_AudioRemoteCommandEvent value) noexcept {
    return Func_void_AudioRemoteCommandEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::unordered_map<std::string, std::string>
  /**
   * Specialized version of `std::unordered_map<std::string, std::string>`.
   */
  using std__unordered_map_std__string__std__string_ = std::unordered_map<std::string, std::string>;
  inline std::unordered_map<std::string, std::string> create_std__unordered_map_std__string__std__string_(size_t size) noexcept {
    std::unordered_map<std::string, std::string> map;
    map.reserve(size);
    return map;
  }
  inline std::vector<std::string> get_std__unordered_map_std__string__std__string__keys(const std__unordered_map_std__string__std__string_& map) noexcept {
    std::vector<std::string> keys;
    keys.reserve(map.size());
    for (const auto& entry : map) {
      keys.push_back(entry.first);
    }
    return keys;
  }
  inline std::string get_std__unordered_map_std__string__std__string__value(const std__unordered_map_std__string__std__string_& map, const std::string& key) noexcept {
    return map.find(key)->second;
  }
  inline void emplace_std__unordered_map_std__string__std__string_(std__unordered_map_std__string__std__string_& map, const std::string& key, const std::string& value) noexcept {
    map.emplace(key, value);
  }
  
  // pragma MARK: std::optional<std::unordered_map<std::string, std::string>>
  /**
   * Specialized version of `std::optional<std::unordered_map<std::string, std::string>>`.
   */
  using std__optional_std__unordered_map_std__string__std__string__ = std::optional<std::unordered_map<std::string, std::string>>;
  inline std::optional<std::unordered_map<std::string, std::string>> create_std__optional_std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
    return std::optional<std::unordered_map<std::string, std::string>>(value);
  }
  inline bool has_value_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::unordered_map<std::string, std::string> get_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<PitchCorrectionQuality>
  /**
   * Specialized version of `std::optional<PitchCorrectionQuality>`.
   */
  using std__optional_PitchCorrectionQuality_ = std::optional<PitchCorrectionQuality>;
  inline std::optional<PitchCorrectionQuality> create_std__optional_PitchCorrectionQuality_(const PitchCorrectionQuality& value) noexcept {
    return std::optional<PitchCorrectionQuality>(value);
  }
  inline bool has_value_std__optional_PitchCorrectionQuality_(const std::optional<PitchCorrectionQuality>& optional) noexcept {
    return optional.has_value();
  }
  inline PitchCorrectionQuality get_std__optional_PitchCorrectionQuality_(const std::optional<PitchCorrectionQuality>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneAudioSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneAudioSpec>`.
   */
  using std__shared_ptr_HybridOneAudioSpec_ = std::shared_ptr<HybridOneAudioSpec>;
  std::shared_ptr<HybridOneAudioSpec> create_std__shared_ptr_HybridOneAudioSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneAudioSpec_(std__shared_ptr_HybridOneAudioSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneAudioSpec>
  using std__weak_ptr_HybridOneAudioSpec_ = std::weak_ptr<HybridOneAudioSpec>;
  inline std__weak_ptr_HybridOneAudioSpec_ weakify_std__shared_ptr_HybridOneAudioSpec_(const std::shared_ptr<HybridOneAudioSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<AudioRecordingPermission>>>
  using Result_std__shared_ptr_Promise_AudioRecordingPermission___ = Result<std::shared_ptr<Promise<AudioRecordingPermission>>>;
  inline Result_std__shared_ptr_Promise_AudioRecordingPermission___ create_Result_std__shared_ptr_Promise_AudioRecordingPermission___(const std::shared_ptr<Promise<AudioRecordingPermission>>& value) noexcept {
    return Result<std::shared_ptr<Promise<AudioRecordingPermission>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_AudioRecordingPermission___ create_Result_std__shared_ptr_Promise_AudioRecordingPermission___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<AudioRecordingPermission>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<AudioPlaybackStatus>>>
  using Result_std__shared_ptr_Promise_AudioPlaybackStatus___ = Result<std::shared_ptr<Promise<AudioPlaybackStatus>>>;
  inline Result_std__shared_ptr_Promise_AudioPlaybackStatus___ create_Result_std__shared_ptr_Promise_AudioPlaybackStatus___(const std::shared_ptr<Promise<AudioPlaybackStatus>>& value) noexcept {
    return Result<std::shared_ptr<Promise<AudioPlaybackStatus>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_AudioPlaybackStatus___ create_Result_std__shared_ptr_Promise_AudioPlaybackStatus___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<AudioPlaybackStatus>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<AudioRecordingStatus>>>
  using Result_std__shared_ptr_Promise_AudioRecordingStatus___ = Result<std::shared_ptr<Promise<AudioRecordingStatus>>>;
  inline Result_std__shared_ptr_Promise_AudioRecordingStatus___ create_Result_std__shared_ptr_Promise_AudioRecordingStatus___(const std::shared_ptr<Promise<AudioRecordingStatus>>& value) noexcept {
    return Result<std::shared_ptr<Promise<AudioRecordingStatus>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_AudioRecordingStatus___ create_Result_std__shared_ptr_Promise_AudioRecordingStatus___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<AudioRecordingStatus>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<AudioRecordingResult>>>
  using Result_std__shared_ptr_Promise_AudioRecordingResult___ = Result<std::shared_ptr<Promise<AudioRecordingResult>>>;
  inline Result_std__shared_ptr_Promise_AudioRecordingResult___ create_Result_std__shared_ptr_Promise_AudioRecordingResult___(const std::shared_ptr<Promise<AudioRecordingResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<AudioRecordingResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_AudioRecordingResult___ create_Result_std__shared_ptr_Promise_AudioRecordingResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<AudioRecordingResult>>>::withError(error);
  }
  
  // pragma MARK: Result<std::string>
  using Result_std__string_ = Result<std::string>;
  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
    return Result<std::string>::withValue(value);
  }
  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
    return Result<std::string>::withError(error);
  }
  
  // pragma MARK: Result<AudioPlayerStatus>
  using Result_AudioPlayerStatus_ = Result<AudioPlayerStatus>;
  inline Result_AudioPlayerStatus_ create_Result_AudioPlayerStatus_(const AudioPlayerStatus& value) noexcept {
    return Result<AudioPlayerStatus>::withValue(value);
  }
  inline Result_AudioPlayerStatus_ create_Result_AudioPlayerStatus_(const std::exception_ptr& error) noexcept {
    return Result<AudioPlayerStatus>::withError(error);
  }
  
  // pragma MARK: std::optional<bool>
  /**
   * Specialized version of `std::optional<bool>`.
   */
  using std__optional_bool_ = std::optional<bool>;
  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
    return std::optional<bool>(value);
  }
  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
    return optional.has_value();
  }
  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<PendingBackgroundTask>
  /**
   * Specialized version of `std::vector<PendingBackgroundTask>`.
   */
  using std__vector_PendingBackgroundTask_ = std::vector<PendingBackgroundTask>;
  inline std::vector<PendingBackgroundTask> create_std__vector_PendingBackgroundTask_(size_t size) noexcept {
    std::vector<PendingBackgroundTask> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>>`.
   */
  using std__shared_ptr_Promise_std__vector_PendingBackgroundTask___ = std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>>;
  inline std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>> create_std__shared_ptr_Promise_std__vector_PendingBackgroundTask___() noexcept {
    return Promise<std::vector<PendingBackgroundTask>>::create();
  }
  inline PromiseHolder<std::vector<PendingBackgroundTask>> wrap_std__shared_ptr_Promise_std__vector_PendingBackgroundTask___(std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>> promise) noexcept {
    return PromiseHolder<std::vector<PendingBackgroundTask>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<PendingBackgroundTask>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<PendingBackgroundTask>&)>`.
   */
  using Func_void_std__vector_PendingBackgroundTask_ = std::function<void(const std::vector<PendingBackgroundTask>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<PendingBackgroundTask>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_PendingBackgroundTask__Wrapper final {
  public:
    explicit Func_void_std__vector_PendingBackgroundTask__Wrapper(std::function<void(const std::vector<PendingBackgroundTask>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<PendingBackgroundTask>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<PendingBackgroundTask> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<PendingBackgroundTask>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_PendingBackgroundTask_ create_Func_void_std__vector_PendingBackgroundTask_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_PendingBackgroundTask__Wrapper wrap_Func_void_std__vector_PendingBackgroundTask_(Func_void_std__vector_PendingBackgroundTask_ value) noexcept {
    return Func_void_std__vector_PendingBackgroundTask__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const BackgroundTaskInvocation& /* invocation */)>
  /**
   * Specialized version of `std::function<void(const BackgroundTaskInvocation&)>`.
   */
  using Func_void_BackgroundTaskInvocation = std::function<void(const BackgroundTaskInvocation& /* invocation */)>;
  /**
   * Wrapper class for a `std::function<void(const BackgroundTaskInvocation& / * invocation * /)>`, this can be used from Swift.
   */
  class Func_void_BackgroundTaskInvocation_Wrapper final {
  public:
    explicit Func_void_BackgroundTaskInvocation_Wrapper(std::function<void(const BackgroundTaskInvocation& /* invocation */)>&& func): _function(std::make_unique<std::function<void(const BackgroundTaskInvocation& /* invocation */)>>(std::move(func))) {}
    inline void call(BackgroundTaskInvocation invocation) const noexcept {
      _function->operator()(invocation);
    }
  private:
    std::unique_ptr<std::function<void(const BackgroundTaskInvocation& /* invocation */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BackgroundTaskInvocation create_Func_void_BackgroundTaskInvocation(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BackgroundTaskInvocation_Wrapper wrap_Func_void_BackgroundTaskInvocation(Func_void_BackgroundTaskInvocation value) noexcept {
    return Func_void_BackgroundTaskInvocation_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const std::string& /* executionId */)>
  /**
   * Specialized version of `std::function<void(const std::string&)>`.
   */
  using Func_void_std__string = std::function<void(const std::string& /* executionId */)>;
  /**
   * Wrapper class for a `std::function<void(const std::string& / * executionId * /)>`, this can be used from Swift.
   */
  class Func_void_std__string_Wrapper final {
  public:
    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* executionId */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* executionId */)>>(std::move(func))) {}
    inline void call(std::string executionId) const noexcept {
      _function->operator()(executionId);
    }
  private:
    std::unique_ptr<std::function<void(const std::string& /* executionId */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
    return Func_void_std__string_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBackgroundTasksSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneBackgroundTasksSpec>`.
   */
  using std__shared_ptr_HybridOneBackgroundTasksSpec_ = std::shared_ptr<HybridOneBackgroundTasksSpec>;
  std::shared_ptr<HybridOneBackgroundTasksSpec> create_std__shared_ptr_HybridOneBackgroundTasksSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneBackgroundTasksSpec_(std__shared_ptr_HybridOneBackgroundTasksSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneBackgroundTasksSpec>
  using std__weak_ptr_HybridOneBackgroundTasksSpec_ = std::weak_ptr<HybridOneBackgroundTasksSpec>;
  inline std__weak_ptr_HybridOneBackgroundTasksSpec_ weakify_std__shared_ptr_HybridOneBackgroundTasksSpec_(const std::shared_ptr<HybridOneBackgroundTasksSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>>>
  using Result_std__shared_ptr_Promise_std__vector_PendingBackgroundTask____ = Result<std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_PendingBackgroundTask____ create_Result_std__shared_ptr_Promise_std__vector_PendingBackgroundTask____(const std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_PendingBackgroundTask____ create_Result_std__shared_ptr_Promise_std__vector_PendingBackgroundTask____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<PendingBackgroundTask>>>>::withError(error);
  }
  
  // pragma MARK: std::function<void(const BarometerMeasurement& /* event */)>
  /**
   * Specialized version of `std::function<void(const BarometerMeasurement&)>`.
   */
  using Func_void_BarometerMeasurement = std::function<void(const BarometerMeasurement& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const BarometerMeasurement& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_BarometerMeasurement_Wrapper final {
  public:
    explicit Func_void_BarometerMeasurement_Wrapper(std::function<void(const BarometerMeasurement& /* event */)>&& func): _function(std::make_unique<std::function<void(const BarometerMeasurement& /* event */)>>(std::move(func))) {}
    inline void call(BarometerMeasurement event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const BarometerMeasurement& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BarometerMeasurement create_Func_void_BarometerMeasurement(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BarometerMeasurement_Wrapper wrap_Func_void_BarometerMeasurement(Func_void_BarometerMeasurement value) noexcept {
    return Func_void_BarometerMeasurement_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBarometerSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneBarometerSpec>`.
   */
  using std__shared_ptr_HybridOneBarometerSpec_ = std::shared_ptr<HybridOneBarometerSpec>;
  std::shared_ptr<HybridOneBarometerSpec> create_std__shared_ptr_HybridOneBarometerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneBarometerSpec_(std__shared_ptr_HybridOneBarometerSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneBarometerSpec>
  using std__weak_ptr_HybridOneBarometerSpec_ = std::weak_ptr<HybridOneBarometerSpec>;
  inline std__weak_ptr_HybridOneBarometerSpec_ weakify_std__shared_ptr_HybridOneBarometerSpec_(const std::shared_ptr<HybridOneBarometerSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<Promise<double>>
  /**
   * Specialized version of `std::shared_ptr<Promise<double>>`.
   */
  using std__shared_ptr_Promise_double__ = std::shared_ptr<Promise<double>>;
  inline std::shared_ptr<Promise<double>> create_std__shared_ptr_Promise_double__() noexcept {
    return Promise<double>::create();
  }
  inline PromiseHolder<double> wrap_std__shared_ptr_Promise_double__(std::shared_ptr<Promise<double>> promise) noexcept {
    return PromiseHolder<double>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(double /* result */)>
  /**
   * Specialized version of `std::function<void(double)>`.
   */
  using Func_void_double = std::function<void(double /* result */)>;
  /**
   * Wrapper class for a `std::function<void(double / * result * /)>`, this can be used from Swift.
   */
  class Func_void_double_Wrapper final {
  public:
    explicit Func_void_double_Wrapper(std::function<void(double /* result */)>&& func): _function(std::make_unique<std::function<void(double /* result */)>>(std::move(func))) {}
    inline void call(double result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(double /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
    return Func_void_double_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<BatteryState>>
  /**
   * Specialized version of `std::shared_ptr<Promise<BatteryState>>`.
   */
  using std__shared_ptr_Promise_BatteryState__ = std::shared_ptr<Promise<BatteryState>>;
  inline std::shared_ptr<Promise<BatteryState>> create_std__shared_ptr_Promise_BatteryState__() noexcept {
    return Promise<BatteryState>::create();
  }
  inline PromiseHolder<BatteryState> wrap_std__shared_ptr_Promise_BatteryState__(std::shared_ptr<Promise<BatteryState>> promise) noexcept {
    return PromiseHolder<BatteryState>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(BatteryState /* result */)>
  /**
   * Specialized version of `std::function<void(BatteryState)>`.
   */
  using Func_void_BatteryState = std::function<void(BatteryState /* result */)>;
  /**
   * Wrapper class for a `std::function<void(BatteryState / * result * /)>`, this can be used from Swift.
   */
  class Func_void_BatteryState_Wrapper final {
  public:
    explicit Func_void_BatteryState_Wrapper(std::function<void(BatteryState /* result */)>&& func): _function(std::make_unique<std::function<void(BatteryState /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<BatteryState>(result));
    }
  private:
    std::unique_ptr<std::function<void(BatteryState /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BatteryState create_Func_void_BatteryState(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BatteryState_Wrapper wrap_Func_void_BatteryState(Func_void_BatteryState value) noexcept {
    return Func_void_BatteryState_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<BatteryPowerState>>
  /**
   * Specialized version of `std::shared_ptr<Promise<BatteryPowerState>>`.
   */
  using std__shared_ptr_Promise_BatteryPowerState__ = std::shared_ptr<Promise<BatteryPowerState>>;
  inline std::shared_ptr<Promise<BatteryPowerState>> create_std__shared_ptr_Promise_BatteryPowerState__() noexcept {
    return Promise<BatteryPowerState>::create();
  }
  inline PromiseHolder<BatteryPowerState> wrap_std__shared_ptr_Promise_BatteryPowerState__(std::shared_ptr<Promise<BatteryPowerState>> promise) noexcept {
    return PromiseHolder<BatteryPowerState>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const BatteryPowerState& /* result */)>
  /**
   * Specialized version of `std::function<void(const BatteryPowerState&)>`.
   */
  using Func_void_BatteryPowerState = std::function<void(const BatteryPowerState& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const BatteryPowerState& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_BatteryPowerState_Wrapper final {
  public:
    explicit Func_void_BatteryPowerState_Wrapper(std::function<void(const BatteryPowerState& /* result */)>&& func): _function(std::make_unique<std::function<void(const BatteryPowerState& /* result */)>>(std::move(func))) {}
    inline void call(BatteryPowerState result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const BatteryPowerState& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BatteryPowerState create_Func_void_BatteryPowerState(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BatteryPowerState_Wrapper wrap_Func_void_BatteryPowerState(Func_void_BatteryPowerState value) noexcept {
    return Func_void_BatteryPowerState_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const BatteryLevelEvent& /* event */)>
  /**
   * Specialized version of `std::function<void(const BatteryLevelEvent&)>`.
   */
  using Func_void_BatteryLevelEvent = std::function<void(const BatteryLevelEvent& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const BatteryLevelEvent& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_BatteryLevelEvent_Wrapper final {
  public:
    explicit Func_void_BatteryLevelEvent_Wrapper(std::function<void(const BatteryLevelEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const BatteryLevelEvent& /* event */)>>(std::move(func))) {}
    inline void call(BatteryLevelEvent event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const BatteryLevelEvent& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BatteryLevelEvent create_Func_void_BatteryLevelEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BatteryLevelEvent_Wrapper wrap_Func_void_BatteryLevelEvent(Func_void_BatteryLevelEvent value) noexcept {
    return Func_void_BatteryLevelEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const BatteryStateEvent& /* event */)>
  /**
   * Specialized version of `std::function<void(const BatteryStateEvent&)>`.
   */
  using Func_void_BatteryStateEvent = std::function<void(const BatteryStateEvent& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const BatteryStateEvent& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_BatteryStateEvent_Wrapper final {
  public:
    explicit Func_void_BatteryStateEvent_Wrapper(std::function<void(const BatteryStateEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const BatteryStateEvent& /* event */)>>(std::move(func))) {}
    inline void call(BatteryStateEvent event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const BatteryStateEvent& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BatteryStateEvent create_Func_void_BatteryStateEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BatteryStateEvent_Wrapper wrap_Func_void_BatteryStateEvent(Func_void_BatteryStateEvent value) noexcept {
    return Func_void_BatteryStateEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const BatteryPowerModeEvent& /* event */)>
  /**
   * Specialized version of `std::function<void(const BatteryPowerModeEvent&)>`.
   */
  using Func_void_BatteryPowerModeEvent = std::function<void(const BatteryPowerModeEvent& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const BatteryPowerModeEvent& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_BatteryPowerModeEvent_Wrapper final {
  public:
    explicit Func_void_BatteryPowerModeEvent_Wrapper(std::function<void(const BatteryPowerModeEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const BatteryPowerModeEvent& /* event */)>>(std::move(func))) {}
    inline void call(BatteryPowerModeEvent event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const BatteryPowerModeEvent& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BatteryPowerModeEvent create_Func_void_BatteryPowerModeEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BatteryPowerModeEvent_Wrapper wrap_Func_void_BatteryPowerModeEvent(Func_void_BatteryPowerModeEvent value) noexcept {
    return Func_void_BatteryPowerModeEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBatterySpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneBatterySpec>`.
   */
  using std__shared_ptr_HybridOneBatterySpec_ = std::shared_ptr<HybridOneBatterySpec>;
  std::shared_ptr<HybridOneBatterySpec> create_std__shared_ptr_HybridOneBatterySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneBatterySpec_(std__shared_ptr_HybridOneBatterySpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneBatterySpec>
  using std__weak_ptr_HybridOneBatterySpec_ = std::weak_ptr<HybridOneBatterySpec>;
  inline std__weak_ptr_HybridOneBatterySpec_ weakify_std__shared_ptr_HybridOneBatterySpec_(const std::shared_ptr<HybridOneBatterySpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<double>>>
  using Result_std__shared_ptr_Promise_double___ = Result<std::shared_ptr<Promise<double>>>;
  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::shared_ptr<Promise<double>>& value) noexcept {
    return Result<std::shared_ptr<Promise<double>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<double>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<BatteryState>>>
  using Result_std__shared_ptr_Promise_BatteryState___ = Result<std::shared_ptr<Promise<BatteryState>>>;
  inline Result_std__shared_ptr_Promise_BatteryState___ create_Result_std__shared_ptr_Promise_BatteryState___(const std::shared_ptr<Promise<BatteryState>>& value) noexcept {
    return Result<std::shared_ptr<Promise<BatteryState>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_BatteryState___ create_Result_std__shared_ptr_Promise_BatteryState___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<BatteryState>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<BatteryPowerState>>>
  using Result_std__shared_ptr_Promise_BatteryPowerState___ = Result<std::shared_ptr<Promise<BatteryPowerState>>>;
  inline Result_std__shared_ptr_Promise_BatteryPowerState___ create_Result_std__shared_ptr_Promise_BatteryPowerState___(const std::shared_ptr<Promise<BatteryPowerState>>& value) noexcept {
    return Result<std::shared_ptr<Promise<BatteryPowerState>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_BatteryPowerState___ create_Result_std__shared_ptr_Promise_BatteryPowerState___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<BatteryPowerState>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<BrightnessMode>>
  /**
   * Specialized version of `std::shared_ptr<Promise<BrightnessMode>>`.
   */
  using std__shared_ptr_Promise_BrightnessMode__ = std::shared_ptr<Promise<BrightnessMode>>;
  inline std::shared_ptr<Promise<BrightnessMode>> create_std__shared_ptr_Promise_BrightnessMode__() noexcept {
    return Promise<BrightnessMode>::create();
  }
  inline PromiseHolder<BrightnessMode> wrap_std__shared_ptr_Promise_BrightnessMode__(std::shared_ptr<Promise<BrightnessMode>> promise) noexcept {
    return PromiseHolder<BrightnessMode>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(BrightnessMode /* result */)>
  /**
   * Specialized version of `std::function<void(BrightnessMode)>`.
   */
  using Func_void_BrightnessMode = std::function<void(BrightnessMode /* result */)>;
  /**
   * Wrapper class for a `std::function<void(BrightnessMode / * result * /)>`, this can be used from Swift.
   */
  class Func_void_BrightnessMode_Wrapper final {
  public:
    explicit Func_void_BrightnessMode_Wrapper(std::function<void(BrightnessMode /* result */)>&& func): _function(std::make_unique<std::function<void(BrightnessMode /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<BrightnessMode>(result));
    }
  private:
    std::unique_ptr<std::function<void(BrightnessMode /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BrightnessMode create_Func_void_BrightnessMode(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BrightnessMode_Wrapper wrap_Func_void_BrightnessMode(Func_void_BrightnessMode value) noexcept {
    return Func_void_BrightnessMode_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<BrightnessPermissionResponse>>
  /**
   * Specialized version of `std::shared_ptr<Promise<BrightnessPermissionResponse>>`.
   */
  using std__shared_ptr_Promise_BrightnessPermissionResponse__ = std::shared_ptr<Promise<BrightnessPermissionResponse>>;
  inline std::shared_ptr<Promise<BrightnessPermissionResponse>> create_std__shared_ptr_Promise_BrightnessPermissionResponse__() noexcept {
    return Promise<BrightnessPermissionResponse>::create();
  }
  inline PromiseHolder<BrightnessPermissionResponse> wrap_std__shared_ptr_Promise_BrightnessPermissionResponse__(std::shared_ptr<Promise<BrightnessPermissionResponse>> promise) noexcept {
    return PromiseHolder<BrightnessPermissionResponse>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const BrightnessPermissionResponse& /* result */)>
  /**
   * Specialized version of `std::function<void(const BrightnessPermissionResponse&)>`.
   */
  using Func_void_BrightnessPermissionResponse = std::function<void(const BrightnessPermissionResponse& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const BrightnessPermissionResponse& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_BrightnessPermissionResponse_Wrapper final {
  public:
    explicit Func_void_BrightnessPermissionResponse_Wrapper(std::function<void(const BrightnessPermissionResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const BrightnessPermissionResponse& /* result */)>>(std::move(func))) {}
    inline void call(BrightnessPermissionResponse result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const BrightnessPermissionResponse& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BrightnessPermissionResponse create_Func_void_BrightnessPermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BrightnessPermissionResponse_Wrapper wrap_Func_void_BrightnessPermissionResponse(Func_void_BrightnessPermissionResponse value) noexcept {
    return Func_void_BrightnessPermissionResponse_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const BrightnessEvent& /* event */)>
  /**
   * Specialized version of `std::function<void(const BrightnessEvent&)>`.
   */
  using Func_void_BrightnessEvent = std::function<void(const BrightnessEvent& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const BrightnessEvent& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_BrightnessEvent_Wrapper final {
  public:
    explicit Func_void_BrightnessEvent_Wrapper(std::function<void(const BrightnessEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const BrightnessEvent& /* event */)>>(std::move(func))) {}
    inline void call(BrightnessEvent event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const BrightnessEvent& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BrightnessEvent create_Func_void_BrightnessEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BrightnessEvent_Wrapper wrap_Func_void_BrightnessEvent(Func_void_BrightnessEvent value) noexcept {
    return Func_void_BrightnessEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBrightnessSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneBrightnessSpec>`.
   */
  using std__shared_ptr_HybridOneBrightnessSpec_ = std::shared_ptr<HybridOneBrightnessSpec>;
  std::shared_ptr<HybridOneBrightnessSpec> create_std__shared_ptr_HybridOneBrightnessSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneBrightnessSpec_(std__shared_ptr_HybridOneBrightnessSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneBrightnessSpec>
  using std__weak_ptr_HybridOneBrightnessSpec_ = std::weak_ptr<HybridOneBrightnessSpec>;
  inline std__weak_ptr_HybridOneBrightnessSpec_ weakify_std__shared_ptr_HybridOneBrightnessSpec_(const std::shared_ptr<HybridOneBrightnessSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<BrightnessMode>>>
  using Result_std__shared_ptr_Promise_BrightnessMode___ = Result<std::shared_ptr<Promise<BrightnessMode>>>;
  inline Result_std__shared_ptr_Promise_BrightnessMode___ create_Result_std__shared_ptr_Promise_BrightnessMode___(const std::shared_ptr<Promise<BrightnessMode>>& value) noexcept {
    return Result<std::shared_ptr<Promise<BrightnessMode>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_BrightnessMode___ create_Result_std__shared_ptr_Promise_BrightnessMode___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<BrightnessMode>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<BrightnessPermissionResponse>>>
  using Result_std__shared_ptr_Promise_BrightnessPermissionResponse___ = Result<std::shared_ptr<Promise<BrightnessPermissionResponse>>>;
  inline Result_std__shared_ptr_Promise_BrightnessPermissionResponse___ create_Result_std__shared_ptr_Promise_BrightnessPermissionResponse___(const std::shared_ptr<Promise<BrightnessPermissionResponse>>& value) noexcept {
    return Result<std::shared_ptr<Promise<BrightnessPermissionResponse>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_BrightnessPermissionResponse___ create_Result_std__shared_ptr_Promise_BrightnessPermissionResponse___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<BrightnessPermissionResponse>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<BrowserResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<BrowserResult>>`.
   */
  using std__shared_ptr_Promise_BrowserResult__ = std::shared_ptr<Promise<BrowserResult>>;
  inline std::shared_ptr<Promise<BrowserResult>> create_std__shared_ptr_Promise_BrowserResult__() noexcept {
    return Promise<BrowserResult>::create();
  }
  inline PromiseHolder<BrowserResult> wrap_std__shared_ptr_Promise_BrowserResult__(std::shared_ptr<Promise<BrowserResult>> promise) noexcept {
    return PromiseHolder<BrowserResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const BrowserResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const BrowserResult&)>`.
   */
  using Func_void_BrowserResult = std::function<void(const BrowserResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const BrowserResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_BrowserResult_Wrapper final {
  public:
    explicit Func_void_BrowserResult_Wrapper(std::function<void(const BrowserResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const BrowserResult& /* result */)>>(std::move(func))) {}
    inline void call(BrowserResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const BrowserResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BrowserResult create_Func_void_BrowserResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BrowserResult_Wrapper wrap_Func_void_BrowserResult(Func_void_BrowserResult value) noexcept {
    return Func_void_BrowserResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<BrowserPresentationStyle>
  /**
   * Specialized version of `std::optional<BrowserPresentationStyle>`.
   */
  using std__optional_BrowserPresentationStyle_ = std::optional<BrowserPresentationStyle>;
  inline std::optional<BrowserPresentationStyle> create_std__optional_BrowserPresentationStyle_(const BrowserPresentationStyle& value) noexcept {
    return std::optional<BrowserPresentationStyle>(value);
  }
  inline bool has_value_std__optional_BrowserPresentationStyle_(const std::optional<BrowserPresentationStyle>& optional) noexcept {
    return optional.has_value();
  }
  inline BrowserPresentationStyle get_std__optional_BrowserPresentationStyle_(const std::optional<BrowserPresentationStyle>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<BrowserColorScheme>
  /**
   * Specialized version of `std::optional<BrowserColorScheme>`.
   */
  using std__optional_BrowserColorScheme_ = std::optional<BrowserColorScheme>;
  inline std::optional<BrowserColorScheme> create_std__optional_BrowserColorScheme_(const BrowserColorScheme& value) noexcept {
    return std::optional<BrowserColorScheme>(value);
  }
  inline bool has_value_std__optional_BrowserColorScheme_(const std::optional<BrowserColorScheme>& optional) noexcept {
    return optional.has_value();
  }
  inline BrowserColorScheme get_std__optional_BrowserColorScheme_(const std::optional<BrowserColorScheme>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<BrowserAuthResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<BrowserAuthResult>>`.
   */
  using std__shared_ptr_Promise_BrowserAuthResult__ = std::shared_ptr<Promise<BrowserAuthResult>>;
  inline std::shared_ptr<Promise<BrowserAuthResult>> create_std__shared_ptr_Promise_BrowserAuthResult__() noexcept {
    return Promise<BrowserAuthResult>::create();
  }
  inline PromiseHolder<BrowserAuthResult> wrap_std__shared_ptr_Promise_BrowserAuthResult__(std::shared_ptr<Promise<BrowserAuthResult>> promise) noexcept {
    return PromiseHolder<BrowserAuthResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const BrowserAuthResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const BrowserAuthResult&)>`.
   */
  using Func_void_BrowserAuthResult = std::function<void(const BrowserAuthResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const BrowserAuthResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_BrowserAuthResult_Wrapper final {
  public:
    explicit Func_void_BrowserAuthResult_Wrapper(std::function<void(const BrowserAuthResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const BrowserAuthResult& /* result */)>>(std::move(func))) {}
    inline void call(BrowserAuthResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const BrowserAuthResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_BrowserAuthResult create_Func_void_BrowserAuthResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_BrowserAuthResult_Wrapper wrap_Func_void_BrowserAuthResult(Func_void_BrowserAuthResult value) noexcept {
    return Func_void_BrowserAuthResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneBrowserSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneBrowserSpec>`.
   */
  using std__shared_ptr_HybridOneBrowserSpec_ = std::shared_ptr<HybridOneBrowserSpec>;
  std::shared_ptr<HybridOneBrowserSpec> create_std__shared_ptr_HybridOneBrowserSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneBrowserSpec_(std__shared_ptr_HybridOneBrowserSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneBrowserSpec>
  using std__weak_ptr_HybridOneBrowserSpec_ = std::weak_ptr<HybridOneBrowserSpec>;
  inline std__weak_ptr_HybridOneBrowserSpec_ weakify_std__shared_ptr_HybridOneBrowserSpec_(const std::shared_ptr<HybridOneBrowserSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<BrowserResult>>>
  using Result_std__shared_ptr_Promise_BrowserResult___ = Result<std::shared_ptr<Promise<BrowserResult>>>;
  inline Result_std__shared_ptr_Promise_BrowserResult___ create_Result_std__shared_ptr_Promise_BrowserResult___(const std::shared_ptr<Promise<BrowserResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<BrowserResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_BrowserResult___ create_Result_std__shared_ptr_Promise_BrowserResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<BrowserResult>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<BrowserAuthResult>>>
  using Result_std__shared_ptr_Promise_BrowserAuthResult___ = Result<std::shared_ptr<Promise<BrowserAuthResult>>>;
  inline Result_std__shared_ptr_Promise_BrowserAuthResult___ create_Result_std__shared_ptr_Promise_BrowserAuthResult___(const std::shared_ptr<Promise<BrowserAuthResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<BrowserAuthResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_BrowserAuthResult___ create_Result_std__shared_ptr_Promise_BrowserAuthResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<BrowserAuthResult>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<CalendarPermissionStatus>>
  /**
   * Specialized version of `std::shared_ptr<Promise<CalendarPermissionStatus>>`.
   */
  using std__shared_ptr_Promise_CalendarPermissionStatus__ = std::shared_ptr<Promise<CalendarPermissionStatus>>;
  inline std::shared_ptr<Promise<CalendarPermissionStatus>> create_std__shared_ptr_Promise_CalendarPermissionStatus__() noexcept {
    return Promise<CalendarPermissionStatus>::create();
  }
  inline PromiseHolder<CalendarPermissionStatus> wrap_std__shared_ptr_Promise_CalendarPermissionStatus__(std::shared_ptr<Promise<CalendarPermissionStatus>> promise) noexcept {
    return PromiseHolder<CalendarPermissionStatus>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(CalendarPermissionStatus /* result */)>
  /**
   * Specialized version of `std::function<void(CalendarPermissionStatus)>`.
   */
  using Func_void_CalendarPermissionStatus = std::function<void(CalendarPermissionStatus /* result */)>;
  /**
   * Wrapper class for a `std::function<void(CalendarPermissionStatus / * result * /)>`, this can be used from Swift.
   */
  class Func_void_CalendarPermissionStatus_Wrapper final {
  public:
    explicit Func_void_CalendarPermissionStatus_Wrapper(std::function<void(CalendarPermissionStatus /* result */)>&& func): _function(std::make_unique<std::function<void(CalendarPermissionStatus /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<CalendarPermissionStatus>(result));
    }
  private:
    std::unique_ptr<std::function<void(CalendarPermissionStatus /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_CalendarPermissionStatus create_Func_void_CalendarPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_CalendarPermissionStatus_Wrapper wrap_Func_void_CalendarPermissionStatus(Func_void_CalendarPermissionStatus value) noexcept {
    return Func_void_CalendarPermissionStatus_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<CalendarRecurrence>
  /**
   * Specialized version of `std::optional<CalendarRecurrence>`.
   */
  using std__optional_CalendarRecurrence_ = std::optional<CalendarRecurrence>;
  inline std::optional<CalendarRecurrence> create_std__optional_CalendarRecurrence_(const CalendarRecurrence& value) noexcept {
    return std::optional<CalendarRecurrence>(value);
  }
  inline bool has_value_std__optional_CalendarRecurrence_(const std::optional<CalendarRecurrence>& optional) noexcept {
    return optional.has_value();
  }
  inline CalendarRecurrence get_std__optional_CalendarRecurrence_(const std::optional<CalendarRecurrence>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<CalendarEvent>
  /**
   * Specialized version of `std::vector<CalendarEvent>`.
   */
  using std__vector_CalendarEvent_ = std::vector<CalendarEvent>;
  inline std::vector<CalendarEvent> create_std__vector_CalendarEvent_(size_t size) noexcept {
    std::vector<CalendarEvent> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<CalendarEvent>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<CalendarEvent>>>`.
   */
  using std__shared_ptr_Promise_std__vector_CalendarEvent___ = std::shared_ptr<Promise<std::vector<CalendarEvent>>>;
  inline std::shared_ptr<Promise<std::vector<CalendarEvent>>> create_std__shared_ptr_Promise_std__vector_CalendarEvent___() noexcept {
    return Promise<std::vector<CalendarEvent>>::create();
  }
  inline PromiseHolder<std::vector<CalendarEvent>> wrap_std__shared_ptr_Promise_std__vector_CalendarEvent___(std::shared_ptr<Promise<std::vector<CalendarEvent>>> promise) noexcept {
    return PromiseHolder<std::vector<CalendarEvent>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<CalendarEvent>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<CalendarEvent>&)>`.
   */
  using Func_void_std__vector_CalendarEvent_ = std::function<void(const std::vector<CalendarEvent>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<CalendarEvent>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_CalendarEvent__Wrapper final {
  public:
    explicit Func_void_std__vector_CalendarEvent__Wrapper(std::function<void(const std::vector<CalendarEvent>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<CalendarEvent>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<CalendarEvent> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<CalendarEvent>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_CalendarEvent_ create_Func_void_std__vector_CalendarEvent_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_CalendarEvent__Wrapper wrap_Func_void_std__vector_CalendarEvent_(Func_void_std__vector_CalendarEvent_ value) noexcept {
    return Func_void_std__vector_CalendarEvent__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::string>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
   */
  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
    return Promise<std::string>::create();
  }
  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
    return PromiseHolder<std::string>(std::move(promise));
  }
  
  // pragma MARK: std::shared_ptr<Promise<CalendarEvent>>
  /**
   * Specialized version of `std::shared_ptr<Promise<CalendarEvent>>`.
   */
  using std__shared_ptr_Promise_CalendarEvent__ = std::shared_ptr<Promise<CalendarEvent>>;
  inline std::shared_ptr<Promise<CalendarEvent>> create_std__shared_ptr_Promise_CalendarEvent__() noexcept {
    return Promise<CalendarEvent>::create();
  }
  inline PromiseHolder<CalendarEvent> wrap_std__shared_ptr_Promise_CalendarEvent__(std::shared_ptr<Promise<CalendarEvent>> promise) noexcept {
    return PromiseHolder<CalendarEvent>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const CalendarEvent& /* result */)>
  /**
   * Specialized version of `std::function<void(const CalendarEvent&)>`.
   */
  using Func_void_CalendarEvent = std::function<void(const CalendarEvent& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const CalendarEvent& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_CalendarEvent_Wrapper final {
  public:
    explicit Func_void_CalendarEvent_Wrapper(std::function<void(const CalendarEvent& /* result */)>&& func): _function(std::make_unique<std::function<void(const CalendarEvent& /* result */)>>(std::move(func))) {}
    inline void call(CalendarEvent result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const CalendarEvent& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_CalendarEvent create_Func_void_CalendarEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_CalendarEvent_Wrapper wrap_Func_void_CalendarEvent(Func_void_CalendarEvent value) noexcept {
    return Func_void_CalendarEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<ReminderInfo>
  /**
   * Specialized version of `std::vector<ReminderInfo>`.
   */
  using std__vector_ReminderInfo_ = std::vector<ReminderInfo>;
  inline std::vector<ReminderInfo> create_std__vector_ReminderInfo_(size_t size) noexcept {
    std::vector<ReminderInfo> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<ReminderInfo>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<ReminderInfo>>>`.
   */
  using std__shared_ptr_Promise_std__vector_ReminderInfo___ = std::shared_ptr<Promise<std::vector<ReminderInfo>>>;
  inline std::shared_ptr<Promise<std::vector<ReminderInfo>>> create_std__shared_ptr_Promise_std__vector_ReminderInfo___() noexcept {
    return Promise<std::vector<ReminderInfo>>::create();
  }
  inline PromiseHolder<std::vector<ReminderInfo>> wrap_std__shared_ptr_Promise_std__vector_ReminderInfo___(std::shared_ptr<Promise<std::vector<ReminderInfo>>> promise) noexcept {
    return PromiseHolder<std::vector<ReminderInfo>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<ReminderInfo>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<ReminderInfo>&)>`.
   */
  using Func_void_std__vector_ReminderInfo_ = std::function<void(const std::vector<ReminderInfo>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<ReminderInfo>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_ReminderInfo__Wrapper final {
  public:
    explicit Func_void_std__vector_ReminderInfo__Wrapper(std::function<void(const std::vector<ReminderInfo>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<ReminderInfo>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<ReminderInfo> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<ReminderInfo>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_ReminderInfo_ create_Func_void_std__vector_ReminderInfo_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_ReminderInfo__Wrapper wrap_Func_void_std__vector_ReminderInfo_(Func_void_std__vector_ReminderInfo_ value) noexcept {
    return Func_void_std__vector_ReminderInfo__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneCalendarSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneCalendarSpec>`.
   */
  using std__shared_ptr_HybridOneCalendarSpec_ = std::shared_ptr<HybridOneCalendarSpec>;
  std::shared_ptr<HybridOneCalendarSpec> create_std__shared_ptr_HybridOneCalendarSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneCalendarSpec_(std__shared_ptr_HybridOneCalendarSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneCalendarSpec>
  using std__weak_ptr_HybridOneCalendarSpec_ = std::weak_ptr<HybridOneCalendarSpec>;
  inline std__weak_ptr_HybridOneCalendarSpec_ weakify_std__shared_ptr_HybridOneCalendarSpec_(const std::shared_ptr<HybridOneCalendarSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<CalendarPermissionStatus>
  using Result_CalendarPermissionStatus_ = Result<CalendarPermissionStatus>;
  inline Result_CalendarPermissionStatus_ create_Result_CalendarPermissionStatus_(CalendarPermissionStatus value) noexcept {
    return Result<CalendarPermissionStatus>::withValue(std::move(value));
  }
  inline Result_CalendarPermissionStatus_ create_Result_CalendarPermissionStatus_(const std::exception_ptr& error) noexcept {
    return Result<CalendarPermissionStatus>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<CalendarPermissionStatus>>>
  using Result_std__shared_ptr_Promise_CalendarPermissionStatus___ = Result<std::shared_ptr<Promise<CalendarPermissionStatus>>>;
  inline Result_std__shared_ptr_Promise_CalendarPermissionStatus___ create_Result_std__shared_ptr_Promise_CalendarPermissionStatus___(const std::shared_ptr<Promise<CalendarPermissionStatus>>& value) noexcept {
    return Result<std::shared_ptr<Promise<CalendarPermissionStatus>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_CalendarPermissionStatus___ create_Result_std__shared_ptr_Promise_CalendarPermissionStatus___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<CalendarPermissionStatus>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<CalendarEvent>>>>
  using Result_std__shared_ptr_Promise_std__vector_CalendarEvent____ = Result<std::shared_ptr<Promise<std::vector<CalendarEvent>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_CalendarEvent____ create_Result_std__shared_ptr_Promise_std__vector_CalendarEvent____(const std::shared_ptr<Promise<std::vector<CalendarEvent>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<CalendarEvent>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_CalendarEvent____ create_Result_std__shared_ptr_Promise_std__vector_CalendarEvent____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<CalendarEvent>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<CalendarEvent>>>
  using Result_std__shared_ptr_Promise_CalendarEvent___ = Result<std::shared_ptr<Promise<CalendarEvent>>>;
  inline Result_std__shared_ptr_Promise_CalendarEvent___ create_Result_std__shared_ptr_Promise_CalendarEvent___(const std::shared_ptr<Promise<CalendarEvent>>& value) noexcept {
    return Result<std::shared_ptr<Promise<CalendarEvent>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_CalendarEvent___ create_Result_std__shared_ptr_Promise_CalendarEvent___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<CalendarEvent>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<ReminderInfo>>>>
  using Result_std__shared_ptr_Promise_std__vector_ReminderInfo____ = Result<std::shared_ptr<Promise<std::vector<ReminderInfo>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_ReminderInfo____ create_Result_std__shared_ptr_Promise_std__vector_ReminderInfo____(const std::shared_ptr<Promise<std::vector<ReminderInfo>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<ReminderInfo>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_ReminderInfo____ create_Result_std__shared_ptr_Promise_std__vector_ReminderInfo____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<ReminderInfo>>>>::withError(error);
  }
  
  // pragma MARK: std::optional<ClipboardImageResult>
  /**
   * Specialized version of `std::optional<ClipboardImageResult>`.
   */
  using std__optional_ClipboardImageResult_ = std::optional<ClipboardImageResult>;
  inline std::optional<ClipboardImageResult> create_std__optional_ClipboardImageResult_(const ClipboardImageResult& value) noexcept {
    return std::optional<ClipboardImageResult>(value);
  }
  inline bool has_value_std__optional_ClipboardImageResult_(const std::optional<ClipboardImageResult>& optional) noexcept {
    return optional.has_value();
  }
  inline ClipboardImageResult get_std__optional_ClipboardImageResult_(const std::optional<ClipboardImageResult>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::optional<ClipboardImageResult>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::optional<ClipboardImageResult>>>`.
   */
  using std__shared_ptr_Promise_std__optional_ClipboardImageResult___ = std::shared_ptr<Promise<std::optional<ClipboardImageResult>>>;
  inline std::shared_ptr<Promise<std::optional<ClipboardImageResult>>> create_std__shared_ptr_Promise_std__optional_ClipboardImageResult___() noexcept {
    return Promise<std::optional<ClipboardImageResult>>::create();
  }
  inline PromiseHolder<std::optional<ClipboardImageResult>> wrap_std__shared_ptr_Promise_std__optional_ClipboardImageResult___(std::shared_ptr<Promise<std::optional<ClipboardImageResult>>> promise) noexcept {
    return PromiseHolder<std::optional<ClipboardImageResult>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::optional<ClipboardImageResult>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::optional<ClipboardImageResult>&)>`.
   */
  using Func_void_std__optional_ClipboardImageResult_ = std::function<void(const std::optional<ClipboardImageResult>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<ClipboardImageResult>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_ClipboardImageResult__Wrapper final {
  public:
    explicit Func_void_std__optional_ClipboardImageResult__Wrapper(std::function<void(const std::optional<ClipboardImageResult>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<ClipboardImageResult>& /* result */)>>(std::move(func))) {}
    inline void call(std::optional<ClipboardImageResult> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<ClipboardImageResult>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_ClipboardImageResult_ create_Func_void_std__optional_ClipboardImageResult_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_ClipboardImageResult__Wrapper wrap_Func_void_std__optional_ClipboardImageResult_(Func_void_std__optional_ClipboardImageResult_ value) noexcept {
    return Func_void_std__optional_ClipboardImageResult__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<std::string>
  /**
   * Specialized version of `std::vector<std::string>`.
   */
  using std__vector_std__string_ = std::vector<std::string>;
  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
    std::vector<std::string> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::function<void(const std::vector<std::string>& /* contentTypes */)>
  /**
   * Specialized version of `std::function<void(const std::vector<std::string>&)>`.
   */
  using Func_void_std__vector_std__string_ = std::function<void(const std::vector<std::string>& /* contentTypes */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<std::string>& / * contentTypes * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_std__string__Wrapper final {
  public:
    explicit Func_void_std__vector_std__string__Wrapper(std::function<void(const std::vector<std::string>& /* contentTypes */)>&& func): _function(std::make_unique<std::function<void(const std::vector<std::string>& /* contentTypes */)>>(std::move(func))) {}
    inline void call(std::vector<std::string> contentTypes) const noexcept {
      _function->operator()(contentTypes);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<std::string>& /* contentTypes */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_std__string_ create_Func_void_std__vector_std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_std__string__Wrapper wrap_Func_void_std__vector_std__string_(Func_void_std__vector_std__string_ value) noexcept {
    return Func_void_std__vector_std__string__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneClipboardSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneClipboardSpec>`.
   */
  using std__shared_ptr_HybridOneClipboardSpec_ = std::shared_ptr<HybridOneClipboardSpec>;
  std::shared_ptr<HybridOneClipboardSpec> create_std__shared_ptr_HybridOneClipboardSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneClipboardSpec_(std__shared_ptr_HybridOneClipboardSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneClipboardSpec>
  using std__weak_ptr_HybridOneClipboardSpec_ = std::weak_ptr<HybridOneClipboardSpec>;
  inline std__weak_ptr_HybridOneClipboardSpec_ weakify_std__shared_ptr_HybridOneClipboardSpec_(const std::shared_ptr<HybridOneClipboardSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<ClipboardImageResult>>>>
  using Result_std__shared_ptr_Promise_std__optional_ClipboardImageResult____ = Result<std::shared_ptr<Promise<std::optional<ClipboardImageResult>>>>;
  inline Result_std__shared_ptr_Promise_std__optional_ClipboardImageResult____ create_Result_std__shared_ptr_Promise_std__optional_ClipboardImageResult____(const std::shared_ptr<Promise<std::optional<ClipboardImageResult>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<ClipboardImageResult>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__optional_ClipboardImageResult____ create_Result_std__shared_ptr_Promise_std__optional_ClipboardImageResult____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<ClipboardImageResult>>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<ContactsPermissionStatus>>
  /**
   * Specialized version of `std::shared_ptr<Promise<ContactsPermissionStatus>>`.
   */
  using std__shared_ptr_Promise_ContactsPermissionStatus__ = std::shared_ptr<Promise<ContactsPermissionStatus>>;
  inline std::shared_ptr<Promise<ContactsPermissionStatus>> create_std__shared_ptr_Promise_ContactsPermissionStatus__() noexcept {
    return Promise<ContactsPermissionStatus>::create();
  }
  inline PromiseHolder<ContactsPermissionStatus> wrap_std__shared_ptr_Promise_ContactsPermissionStatus__(std::shared_ptr<Promise<ContactsPermissionStatus>> promise) noexcept {
    return PromiseHolder<ContactsPermissionStatus>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(ContactsPermissionStatus /* result */)>
  /**
   * Specialized version of `std::function<void(ContactsPermissionStatus)>`.
   */
  using Func_void_ContactsPermissionStatus = std::function<void(ContactsPermissionStatus /* result */)>;
  /**
   * Wrapper class for a `std::function<void(ContactsPermissionStatus / * result * /)>`, this can be used from Swift.
   */
  class Func_void_ContactsPermissionStatus_Wrapper final {
  public:
    explicit Func_void_ContactsPermissionStatus_Wrapper(std::function<void(ContactsPermissionStatus /* result */)>&& func): _function(std::make_unique<std::function<void(ContactsPermissionStatus /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<ContactsPermissionStatus>(result));
    }
  private:
    std::unique_ptr<std::function<void(ContactsPermissionStatus /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_ContactsPermissionStatus create_Func_void_ContactsPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_ContactsPermissionStatus_Wrapper wrap_Func_void_ContactsPermissionStatus(Func_void_ContactsPermissionStatus value) noexcept {
    return Func_void_ContactsPermissionStatus_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<ContactPostalAddress>
  /**
   * Specialized version of `std::vector<ContactPostalAddress>`.
   */
  using std__vector_ContactPostalAddress_ = std::vector<ContactPostalAddress>;
  inline std::vector<ContactPostalAddress> create_std__vector_ContactPostalAddress_(size_t size) noexcept {
    std::vector<ContactPostalAddress> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<ContactInfo>
  /**
   * Specialized version of `std::optional<ContactInfo>`.
   */
  using std__optional_ContactInfo_ = std::optional<ContactInfo>;
  inline std::optional<ContactInfo> create_std__optional_ContactInfo_(const ContactInfo& value) noexcept {
    return std::optional<ContactInfo>(value);
  }
  inline bool has_value_std__optional_ContactInfo_(const std::optional<ContactInfo>& optional) noexcept {
    return optional.has_value();
  }
  inline ContactInfo get_std__optional_ContactInfo_(const std::optional<ContactInfo>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::optional<ContactInfo>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::optional<ContactInfo>>>`.
   */
  using std__shared_ptr_Promise_std__optional_ContactInfo___ = std::shared_ptr<Promise<std::optional<ContactInfo>>>;
  inline std::shared_ptr<Promise<std::optional<ContactInfo>>> create_std__shared_ptr_Promise_std__optional_ContactInfo___() noexcept {
    return Promise<std::optional<ContactInfo>>::create();
  }
  inline PromiseHolder<std::optional<ContactInfo>> wrap_std__shared_ptr_Promise_std__optional_ContactInfo___(std::shared_ptr<Promise<std::optional<ContactInfo>>> promise) noexcept {
    return PromiseHolder<std::optional<ContactInfo>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::optional<ContactInfo>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::optional<ContactInfo>&)>`.
   */
  using Func_void_std__optional_ContactInfo_ = std::function<void(const std::optional<ContactInfo>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<ContactInfo>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_ContactInfo__Wrapper final {
  public:
    explicit Func_void_std__optional_ContactInfo__Wrapper(std::function<void(const std::optional<ContactInfo>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<ContactInfo>& /* result */)>>(std::move(func))) {}
    inline void call(std::optional<ContactInfo> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<ContactInfo>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_ContactInfo_ create_Func_void_std__optional_ContactInfo_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_ContactInfo__Wrapper wrap_Func_void_std__optional_ContactInfo_(Func_void_std__optional_ContactInfo_ value) noexcept {
    return Func_void_std__optional_ContactInfo__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<ContactInfo>
  /**
   * Specialized version of `std::vector<ContactInfo>`.
   */
  using std__vector_ContactInfo_ = std::vector<ContactInfo>;
  inline std::vector<ContactInfo> create_std__vector_ContactInfo_(size_t size) noexcept {
    std::vector<ContactInfo> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<ContactInfo>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<ContactInfo>>>`.
   */
  using std__shared_ptr_Promise_std__vector_ContactInfo___ = std::shared_ptr<Promise<std::vector<ContactInfo>>>;
  inline std::shared_ptr<Promise<std::vector<ContactInfo>>> create_std__shared_ptr_Promise_std__vector_ContactInfo___() noexcept {
    return Promise<std::vector<ContactInfo>>::create();
  }
  inline PromiseHolder<std::vector<ContactInfo>> wrap_std__shared_ptr_Promise_std__vector_ContactInfo___(std::shared_ptr<Promise<std::vector<ContactInfo>>> promise) noexcept {
    return PromiseHolder<std::vector<ContactInfo>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<ContactInfo>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<ContactInfo>&)>`.
   */
  using Func_void_std__vector_ContactInfo_ = std::function<void(const std::vector<ContactInfo>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<ContactInfo>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_ContactInfo__Wrapper final {
  public:
    explicit Func_void_std__vector_ContactInfo__Wrapper(std::function<void(const std::vector<ContactInfo>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<ContactInfo>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<ContactInfo> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<ContactInfo>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_ContactInfo_ create_Func_void_std__vector_ContactInfo_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_ContactInfo__Wrapper wrap_Func_void_std__vector_ContactInfo_(Func_void_std__vector_ContactInfo_ value) noexcept {
    return Func_void_std__vector_ContactInfo__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<ContactPostalAddressInput>
  /**
   * Specialized version of `std::vector<ContactPostalAddressInput>`.
   */
  using std__vector_ContactPostalAddressInput_ = std::vector<ContactPostalAddressInput>;
  inline std::vector<ContactPostalAddressInput> create_std__vector_ContactPostalAddressInput_(size_t size) noexcept {
    std::vector<ContactPostalAddressInput> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<std::vector<ContactPostalAddressInput>>
  /**
   * Specialized version of `std::optional<std::vector<ContactPostalAddressInput>>`.
   */
  using std__optional_std__vector_ContactPostalAddressInput__ = std::optional<std::vector<ContactPostalAddressInput>>;
  inline std::optional<std::vector<ContactPostalAddressInput>> create_std__optional_std__vector_ContactPostalAddressInput__(const std::vector<ContactPostalAddressInput>& value) noexcept {
    return std::optional<std::vector<ContactPostalAddressInput>>(value);
  }
  inline bool has_value_std__optional_std__vector_ContactPostalAddressInput__(const std::optional<std::vector<ContactPostalAddressInput>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::vector<ContactPostalAddressInput> get_std__optional_std__vector_ContactPostalAddressInput__(const std::optional<std::vector<ContactPostalAddressInput>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<ContactInfo>>
  /**
   * Specialized version of `std::shared_ptr<Promise<ContactInfo>>`.
   */
  using std__shared_ptr_Promise_ContactInfo__ = std::shared_ptr<Promise<ContactInfo>>;
  inline std::shared_ptr<Promise<ContactInfo>> create_std__shared_ptr_Promise_ContactInfo__() noexcept {
    return Promise<ContactInfo>::create();
  }
  inline PromiseHolder<ContactInfo> wrap_std__shared_ptr_Promise_ContactInfo__(std::shared_ptr<Promise<ContactInfo>> promise) noexcept {
    return PromiseHolder<ContactInfo>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const ContactInfo& /* result */)>
  /**
   * Specialized version of `std::function<void(const ContactInfo&)>`.
   */
  using Func_void_ContactInfo = std::function<void(const ContactInfo& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const ContactInfo& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_ContactInfo_Wrapper final {
  public:
    explicit Func_void_ContactInfo_Wrapper(std::function<void(const ContactInfo& /* result */)>&& func): _function(std::make_unique<std::function<void(const ContactInfo& /* result */)>>(std::move(func))) {}
    inline void call(ContactInfo result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const ContactInfo& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_ContactInfo create_Func_void_ContactInfo(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_ContactInfo_Wrapper wrap_Func_void_ContactInfo(Func_void_ContactInfo value) noexcept {
    return Func_void_ContactInfo_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<std::vector<std::string>>
  /**
   * Specialized version of `std::optional<std::vector<std::string>>`.
   */
  using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
    return std::optional<std::vector<std::string>>(value);
  }
  inline bool has_value_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::vector<std::string> get_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneContactsSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneContactsSpec>`.
   */
  using std__shared_ptr_HybridOneContactsSpec_ = std::shared_ptr<HybridOneContactsSpec>;
  std::shared_ptr<HybridOneContactsSpec> create_std__shared_ptr_HybridOneContactsSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneContactsSpec_(std__shared_ptr_HybridOneContactsSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneContactsSpec>
  using std__weak_ptr_HybridOneContactsSpec_ = std::weak_ptr<HybridOneContactsSpec>;
  inline std__weak_ptr_HybridOneContactsSpec_ weakify_std__shared_ptr_HybridOneContactsSpec_(const std::shared_ptr<HybridOneContactsSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<ContactsPermissionStatus>
  using Result_ContactsPermissionStatus_ = Result<ContactsPermissionStatus>;
  inline Result_ContactsPermissionStatus_ create_Result_ContactsPermissionStatus_(ContactsPermissionStatus value) noexcept {
    return Result<ContactsPermissionStatus>::withValue(std::move(value));
  }
  inline Result_ContactsPermissionStatus_ create_Result_ContactsPermissionStatus_(const std::exception_ptr& error) noexcept {
    return Result<ContactsPermissionStatus>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<ContactsPermissionStatus>>>
  using Result_std__shared_ptr_Promise_ContactsPermissionStatus___ = Result<std::shared_ptr<Promise<ContactsPermissionStatus>>>;
  inline Result_std__shared_ptr_Promise_ContactsPermissionStatus___ create_Result_std__shared_ptr_Promise_ContactsPermissionStatus___(const std::shared_ptr<Promise<ContactsPermissionStatus>>& value) noexcept {
    return Result<std::shared_ptr<Promise<ContactsPermissionStatus>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_ContactsPermissionStatus___ create_Result_std__shared_ptr_Promise_ContactsPermissionStatus___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<ContactsPermissionStatus>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<ContactInfo>>>>
  using Result_std__shared_ptr_Promise_std__optional_ContactInfo____ = Result<std::shared_ptr<Promise<std::optional<ContactInfo>>>>;
  inline Result_std__shared_ptr_Promise_std__optional_ContactInfo____ create_Result_std__shared_ptr_Promise_std__optional_ContactInfo____(const std::shared_ptr<Promise<std::optional<ContactInfo>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<ContactInfo>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__optional_ContactInfo____ create_Result_std__shared_ptr_Promise_std__optional_ContactInfo____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<ContactInfo>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<ContactInfo>>>>
  using Result_std__shared_ptr_Promise_std__vector_ContactInfo____ = Result<std::shared_ptr<Promise<std::vector<ContactInfo>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_ContactInfo____ create_Result_std__shared_ptr_Promise_std__vector_ContactInfo____(const std::shared_ptr<Promise<std::vector<ContactInfo>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<ContactInfo>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_ContactInfo____ create_Result_std__shared_ptr_Promise_std__vector_ContactInfo____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<ContactInfo>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<ContactInfo>>>
  using Result_std__shared_ptr_Promise_ContactInfo___ = Result<std::shared_ptr<Promise<ContactInfo>>>;
  inline Result_std__shared_ptr_Promise_ContactInfo___ create_Result_std__shared_ptr_Promise_ContactInfo___(const std::shared_ptr<Promise<ContactInfo>>& value) noexcept {
    return Result<std::shared_ptr<Promise<ContactInfo>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_ContactInfo___ create_Result_std__shared_ptr_Promise_ContactInfo___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<ContactInfo>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridNativeCNContactSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridNativeCNContactSpec>`.
   */
  using std__shared_ptr_HybridNativeCNContactSpec_ = std::shared_ptr<HybridNativeCNContactSpec>;
  std::shared_ptr<HybridNativeCNContactSpec> create_std__shared_ptr_HybridNativeCNContactSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridNativeCNContactSpec_(std__shared_ptr_HybridNativeCNContactSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridNativeCNContactSpec>
  using std__weak_ptr_HybridNativeCNContactSpec_ = std::weak_ptr<HybridNativeCNContactSpec>;
  inline std__weak_ptr_HybridNativeCNContactSpec_ weakify_std__shared_ptr_HybridNativeCNContactSpec_(const std::shared_ptr<HybridNativeCNContactSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<HybridNativeCNContactSpec>>
  using Result_std__shared_ptr_HybridNativeCNContactSpec__ = Result<std::shared_ptr<HybridNativeCNContactSpec>>;
  inline Result_std__shared_ptr_HybridNativeCNContactSpec__ create_Result_std__shared_ptr_HybridNativeCNContactSpec__(const std::shared_ptr<HybridNativeCNContactSpec>& value) noexcept {
    return Result<std::shared_ptr<HybridNativeCNContactSpec>>::withValue(value);
  }
  inline Result_std__shared_ptr_HybridNativeCNContactSpec__ create_Result_std__shared_ptr_HybridNativeCNContactSpec__(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<HybridNativeCNContactSpec>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridNativeCNKeyDescriptorSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridNativeCNKeyDescriptorSpec>`.
   */
  using std__shared_ptr_HybridNativeCNKeyDescriptorSpec_ = std::shared_ptr<HybridNativeCNKeyDescriptorSpec>;
  std::shared_ptr<HybridNativeCNKeyDescriptorSpec> create_std__shared_ptr_HybridNativeCNKeyDescriptorSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridNativeCNKeyDescriptorSpec_(std__shared_ptr_HybridNativeCNKeyDescriptorSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridNativeCNKeyDescriptorSpec>
  using std__weak_ptr_HybridNativeCNKeyDescriptorSpec_ = std::weak_ptr<HybridNativeCNKeyDescriptorSpec>;
  inline std__weak_ptr_HybridNativeCNKeyDescriptorSpec_ weakify_std__shared_ptr_HybridNativeCNKeyDescriptorSpec_(const std::shared_ptr<HybridNativeCNKeyDescriptorSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>>`.
   */
  using std__shared_ptr_Promise_std__shared_ptr_HybridNativeCNContactSpec___ = std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>>;
  inline std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>> create_std__shared_ptr_Promise_std__shared_ptr_HybridNativeCNContactSpec___() noexcept {
    return Promise<std::shared_ptr<HybridNativeCNContactSpec>>::create();
  }
  inline PromiseHolder<std::shared_ptr<HybridNativeCNContactSpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_HybridNativeCNContactSpec___(std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>> promise) noexcept {
    return PromiseHolder<std::shared_ptr<HybridNativeCNContactSpec>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridNativeCNContactSpec>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::shared_ptr<HybridNativeCNContactSpec>&)>`.
   */
  using Func_void_std__shared_ptr_HybridNativeCNContactSpec_ = std::function<void(const std::shared_ptr<HybridNativeCNContactSpec>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::shared_ptr<HybridNativeCNContactSpec>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__shared_ptr_HybridNativeCNContactSpec__Wrapper final {
  public:
    explicit Func_void_std__shared_ptr_HybridNativeCNContactSpec__Wrapper(std::function<void(const std::shared_ptr<HybridNativeCNContactSpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<HybridNativeCNContactSpec>& /* result */)>>(std::move(func))) {}
    inline void call(std::shared_ptr<HybridNativeCNContactSpec> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::shared_ptr<HybridNativeCNContactSpec>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__shared_ptr_HybridNativeCNContactSpec_ create_Func_void_std__shared_ptr_HybridNativeCNContactSpec_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__shared_ptr_HybridNativeCNContactSpec__Wrapper wrap_Func_void_std__shared_ptr_HybridNativeCNContactSpec_(Func_void_std__shared_ptr_HybridNativeCNContactSpec_ value) noexcept {
    return Func_void_std__shared_ptr_HybridNativeCNContactSpec__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>>
  /**
   * Specialized version of `std::vector<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>>`.
   */
  using std__vector_std__shared_ptr_HybridNativeCNKeyDescriptorSpec__ = std::vector<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>>;
  inline std::vector<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>> create_std__vector_std__shared_ptr_HybridNativeCNKeyDescriptorSpec__(size_t size) noexcept {
    std::vector<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<HybridNativeCNContactStoreSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridNativeCNContactStoreSpec>`.
   */
  using std__shared_ptr_HybridNativeCNContactStoreSpec_ = std::shared_ptr<HybridNativeCNContactStoreSpec>;
  std::shared_ptr<HybridNativeCNContactStoreSpec> create_std__shared_ptr_HybridNativeCNContactStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridNativeCNContactStoreSpec_(std__shared_ptr_HybridNativeCNContactStoreSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridNativeCNContactStoreSpec>
  using std__weak_ptr_HybridNativeCNContactStoreSpec_ = std::weak_ptr<HybridNativeCNContactStoreSpec>;
  inline std__weak_ptr_HybridNativeCNContactStoreSpec_ weakify_std__shared_ptr_HybridNativeCNContactStoreSpec_(const std::shared_ptr<HybridNativeCNContactStoreSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>>>
  using Result_std__shared_ptr_Promise_std__shared_ptr_HybridNativeCNContactSpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>>>;
  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridNativeCNContactSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridNativeCNContactSpec____(const std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridNativeCNContactSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridNativeCNContactSpec____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridNativeCNContactSpec>>>>::withError(error);
  }
  
  // pragma MARK: std::optional<std::shared_ptr<HybridNativeCNContactSpec>>
  /**
   * Specialized version of `std::optional<std::shared_ptr<HybridNativeCNContactSpec>>`.
   */
  using std__optional_std__shared_ptr_HybridNativeCNContactSpec__ = std::optional<std::shared_ptr<HybridNativeCNContactSpec>>;
  inline std::optional<std::shared_ptr<HybridNativeCNContactSpec>> create_std__optional_std__shared_ptr_HybridNativeCNContactSpec__(const std::shared_ptr<HybridNativeCNContactSpec>& value) noexcept {
    return std::optional<std::shared_ptr<HybridNativeCNContactSpec>>(value);
  }
  inline bool has_value_std__optional_std__shared_ptr_HybridNativeCNContactSpec__(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::shared_ptr<HybridNativeCNContactSpec> get_std__optional_std__shared_ptr_HybridNativeCNContactSpec__(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>
  /**
   * Specialized version of `std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>`.
   */
  using std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec__ = std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>;
  inline std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>> create_std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec__(const std::shared_ptr<HybridNativeCNContactStoreSpec>& value) noexcept {
    return std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>(value);
  }
  inline bool has_value_std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec__(const std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::shared_ptr<HybridNativeCNContactStoreSpec> get_std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec__(const std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::function<void(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& /* contact */)>
  /**
   * Specialized version of `std::function<void(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>&)>`.
   */
  using Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec__ = std::function<void(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& /* contact */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& / * contact * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec___Wrapper final {
  public:
    explicit Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec___Wrapper(std::function<void(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& /* contact */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& /* contact */)>>(std::move(func))) {}
    inline void call(std::optional<std::shared_ptr<HybridNativeCNContactSpec>> contact) const noexcept {
      _function->operator()(contact);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<std::shared_ptr<HybridNativeCNContactSpec>>& /* contact */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec__ create_Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec__(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec___Wrapper wrap_Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec__(Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec__ value) noexcept {
    return Func_void_std__optional_std__shared_ptr_HybridNativeCNContactSpec___Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneContactUISpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneContactUISpec>`.
   */
  using std__shared_ptr_HybridOneContactUISpec_ = std::shared_ptr<HybridOneContactUISpec>;
  std::shared_ptr<HybridOneContactUISpec> create_std__shared_ptr_HybridOneContactUISpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneContactUISpec_(std__shared_ptr_HybridOneContactUISpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneContactUISpec>
  using std__weak_ptr_HybridOneContactUISpec_ = std::weak_ptr<HybridOneContactUISpec>;
  inline std__weak_ptr_HybridOneContactUISpec_ weakify_std__shared_ptr_HybridOneContactUISpec_(const std::shared_ptr<HybridOneContactUISpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>>
  using Result_std__shared_ptr_HybridNativeCNKeyDescriptorSpec__ = Result<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>>;
  inline Result_std__shared_ptr_HybridNativeCNKeyDescriptorSpec__ create_Result_std__shared_ptr_HybridNativeCNKeyDescriptorSpec__(const std::shared_ptr<HybridNativeCNKeyDescriptorSpec>& value) noexcept {
    return Result<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>>::withValue(value);
  }
  inline Result_std__shared_ptr_HybridNativeCNKeyDescriptorSpec__ create_Result_std__shared_ptr_HybridNativeCNKeyDescriptorSpec__(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<HybridNativeCNKeyDescriptorSpec>>::withError(error);
  }
  
  // pragma MARK: Result<std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>>
  using Result_std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec___ = Result<std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>>;
  inline Result_std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec___ create_Result_std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec___(const std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>& value) noexcept {
    return Result<std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>>::withValue(value);
  }
  inline Result_std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec___ create_Result_std__optional_std__shared_ptr_HybridNativeCNContactStoreSpec___(const std::exception_ptr& error) noexcept {
    return Result<std::optional<std::shared_ptr<HybridNativeCNContactStoreSpec>>>::withError(error);
  }
  
  // pragma MARK: std::optional<DataScannerTextContentType>
  /**
   * Specialized version of `std::optional<DataScannerTextContentType>`.
   */
  using std__optional_DataScannerTextContentType_ = std::optional<DataScannerTextContentType>;
  inline std::optional<DataScannerTextContentType> create_std__optional_DataScannerTextContentType_(const DataScannerTextContentType& value) noexcept {
    return std::optional<DataScannerTextContentType>(value);
  }
  inline bool has_value_std__optional_DataScannerTextContentType_(const std::optional<DataScannerTextContentType>& optional) noexcept {
    return optional.has_value();
  }
  inline DataScannerTextContentType get_std__optional_DataScannerTextContentType_(const std::optional<DataScannerTextContentType>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<DataScannerRecognizedDataType>
  /**
   * Specialized version of `std::vector<DataScannerRecognizedDataType>`.
   */
  using std__vector_DataScannerRecognizedDataType_ = std::vector<DataScannerRecognizedDataType>;
  inline std::vector<DataScannerRecognizedDataType> create_std__vector_DataScannerRecognizedDataType_(size_t size) noexcept {
    std::vector<DataScannerRecognizedDataType> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::function<void(const DataScannerRecognizedItem& /* item */)>
  /**
   * Specialized version of `std::function<void(const DataScannerRecognizedItem&)>`.
   */
  using Func_void_DataScannerRecognizedItem = std::function<void(const DataScannerRecognizedItem& /* item */)>;
  /**
   * Wrapper class for a `std::function<void(const DataScannerRecognizedItem& / * item * /)>`, this can be used from Swift.
   */
  class Func_void_DataScannerRecognizedItem_Wrapper final {
  public:
    explicit Func_void_DataScannerRecognizedItem_Wrapper(std::function<void(const DataScannerRecognizedItem& /* item */)>&& func): _function(std::make_unique<std::function<void(const DataScannerRecognizedItem& /* item */)>>(std::move(func))) {}
    inline void call(DataScannerRecognizedItem item) const noexcept {
      _function->operator()(item);
    }
  private:
    std::unique_ptr<std::function<void(const DataScannerRecognizedItem& /* item */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_DataScannerRecognizedItem create_Func_void_DataScannerRecognizedItem(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_DataScannerRecognizedItem_Wrapper wrap_Func_void_DataScannerRecognizedItem(Func_void_DataScannerRecognizedItem value) noexcept {
    return Func_void_DataScannerRecognizedItem_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<DataScannerRecognizedItem>
  /**
   * Specialized version of `std::vector<DataScannerRecognizedItem>`.
   */
  using std__vector_DataScannerRecognizedItem_ = std::vector<DataScannerRecognizedItem>;
  inline std::vector<DataScannerRecognizedItem> create_std__vector_DataScannerRecognizedItem_(size_t size) noexcept {
    std::vector<DataScannerRecognizedItem> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */, const std::vector<DataScannerRecognizedItem>& /* allItems */)>
  /**
   * Specialized version of `std::function<void(const std::vector<DataScannerRecognizedItem>&, const std::vector<DataScannerRecognizedItem>&)>`.
   */
  using Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem_ = std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */, const std::vector<DataScannerRecognizedItem>& /* allItems */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<DataScannerRecognizedItem>& / * items * /, const std::vector<DataScannerRecognizedItem>& / * allItems * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem__Wrapper final {
  public:
    explicit Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem__Wrapper(std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */, const std::vector<DataScannerRecognizedItem>& /* allItems */)>&& func): _function(std::make_unique<std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */, const std::vector<DataScannerRecognizedItem>& /* allItems */)>>(std::move(func))) {}
    inline void call(std::vector<DataScannerRecognizedItem> items, std::vector<DataScannerRecognizedItem> allItems) const noexcept {
      _function->operator()(items, allItems);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */, const std::vector<DataScannerRecognizedItem>& /* allItems */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem_ create_Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem__Wrapper wrap_Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem_(Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem_ value) noexcept {
    return Func_void_std__vector_DataScannerRecognizedItem__std__vector_DataScannerRecognizedItem__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(DataScannerScanningUnavailable /* error */)>
  /**
   * Specialized version of `std::function<void(DataScannerScanningUnavailable)>`.
   */
  using Func_void_DataScannerScanningUnavailable = std::function<void(DataScannerScanningUnavailable /* error */)>;
  /**
   * Wrapper class for a `std::function<void(DataScannerScanningUnavailable / * error * /)>`, this can be used from Swift.
   */
  class Func_void_DataScannerScanningUnavailable_Wrapper final {
  public:
    explicit Func_void_DataScannerScanningUnavailable_Wrapper(std::function<void(DataScannerScanningUnavailable /* error */)>&& func): _function(std::make_unique<std::function<void(DataScannerScanningUnavailable /* error */)>>(std::move(func))) {}
    inline void call(int error) const noexcept {
      _function->operator()(static_cast<DataScannerScanningUnavailable>(error));
    }
  private:
    std::unique_ptr<std::function<void(DataScannerScanningUnavailable /* error */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_DataScannerScanningUnavailable create_Func_void_DataScannerScanningUnavailable(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_DataScannerScanningUnavailable_Wrapper wrap_Func_void_DataScannerScanningUnavailable(Func_void_DataScannerScanningUnavailable value) noexcept {
    return Func_void_DataScannerScanningUnavailable_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<DataScannerRect>
  /**
   * Specialized version of `std::optional<DataScannerRect>`.
   */
  using std__optional_DataScannerRect_ = std::optional<DataScannerRect>;
  inline std::optional<DataScannerRect> create_std__optional_DataScannerRect_(const DataScannerRect& value) noexcept {
    return std::optional<DataScannerRect>(value);
  }
  inline bool has_value_std__optional_DataScannerRect_(const std::optional<DataScannerRect>& optional) noexcept {
    return optional.has_value();
  }
  inline DataScannerRect get_std__optional_DataScannerRect_(const std::optional<DataScannerRect>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridDocumentCameraImageSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridDocumentCameraImageSpec>`.
   */
  using std__shared_ptr_HybridDocumentCameraImageSpec_ = std::shared_ptr<HybridDocumentCameraImageSpec>;
  std::shared_ptr<HybridDocumentCameraImageSpec> create_std__shared_ptr_HybridDocumentCameraImageSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridDocumentCameraImageSpec_(std__shared_ptr_HybridDocumentCameraImageSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridDocumentCameraImageSpec>
  using std__weak_ptr_HybridDocumentCameraImageSpec_ = std::weak_ptr<HybridDocumentCameraImageSpec>;
  inline std__weak_ptr_HybridDocumentCameraImageSpec_ weakify_std__shared_ptr_HybridDocumentCameraImageSpec_(const std::shared_ptr<HybridDocumentCameraImageSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>>`.
   */
  using std__shared_ptr_Promise_std__shared_ptr_HybridDocumentCameraImageSpec___ = std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>>;
  inline std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>> create_std__shared_ptr_Promise_std__shared_ptr_HybridDocumentCameraImageSpec___() noexcept {
    return Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>::create();
  }
  inline PromiseHolder<std::shared_ptr<HybridDocumentCameraImageSpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_HybridDocumentCameraImageSpec___(std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>> promise) noexcept {
    return PromiseHolder<std::shared_ptr<HybridDocumentCameraImageSpec>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridDocumentCameraImageSpec>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::shared_ptr<HybridDocumentCameraImageSpec>&)>`.
   */
  using Func_void_std__shared_ptr_HybridDocumentCameraImageSpec_ = std::function<void(const std::shared_ptr<HybridDocumentCameraImageSpec>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::shared_ptr<HybridDocumentCameraImageSpec>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__shared_ptr_HybridDocumentCameraImageSpec__Wrapper final {
  public:
    explicit Func_void_std__shared_ptr_HybridDocumentCameraImageSpec__Wrapper(std::function<void(const std::shared_ptr<HybridDocumentCameraImageSpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<HybridDocumentCameraImageSpec>& /* result */)>>(std::move(func))) {}
    inline void call(std::shared_ptr<HybridDocumentCameraImageSpec> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::shared_ptr<HybridDocumentCameraImageSpec>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__shared_ptr_HybridDocumentCameraImageSpec_ create_Func_void_std__shared_ptr_HybridDocumentCameraImageSpec_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__shared_ptr_HybridDocumentCameraImageSpec__Wrapper wrap_Func_void_std__shared_ptr_HybridDocumentCameraImageSpec_(Func_void_std__shared_ptr_HybridDocumentCameraImageSpec_ value) noexcept {
    return Func_void_std__shared_ptr_HybridDocumentCameraImageSpec__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */)>
  /**
   * Specialized version of `std::function<void(const std::vector<DataScannerRecognizedItem>&)>`.
   */
  using Func_void_std__vector_DataScannerRecognizedItem_ = std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<DataScannerRecognizedItem>& / * items * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_DataScannerRecognizedItem__Wrapper final {
  public:
    explicit Func_void_std__vector_DataScannerRecognizedItem__Wrapper(std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */)>&& func): _function(std::make_unique<std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */)>>(std::move(func))) {}
    inline void call(std::vector<DataScannerRecognizedItem> items) const noexcept {
      _function->operator()(items);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<DataScannerRecognizedItem>& /* items */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_DataScannerRecognizedItem_ create_Func_void_std__vector_DataScannerRecognizedItem_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_DataScannerRecognizedItem__Wrapper wrap_Func_void_std__vector_DataScannerRecognizedItem_(Func_void_std__vector_DataScannerRecognizedItem_ value) noexcept {
    return Func_void_std__vector_DataScannerRecognizedItem__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneDataScannerSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneDataScannerSpec>`.
   */
  using std__shared_ptr_HybridOneDataScannerSpec_ = std::shared_ptr<HybridOneDataScannerSpec>;
  std::shared_ptr<HybridOneDataScannerSpec> create_std__shared_ptr_HybridOneDataScannerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneDataScannerSpec_(std__shared_ptr_HybridOneDataScannerSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneDataScannerSpec>
  using std__weak_ptr_HybridOneDataScannerSpec_ = std::weak_ptr<HybridOneDataScannerSpec>;
  inline std__weak_ptr_HybridOneDataScannerSpec_ weakify_std__shared_ptr_HybridOneDataScannerSpec_(const std::shared_ptr<HybridOneDataScannerSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<double>
  using Result_double_ = Result<double>;
  inline Result_double_ create_Result_double_(double value) noexcept {
    return Result<double>::withValue(std::move(value));
  }
  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
    return Result<double>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>>>
  using Result_std__shared_ptr_Promise_std__shared_ptr_HybridDocumentCameraImageSpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>>>;
  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridDocumentCameraImageSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridDocumentCameraImageSpec____(const std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridDocumentCameraImageSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridDocumentCameraImageSpec____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridDocumentCameraImageSpec>>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<DeviceInfo>>
  /**
   * Specialized version of `std::shared_ptr<Promise<DeviceInfo>>`.
   */
  using std__shared_ptr_Promise_DeviceInfo__ = std::shared_ptr<Promise<DeviceInfo>>;
  inline std::shared_ptr<Promise<DeviceInfo>> create_std__shared_ptr_Promise_DeviceInfo__() noexcept {
    return Promise<DeviceInfo>::create();
  }
  inline PromiseHolder<DeviceInfo> wrap_std__shared_ptr_Promise_DeviceInfo__(std::shared_ptr<Promise<DeviceInfo>> promise) noexcept {
    return PromiseHolder<DeviceInfo>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const DeviceInfo& /* result */)>
  /**
   * Specialized version of `std::function<void(const DeviceInfo&)>`.
   */
  using Func_void_DeviceInfo = std::function<void(const DeviceInfo& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const DeviceInfo& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_DeviceInfo_Wrapper final {
  public:
    explicit Func_void_DeviceInfo_Wrapper(std::function<void(const DeviceInfo& /* result */)>&& func): _function(std::make_unique<std::function<void(const DeviceInfo& /* result */)>>(std::move(func))) {}
    inline void call(DeviceInfo result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const DeviceInfo& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_DeviceInfo create_Func_void_DeviceInfo(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_DeviceInfo_Wrapper wrap_Func_void_DeviceInfo(Func_void_DeviceInfo value) noexcept {
    return Func_void_DeviceInfo_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<LocalizationInfo>>
  /**
   * Specialized version of `std::shared_ptr<Promise<LocalizationInfo>>`.
   */
  using std__shared_ptr_Promise_LocalizationInfo__ = std::shared_ptr<Promise<LocalizationInfo>>;
  inline std::shared_ptr<Promise<LocalizationInfo>> create_std__shared_ptr_Promise_LocalizationInfo__() noexcept {
    return Promise<LocalizationInfo>::create();
  }
  inline PromiseHolder<LocalizationInfo> wrap_std__shared_ptr_Promise_LocalizationInfo__(std::shared_ptr<Promise<LocalizationInfo>> promise) noexcept {
    return PromiseHolder<LocalizationInfo>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const LocalizationInfo& /* result */)>
  /**
   * Specialized version of `std::function<void(const LocalizationInfo&)>`.
   */
  using Func_void_LocalizationInfo = std::function<void(const LocalizationInfo& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const LocalizationInfo& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_LocalizationInfo_Wrapper final {
  public:
    explicit Func_void_LocalizationInfo_Wrapper(std::function<void(const LocalizationInfo& /* result */)>&& func): _function(std::make_unique<std::function<void(const LocalizationInfo& /* result */)>>(std::move(func))) {}
    inline void call(LocalizationInfo result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const LocalizationInfo& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_LocalizationInfo create_Func_void_LocalizationInfo(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_LocalizationInfo_Wrapper wrap_Func_void_LocalizationInfo(Func_void_LocalizationInfo value) noexcept {
    return Func_void_LocalizationInfo_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<LocaleInfo>
  /**
   * Specialized version of `std::vector<LocaleInfo>`.
   */
  using std__vector_LocaleInfo_ = std::vector<LocaleInfo>;
  inline std::vector<LocaleInfo> create_std__vector_LocaleInfo_(size_t size) noexcept {
    std::vector<LocaleInfo> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::vector<CalendarInfo>
  /**
   * Specialized version of `std::vector<CalendarInfo>`.
   */
  using std__vector_CalendarInfo_ = std::vector<CalendarInfo>;
  inline std::vector<CalendarInfo> create_std__vector_CalendarInfo_(size_t size) noexcept {
    std::vector<CalendarInfo> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<HybridOneDeviceSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneDeviceSpec>`.
   */
  using std__shared_ptr_HybridOneDeviceSpec_ = std::shared_ptr<HybridOneDeviceSpec>;
  std::shared_ptr<HybridOneDeviceSpec> create_std__shared_ptr_HybridOneDeviceSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneDeviceSpec_(std__shared_ptr_HybridOneDeviceSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneDeviceSpec>
  using std__weak_ptr_HybridOneDeviceSpec_ = std::weak_ptr<HybridOneDeviceSpec>;
  inline std__weak_ptr_HybridOneDeviceSpec_ weakify_std__shared_ptr_HybridOneDeviceSpec_(const std::shared_ptr<HybridOneDeviceSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<DeviceInfo>>>
  using Result_std__shared_ptr_Promise_DeviceInfo___ = Result<std::shared_ptr<Promise<DeviceInfo>>>;
  inline Result_std__shared_ptr_Promise_DeviceInfo___ create_Result_std__shared_ptr_Promise_DeviceInfo___(const std::shared_ptr<Promise<DeviceInfo>>& value) noexcept {
    return Result<std::shared_ptr<Promise<DeviceInfo>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_DeviceInfo___ create_Result_std__shared_ptr_Promise_DeviceInfo___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<DeviceInfo>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<LocalizationInfo>>>
  using Result_std__shared_ptr_Promise_LocalizationInfo___ = Result<std::shared_ptr<Promise<LocalizationInfo>>>;
  inline Result_std__shared_ptr_Promise_LocalizationInfo___ create_Result_std__shared_ptr_Promise_LocalizationInfo___(const std::shared_ptr<Promise<LocalizationInfo>>& value) noexcept {
    return Result<std::shared_ptr<Promise<LocalizationInfo>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_LocalizationInfo___ create_Result_std__shared_ptr_Promise_LocalizationInfo___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<LocalizationInfo>>>::withError(error);
  }
  
  // pragma MARK: Result<std::vector<LocaleInfo>>
  using Result_std__vector_LocaleInfo__ = Result<std::vector<LocaleInfo>>;
  inline Result_std__vector_LocaleInfo__ create_Result_std__vector_LocaleInfo__(const std::vector<LocaleInfo>& value) noexcept {
    return Result<std::vector<LocaleInfo>>::withValue(value);
  }
  inline Result_std__vector_LocaleInfo__ create_Result_std__vector_LocaleInfo__(const std::exception_ptr& error) noexcept {
    return Result<std::vector<LocaleInfo>>::withError(error);
  }
  
  // pragma MARK: Result<std::vector<CalendarInfo>>
  using Result_std__vector_CalendarInfo__ = Result<std::vector<CalendarInfo>>;
  inline Result_std__vector_CalendarInfo__ create_Result_std__vector_CalendarInfo__(const std::vector<CalendarInfo>& value) noexcept {
    return Result<std::vector<CalendarInfo>>::withValue(value);
  }
  inline Result_std__vector_CalendarInfo__ create_Result_std__vector_CalendarInfo__(const std::exception_ptr& error) noexcept {
    return Result<std::vector<CalendarInfo>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridOneDeviceAttestationSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneDeviceAttestationSpec>`.
   */
  using std__shared_ptr_HybridOneDeviceAttestationSpec_ = std::shared_ptr<HybridOneDeviceAttestationSpec>;
  std::shared_ptr<HybridOneDeviceAttestationSpec> create_std__shared_ptr_HybridOneDeviceAttestationSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneDeviceAttestationSpec_(std__shared_ptr_HybridOneDeviceAttestationSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneDeviceAttestationSpec>
  using std__weak_ptr_HybridOneDeviceAttestationSpec_ = std::weak_ptr<HybridOneDeviceAttestationSpec>;
  inline std__weak_ptr_HybridOneDeviceAttestationSpec_ weakify_std__shared_ptr_HybridOneDeviceAttestationSpec_(const std::shared_ptr<HybridOneDeviceAttestationSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<DeviceAttestationAvailability>
  using Result_DeviceAttestationAvailability_ = Result<DeviceAttestationAvailability>;
  inline Result_DeviceAttestationAvailability_ create_Result_DeviceAttestationAvailability_(const DeviceAttestationAvailability& value) noexcept {
    return Result<DeviceAttestationAvailability>::withValue(value);
  }
  inline Result_DeviceAttestationAvailability_ create_Result_DeviceAttestationAvailability_(const std::exception_ptr& error) noexcept {
    return Result<DeviceAttestationAvailability>::withError(error);
  }
  
  // pragma MARK: std::optional<std::shared_ptr<ArrayBuffer>>
  /**
   * Specialized version of `std::optional<std::shared_ptr<ArrayBuffer>>`.
   */
  using std__optional_std__shared_ptr_ArrayBuffer__ = std::optional<std::shared_ptr<ArrayBuffer>>;
  inline std::optional<std::shared_ptr<ArrayBuffer>> create_std__optional_std__shared_ptr_ArrayBuffer__(const std::shared_ptr<ArrayBuffer>& value) noexcept {
    return std::optional<std::shared_ptr<ArrayBuffer>>(value);
  }
  inline bool has_value_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::shared_ptr<ArrayBuffer> get_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: Result<std::optional<std::shared_ptr<ArrayBuffer>>>
  using Result_std__optional_std__shared_ptr_ArrayBuffer___ = Result<std::optional<std::shared_ptr<ArrayBuffer>>>;
  inline Result_std__optional_std__shared_ptr_ArrayBuffer___ create_Result_std__optional_std__shared_ptr_ArrayBuffer___(const std::optional<std::shared_ptr<ArrayBuffer>>& value) noexcept {
    return Result<std::optional<std::shared_ptr<ArrayBuffer>>>::withValue(value);
  }
  inline Result_std__optional_std__shared_ptr_ArrayBuffer___ create_Result_std__optional_std__shared_ptr_ArrayBuffer___(const std::exception_ptr& error) noexcept {
    return Result<std::optional<std::shared_ptr<ArrayBuffer>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridDocumentCameraScanSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridDocumentCameraScanSpec>`.
   */
  using std__shared_ptr_HybridDocumentCameraScanSpec_ = std::shared_ptr<HybridDocumentCameraScanSpec>;
  std::shared_ptr<HybridDocumentCameraScanSpec> create_std__shared_ptr_HybridDocumentCameraScanSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridDocumentCameraScanSpec_(std__shared_ptr_HybridDocumentCameraScanSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridDocumentCameraScanSpec>
  using std__weak_ptr_HybridDocumentCameraScanSpec_ = std::weak_ptr<HybridDocumentCameraScanSpec>;
  inline std__weak_ptr_HybridDocumentCameraScanSpec_ weakify_std__shared_ptr_HybridDocumentCameraScanSpec_(const std::shared_ptr<HybridDocumentCameraScanSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<HybridDocumentCameraImageSpec>>
  using Result_std__shared_ptr_HybridDocumentCameraImageSpec__ = Result<std::shared_ptr<HybridDocumentCameraImageSpec>>;
  inline Result_std__shared_ptr_HybridDocumentCameraImageSpec__ create_Result_std__shared_ptr_HybridDocumentCameraImageSpec__(const std::shared_ptr<HybridDocumentCameraImageSpec>& value) noexcept {
    return Result<std::shared_ptr<HybridDocumentCameraImageSpec>>::withValue(value);
  }
  inline Result_std__shared_ptr_HybridDocumentCameraImageSpec__ create_Result_std__shared_ptr_HybridDocumentCameraImageSpec__(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<HybridDocumentCameraImageSpec>>::withError(error);
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridDocumentCameraScanSpec>& /* scan */)>
  /**
   * Specialized version of `std::function<void(const std::shared_ptr<HybridDocumentCameraScanSpec>&)>`.
   */
  using Func_void_std__shared_ptr_HybridDocumentCameraScanSpec_ = std::function<void(const std::shared_ptr<HybridDocumentCameraScanSpec>& /* scan */)>;
  /**
   * Wrapper class for a `std::function<void(const std::shared_ptr<HybridDocumentCameraScanSpec>& / * scan * /)>`, this can be used from Swift.
   */
  class Func_void_std__shared_ptr_HybridDocumentCameraScanSpec__Wrapper final {
  public:
    explicit Func_void_std__shared_ptr_HybridDocumentCameraScanSpec__Wrapper(std::function<void(const std::shared_ptr<HybridDocumentCameraScanSpec>& /* scan */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<HybridDocumentCameraScanSpec>& /* scan */)>>(std::move(func))) {}
    inline void call(std::shared_ptr<HybridDocumentCameraScanSpec> scan) const noexcept {
      _function->operator()(scan);
    }
  private:
    std::unique_ptr<std::function<void(const std::shared_ptr<HybridDocumentCameraScanSpec>& /* scan */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__shared_ptr_HybridDocumentCameraScanSpec_ create_Func_void_std__shared_ptr_HybridDocumentCameraScanSpec_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__shared_ptr_HybridDocumentCameraScanSpec__Wrapper wrap_Func_void_std__shared_ptr_HybridDocumentCameraScanSpec_(Func_void_std__shared_ptr_HybridDocumentCameraScanSpec_ value) noexcept {
    return Func_void_std__shared_ptr_HybridDocumentCameraScanSpec__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const DocumentCameraError& /* error */)>
  /**
   * Specialized version of `std::function<void(const DocumentCameraError&)>`.
   */
  using Func_void_DocumentCameraError = std::function<void(const DocumentCameraError& /* error */)>;
  /**
   * Wrapper class for a `std::function<void(const DocumentCameraError& / * error * /)>`, this can be used from Swift.
   */
  class Func_void_DocumentCameraError_Wrapper final {
  public:
    explicit Func_void_DocumentCameraError_Wrapper(std::function<void(const DocumentCameraError& /* error */)>&& func): _function(std::make_unique<std::function<void(const DocumentCameraError& /* error */)>>(std::move(func))) {}
    inline void call(DocumentCameraError error) const noexcept {
      _function->operator()(error);
    }
  private:
    std::unique_ptr<std::function<void(const DocumentCameraError& /* error */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_DocumentCameraError create_Func_void_DocumentCameraError(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_DocumentCameraError_Wrapper wrap_Func_void_DocumentCameraError(Func_void_DocumentCameraError value) noexcept {
    return Func_void_DocumentCameraError_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneDocumentCameraSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneDocumentCameraSpec>`.
   */
  using std__shared_ptr_HybridOneDocumentCameraSpec_ = std::shared_ptr<HybridOneDocumentCameraSpec>;
  std::shared_ptr<HybridOneDocumentCameraSpec> create_std__shared_ptr_HybridOneDocumentCameraSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneDocumentCameraSpec_(std__shared_ptr_HybridOneDocumentCameraSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneDocumentCameraSpec>
  using std__weak_ptr_HybridOneDocumentCameraSpec_ = std::weak_ptr<HybridOneDocumentCameraSpec>;
  inline std__weak_ptr_HybridOneDocumentCameraSpec_ weakify_std__shared_ptr_HybridOneDocumentCameraSpec_(const std::shared_ptr<HybridOneDocumentCameraSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::vector<DocumentPickerAsset>
  /**
   * Specialized version of `std::vector<DocumentPickerAsset>`.
   */
  using std__vector_DocumentPickerAsset_ = std::vector<DocumentPickerAsset>;
  inline std::vector<DocumentPickerAsset> create_std__vector_DocumentPickerAsset_(size_t size) noexcept {
    std::vector<DocumentPickerAsset> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<std::vector<DocumentPickerAsset>>
  /**
   * Specialized version of `std::optional<std::vector<DocumentPickerAsset>>`.
   */
  using std__optional_std__vector_DocumentPickerAsset__ = std::optional<std::vector<DocumentPickerAsset>>;
  inline std::optional<std::vector<DocumentPickerAsset>> create_std__optional_std__vector_DocumentPickerAsset__(const std::vector<DocumentPickerAsset>& value) noexcept {
    return std::optional<std::vector<DocumentPickerAsset>>(value);
  }
  inline bool has_value_std__optional_std__vector_DocumentPickerAsset__(const std::optional<std::vector<DocumentPickerAsset>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::vector<DocumentPickerAsset> get_std__optional_std__vector_DocumentPickerAsset__(const std::optional<std::vector<DocumentPickerAsset>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<DocumentPickerNativeResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<DocumentPickerNativeResult>>`.
   */
  using std__shared_ptr_Promise_DocumentPickerNativeResult__ = std::shared_ptr<Promise<DocumentPickerNativeResult>>;
  inline std::shared_ptr<Promise<DocumentPickerNativeResult>> create_std__shared_ptr_Promise_DocumentPickerNativeResult__() noexcept {
    return Promise<DocumentPickerNativeResult>::create();
  }
  inline PromiseHolder<DocumentPickerNativeResult> wrap_std__shared_ptr_Promise_DocumentPickerNativeResult__(std::shared_ptr<Promise<DocumentPickerNativeResult>> promise) noexcept {
    return PromiseHolder<DocumentPickerNativeResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const DocumentPickerNativeResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const DocumentPickerNativeResult&)>`.
   */
  using Func_void_DocumentPickerNativeResult = std::function<void(const DocumentPickerNativeResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const DocumentPickerNativeResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_DocumentPickerNativeResult_Wrapper final {
  public:
    explicit Func_void_DocumentPickerNativeResult_Wrapper(std::function<void(const DocumentPickerNativeResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const DocumentPickerNativeResult& /* result */)>>(std::move(func))) {}
    inline void call(DocumentPickerNativeResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const DocumentPickerNativeResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_DocumentPickerNativeResult create_Func_void_DocumentPickerNativeResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_DocumentPickerNativeResult_Wrapper wrap_Func_void_DocumentPickerNativeResult(Func_void_DocumentPickerNativeResult value) noexcept {
    return Func_void_DocumentPickerNativeResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneDocumentPickerSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneDocumentPickerSpec>`.
   */
  using std__shared_ptr_HybridOneDocumentPickerSpec_ = std::shared_ptr<HybridOneDocumentPickerSpec>;
  std::shared_ptr<HybridOneDocumentPickerSpec> create_std__shared_ptr_HybridOneDocumentPickerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneDocumentPickerSpec_(std__shared_ptr_HybridOneDocumentPickerSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneDocumentPickerSpec>
  using std__weak_ptr_HybridOneDocumentPickerSpec_ = std::weak_ptr<HybridOneDocumentPickerSpec>;
  inline std__weak_ptr_HybridOneDocumentPickerSpec_ weakify_std__shared_ptr_HybridOneDocumentPickerSpec_(const std::shared_ptr<HybridOneDocumentPickerSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<DocumentPickerNativeResult>>>
  using Result_std__shared_ptr_Promise_DocumentPickerNativeResult___ = Result<std::shared_ptr<Promise<DocumentPickerNativeResult>>>;
  inline Result_std__shared_ptr_Promise_DocumentPickerNativeResult___ create_Result_std__shared_ptr_Promise_DocumentPickerNativeResult___(const std::shared_ptr<Promise<DocumentPickerNativeResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<DocumentPickerNativeResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_DocumentPickerNativeResult___ create_Result_std__shared_ptr_Promise_DocumentPickerNativeResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<DocumentPickerNativeResult>>>::withError(error);
  }
  
  // pragma MARK: std::vector<FetchHeader>
  /**
   * Specialized version of `std::vector<FetchHeader>`.
   */
  using std__vector_FetchHeader_ = std::vector<FetchHeader>;
  inline std::vector<FetchHeader> create_std__vector_FetchHeader_(size_t size) noexcept {
    std::vector<FetchHeader> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<FetchBlobRef>
  /**
   * Specialized version of `std::optional<FetchBlobRef>`.
   */
  using std__optional_FetchBlobRef_ = std::optional<FetchBlobRef>;
  inline std::optional<FetchBlobRef> create_std__optional_FetchBlobRef_(const FetchBlobRef& value) noexcept {
    return std::optional<FetchBlobRef>(value);
  }
  inline bool has_value_std__optional_FetchBlobRef_(const std::optional<FetchBlobRef>& optional) noexcept {
    return optional.has_value();
  }
  inline FetchBlobRef get_std__optional_FetchBlobRef_(const std::optional<FetchBlobRef>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<FetchFormPart>
  /**
   * Specialized version of `std::vector<FetchFormPart>`.
   */
  using std__vector_FetchFormPart_ = std::vector<FetchFormPart>;
  inline std::vector<FetchFormPart> create_std__vector_FetchFormPart_(size_t size) noexcept {
    std::vector<FetchFormPart> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<std::vector<FetchFormPart>>
  /**
   * Specialized version of `std::optional<std::vector<FetchFormPart>>`.
   */
  using std__optional_std__vector_FetchFormPart__ = std::optional<std::vector<FetchFormPart>>;
  inline std::optional<std::vector<FetchFormPart>> create_std__optional_std__vector_FetchFormPart__(const std::vector<FetchFormPart>& value) noexcept {
    return std::optional<std::vector<FetchFormPart>>(value);
  }
  inline bool has_value_std__optional_std__vector_FetchFormPart__(const std::optional<std::vector<FetchFormPart>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::vector<FetchFormPart> get_std__optional_std__vector_FetchFormPart__(const std::optional<std::vector<FetchFormPart>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::function<void(const FetchNativeResponse& /* response */)>
  /**
   * Specialized version of `std::function<void(const FetchNativeResponse&)>`.
   */
  using Func_void_FetchNativeResponse = std::function<void(const FetchNativeResponse& /* response */)>;
  /**
   * Wrapper class for a `std::function<void(const FetchNativeResponse& / * response * /)>`, this can be used from Swift.
   */
  class Func_void_FetchNativeResponse_Wrapper final {
  public:
    explicit Func_void_FetchNativeResponse_Wrapper(std::function<void(const FetchNativeResponse& /* response */)>&& func): _function(std::make_unique<std::function<void(const FetchNativeResponse& /* response */)>>(std::move(func))) {}
    inline void call(FetchNativeResponse response) const noexcept {
      _function->operator()(response);
    }
  private:
    std::unique_ptr<std::function<void(const FetchNativeResponse& /* response */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_FetchNativeResponse create_Func_void_FetchNativeResponse(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_FetchNativeResponse_Wrapper wrap_Func_void_FetchNativeResponse(Func_void_FetchNativeResponse value) noexcept {
    return Func_void_FetchNativeResponse_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* chunk */)>
  /**
   * Specialized version of `std::function<void(const std::shared_ptr<ArrayBuffer>&)>`.
   */
  using Func_void_std__shared_ptr_ArrayBuffer_ = std::function<void(const std::shared_ptr<ArrayBuffer>& /* chunk */)>;
  /**
   * Wrapper class for a `std::function<void(const std::shared_ptr<ArrayBuffer>& / * chunk * /)>`, this can be used from Swift.
   */
  class Func_void_std__shared_ptr_ArrayBuffer__Wrapper final {
  public:
    explicit Func_void_std__shared_ptr_ArrayBuffer__Wrapper(std::function<void(const std::shared_ptr<ArrayBuffer>& /* chunk */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<ArrayBuffer>& /* chunk */)>>(std::move(func))) {}
    inline void call(ArrayBufferHolder chunk) const noexcept {
      _function->operator()(chunk.getArrayBuffer());
    }
  private:
    std::unique_ptr<std::function<void(const std::shared_ptr<ArrayBuffer>& /* chunk */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__shared_ptr_ArrayBuffer__Wrapper wrap_Func_void_std__shared_ptr_ArrayBuffer_(Func_void_std__shared_ptr_ArrayBuffer_ value) noexcept {
    return Func_void_std__shared_ptr_ArrayBuffer__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneFetchSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneFetchSpec>`.
   */
  using std__shared_ptr_HybridOneFetchSpec_ = std::shared_ptr<HybridOneFetchSpec>;
  std::shared_ptr<HybridOneFetchSpec> create_std__shared_ptr_HybridOneFetchSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneFetchSpec_(std__shared_ptr_HybridOneFetchSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneFetchSpec>
  using std__weak_ptr_HybridOneFetchSpec_ = std::weak_ptr<HybridOneFetchSpec>;
  inline std__weak_ptr_HybridOneFetchSpec_ weakify_std__shared_ptr_HybridOneFetchSpec_(const std::shared_ptr<HybridOneFetchSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<Promise<FileInfo>>
  /**
   * Specialized version of `std::shared_ptr<Promise<FileInfo>>`.
   */
  using std__shared_ptr_Promise_FileInfo__ = std::shared_ptr<Promise<FileInfo>>;
  inline std::shared_ptr<Promise<FileInfo>> create_std__shared_ptr_Promise_FileInfo__() noexcept {
    return Promise<FileInfo>::create();
  }
  inline PromiseHolder<FileInfo> wrap_std__shared_ptr_Promise_FileInfo__(std::shared_ptr<Promise<FileInfo>> promise) noexcept {
    return PromiseHolder<FileInfo>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const FileInfo& /* result */)>
  /**
   * Specialized version of `std::function<void(const FileInfo&)>`.
   */
  using Func_void_FileInfo = std::function<void(const FileInfo& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const FileInfo& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_FileInfo_Wrapper final {
  public:
    explicit Func_void_FileInfo_Wrapper(std::function<void(const FileInfo& /* result */)>&& func): _function(std::make_unique<std::function<void(const FileInfo& /* result */)>>(std::move(func))) {}
    inline void call(FileInfo result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const FileInfo& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_FileInfo create_Func_void_FileInfo(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_FileInfo_Wrapper wrap_Func_void_FileInfo(Func_void_FileInfo value) noexcept {
    return Func_void_FileInfo_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<FileEntry>
  /**
   * Specialized version of `std::vector<FileEntry>`.
   */
  using std__vector_FileEntry_ = std::vector<FileEntry>;
  inline std::vector<FileEntry> create_std__vector_FileEntry_(size_t size) noexcept {
    std::vector<FileEntry> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<FileEntry>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<FileEntry>>>`.
   */
  using std__shared_ptr_Promise_std__vector_FileEntry___ = std::shared_ptr<Promise<std::vector<FileEntry>>>;
  inline std::shared_ptr<Promise<std::vector<FileEntry>>> create_std__shared_ptr_Promise_std__vector_FileEntry___() noexcept {
    return Promise<std::vector<FileEntry>>::create();
  }
  inline PromiseHolder<std::vector<FileEntry>> wrap_std__shared_ptr_Promise_std__vector_FileEntry___(std::shared_ptr<Promise<std::vector<FileEntry>>> promise) noexcept {
    return PromiseHolder<std::vector<FileEntry>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<FileEntry>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<FileEntry>&)>`.
   */
  using Func_void_std__vector_FileEntry_ = std::function<void(const std::vector<FileEntry>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<FileEntry>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_FileEntry__Wrapper final {
  public:
    explicit Func_void_std__vector_FileEntry__Wrapper(std::function<void(const std::vector<FileEntry>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<FileEntry>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<FileEntry> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<FileEntry>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_FileEntry_ create_Func_void_std__vector_FileEntry_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_FileEntry__Wrapper wrap_Func_void_std__vector_FileEntry_(Func_void_std__vector_FileEntry_ value) noexcept {
    return Func_void_std__vector_FileEntry__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>`.
   */
  using std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ = std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>;
  inline std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___() noexcept {
    return Promise<std::shared_ptr<ArrayBuffer>>::create();
  }
  inline PromiseHolder<std::shared_ptr<ArrayBuffer>> wrap_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___(std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> promise) noexcept {
    return PromiseHolder<std::shared_ptr<ArrayBuffer>>(std::move(promise));
  }
  
  // pragma MARK: std::vector<ListedEntry>
  /**
   * Specialized version of `std::vector<ListedEntry>`.
   */
  using std__vector_ListedEntry_ = std::vector<ListedEntry>;
  inline std::vector<ListedEntry> create_std__vector_ListedEntry_(size_t size) noexcept {
    std::vector<ListedEntry> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<HybridOneFileSystemSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneFileSystemSpec>`.
   */
  using std__shared_ptr_HybridOneFileSystemSpec_ = std::shared_ptr<HybridOneFileSystemSpec>;
  std::shared_ptr<HybridOneFileSystemSpec> create_std__shared_ptr_HybridOneFileSystemSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneFileSystemSpec_(std__shared_ptr_HybridOneFileSystemSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneFileSystemSpec>
  using std__weak_ptr_HybridOneFileSystemSpec_ = std::weak_ptr<HybridOneFileSystemSpec>;
  inline std__weak_ptr_HybridOneFileSystemSpec_ weakify_std__shared_ptr_HybridOneFileSystemSpec_(const std::shared_ptr<HybridOneFileSystemSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<FileDirectories>
  using Result_FileDirectories_ = Result<FileDirectories>;
  inline Result_FileDirectories_ create_Result_FileDirectories_(const FileDirectories& value) noexcept {
    return Result<FileDirectories>::withValue(value);
  }
  inline Result_FileDirectories_ create_Result_FileDirectories_(const std::exception_ptr& error) noexcept {
    return Result<FileDirectories>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<FileInfo>>>
  using Result_std__shared_ptr_Promise_FileInfo___ = Result<std::shared_ptr<Promise<FileInfo>>>;
  inline Result_std__shared_ptr_Promise_FileInfo___ create_Result_std__shared_ptr_Promise_FileInfo___(const std::shared_ptr<Promise<FileInfo>>& value) noexcept {
    return Result<std::shared_ptr<Promise<FileInfo>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_FileInfo___ create_Result_std__shared_ptr_Promise_FileInfo___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<FileInfo>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<FileEntry>>>>
  using Result_std__shared_ptr_Promise_std__vector_FileEntry____ = Result<std::shared_ptr<Promise<std::vector<FileEntry>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_FileEntry____ create_Result_std__shared_ptr_Promise_std__vector_FileEntry____(const std::shared_ptr<Promise<std::vector<FileEntry>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<FileEntry>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_FileEntry____ create_Result_std__shared_ptr_Promise_std__vector_FileEntry____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<FileEntry>>>>::withError(error);
  }
  
  // pragma MARK: Result<DiskSpace>
  using Result_DiskSpace_ = Result<DiskSpace>;
  inline Result_DiskSpace_ create_Result_DiskSpace_(const DiskSpace& value) noexcept {
    return Result<DiskSpace>::withValue(value);
  }
  inline Result_DiskSpace_ create_Result_DiskSpace_(const std::exception_ptr& error) noexcept {
    return Result<DiskSpace>::withError(error);
  }
  
  // pragma MARK: Result<PathStat>
  using Result_PathStat_ = Result<PathStat>;
  inline Result_PathStat_ create_Result_PathStat_(const PathStat& value) noexcept {
    return Result<PathStat>::withValue(value);
  }
  inline Result_PathStat_ create_Result_PathStat_(const std::exception_ptr& error) noexcept {
    return Result<PathStat>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<ArrayBuffer>>
  using Result_std__shared_ptr_ArrayBuffer__ = Result<std::shared_ptr<ArrayBuffer>>;
  inline Result_std__shared_ptr_ArrayBuffer__ create_Result_std__shared_ptr_ArrayBuffer__(const std::shared_ptr<ArrayBuffer>& value) noexcept {
    return Result<std::shared_ptr<ArrayBuffer>>::withValue(value);
  }
  inline Result_std__shared_ptr_ArrayBuffer__ create_Result_std__shared_ptr_ArrayBuffer__(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<ArrayBuffer>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>
  using Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ = Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>;
  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::vector<ListedEntry>>
  using Result_std__vector_ListedEntry__ = Result<std::vector<ListedEntry>>;
  inline Result_std__vector_ListedEntry__ create_Result_std__vector_ListedEntry__(const std::vector<ListedEntry>& value) noexcept {
    return Result<std::vector<ListedEntry>>::withValue(value);
  }
  inline Result_std__vector_ListedEntry__ create_Result_std__vector_ListedEntry__(const std::exception_ptr& error) noexcept {
    return Result<std::vector<ListedEntry>>::withError(error);
  }
  
  // pragma MARK: Result<DetailedFileInfo>
  using Result_DetailedFileInfo_ = Result<DetailedFileInfo>;
  inline Result_DetailedFileInfo_ create_Result_DetailedFileInfo_(const DetailedFileInfo& value) noexcept {
    return Result<DetailedFileInfo>::withValue(value);
  }
  inline Result_DetailedFileInfo_ create_Result_DetailedFileInfo_(const std::exception_ptr& error) noexcept {
    return Result<DetailedFileInfo>::withError(error);
  }
  
  // pragma MARK: Result<DetailedDirectoryInfo>
  using Result_DetailedDirectoryInfo_ = Result<DetailedDirectoryInfo>;
  inline Result_DetailedDirectoryInfo_ create_Result_DetailedDirectoryInfo_(const DetailedDirectoryInfo& value) noexcept {
    return Result<DetailedDirectoryInfo>::withValue(value);
  }
  inline Result_DetailedDirectoryInfo_ create_Result_DetailedDirectoryInfo_(const std::exception_ptr& error) noexcept {
    return Result<DetailedDirectoryInfo>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridOneFontsSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneFontsSpec>`.
   */
  using std__shared_ptr_HybridOneFontsSpec_ = std::shared_ptr<HybridOneFontsSpec>;
  std::shared_ptr<HybridOneFontsSpec> create_std__shared_ptr_HybridOneFontsSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneFontsSpec_(std__shared_ptr_HybridOneFontsSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneFontsSpec>
  using std__weak_ptr_HybridOneFontsSpec_ = std::weak_ptr<HybridOneFontsSpec>;
  inline std__weak_ptr_HybridOneFontsSpec_ weakify_std__shared_ptr_HybridOneFontsSpec_(const std::shared_ptr<HybridOneFontsSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<HybridOneHapticsSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneHapticsSpec>`.
   */
  using std__shared_ptr_HybridOneHapticsSpec_ = std::shared_ptr<HybridOneHapticsSpec>;
  std::shared_ptr<HybridOneHapticsSpec> create_std__shared_ptr_HybridOneHapticsSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneHapticsSpec_(std__shared_ptr_HybridOneHapticsSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneHapticsSpec>
  using std__weak_ptr_HybridOneHapticsSpec_ = std::weak_ptr<HybridOneHapticsSpec>;
  inline std__weak_ptr_HybridOneHapticsSpec_ weakify_std__shared_ptr_HybridOneHapticsSpec_(const std::shared_ptr<HybridOneHapticsSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<Promise<ImageTransformResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<ImageTransformResult>>`.
   */
  using std__shared_ptr_Promise_ImageTransformResult__ = std::shared_ptr<Promise<ImageTransformResult>>;
  inline std::shared_ptr<Promise<ImageTransformResult>> create_std__shared_ptr_Promise_ImageTransformResult__() noexcept {
    return Promise<ImageTransformResult>::create();
  }
  inline PromiseHolder<ImageTransformResult> wrap_std__shared_ptr_Promise_ImageTransformResult__(std::shared_ptr<Promise<ImageTransformResult>> promise) noexcept {
    return PromiseHolder<ImageTransformResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const ImageTransformResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const ImageTransformResult&)>`.
   */
  using Func_void_ImageTransformResult = std::function<void(const ImageTransformResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const ImageTransformResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_ImageTransformResult_Wrapper final {
  public:
    explicit Func_void_ImageTransformResult_Wrapper(std::function<void(const ImageTransformResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const ImageTransformResult& /* result */)>>(std::move(func))) {}
    inline void call(ImageTransformResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const ImageTransformResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_ImageTransformResult create_Func_void_ImageTransformResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_ImageTransformResult_Wrapper wrap_Func_void_ImageTransformResult(Func_void_ImageTransformResult value) noexcept {
    return Func_void_ImageTransformResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<ImageCrop>
  /**
   * Specialized version of `std::optional<ImageCrop>`.
   */
  using std__optional_ImageCrop_ = std::optional<ImageCrop>;
  inline std::optional<ImageCrop> create_std__optional_ImageCrop_(const ImageCrop& value) noexcept {
    return std::optional<ImageCrop>(value);
  }
  inline bool has_value_std__optional_ImageCrop_(const std::optional<ImageCrop>& optional) noexcept {
    return optional.has_value();
  }
  inline ImageCrop get_std__optional_ImageCrop_(const std::optional<ImageCrop>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<ImageResize>
  /**
   * Specialized version of `std::optional<ImageResize>`.
   */
  using std__optional_ImageResize_ = std::optional<ImageResize>;
  inline std::optional<ImageResize> create_std__optional_ImageResize_(const ImageResize& value) noexcept {
    return std::optional<ImageResize>(value);
  }
  inline bool has_value_std__optional_ImageResize_(const std::optional<ImageResize>& optional) noexcept {
    return optional.has_value();
  }
  inline ImageResize get_std__optional_ImageResize_(const std::optional<ImageResize>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<OneImageFlip>
  /**
   * Specialized version of `std::optional<OneImageFlip>`.
   */
  using std__optional_OneImageFlip_ = std::optional<OneImageFlip>;
  inline std::optional<OneImageFlip> create_std__optional_OneImageFlip_(const OneImageFlip& value) noexcept {
    return std::optional<OneImageFlip>(value);
  }
  inline bool has_value_std__optional_OneImageFlip_(const std::optional<OneImageFlip>& optional) noexcept {
    return optional.has_value();
  }
  inline OneImageFlip get_std__optional_OneImageFlip_(const std::optional<OneImageFlip>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneImageManipulatorSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneImageManipulatorSpec>`.
   */
  using std__shared_ptr_HybridOneImageManipulatorSpec_ = std::shared_ptr<HybridOneImageManipulatorSpec>;
  std::shared_ptr<HybridOneImageManipulatorSpec> create_std__shared_ptr_HybridOneImageManipulatorSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneImageManipulatorSpec_(std__shared_ptr_HybridOneImageManipulatorSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneImageManipulatorSpec>
  using std__weak_ptr_HybridOneImageManipulatorSpec_ = std::weak_ptr<HybridOneImageManipulatorSpec>;
  inline std__weak_ptr_HybridOneImageManipulatorSpec_ weakify_std__shared_ptr_HybridOneImageManipulatorSpec_(const std::shared_ptr<HybridOneImageManipulatorSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<ImageTransformResult>>>
  using Result_std__shared_ptr_Promise_ImageTransformResult___ = Result<std::shared_ptr<Promise<ImageTransformResult>>>;
  inline Result_std__shared_ptr_Promise_ImageTransformResult___ create_Result_std__shared_ptr_Promise_ImageTransformResult___(const std::shared_ptr<Promise<ImageTransformResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<ImageTransformResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_ImageTransformResult___ create_Result_std__shared_ptr_Promise_ImageTransformResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<ImageTransformResult>>>::withError(error);
  }
  
  // pragma MARK: std::optional<ImagePickerAssetType>
  /**
   * Specialized version of `std::optional<ImagePickerAssetType>`.
   */
  using std__optional_ImagePickerAssetType_ = std::optional<ImagePickerAssetType>;
  inline std::optional<ImagePickerAssetType> create_std__optional_ImagePickerAssetType_(const ImagePickerAssetType& value) noexcept {
    return std::optional<ImagePickerAssetType>(value);
  }
  inline bool has_value_std__optional_ImagePickerAssetType_(const std::optional<ImagePickerAssetType>& optional) noexcept {
    return optional.has_value();
  }
  inline ImagePickerAssetType get_std__optional_ImagePickerAssetType_(const std::optional<ImagePickerAssetType>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<ImagePickerAsset>
  /**
   * Specialized version of `std::vector<ImagePickerAsset>`.
   */
  using std__vector_ImagePickerAsset_ = std::vector<ImagePickerAsset>;
  inline std::vector<ImagePickerAsset> create_std__vector_ImagePickerAsset_(size_t size) noexcept {
    std::vector<ImagePickerAsset> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<std::vector<ImagePickerAsset>>
  /**
   * Specialized version of `std::optional<std::vector<ImagePickerAsset>>`.
   */
  using std__optional_std__vector_ImagePickerAsset__ = std::optional<std::vector<ImagePickerAsset>>;
  inline std::optional<std::vector<ImagePickerAsset>> create_std__optional_std__vector_ImagePickerAsset__(const std::vector<ImagePickerAsset>& value) noexcept {
    return std::optional<std::vector<ImagePickerAsset>>(value);
  }
  inline bool has_value_std__optional_std__vector_ImagePickerAsset__(const std::optional<std::vector<ImagePickerAsset>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::vector<ImagePickerAsset> get_std__optional_std__vector_ImagePickerAsset__(const std::optional<std::vector<ImagePickerAsset>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<ImagePickerNativeResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<ImagePickerNativeResult>>`.
   */
  using std__shared_ptr_Promise_ImagePickerNativeResult__ = std::shared_ptr<Promise<ImagePickerNativeResult>>;
  inline std::shared_ptr<Promise<ImagePickerNativeResult>> create_std__shared_ptr_Promise_ImagePickerNativeResult__() noexcept {
    return Promise<ImagePickerNativeResult>::create();
  }
  inline PromiseHolder<ImagePickerNativeResult> wrap_std__shared_ptr_Promise_ImagePickerNativeResult__(std::shared_ptr<Promise<ImagePickerNativeResult>> promise) noexcept {
    return PromiseHolder<ImagePickerNativeResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const ImagePickerNativeResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const ImagePickerNativeResult&)>`.
   */
  using Func_void_ImagePickerNativeResult = std::function<void(const ImagePickerNativeResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const ImagePickerNativeResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_ImagePickerNativeResult_Wrapper final {
  public:
    explicit Func_void_ImagePickerNativeResult_Wrapper(std::function<void(const ImagePickerNativeResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const ImagePickerNativeResult& /* result */)>>(std::move(func))) {}
    inline void call(ImagePickerNativeResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const ImagePickerNativeResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_ImagePickerNativeResult create_Func_void_ImagePickerNativeResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_ImagePickerNativeResult_Wrapper wrap_Func_void_ImagePickerNativeResult(Func_void_ImagePickerNativeResult value) noexcept {
    return Func_void_ImagePickerNativeResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<ImagePickerMediaType>
  /**
   * Specialized version of `std::vector<ImagePickerMediaType>`.
   */
  using std__vector_ImagePickerMediaType_ = std::vector<ImagePickerMediaType>;
  inline std::vector<ImagePickerMediaType> create_std__vector_ImagePickerMediaType_(size_t size) noexcept {
    std::vector<ImagePickerMediaType> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<ImagePickerCropAspect>
  /**
   * Specialized version of `std::optional<ImagePickerCropAspect>`.
   */
  using std__optional_ImagePickerCropAspect_ = std::optional<ImagePickerCropAspect>;
  inline std::optional<ImagePickerCropAspect> create_std__optional_ImagePickerCropAspect_(const ImagePickerCropAspect& value) noexcept {
    return std::optional<ImagePickerCropAspect>(value);
  }
  inline bool has_value_std__optional_ImagePickerCropAspect_(const std::optional<ImagePickerCropAspect>& optional) noexcept {
    return optional.has_value();
  }
  inline ImagePickerCropAspect get_std__optional_ImagePickerCropAspect_(const std::optional<ImagePickerCropAspect>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<CameraPermissionResponse>>
  /**
   * Specialized version of `std::shared_ptr<Promise<CameraPermissionResponse>>`.
   */
  using std__shared_ptr_Promise_CameraPermissionResponse__ = std::shared_ptr<Promise<CameraPermissionResponse>>;
  inline std::shared_ptr<Promise<CameraPermissionResponse>> create_std__shared_ptr_Promise_CameraPermissionResponse__() noexcept {
    return Promise<CameraPermissionResponse>::create();
  }
  inline PromiseHolder<CameraPermissionResponse> wrap_std__shared_ptr_Promise_CameraPermissionResponse__(std::shared_ptr<Promise<CameraPermissionResponse>> promise) noexcept {
    return PromiseHolder<CameraPermissionResponse>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const CameraPermissionResponse& /* result */)>
  /**
   * Specialized version of `std::function<void(const CameraPermissionResponse&)>`.
   */
  using Func_void_CameraPermissionResponse = std::function<void(const CameraPermissionResponse& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const CameraPermissionResponse& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_CameraPermissionResponse_Wrapper final {
  public:
    explicit Func_void_CameraPermissionResponse_Wrapper(std::function<void(const CameraPermissionResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const CameraPermissionResponse& /* result */)>>(std::move(func))) {}
    inline void call(CameraPermissionResponse result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const CameraPermissionResponse& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_CameraPermissionResponse create_Func_void_CameraPermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_CameraPermissionResponse_Wrapper wrap_Func_void_CameraPermissionResponse(Func_void_CameraPermissionResponse value) noexcept {
    return Func_void_CameraPermissionResponse_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneImagePickerSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneImagePickerSpec>`.
   */
  using std__shared_ptr_HybridOneImagePickerSpec_ = std::shared_ptr<HybridOneImagePickerSpec>;
  std::shared_ptr<HybridOneImagePickerSpec> create_std__shared_ptr_HybridOneImagePickerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneImagePickerSpec_(std__shared_ptr_HybridOneImagePickerSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneImagePickerSpec>
  using std__weak_ptr_HybridOneImagePickerSpec_ = std::weak_ptr<HybridOneImagePickerSpec>;
  inline std__weak_ptr_HybridOneImagePickerSpec_ weakify_std__shared_ptr_HybridOneImagePickerSpec_(const std::shared_ptr<HybridOneImagePickerSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<ImagePickerNativeResult>>>
  using Result_std__shared_ptr_Promise_ImagePickerNativeResult___ = Result<std::shared_ptr<Promise<ImagePickerNativeResult>>>;
  inline Result_std__shared_ptr_Promise_ImagePickerNativeResult___ create_Result_std__shared_ptr_Promise_ImagePickerNativeResult___(const std::shared_ptr<Promise<ImagePickerNativeResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<ImagePickerNativeResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_ImagePickerNativeResult___ create_Result_std__shared_ptr_Promise_ImagePickerNativeResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<ImagePickerNativeResult>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<CameraPermissionResponse>>>
  using Result_std__shared_ptr_Promise_CameraPermissionResponse___ = Result<std::shared_ptr<Promise<CameraPermissionResponse>>>;
  inline Result_std__shared_ptr_Promise_CameraPermissionResponse___ create_Result_std__shared_ptr_Promise_CameraPermissionResponse___(const std::shared_ptr<Promise<CameraPermissionResponse>>& value) noexcept {
    return Result<std::shared_ptr<Promise<CameraPermissionResponse>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_CameraPermissionResponse___ create_Result_std__shared_ptr_Promise_CameraPermissionResponse___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<CameraPermissionResponse>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridOneKeepAwakeSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneKeepAwakeSpec>`.
   */
  using std__shared_ptr_HybridOneKeepAwakeSpec_ = std::shared_ptr<HybridOneKeepAwakeSpec>;
  std::shared_ptr<HybridOneKeepAwakeSpec> create_std__shared_ptr_HybridOneKeepAwakeSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneKeepAwakeSpec_(std__shared_ptr_HybridOneKeepAwakeSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneKeepAwakeSpec>
  using std__weak_ptr_HybridOneKeepAwakeSpec_ = std::weak_ptr<HybridOneKeepAwakeSpec>;
  inline std__weak_ptr_HybridOneKeepAwakeSpec_ weakify_std__shared_ptr_HybridOneKeepAwakeSpec_(const std::shared_ptr<HybridOneKeepAwakeSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<HybridOneLaunchScreenSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneLaunchScreenSpec>`.
   */
  using std__shared_ptr_HybridOneLaunchScreenSpec_ = std::shared_ptr<HybridOneLaunchScreenSpec>;
  std::shared_ptr<HybridOneLaunchScreenSpec> create_std__shared_ptr_HybridOneLaunchScreenSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneLaunchScreenSpec_(std__shared_ptr_HybridOneLaunchScreenSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneLaunchScreenSpec>
  using std__weak_ptr_HybridOneLaunchScreenSpec_ = std::weak_ptr<HybridOneLaunchScreenSpec>;
  inline std__weak_ptr_HybridOneLaunchScreenSpec_ weakify_std__shared_ptr_HybridOneLaunchScreenSpec_(const std::shared_ptr<HybridOneLaunchScreenSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::function<void(const LightSensorMeasurement& /* event */)>
  /**
   * Specialized version of `std::function<void(const LightSensorMeasurement&)>`.
   */
  using Func_void_LightSensorMeasurement = std::function<void(const LightSensorMeasurement& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const LightSensorMeasurement& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_LightSensorMeasurement_Wrapper final {
  public:
    explicit Func_void_LightSensorMeasurement_Wrapper(std::function<void(const LightSensorMeasurement& /* event */)>&& func): _function(std::make_unique<std::function<void(const LightSensorMeasurement& /* event */)>>(std::move(func))) {}
    inline void call(LightSensorMeasurement event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const LightSensorMeasurement& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_LightSensorMeasurement create_Func_void_LightSensorMeasurement(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_LightSensorMeasurement_Wrapper wrap_Func_void_LightSensorMeasurement(Func_void_LightSensorMeasurement value) noexcept {
    return Func_void_LightSensorMeasurement_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneLightSensorSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneLightSensorSpec>`.
   */
  using std__shared_ptr_HybridOneLightSensorSpec_ = std::shared_ptr<HybridOneLightSensorSpec>;
  std::shared_ptr<HybridOneLightSensorSpec> create_std__shared_ptr_HybridOneLightSensorSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneLightSensorSpec_(std__shared_ptr_HybridOneLightSensorSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneLightSensorSpec>
  using std__weak_ptr_HybridOneLightSensorSpec_ = std::weak_ptr<HybridOneLightSensorSpec>;
  inline std__weak_ptr_HybridOneLightSensorSpec_ weakify_std__shared_ptr_HybridOneLightSensorSpec_(const std::shared_ptr<HybridOneLightSensorSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<HybridOneLocalAuthenticationSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneLocalAuthenticationSpec>`.
   */
  using std__shared_ptr_HybridOneLocalAuthenticationSpec_ = std::shared_ptr<HybridOneLocalAuthenticationSpec>;
  std::shared_ptr<HybridOneLocalAuthenticationSpec> create_std__shared_ptr_HybridOneLocalAuthenticationSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneLocalAuthenticationSpec_(std__shared_ptr_HybridOneLocalAuthenticationSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneLocalAuthenticationSpec>
  using std__weak_ptr_HybridOneLocalAuthenticationSpec_ = std::weak_ptr<HybridOneLocalAuthenticationSpec>;
  inline std__weak_ptr_HybridOneLocalAuthenticationSpec_ weakify_std__shared_ptr_HybridOneLocalAuthenticationSpec_(const std::shared_ptr<HybridOneLocalAuthenticationSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<LocalAuthenticationStatus>
  using Result_LocalAuthenticationStatus_ = Result<LocalAuthenticationStatus>;
  inline Result_LocalAuthenticationStatus_ create_Result_LocalAuthenticationStatus_(const LocalAuthenticationStatus& value) noexcept {
    return Result<LocalAuthenticationStatus>::withValue(value);
  }
  inline Result_LocalAuthenticationStatus_ create_Result_LocalAuthenticationStatus_(const std::exception_ptr& error) noexcept {
    return Result<LocalAuthenticationStatus>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<LocationPermissionStatus>>
  /**
   * Specialized version of `std::shared_ptr<Promise<LocationPermissionStatus>>`.
   */
  using std__shared_ptr_Promise_LocationPermissionStatus__ = std::shared_ptr<Promise<LocationPermissionStatus>>;
  inline std::shared_ptr<Promise<LocationPermissionStatus>> create_std__shared_ptr_Promise_LocationPermissionStatus__() noexcept {
    return Promise<LocationPermissionStatus>::create();
  }
  inline PromiseHolder<LocationPermissionStatus> wrap_std__shared_ptr_Promise_LocationPermissionStatus__(std::shared_ptr<Promise<LocationPermissionStatus>> promise) noexcept {
    return PromiseHolder<LocationPermissionStatus>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(LocationPermissionStatus /* result */)>
  /**
   * Specialized version of `std::function<void(LocationPermissionStatus)>`.
   */
  using Func_void_LocationPermissionStatus = std::function<void(LocationPermissionStatus /* result */)>;
  /**
   * Wrapper class for a `std::function<void(LocationPermissionStatus / * result * /)>`, this can be used from Swift.
   */
  class Func_void_LocationPermissionStatus_Wrapper final {
  public:
    explicit Func_void_LocationPermissionStatus_Wrapper(std::function<void(LocationPermissionStatus /* result */)>&& func): _function(std::make_unique<std::function<void(LocationPermissionStatus /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<LocationPermissionStatus>(result));
    }
  private:
    std::unique_ptr<std::function<void(LocationPermissionStatus /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_LocationPermissionStatus create_Func_void_LocationPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_LocationPermissionStatus_Wrapper wrap_Func_void_LocationPermissionStatus(Func_void_LocationPermissionStatus value) noexcept {
    return Func_void_LocationPermissionStatus_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<LocationPosition>>
  /**
   * Specialized version of `std::shared_ptr<Promise<LocationPosition>>`.
   */
  using std__shared_ptr_Promise_LocationPosition__ = std::shared_ptr<Promise<LocationPosition>>;
  inline std::shared_ptr<Promise<LocationPosition>> create_std__shared_ptr_Promise_LocationPosition__() noexcept {
    return Promise<LocationPosition>::create();
  }
  inline PromiseHolder<LocationPosition> wrap_std__shared_ptr_Promise_LocationPosition__(std::shared_ptr<Promise<LocationPosition>> promise) noexcept {
    return PromiseHolder<LocationPosition>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const LocationPosition& /* result */)>
  /**
   * Specialized version of `std::function<void(const LocationPosition&)>`.
   */
  using Func_void_LocationPosition = std::function<void(const LocationPosition& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const LocationPosition& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_LocationPosition_Wrapper final {
  public:
    explicit Func_void_LocationPosition_Wrapper(std::function<void(const LocationPosition& /* result */)>&& func): _function(std::make_unique<std::function<void(const LocationPosition& /* result */)>>(std::move(func))) {}
    inline void call(LocationPosition result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const LocationPosition& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_LocationPosition create_Func_void_LocationPosition(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_LocationPosition_Wrapper wrap_Func_void_LocationPosition(Func_void_LocationPosition value) noexcept {
    return Func_void_LocationPosition_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const std::string& /* code */, const std::string& /* message */)>
  /**
   * Specialized version of `std::function<void(const std::string&, const std::string&)>`.
   */
  using Func_void_std__string_std__string = std::function<void(const std::string& /* code */, const std::string& /* message */)>;
  /**
   * Wrapper class for a `std::function<void(const std::string& / * code * /, const std::string& / * message * /)>`, this can be used from Swift.
   */
  class Func_void_std__string_std__string_Wrapper final {
  public:
    explicit Func_void_std__string_std__string_Wrapper(std::function<void(const std::string& /* code */, const std::string& /* message */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* code */, const std::string& /* message */)>>(std::move(func))) {}
    inline void call(std::string code, std::string message) const noexcept {
      _function->operator()(code, message);
    }
  private:
    std::unique_ptr<std::function<void(const std::string& /* code */, const std::string& /* message */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__string_std__string create_Func_void_std__string_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__string_std__string_Wrapper wrap_Func_void_std__string_std__string(Func_void_std__string_std__string value) noexcept {
    return Func_void_std__string_std__string_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<LocationPlace>
  /**
   * Specialized version of `std::vector<LocationPlace>`.
   */
  using std__vector_LocationPlace_ = std::vector<LocationPlace>;
  inline std::vector<LocationPlace> create_std__vector_LocationPlace_(size_t size) noexcept {
    std::vector<LocationPlace> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<LocationPlace>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<LocationPlace>>>`.
   */
  using std__shared_ptr_Promise_std__vector_LocationPlace___ = std::shared_ptr<Promise<std::vector<LocationPlace>>>;
  inline std::shared_ptr<Promise<std::vector<LocationPlace>>> create_std__shared_ptr_Promise_std__vector_LocationPlace___() noexcept {
    return Promise<std::vector<LocationPlace>>::create();
  }
  inline PromiseHolder<std::vector<LocationPlace>> wrap_std__shared_ptr_Promise_std__vector_LocationPlace___(std::shared_ptr<Promise<std::vector<LocationPlace>>> promise) noexcept {
    return PromiseHolder<std::vector<LocationPlace>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<LocationPlace>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<LocationPlace>&)>`.
   */
  using Func_void_std__vector_LocationPlace_ = std::function<void(const std::vector<LocationPlace>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<LocationPlace>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_LocationPlace__Wrapper final {
  public:
    explicit Func_void_std__vector_LocationPlace__Wrapper(std::function<void(const std::vector<LocationPlace>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<LocationPlace>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<LocationPlace> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<LocationPlace>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_LocationPlace_ create_Func_void_std__vector_LocationPlace_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_LocationPlace__Wrapper wrap_Func_void_std__vector_LocationPlace_(Func_void_std__vector_LocationPlace_ value) noexcept {
    return Func_void_std__vector_LocationPlace__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<RegionState>
  /**
   * Specialized version of `std::optional<RegionState>`.
   */
  using std__optional_RegionState_ = std::optional<RegionState>;
  inline std::optional<RegionState> create_std__optional_RegionState_(const RegionState& value) noexcept {
    return std::optional<RegionState>(value);
  }
  inline bool has_value_std__optional_RegionState_(const std::optional<RegionState>& optional) noexcept {
    return optional.has_value();
  }
  inline RegionState get_std__optional_RegionState_(const std::optional<RegionState>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<LocationRegion>
  /**
   * Specialized version of `std::vector<LocationRegion>`.
   */
  using std__vector_LocationRegion_ = std::vector<LocationRegion>;
  inline std::vector<LocationRegion> create_std__vector_LocationRegion_(size_t size) noexcept {
    std::vector<LocationRegion> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<RegionState>>
  /**
   * Specialized version of `std::shared_ptr<Promise<RegionState>>`.
   */
  using std__shared_ptr_Promise_RegionState__ = std::shared_ptr<Promise<RegionState>>;
  inline std::shared_ptr<Promise<RegionState>> create_std__shared_ptr_Promise_RegionState__() noexcept {
    return Promise<RegionState>::create();
  }
  inline PromiseHolder<RegionState> wrap_std__shared_ptr_Promise_RegionState__(std::shared_ptr<Promise<RegionState>> promise) noexcept {
    return PromiseHolder<RegionState>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(RegionState /* result */)>
  /**
   * Specialized version of `std::function<void(RegionState)>`.
   */
  using Func_void_RegionState = std::function<void(RegionState /* result */)>;
  /**
   * Wrapper class for a `std::function<void(RegionState / * result * /)>`, this can be used from Swift.
   */
  class Func_void_RegionState_Wrapper final {
  public:
    explicit Func_void_RegionState_Wrapper(std::function<void(RegionState /* result */)>&& func): _function(std::make_unique<std::function<void(RegionState /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<RegionState>(result));
    }
  private:
    std::unique_ptr<std::function<void(RegionState /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_RegionState create_Func_void_RegionState(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_RegionState_Wrapper wrap_Func_void_RegionState(Func_void_RegionState value) noexcept {
    return Func_void_RegionState_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const LocationRegion& /* region */)>
  /**
   * Specialized version of `std::function<void(const LocationRegion&)>`.
   */
  using Func_void_LocationRegion = std::function<void(const LocationRegion& /* region */)>;
  /**
   * Wrapper class for a `std::function<void(const LocationRegion& / * region * /)>`, this can be used from Swift.
   */
  class Func_void_LocationRegion_Wrapper final {
  public:
    explicit Func_void_LocationRegion_Wrapper(std::function<void(const LocationRegion& /* region */)>&& func): _function(std::make_unique<std::function<void(const LocationRegion& /* region */)>>(std::move(func))) {}
    inline void call(LocationRegion region) const noexcept {
      _function->operator()(region);
    }
  private:
    std::unique_ptr<std::function<void(const LocationRegion& /* region */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_LocationRegion create_Func_void_LocationRegion(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_LocationRegion_Wrapper wrap_Func_void_LocationRegion(Func_void_LocationRegion value) noexcept {
    return Func_void_LocationRegion_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneLocationSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneLocationSpec>`.
   */
  using std__shared_ptr_HybridOneLocationSpec_ = std::shared_ptr<HybridOneLocationSpec>;
  std::shared_ptr<HybridOneLocationSpec> create_std__shared_ptr_HybridOneLocationSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneLocationSpec_(std__shared_ptr_HybridOneLocationSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneLocationSpec>
  using std__weak_ptr_HybridOneLocationSpec_ = std::weak_ptr<HybridOneLocationSpec>;
  inline std__weak_ptr_HybridOneLocationSpec_ weakify_std__shared_ptr_HybridOneLocationSpec_(const std::shared_ptr<HybridOneLocationSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<LocationPermissionStatus>
  using Result_LocationPermissionStatus_ = Result<LocationPermissionStatus>;
  inline Result_LocationPermissionStatus_ create_Result_LocationPermissionStatus_(LocationPermissionStatus value) noexcept {
    return Result<LocationPermissionStatus>::withValue(std::move(value));
  }
  inline Result_LocationPermissionStatus_ create_Result_LocationPermissionStatus_(const std::exception_ptr& error) noexcept {
    return Result<LocationPermissionStatus>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<LocationPermissionStatus>>>
  using Result_std__shared_ptr_Promise_LocationPermissionStatus___ = Result<std::shared_ptr<Promise<LocationPermissionStatus>>>;
  inline Result_std__shared_ptr_Promise_LocationPermissionStatus___ create_Result_std__shared_ptr_Promise_LocationPermissionStatus___(const std::shared_ptr<Promise<LocationPermissionStatus>>& value) noexcept {
    return Result<std::shared_ptr<Promise<LocationPermissionStatus>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_LocationPermissionStatus___ create_Result_std__shared_ptr_Promise_LocationPermissionStatus___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<LocationPermissionStatus>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<LocationPosition>>>
  using Result_std__shared_ptr_Promise_LocationPosition___ = Result<std::shared_ptr<Promise<LocationPosition>>>;
  inline Result_std__shared_ptr_Promise_LocationPosition___ create_Result_std__shared_ptr_Promise_LocationPosition___(const std::shared_ptr<Promise<LocationPosition>>& value) noexcept {
    return Result<std::shared_ptr<Promise<LocationPosition>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_LocationPosition___ create_Result_std__shared_ptr_Promise_LocationPosition___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<LocationPosition>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<LocationPlace>>>>
  using Result_std__shared_ptr_Promise_std__vector_LocationPlace____ = Result<std::shared_ptr<Promise<std::vector<LocationPlace>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_LocationPlace____ create_Result_std__shared_ptr_Promise_std__vector_LocationPlace____(const std::shared_ptr<Promise<std::vector<LocationPlace>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<LocationPlace>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_LocationPlace____ create_Result_std__shared_ptr_Promise_std__vector_LocationPlace____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<LocationPlace>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::vector<LocationRegion>>
  using Result_std__vector_LocationRegion__ = Result<std::vector<LocationRegion>>;
  inline Result_std__vector_LocationRegion__ create_Result_std__vector_LocationRegion__(const std::vector<LocationRegion>& value) noexcept {
    return Result<std::vector<LocationRegion>>::withValue(value);
  }
  inline Result_std__vector_LocationRegion__ create_Result_std__vector_LocationRegion__(const std::exception_ptr& error) noexcept {
    return Result<std::vector<LocationRegion>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<RegionState>>>
  using Result_std__shared_ptr_Promise_RegionState___ = Result<std::shared_ptr<Promise<RegionState>>>;
  inline Result_std__shared_ptr_Promise_RegionState___ create_Result_std__shared_ptr_Promise_RegionState___(const std::shared_ptr<Promise<RegionState>>& value) noexcept {
    return Result<std::shared_ptr<Promise<RegionState>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_RegionState___ create_Result_std__shared_ptr_Promise_RegionState___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<RegionState>>>::withError(error);
  }
  
  // pragma MARK: std::vector<MapPlace>
  /**
   * Specialized version of `std::vector<MapPlace>`.
   */
  using std__vector_MapPlace_ = std::vector<MapPlace>;
  inline std::vector<MapPlace> create_std__vector_MapPlace_(size_t size) noexcept {
    std::vector<MapPlace> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<MapPlace>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<MapPlace>>>`.
   */
  using std__shared_ptr_Promise_std__vector_MapPlace___ = std::shared_ptr<Promise<std::vector<MapPlace>>>;
  inline std::shared_ptr<Promise<std::vector<MapPlace>>> create_std__shared_ptr_Promise_std__vector_MapPlace___() noexcept {
    return Promise<std::vector<MapPlace>>::create();
  }
  inline PromiseHolder<std::vector<MapPlace>> wrap_std__shared_ptr_Promise_std__vector_MapPlace___(std::shared_ptr<Promise<std::vector<MapPlace>>> promise) noexcept {
    return PromiseHolder<std::vector<MapPlace>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<MapPlace>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<MapPlace>&)>`.
   */
  using Func_void_std__vector_MapPlace_ = std::function<void(const std::vector<MapPlace>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<MapPlace>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_MapPlace__Wrapper final {
  public:
    explicit Func_void_std__vector_MapPlace__Wrapper(std::function<void(const std::vector<MapPlace>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<MapPlace>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<MapPlace> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<MapPlace>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_MapPlace_ create_Func_void_std__vector_MapPlace_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_MapPlace__Wrapper wrap_Func_void_std__vector_MapPlace_(Func_void_std__vector_MapPlace_ value) noexcept {
    return Func_void_std__vector_MapPlace__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<MapSuggestion>
  /**
   * Specialized version of `std::vector<MapSuggestion>`.
   */
  using std__vector_MapSuggestion_ = std::vector<MapSuggestion>;
  inline std::vector<MapSuggestion> create_std__vector_MapSuggestion_(size_t size) noexcept {
    std::vector<MapSuggestion> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<MapSuggestion>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<MapSuggestion>>>`.
   */
  using std__shared_ptr_Promise_std__vector_MapSuggestion___ = std::shared_ptr<Promise<std::vector<MapSuggestion>>>;
  inline std::shared_ptr<Promise<std::vector<MapSuggestion>>> create_std__shared_ptr_Promise_std__vector_MapSuggestion___() noexcept {
    return Promise<std::vector<MapSuggestion>>::create();
  }
  inline PromiseHolder<std::vector<MapSuggestion>> wrap_std__shared_ptr_Promise_std__vector_MapSuggestion___(std::shared_ptr<Promise<std::vector<MapSuggestion>>> promise) noexcept {
    return PromiseHolder<std::vector<MapSuggestion>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<MapSuggestion>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<MapSuggestion>&)>`.
   */
  using Func_void_std__vector_MapSuggestion_ = std::function<void(const std::vector<MapSuggestion>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<MapSuggestion>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_MapSuggestion__Wrapper final {
  public:
    explicit Func_void_std__vector_MapSuggestion__Wrapper(std::function<void(const std::vector<MapSuggestion>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<MapSuggestion>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<MapSuggestion> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<MapSuggestion>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_MapSuggestion_ create_Func_void_std__vector_MapSuggestion_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_MapSuggestion__Wrapper wrap_Func_void_std__vector_MapSuggestion_(Func_void_std__vector_MapSuggestion_ value) noexcept {
    return Func_void_std__vector_MapSuggestion__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<MapPlace>>
  /**
   * Specialized version of `std::shared_ptr<Promise<MapPlace>>`.
   */
  using std__shared_ptr_Promise_MapPlace__ = std::shared_ptr<Promise<MapPlace>>;
  inline std::shared_ptr<Promise<MapPlace>> create_std__shared_ptr_Promise_MapPlace__() noexcept {
    return Promise<MapPlace>::create();
  }
  inline PromiseHolder<MapPlace> wrap_std__shared_ptr_Promise_MapPlace__(std::shared_ptr<Promise<MapPlace>> promise) noexcept {
    return PromiseHolder<MapPlace>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const MapPlace& /* result */)>
  /**
   * Specialized version of `std::function<void(const MapPlace&)>`.
   */
  using Func_void_MapPlace = std::function<void(const MapPlace& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const MapPlace& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_MapPlace_Wrapper final {
  public:
    explicit Func_void_MapPlace_Wrapper(std::function<void(const MapPlace& /* result */)>&& func): _function(std::make_unique<std::function<void(const MapPlace& /* result */)>>(std::move(func))) {}
    inline void call(MapPlace result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const MapPlace& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_MapPlace create_Func_void_MapPlace(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_MapPlace_Wrapper wrap_Func_void_MapPlace(Func_void_MapPlace value) noexcept {
    return Func_void_MapPlace_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<MapCoordinate>
  /**
   * Specialized version of `std::vector<MapCoordinate>`.
   */
  using std__vector_MapCoordinate_ = std::vector<MapCoordinate>;
  inline std::vector<MapCoordinate> create_std__vector_MapCoordinate_(size_t size) noexcept {
    std::vector<MapCoordinate> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::vector<MapRouteStep>
  /**
   * Specialized version of `std::vector<MapRouteStep>`.
   */
  using std__vector_MapRouteStep_ = std::vector<MapRouteStep>;
  inline std::vector<MapRouteStep> create_std__vector_MapRouteStep_(size_t size) noexcept {
    std::vector<MapRouteStep> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<MapRoute>>
  /**
   * Specialized version of `std::shared_ptr<Promise<MapRoute>>`.
   */
  using std__shared_ptr_Promise_MapRoute__ = std::shared_ptr<Promise<MapRoute>>;
  inline std::shared_ptr<Promise<MapRoute>> create_std__shared_ptr_Promise_MapRoute__() noexcept {
    return Promise<MapRoute>::create();
  }
  inline PromiseHolder<MapRoute> wrap_std__shared_ptr_Promise_MapRoute__(std::shared_ptr<Promise<MapRoute>> promise) noexcept {
    return PromiseHolder<MapRoute>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const MapRoute& /* result */)>
  /**
   * Specialized version of `std::function<void(const MapRoute&)>`.
   */
  using Func_void_MapRoute = std::function<void(const MapRoute& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const MapRoute& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_MapRoute_Wrapper final {
  public:
    explicit Func_void_MapRoute_Wrapper(std::function<void(const MapRoute& /* result */)>&& func): _function(std::make_unique<std::function<void(const MapRoute& /* result */)>>(std::move(func))) {}
    inline void call(MapRoute result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const MapRoute& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_MapRoute create_Func_void_MapRoute(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_MapRoute_Wrapper wrap_Func_void_MapRoute(Func_void_MapRoute value) noexcept {
    return Func_void_MapRoute_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneMapServicesSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneMapServicesSpec>`.
   */
  using std__shared_ptr_HybridOneMapServicesSpec_ = std::shared_ptr<HybridOneMapServicesSpec>;
  std::shared_ptr<HybridOneMapServicesSpec> create_std__shared_ptr_HybridOneMapServicesSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneMapServicesSpec_(std__shared_ptr_HybridOneMapServicesSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneMapServicesSpec>
  using std__weak_ptr_HybridOneMapServicesSpec_ = std::weak_ptr<HybridOneMapServicesSpec>;
  inline std__weak_ptr_HybridOneMapServicesSpec_ weakify_std__shared_ptr_HybridOneMapServicesSpec_(const std::shared_ptr<HybridOneMapServicesSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<MapPlace>>>>
  using Result_std__shared_ptr_Promise_std__vector_MapPlace____ = Result<std::shared_ptr<Promise<std::vector<MapPlace>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_MapPlace____ create_Result_std__shared_ptr_Promise_std__vector_MapPlace____(const std::shared_ptr<Promise<std::vector<MapPlace>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<MapPlace>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_MapPlace____ create_Result_std__shared_ptr_Promise_std__vector_MapPlace____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<MapPlace>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<MapSuggestion>>>>
  using Result_std__shared_ptr_Promise_std__vector_MapSuggestion____ = Result<std::shared_ptr<Promise<std::vector<MapSuggestion>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_MapSuggestion____ create_Result_std__shared_ptr_Promise_std__vector_MapSuggestion____(const std::shared_ptr<Promise<std::vector<MapSuggestion>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<MapSuggestion>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_MapSuggestion____ create_Result_std__shared_ptr_Promise_std__vector_MapSuggestion____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<MapSuggestion>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<MapPlace>>>
  using Result_std__shared_ptr_Promise_MapPlace___ = Result<std::shared_ptr<Promise<MapPlace>>>;
  inline Result_std__shared_ptr_Promise_MapPlace___ create_Result_std__shared_ptr_Promise_MapPlace___(const std::shared_ptr<Promise<MapPlace>>& value) noexcept {
    return Result<std::shared_ptr<Promise<MapPlace>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_MapPlace___ create_Result_std__shared_ptr_Promise_MapPlace___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<MapPlace>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<MapRoute>>>
  using Result_std__shared_ptr_Promise_MapRoute___ = Result<std::shared_ptr<Promise<MapRoute>>>;
  inline Result_std__shared_ptr_Promise_MapRoute___ create_Result_std__shared_ptr_Promise_MapRoute___(const std::shared_ptr<Promise<MapRoute>>& value) noexcept {
    return Result<std::shared_ptr<Promise<MapRoute>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_MapRoute___ create_Result_std__shared_ptr_Promise_MapRoute___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<MapRoute>>>::withError(error);
  }
  
  // pragma MARK: std::optional<DocumentCameraError>
  /**
   * Specialized version of `std::optional<DocumentCameraError>`.
   */
  using std__optional_DocumentCameraError_ = std::optional<DocumentCameraError>;
  inline std::optional<DocumentCameraError> create_std__optional_DocumentCameraError_(const DocumentCameraError& value) noexcept {
    return std::optional<DocumentCameraError>(value);
  }
  inline bool has_value_std__optional_DocumentCameraError_(const std::optional<DocumentCameraError>& optional) noexcept {
    return optional.has_value();
  }
  inline DocumentCameraError get_std__optional_DocumentCameraError_(const std::optional<DocumentCameraError>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::function<void(MailComposeResult /* result */, const std::optional<DocumentCameraError>& /* error */)>
  /**
   * Specialized version of `std::function<void(MailComposeResult, const std::optional<DocumentCameraError>&)>`.
   */
  using Func_void_MailComposeResult_std__optional_DocumentCameraError_ = std::function<void(MailComposeResult /* result */, const std::optional<DocumentCameraError>& /* error */)>;
  /**
   * Wrapper class for a `std::function<void(MailComposeResult / * result * /, const std::optional<DocumentCameraError>& / * error * /)>`, this can be used from Swift.
   */
  class Func_void_MailComposeResult_std__optional_DocumentCameraError__Wrapper final {
  public:
    explicit Func_void_MailComposeResult_std__optional_DocumentCameraError__Wrapper(std::function<void(MailComposeResult /* result */, const std::optional<DocumentCameraError>& /* error */)>&& func): _function(std::make_unique<std::function<void(MailComposeResult /* result */, const std::optional<DocumentCameraError>& /* error */)>>(std::move(func))) {}
    inline void call(int result, std::optional<DocumentCameraError> error) const noexcept {
      _function->operator()(static_cast<MailComposeResult>(result), error);
    }
  private:
    std::unique_ptr<std::function<void(MailComposeResult /* result */, const std::optional<DocumentCameraError>& /* error */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_MailComposeResult_std__optional_DocumentCameraError_ create_Func_void_MailComposeResult_std__optional_DocumentCameraError_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_MailComposeResult_std__optional_DocumentCameraError__Wrapper wrap_Func_void_MailComposeResult_std__optional_DocumentCameraError_(Func_void_MailComposeResult_std__optional_DocumentCameraError_ value) noexcept {
    return Func_void_MailComposeResult_std__optional_DocumentCameraError__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneMailComposeSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneMailComposeSpec>`.
   */
  using std__shared_ptr_HybridOneMailComposeSpec_ = std::shared_ptr<HybridOneMailComposeSpec>;
  std::shared_ptr<HybridOneMailComposeSpec> create_std__shared_ptr_HybridOneMailComposeSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneMailComposeSpec_(std__shared_ptr_HybridOneMailComposeSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneMailComposeSpec>
  using std__weak_ptr_HybridOneMailComposeSpec_ = std::weak_ptr<HybridOneMailComposeSpec>;
  inline std__weak_ptr_HybridOneMailComposeSpec_ weakify_std__shared_ptr_HybridOneMailComposeSpec_(const std::shared_ptr<HybridOneMailComposeSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::vector<MessageAttachment>
  /**
   * Specialized version of `std::vector<MessageAttachment>`.
   */
  using std__vector_MessageAttachment_ = std::vector<MessageAttachment>;
  inline std::vector<MessageAttachment> create_std__vector_MessageAttachment_(size_t size) noexcept {
    std::vector<MessageAttachment> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::function<void(MessageComposeResult /* result */)>
  /**
   * Specialized version of `std::function<void(MessageComposeResult)>`.
   */
  using Func_void_MessageComposeResult = std::function<void(MessageComposeResult /* result */)>;
  /**
   * Wrapper class for a `std::function<void(MessageComposeResult / * result * /)>`, this can be used from Swift.
   */
  class Func_void_MessageComposeResult_Wrapper final {
  public:
    explicit Func_void_MessageComposeResult_Wrapper(std::function<void(MessageComposeResult /* result */)>&& func): _function(std::make_unique<std::function<void(MessageComposeResult /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<MessageComposeResult>(result));
    }
  private:
    std::unique_ptr<std::function<void(MessageComposeResult /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_MessageComposeResult create_Func_void_MessageComposeResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_MessageComposeResult_Wrapper wrap_Func_void_MessageComposeResult(Func_void_MessageComposeResult value) noexcept {
    return Func_void_MessageComposeResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneMessageComposeSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneMessageComposeSpec>`.
   */
  using std__shared_ptr_HybridOneMessageComposeSpec_ = std::shared_ptr<HybridOneMessageComposeSpec>;
  std::shared_ptr<HybridOneMessageComposeSpec> create_std__shared_ptr_HybridOneMessageComposeSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneMessageComposeSpec_(std__shared_ptr_HybridOneMessageComposeSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneMessageComposeSpec>
  using std__weak_ptr_HybridOneMessageComposeSpec_ = std::weak_ptr<HybridOneMessageComposeSpec>;
  inline std__weak_ptr_HybridOneMessageComposeSpec_ weakify_std__shared_ptr_HybridOneMessageComposeSpec_(const std::shared_ptr<HybridOneMessageComposeSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::optional<MotionVector>
  /**
   * Specialized version of `std::optional<MotionVector>`.
   */
  using std__optional_MotionVector_ = std::optional<MotionVector>;
  inline std::optional<MotionVector> create_std__optional_MotionVector_(const MotionVector& value) noexcept {
    return std::optional<MotionVector>(value);
  }
  inline bool has_value_std__optional_MotionVector_(const std::optional<MotionVector>& optional) noexcept {
    return optional.has_value();
  }
  inline MotionVector get_std__optional_MotionVector_(const std::optional<MotionVector>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::function<void(const MotionReading& /* reading */)>
  /**
   * Specialized version of `std::function<void(const MotionReading&)>`.
   */
  using Func_void_MotionReading = std::function<void(const MotionReading& /* reading */)>;
  /**
   * Wrapper class for a `std::function<void(const MotionReading& / * reading * /)>`, this can be used from Swift.
   */
  class Func_void_MotionReading_Wrapper final {
  public:
    explicit Func_void_MotionReading_Wrapper(std::function<void(const MotionReading& /* reading */)>&& func): _function(std::make_unique<std::function<void(const MotionReading& /* reading */)>>(std::move(func))) {}
    inline void call(MotionReading reading) const noexcept {
      _function->operator()(reading);
    }
  private:
    std::unique_ptr<std::function<void(const MotionReading& /* reading */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_MotionReading create_Func_void_MotionReading(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_MotionReading_Wrapper wrap_Func_void_MotionReading(Func_void_MotionReading value) noexcept {
    return Func_void_MotionReading_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneMotionSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneMotionSpec>`.
   */
  using std__shared_ptr_HybridOneMotionSpec_ = std::shared_ptr<HybridOneMotionSpec>;
  std::shared_ptr<HybridOneMotionSpec> create_std__shared_ptr_HybridOneMotionSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneMotionSpec_(std__shared_ptr_HybridOneMotionSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneMotionSpec>
  using std__weak_ptr_HybridOneMotionSpec_ = std::weak_ptr<HybridOneMotionSpec>;
  inline std__weak_ptr_HybridOneMotionSpec_ weakify_std__shared_ptr_HybridOneMotionSpec_(const std::shared_ptr<HybridOneMotionSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<MotionAvailability>
  using Result_MotionAvailability_ = Result<MotionAvailability>;
  inline Result_MotionAvailability_ create_Result_MotionAvailability_(const MotionAvailability& value) noexcept {
    return Result<MotionAvailability>::withValue(value);
  }
  inline Result_MotionAvailability_ create_Result_MotionAvailability_(const std::exception_ptr& error) noexcept {
    return Result<MotionAvailability>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridOneNativeModulesSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneNativeModulesSpec>`.
   */
  using std__shared_ptr_HybridOneNativeModulesSpec_ = std::shared_ptr<HybridOneNativeModulesSpec>;
  std::shared_ptr<HybridOneNativeModulesSpec> create_std__shared_ptr_HybridOneNativeModulesSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneNativeModulesSpec_(std__shared_ptr_HybridOneNativeModulesSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneNativeModulesSpec>
  using std__weak_ptr_HybridOneNativeModulesSpec_ = std::weak_ptr<HybridOneNativeModulesSpec>;
  inline std__weak_ptr_HybridOneNativeModulesSpec_ weakify_std__shared_ptr_HybridOneNativeModulesSpec_(const std::shared_ptr<HybridOneNativeModulesSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<Promise<NetworkState>>
  /**
   * Specialized version of `std::shared_ptr<Promise<NetworkState>>`.
   */
  using std__shared_ptr_Promise_NetworkState__ = std::shared_ptr<Promise<NetworkState>>;
  inline std::shared_ptr<Promise<NetworkState>> create_std__shared_ptr_Promise_NetworkState__() noexcept {
    return Promise<NetworkState>::create();
  }
  inline PromiseHolder<NetworkState> wrap_std__shared_ptr_Promise_NetworkState__(std::shared_ptr<Promise<NetworkState>> promise) noexcept {
    return PromiseHolder<NetworkState>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const NetworkState& /* result */)>
  /**
   * Specialized version of `std::function<void(const NetworkState&)>`.
   */
  using Func_void_NetworkState = std::function<void(const NetworkState& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const NetworkState& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_NetworkState_Wrapper final {
  public:
    explicit Func_void_NetworkState_Wrapper(std::function<void(const NetworkState& /* result */)>&& func): _function(std::make_unique<std::function<void(const NetworkState& /* result */)>>(std::move(func))) {}
    inline void call(NetworkState result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const NetworkState& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_NetworkState create_Func_void_NetworkState(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_NetworkState_Wrapper wrap_Func_void_NetworkState(Func_void_NetworkState value) noexcept {
    return Func_void_NetworkState_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneNetworkSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneNetworkSpec>`.
   */
  using std__shared_ptr_HybridOneNetworkSpec_ = std::shared_ptr<HybridOneNetworkSpec>;
  std::shared_ptr<HybridOneNetworkSpec> create_std__shared_ptr_HybridOneNetworkSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneNetworkSpec_(std__shared_ptr_HybridOneNetworkSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneNetworkSpec>
  using std__weak_ptr_HybridOneNetworkSpec_ = std::weak_ptr<HybridOneNetworkSpec>;
  inline std__weak_ptr_HybridOneNetworkSpec_ weakify_std__shared_ptr_HybridOneNetworkSpec_(const std::shared_ptr<HybridOneNetworkSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<NetworkState>>>
  using Result_std__shared_ptr_Promise_NetworkState___ = Result<std::shared_ptr<Promise<NetworkState>>>;
  inline Result_std__shared_ptr_Promise_NetworkState___ create_Result_std__shared_ptr_Promise_NetworkState___(const std::shared_ptr<Promise<NetworkState>>& value) noexcept {
    return Result<std::shared_ptr<Promise<NetworkState>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_NetworkState___ create_Result_std__shared_ptr_Promise_NetworkState___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<NetworkState>>>::withError(error);
  }
  
  // pragma MARK: std::optional<NativeIosPermission>
  /**
   * Specialized version of `std::optional<NativeIosPermission>`.
   */
  using std__optional_NativeIosPermission_ = std::optional<NativeIosPermission>;
  inline std::optional<NativeIosPermission> create_std__optional_NativeIosPermission_(const NativeIosPermission& value) noexcept {
    return std::optional<NativeIosPermission>(value);
  }
  inline bool has_value_std__optional_NativeIosPermission_(const std::optional<NativeIosPermission>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeIosPermission get_std__optional_NativeIosPermission_(const std::optional<NativeIosPermission>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<NativePermissionResponse>>
  /**
   * Specialized version of `std::shared_ptr<Promise<NativePermissionResponse>>`.
   */
  using std__shared_ptr_Promise_NativePermissionResponse__ = std::shared_ptr<Promise<NativePermissionResponse>>;
  inline std::shared_ptr<Promise<NativePermissionResponse>> create_std__shared_ptr_Promise_NativePermissionResponse__() noexcept {
    return Promise<NativePermissionResponse>::create();
  }
  inline PromiseHolder<NativePermissionResponse> wrap_std__shared_ptr_Promise_NativePermissionResponse__(std::shared_ptr<Promise<NativePermissionResponse>> promise) noexcept {
    return PromiseHolder<NativePermissionResponse>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const NativePermissionResponse& /* result */)>
  /**
   * Specialized version of `std::function<void(const NativePermissionResponse&)>`.
   */
  using Func_void_NativePermissionResponse = std::function<void(const NativePermissionResponse& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const NativePermissionResponse& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_NativePermissionResponse_Wrapper final {
  public:
    explicit Func_void_NativePermissionResponse_Wrapper(std::function<void(const NativePermissionResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const NativePermissionResponse& /* result */)>>(std::move(func))) {}
    inline void call(NativePermissionResponse result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const NativePermissionResponse& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_NativePermissionResponse create_Func_void_NativePermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_NativePermissionResponse_Wrapper wrap_Func_void_NativePermissionResponse(Func_void_NativePermissionResponse value) noexcept {
    return Func_void_NativePermissionResponse_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<NativeIosPermissionRequest>
  /**
   * Specialized version of `std::optional<NativeIosPermissionRequest>`.
   */
  using std__optional_NativeIosPermissionRequest_ = std::optional<NativeIosPermissionRequest>;
  inline std::optional<NativeIosPermissionRequest> create_std__optional_NativeIosPermissionRequest_(const NativeIosPermissionRequest& value) noexcept {
    return std::optional<NativeIosPermissionRequest>(value);
  }
  inline bool has_value_std__optional_NativeIosPermissionRequest_(const std::optional<NativeIosPermissionRequest>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeIosPermissionRequest get_std__optional_NativeIosPermissionRequest_(const std::optional<NativeIosPermissionRequest>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<NativeNotificationAction>
  /**
   * Specialized version of `std::vector<NativeNotificationAction>`.
   */
  using std__vector_NativeNotificationAction_ = std::vector<NativeNotificationAction>;
  inline std::vector<NativeNotificationAction> create_std__vector_NativeNotificationAction_(size_t size) noexcept {
    std::vector<NativeNotificationAction> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<NativeNotificationCategoryOptions>
  /**
   * Specialized version of `std::optional<NativeNotificationCategoryOptions>`.
   */
  using std__optional_NativeNotificationCategoryOptions_ = std::optional<NativeNotificationCategoryOptions>;
  inline std::optional<NativeNotificationCategoryOptions> create_std__optional_NativeNotificationCategoryOptions_(const NativeNotificationCategoryOptions& value) noexcept {
    return std::optional<NativeNotificationCategoryOptions>(value);
  }
  inline bool has_value_std__optional_NativeNotificationCategoryOptions_(const std::optional<NativeNotificationCategoryOptions>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeNotificationCategoryOptions get_std__optional_NativeNotificationCategoryOptions_(const std::optional<NativeNotificationCategoryOptions>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<NativeNotificationCategory>>
  /**
   * Specialized version of `std::shared_ptr<Promise<NativeNotificationCategory>>`.
   */
  using std__shared_ptr_Promise_NativeNotificationCategory__ = std::shared_ptr<Promise<NativeNotificationCategory>>;
  inline std::shared_ptr<Promise<NativeNotificationCategory>> create_std__shared_ptr_Promise_NativeNotificationCategory__() noexcept {
    return Promise<NativeNotificationCategory>::create();
  }
  inline PromiseHolder<NativeNotificationCategory> wrap_std__shared_ptr_Promise_NativeNotificationCategory__(std::shared_ptr<Promise<NativeNotificationCategory>> promise) noexcept {
    return PromiseHolder<NativeNotificationCategory>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const NativeNotificationCategory& /* result */)>
  /**
   * Specialized version of `std::function<void(const NativeNotificationCategory&)>`.
   */
  using Func_void_NativeNotificationCategory = std::function<void(const NativeNotificationCategory& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const NativeNotificationCategory& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_NativeNotificationCategory_Wrapper final {
  public:
    explicit Func_void_NativeNotificationCategory_Wrapper(std::function<void(const NativeNotificationCategory& /* result */)>&& func): _function(std::make_unique<std::function<void(const NativeNotificationCategory& /* result */)>>(std::move(func))) {}
    inline void call(NativeNotificationCategory result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const NativeNotificationCategory& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_NativeNotificationCategory create_Func_void_NativeNotificationCategory(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_NativeNotificationCategory_Wrapper wrap_Func_void_NativeNotificationCategory(Func_void_NativeNotificationCategory value) noexcept {
    return Func_void_NativeNotificationCategory_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<NativeNotificationCategory>
  /**
   * Specialized version of `std::vector<NativeNotificationCategory>`.
   */
  using std__vector_NativeNotificationCategory_ = std::vector<NativeNotificationCategory>;
  inline std::vector<NativeNotificationCategory> create_std__vector_NativeNotificationCategory_(size_t size) noexcept {
    std::vector<NativeNotificationCategory> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>>`.
   */
  using std__shared_ptr_Promise_std__vector_NativeNotificationCategory___ = std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>>;
  inline std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>> create_std__shared_ptr_Promise_std__vector_NativeNotificationCategory___() noexcept {
    return Promise<std::vector<NativeNotificationCategory>>::create();
  }
  inline PromiseHolder<std::vector<NativeNotificationCategory>> wrap_std__shared_ptr_Promise_std__vector_NativeNotificationCategory___(std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>> promise) noexcept {
    return PromiseHolder<std::vector<NativeNotificationCategory>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<NativeNotificationCategory>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<NativeNotificationCategory>&)>`.
   */
  using Func_void_std__vector_NativeNotificationCategory_ = std::function<void(const std::vector<NativeNotificationCategory>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<NativeNotificationCategory>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_NativeNotificationCategory__Wrapper final {
  public:
    explicit Func_void_std__vector_NativeNotificationCategory__Wrapper(std::function<void(const std::vector<NativeNotificationCategory>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<NativeNotificationCategory>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<NativeNotificationCategory> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<NativeNotificationCategory>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_NativeNotificationCategory_ create_Func_void_std__vector_NativeNotificationCategory_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_NativeNotificationCategory__Wrapper wrap_Func_void_std__vector_NativeNotificationCategory_(Func_void_std__vector_NativeNotificationCategory_ value) noexcept {
    return Func_void_std__vector_NativeNotificationCategory__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<double>
  /**
   * Specialized version of `std::vector<double>`.
   */
  using std__vector_double_ = std::vector<double>;
  inline std::vector<double> create_std__vector_double_(size_t size) noexcept {
    std::vector<double> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::optional<std::vector<double>>
  /**
   * Specialized version of `std::optional<std::vector<double>>`.
   */
  using std__optional_std__vector_double__ = std::optional<std::vector<double>>;
  inline std::optional<std::vector<double>> create_std__optional_std__vector_double__(const std::vector<double>& value) noexcept {
    return std::optional<std::vector<double>>(value);
  }
  inline bool has_value_std__optional_std__vector_double__(const std::optional<std::vector<double>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::vector<double> get_std__optional_std__vector_double__(const std::optional<std::vector<double>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<NativeChannel>
  /**
   * Specialized version of `std::optional<NativeChannel>`.
   */
  using std__optional_NativeChannel_ = std::optional<NativeChannel>;
  inline std::optional<NativeChannel> create_std__optional_NativeChannel_(const NativeChannel& value) noexcept {
    return std::optional<NativeChannel>(value);
  }
  inline bool has_value_std__optional_NativeChannel_(const std::optional<NativeChannel>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeChannel get_std__optional_NativeChannel_(const std::optional<NativeChannel>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::optional<NativeChannel>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::optional<NativeChannel>>>`.
   */
  using std__shared_ptr_Promise_std__optional_NativeChannel___ = std::shared_ptr<Promise<std::optional<NativeChannel>>>;
  inline std::shared_ptr<Promise<std::optional<NativeChannel>>> create_std__shared_ptr_Promise_std__optional_NativeChannel___() noexcept {
    return Promise<std::optional<NativeChannel>>::create();
  }
  inline PromiseHolder<std::optional<NativeChannel>> wrap_std__shared_ptr_Promise_std__optional_NativeChannel___(std::shared_ptr<Promise<std::optional<NativeChannel>>> promise) noexcept {
    return PromiseHolder<std::optional<NativeChannel>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::optional<NativeChannel>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::optional<NativeChannel>&)>`.
   */
  using Func_void_std__optional_NativeChannel_ = std::function<void(const std::optional<NativeChannel>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<NativeChannel>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_NativeChannel__Wrapper final {
  public:
    explicit Func_void_std__optional_NativeChannel__Wrapper(std::function<void(const std::optional<NativeChannel>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<NativeChannel>& /* result */)>>(std::move(func))) {}
    inline void call(std::optional<NativeChannel> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<NativeChannel>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_NativeChannel_ create_Func_void_std__optional_NativeChannel_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_NativeChannel__Wrapper wrap_Func_void_std__optional_NativeChannel_(Func_void_std__optional_NativeChannel_ value) noexcept {
    return Func_void_std__optional_NativeChannel__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<NativeChannel>
  /**
   * Specialized version of `std::vector<NativeChannel>`.
   */
  using std__vector_NativeChannel_ = std::vector<NativeChannel>;
  inline std::vector<NativeChannel> create_std__vector_NativeChannel_(size_t size) noexcept {
    std::vector<NativeChannel> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<NativeChannel>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeChannel>>>`.
   */
  using std__shared_ptr_Promise_std__vector_NativeChannel___ = std::shared_ptr<Promise<std::vector<NativeChannel>>>;
  inline std::shared_ptr<Promise<std::vector<NativeChannel>>> create_std__shared_ptr_Promise_std__vector_NativeChannel___() noexcept {
    return Promise<std::vector<NativeChannel>>::create();
  }
  inline PromiseHolder<std::vector<NativeChannel>> wrap_std__shared_ptr_Promise_std__vector_NativeChannel___(std::shared_ptr<Promise<std::vector<NativeChannel>>> promise) noexcept {
    return PromiseHolder<std::vector<NativeChannel>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<NativeChannel>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<NativeChannel>&)>`.
   */
  using Func_void_std__vector_NativeChannel_ = std::function<void(const std::vector<NativeChannel>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<NativeChannel>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_NativeChannel__Wrapper final {
  public:
    explicit Func_void_std__vector_NativeChannel__Wrapper(std::function<void(const std::vector<NativeChannel>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<NativeChannel>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<NativeChannel> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<NativeChannel>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_NativeChannel_ create_Func_void_std__vector_NativeChannel_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_NativeChannel__Wrapper wrap_Func_void_std__vector_NativeChannel_(Func_void_std__vector_NativeChannel_ value) noexcept {
    return Func_void_std__vector_NativeChannel__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<std::shared_ptr<AnyMap>>
  /**
   * Specialized version of `std::optional<std::shared_ptr<AnyMap>>`.
   */
  using std__optional_std__shared_ptr_AnyMap__ = std::optional<std::shared_ptr<AnyMap>>;
  inline std::optional<std::shared_ptr<AnyMap>> create_std__optional_std__shared_ptr_AnyMap__(const std::shared_ptr<AnyMap>& value) noexcept {
    return std::optional<std::shared_ptr<AnyMap>>(value);
  }
  inline bool has_value_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::shared_ptr<AnyMap> get_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::optional<NativeTriggerInput>
  /**
   * Specialized version of `std::optional<NativeTriggerInput>`.
   */
  using std__optional_NativeTriggerInput_ = std::optional<NativeTriggerInput>;
  inline std::optional<NativeTriggerInput> create_std__optional_NativeTriggerInput_(const NativeTriggerInput& value) noexcept {
    return std::optional<NativeTriggerInput>(value);
  }
  inline bool has_value_std__optional_NativeTriggerInput_(const std::optional<NativeTriggerInput>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeTriggerInput get_std__optional_NativeTriggerInput_(const std::optional<NativeTriggerInput>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::vector<NativeNotificationRequest>
  /**
   * Specialized version of `std::vector<NativeNotificationRequest>`.
   */
  using std__vector_NativeNotificationRequest_ = std::vector<NativeNotificationRequest>;
  inline std::vector<NativeNotificationRequest> create_std__vector_NativeNotificationRequest_(size_t size) noexcept {
    std::vector<NativeNotificationRequest> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>>`.
   */
  using std__shared_ptr_Promise_std__vector_NativeNotificationRequest___ = std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>>;
  inline std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>> create_std__shared_ptr_Promise_std__vector_NativeNotificationRequest___() noexcept {
    return Promise<std::vector<NativeNotificationRequest>>::create();
  }
  inline PromiseHolder<std::vector<NativeNotificationRequest>> wrap_std__shared_ptr_Promise_std__vector_NativeNotificationRequest___(std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>> promise) noexcept {
    return PromiseHolder<std::vector<NativeNotificationRequest>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<NativeNotificationRequest>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<NativeNotificationRequest>&)>`.
   */
  using Func_void_std__vector_NativeNotificationRequest_ = std::function<void(const std::vector<NativeNotificationRequest>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<NativeNotificationRequest>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_NativeNotificationRequest__Wrapper final {
  public:
    explicit Func_void_std__vector_NativeNotificationRequest__Wrapper(std::function<void(const std::vector<NativeNotificationRequest>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<NativeNotificationRequest>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<NativeNotificationRequest> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<NativeNotificationRequest>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_NativeNotificationRequest_ create_Func_void_std__vector_NativeNotificationRequest_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_NativeNotificationRequest__Wrapper wrap_Func_void_std__vector_NativeNotificationRequest_(Func_void_std__vector_NativeNotificationRequest_ value) noexcept {
    return Func_void_std__vector_NativeNotificationRequest__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<NativeNotification>
  /**
   * Specialized version of `std::vector<NativeNotification>`.
   */
  using std__vector_NativeNotification_ = std::vector<NativeNotification>;
  inline std::vector<NativeNotification> create_std__vector_NativeNotification_(size_t size) noexcept {
    std::vector<NativeNotification> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<NativeNotification>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeNotification>>>`.
   */
  using std__shared_ptr_Promise_std__vector_NativeNotification___ = std::shared_ptr<Promise<std::vector<NativeNotification>>>;
  inline std::shared_ptr<Promise<std::vector<NativeNotification>>> create_std__shared_ptr_Promise_std__vector_NativeNotification___() noexcept {
    return Promise<std::vector<NativeNotification>>::create();
  }
  inline PromiseHolder<std::vector<NativeNotification>> wrap_std__shared_ptr_Promise_std__vector_NativeNotification___(std::shared_ptr<Promise<std::vector<NativeNotification>>> promise) noexcept {
    return PromiseHolder<std::vector<NativeNotification>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<NativeNotification>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<NativeNotification>&)>`.
   */
  using Func_void_std__vector_NativeNotification_ = std::function<void(const std::vector<NativeNotification>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<NativeNotification>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_NativeNotification__Wrapper final {
  public:
    explicit Func_void_std__vector_NativeNotification__Wrapper(std::function<void(const std::vector<NativeNotification>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<NativeNotification>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<NativeNotification> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<NativeNotification>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_NativeNotification_ create_Func_void_std__vector_NativeNotification_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_NativeNotification__Wrapper wrap_Func_void_std__vector_NativeNotification_(Func_void_std__vector_NativeNotification_ value) noexcept {
    return Func_void_std__vector_NativeNotification__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<NativePushToken>>
  /**
   * Specialized version of `std::shared_ptr<Promise<NativePushToken>>`.
   */
  using std__shared_ptr_Promise_NativePushToken__ = std::shared_ptr<Promise<NativePushToken>>;
  inline std::shared_ptr<Promise<NativePushToken>> create_std__shared_ptr_Promise_NativePushToken__() noexcept {
    return Promise<NativePushToken>::create();
  }
  inline PromiseHolder<NativePushToken> wrap_std__shared_ptr_Promise_NativePushToken__(std::shared_ptr<Promise<NativePushToken>> promise) noexcept {
    return PromiseHolder<NativePushToken>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const NativePushToken& /* result */)>
  /**
   * Specialized version of `std::function<void(const NativePushToken&)>`.
   */
  using Func_void_NativePushToken = std::function<void(const NativePushToken& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const NativePushToken& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_NativePushToken_Wrapper final {
  public:
    explicit Func_void_NativePushToken_Wrapper(std::function<void(const NativePushToken& /* result */)>&& func): _function(std::make_unique<std::function<void(const NativePushToken& /* result */)>>(std::move(func))) {}
    inline void call(NativePushToken result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const NativePushToken& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_NativePushToken create_Func_void_NativePushToken(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_NativePushToken_Wrapper wrap_Func_void_NativePushToken(Func_void_NativePushToken value) noexcept {
    return Func_void_NativePushToken_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const std::string& /* requestId */, const NativeNotification& /* notification */)>
  /**
   * Specialized version of `std::function<void(const std::string&, const NativeNotification&)>`.
   */
  using Func_void_std__string_NativeNotification = std::function<void(const std::string& /* requestId */, const NativeNotification& /* notification */)>;
  /**
   * Wrapper class for a `std::function<void(const std::string& / * requestId * /, const NativeNotification& / * notification * /)>`, this can be used from Swift.
   */
  class Func_void_std__string_NativeNotification_Wrapper final {
  public:
    explicit Func_void_std__string_NativeNotification_Wrapper(std::function<void(const std::string& /* requestId */, const NativeNotification& /* notification */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* requestId */, const NativeNotification& /* notification */)>>(std::move(func))) {}
    inline void call(std::string requestId, NativeNotification notification) const noexcept {
      _function->operator()(requestId, notification);
    }
  private:
    std::unique_ptr<std::function<void(const std::string& /* requestId */, const NativeNotification& /* notification */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__string_NativeNotification create_Func_void_std__string_NativeNotification(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__string_NativeNotification_Wrapper wrap_Func_void_std__string_NativeNotification(Func_void_std__string_NativeNotification value) noexcept {
    return Func_void_std__string_NativeNotification_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const NativeNotificationResponse& /* response */)>
  /**
   * Specialized version of `std::function<void(const NativeNotificationResponse&)>`.
   */
  using Func_void_NativeNotificationResponse = std::function<void(const NativeNotificationResponse& /* response */)>;
  /**
   * Wrapper class for a `std::function<void(const NativeNotificationResponse& / * response * /)>`, this can be used from Swift.
   */
  class Func_void_NativeNotificationResponse_Wrapper final {
  public:
    explicit Func_void_NativeNotificationResponse_Wrapper(std::function<void(const NativeNotificationResponse& /* response */)>&& func): _function(std::make_unique<std::function<void(const NativeNotificationResponse& /* response */)>>(std::move(func))) {}
    inline void call(NativeNotificationResponse response) const noexcept {
      _function->operator()(response);
    }
  private:
    std::unique_ptr<std::function<void(const NativeNotificationResponse& /* response */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_NativeNotificationResponse create_Func_void_NativeNotificationResponse(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_NativeNotificationResponse_Wrapper wrap_Func_void_NativeNotificationResponse(Func_void_NativeNotificationResponse value) noexcept {
    return Func_void_NativeNotificationResponse_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<NativeNotificationResponse>
  /**
   * Specialized version of `std::optional<NativeNotificationResponse>`.
   */
  using std__optional_NativeNotificationResponse_ = std::optional<NativeNotificationResponse>;
  inline std::optional<NativeNotificationResponse> create_std__optional_NativeNotificationResponse_(const NativeNotificationResponse& value) noexcept {
    return std::optional<NativeNotificationResponse>(value);
  }
  inline bool has_value_std__optional_NativeNotificationResponse_(const std::optional<NativeNotificationResponse>& optional) noexcept {
    return optional.has_value();
  }
  inline NativeNotificationResponse get_std__optional_NativeNotificationResponse_(const std::optional<NativeNotificationResponse>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneNotificationsSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneNotificationsSpec>`.
   */
  using std__shared_ptr_HybridOneNotificationsSpec_ = std::shared_ptr<HybridOneNotificationsSpec>;
  std::shared_ptr<HybridOneNotificationsSpec> create_std__shared_ptr_HybridOneNotificationsSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneNotificationsSpec_(std__shared_ptr_HybridOneNotificationsSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneNotificationsSpec>
  using std__weak_ptr_HybridOneNotificationsSpec_ = std::weak_ptr<HybridOneNotificationsSpec>;
  inline std__weak_ptr_HybridOneNotificationsSpec_ weakify_std__shared_ptr_HybridOneNotificationsSpec_(const std::shared_ptr<HybridOneNotificationsSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<NativePermissionResponse>>>
  using Result_std__shared_ptr_Promise_NativePermissionResponse___ = Result<std::shared_ptr<Promise<NativePermissionResponse>>>;
  inline Result_std__shared_ptr_Promise_NativePermissionResponse___ create_Result_std__shared_ptr_Promise_NativePermissionResponse___(const std::shared_ptr<Promise<NativePermissionResponse>>& value) noexcept {
    return Result<std::shared_ptr<Promise<NativePermissionResponse>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_NativePermissionResponse___ create_Result_std__shared_ptr_Promise_NativePermissionResponse___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<NativePermissionResponse>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<NativeNotificationCategory>>>
  using Result_std__shared_ptr_Promise_NativeNotificationCategory___ = Result<std::shared_ptr<Promise<NativeNotificationCategory>>>;
  inline Result_std__shared_ptr_Promise_NativeNotificationCategory___ create_Result_std__shared_ptr_Promise_NativeNotificationCategory___(const std::shared_ptr<Promise<NativeNotificationCategory>>& value) noexcept {
    return Result<std::shared_ptr<Promise<NativeNotificationCategory>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_NativeNotificationCategory___ create_Result_std__shared_ptr_Promise_NativeNotificationCategory___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<NativeNotificationCategory>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>>>
  using Result_std__shared_ptr_Promise_std__vector_NativeNotificationCategory____ = Result<std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_NativeNotificationCategory____ create_Result_std__shared_ptr_Promise_std__vector_NativeNotificationCategory____(const std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_NativeNotificationCategory____ create_Result_std__shared_ptr_Promise_std__vector_NativeNotificationCategory____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<NativeNotificationCategory>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<NativeChannel>>>>
  using Result_std__shared_ptr_Promise_std__optional_NativeChannel____ = Result<std::shared_ptr<Promise<std::optional<NativeChannel>>>>;
  inline Result_std__shared_ptr_Promise_std__optional_NativeChannel____ create_Result_std__shared_ptr_Promise_std__optional_NativeChannel____(const std::shared_ptr<Promise<std::optional<NativeChannel>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<NativeChannel>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__optional_NativeChannel____ create_Result_std__shared_ptr_Promise_std__optional_NativeChannel____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<NativeChannel>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NativeChannel>>>>
  using Result_std__shared_ptr_Promise_std__vector_NativeChannel____ = Result<std::shared_ptr<Promise<std::vector<NativeChannel>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_NativeChannel____ create_Result_std__shared_ptr_Promise_std__vector_NativeChannel____(const std::shared_ptr<Promise<std::vector<NativeChannel>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<NativeChannel>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_NativeChannel____ create_Result_std__shared_ptr_Promise_std__vector_NativeChannel____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<NativeChannel>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>>>
  using Result_std__shared_ptr_Promise_std__vector_NativeNotificationRequest____ = Result<std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_NativeNotificationRequest____ create_Result_std__shared_ptr_Promise_std__vector_NativeNotificationRequest____(const std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_NativeNotificationRequest____ create_Result_std__shared_ptr_Promise_std__vector_NativeNotificationRequest____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<NativeNotificationRequest>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NativeNotification>>>>
  using Result_std__shared_ptr_Promise_std__vector_NativeNotification____ = Result<std::shared_ptr<Promise<std::vector<NativeNotification>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_NativeNotification____ create_Result_std__shared_ptr_Promise_std__vector_NativeNotification____(const std::shared_ptr<Promise<std::vector<NativeNotification>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<NativeNotification>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_NativeNotification____ create_Result_std__shared_ptr_Promise_std__vector_NativeNotification____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<NativeNotification>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<NativePushToken>>>
  using Result_std__shared_ptr_Promise_NativePushToken___ = Result<std::shared_ptr<Promise<NativePushToken>>>;
  inline Result_std__shared_ptr_Promise_NativePushToken___ create_Result_std__shared_ptr_Promise_NativePushToken___(const std::shared_ptr<Promise<NativePushToken>>& value) noexcept {
    return Result<std::shared_ptr<Promise<NativePushToken>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_NativePushToken___ create_Result_std__shared_ptr_Promise_NativePushToken___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<NativePushToken>>>::withError(error);
  }
  
  // pragma MARK: Result<std::optional<NativeNotificationResponse>>
  using Result_std__optional_NativeNotificationResponse__ = Result<std::optional<NativeNotificationResponse>>;
  inline Result_std__optional_NativeNotificationResponse__ create_Result_std__optional_NativeNotificationResponse__(const std::optional<NativeNotificationResponse>& value) noexcept {
    return Result<std::optional<NativeNotificationResponse>>::withValue(value);
  }
  inline Result_std__optional_NativeNotificationResponse__ create_Result_std__optional_NativeNotificationResponse__(const std::exception_ptr& error) noexcept {
    return Result<std::optional<NativeNotificationResponse>>::withError(error);
  }
  
  // pragma MARK: std::function<void(const PedometerResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const PedometerResult&)>`.
   */
  using Func_void_PedometerResult = std::function<void(const PedometerResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const PedometerResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PedometerResult_Wrapper final {
  public:
    explicit Func_void_PedometerResult_Wrapper(std::function<void(const PedometerResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const PedometerResult& /* result */)>>(std::move(func))) {}
    inline void call(PedometerResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const PedometerResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PedometerResult create_Func_void_PedometerResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PedometerResult_Wrapper wrap_Func_void_PedometerResult(Func_void_PedometerResult value) noexcept {
    return Func_void_PedometerResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<PedometerResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PedometerResult>>`.
   */
  using std__shared_ptr_Promise_PedometerResult__ = std::shared_ptr<Promise<PedometerResult>>;
  inline std::shared_ptr<Promise<PedometerResult>> create_std__shared_ptr_Promise_PedometerResult__() noexcept {
    return Promise<PedometerResult>::create();
  }
  inline PromiseHolder<PedometerResult> wrap_std__shared_ptr_Promise_PedometerResult__(std::shared_ptr<Promise<PedometerResult>> promise) noexcept {
    return PromiseHolder<PedometerResult>(std::move(promise));
  }
  
  // pragma MARK: std::shared_ptr<Promise<PedometerPermissionResponse>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PedometerPermissionResponse>>`.
   */
  using std__shared_ptr_Promise_PedometerPermissionResponse__ = std::shared_ptr<Promise<PedometerPermissionResponse>>;
  inline std::shared_ptr<Promise<PedometerPermissionResponse>> create_std__shared_ptr_Promise_PedometerPermissionResponse__() noexcept {
    return Promise<PedometerPermissionResponse>::create();
  }
  inline PromiseHolder<PedometerPermissionResponse> wrap_std__shared_ptr_Promise_PedometerPermissionResponse__(std::shared_ptr<Promise<PedometerPermissionResponse>> promise) noexcept {
    return PromiseHolder<PedometerPermissionResponse>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const PedometerPermissionResponse& /* result */)>
  /**
   * Specialized version of `std::function<void(const PedometerPermissionResponse&)>`.
   */
  using Func_void_PedometerPermissionResponse = std::function<void(const PedometerPermissionResponse& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const PedometerPermissionResponse& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PedometerPermissionResponse_Wrapper final {
  public:
    explicit Func_void_PedometerPermissionResponse_Wrapper(std::function<void(const PedometerPermissionResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const PedometerPermissionResponse& /* result */)>>(std::move(func))) {}
    inline void call(PedometerPermissionResponse result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const PedometerPermissionResponse& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PedometerPermissionResponse create_Func_void_PedometerPermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PedometerPermissionResponse_Wrapper wrap_Func_void_PedometerPermissionResponse(Func_void_PedometerPermissionResponse value) noexcept {
    return Func_void_PedometerPermissionResponse_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOnePedometerSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOnePedometerSpec>`.
   */
  using std__shared_ptr_HybridOnePedometerSpec_ = std::shared_ptr<HybridOnePedometerSpec>;
  std::shared_ptr<HybridOnePedometerSpec> create_std__shared_ptr_HybridOnePedometerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOnePedometerSpec_(std__shared_ptr_HybridOnePedometerSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOnePedometerSpec>
  using std__weak_ptr_HybridOnePedometerSpec_ = std::weak_ptr<HybridOnePedometerSpec>;
  inline std__weak_ptr_HybridOnePedometerSpec_ weakify_std__shared_ptr_HybridOnePedometerSpec_(const std::shared_ptr<HybridOnePedometerSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PedometerResult>>>
  using Result_std__shared_ptr_Promise_PedometerResult___ = Result<std::shared_ptr<Promise<PedometerResult>>>;
  inline Result_std__shared_ptr_Promise_PedometerResult___ create_Result_std__shared_ptr_Promise_PedometerResult___(const std::shared_ptr<Promise<PedometerResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PedometerResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PedometerResult___ create_Result_std__shared_ptr_Promise_PedometerResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PedometerResult>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PedometerPermissionResponse>>>
  using Result_std__shared_ptr_Promise_PedometerPermissionResponse___ = Result<std::shared_ptr<Promise<PedometerPermissionResponse>>>;
  inline Result_std__shared_ptr_Promise_PedometerPermissionResponse___ create_Result_std__shared_ptr_Promise_PedometerPermissionResponse___(const std::shared_ptr<Promise<PedometerPermissionResponse>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PedometerPermissionResponse>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PedometerPermissionResponse___ create_Result_std__shared_ptr_Promise_PedometerPermissionResponse___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PedometerPermissionResponse>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<PhotoLibraryPermissionStatus>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PhotoLibraryPermissionStatus>>`.
   */
  using std__shared_ptr_Promise_PhotoLibraryPermissionStatus__ = std::shared_ptr<Promise<PhotoLibraryPermissionStatus>>;
  inline std::shared_ptr<Promise<PhotoLibraryPermissionStatus>> create_std__shared_ptr_Promise_PhotoLibraryPermissionStatus__() noexcept {
    return Promise<PhotoLibraryPermissionStatus>::create();
  }
  inline PromiseHolder<PhotoLibraryPermissionStatus> wrap_std__shared_ptr_Promise_PhotoLibraryPermissionStatus__(std::shared_ptr<Promise<PhotoLibraryPermissionStatus>> promise) noexcept {
    return PromiseHolder<PhotoLibraryPermissionStatus>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(PhotoLibraryPermissionStatus /* result */)>
  /**
   * Specialized version of `std::function<void(PhotoLibraryPermissionStatus)>`.
   */
  using Func_void_PhotoLibraryPermissionStatus = std::function<void(PhotoLibraryPermissionStatus /* result */)>;
  /**
   * Wrapper class for a `std::function<void(PhotoLibraryPermissionStatus / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PhotoLibraryPermissionStatus_Wrapper final {
  public:
    explicit Func_void_PhotoLibraryPermissionStatus_Wrapper(std::function<void(PhotoLibraryPermissionStatus /* result */)>&& func): _function(std::make_unique<std::function<void(PhotoLibraryPermissionStatus /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<PhotoLibraryPermissionStatus>(result));
    }
  private:
    std::unique_ptr<std::function<void(PhotoLibraryPermissionStatus /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PhotoLibraryPermissionStatus create_Func_void_PhotoLibraryPermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PhotoLibraryPermissionStatus_Wrapper wrap_Func_void_PhotoLibraryPermissionStatus(Func_void_PhotoLibraryPermissionStatus value) noexcept {
    return Func_void_PhotoLibraryPermissionStatus_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<std::string>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<std::string>>>`.
   */
  using std__shared_ptr_Promise_std__vector_std__string___ = std::shared_ptr<Promise<std::vector<std::string>>>;
  inline std::shared_ptr<Promise<std::vector<std::string>>> create_std__shared_ptr_Promise_std__vector_std__string___() noexcept {
    return Promise<std::vector<std::string>>::create();
  }
  inline PromiseHolder<std::vector<std::string>> wrap_std__shared_ptr_Promise_std__vector_std__string___(std::shared_ptr<Promise<std::vector<std::string>>> promise) noexcept {
    return PromiseHolder<std::vector<std::string>>(std::move(promise));
  }
  
  // pragma MARK: std::vector<PhotoLibraryAsset>
  /**
   * Specialized version of `std::vector<PhotoLibraryAsset>`.
   */
  using std__vector_PhotoLibraryAsset_ = std::vector<PhotoLibraryAsset>;
  inline std::vector<PhotoLibraryAsset> create_std__vector_PhotoLibraryAsset_(size_t size) noexcept {
    std::vector<PhotoLibraryAsset> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<PhotoLibraryAssetPage>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PhotoLibraryAssetPage>>`.
   */
  using std__shared_ptr_Promise_PhotoLibraryAssetPage__ = std::shared_ptr<Promise<PhotoLibraryAssetPage>>;
  inline std::shared_ptr<Promise<PhotoLibraryAssetPage>> create_std__shared_ptr_Promise_PhotoLibraryAssetPage__() noexcept {
    return Promise<PhotoLibraryAssetPage>::create();
  }
  inline PromiseHolder<PhotoLibraryAssetPage> wrap_std__shared_ptr_Promise_PhotoLibraryAssetPage__(std::shared_ptr<Promise<PhotoLibraryAssetPage>> promise) noexcept {
    return PromiseHolder<PhotoLibraryAssetPage>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const PhotoLibraryAssetPage& /* result */)>
  /**
   * Specialized version of `std::function<void(const PhotoLibraryAssetPage&)>`.
   */
  using Func_void_PhotoLibraryAssetPage = std::function<void(const PhotoLibraryAssetPage& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const PhotoLibraryAssetPage& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PhotoLibraryAssetPage_Wrapper final {
  public:
    explicit Func_void_PhotoLibraryAssetPage_Wrapper(std::function<void(const PhotoLibraryAssetPage& /* result */)>&& func): _function(std::make_unique<std::function<void(const PhotoLibraryAssetPage& /* result */)>>(std::move(func))) {}
    inline void call(PhotoLibraryAssetPage result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const PhotoLibraryAssetPage& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PhotoLibraryAssetPage create_Func_void_PhotoLibraryAssetPage(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PhotoLibraryAssetPage_Wrapper wrap_Func_void_PhotoLibraryAssetPage(Func_void_PhotoLibraryAssetPage value) noexcept {
    return Func_void_PhotoLibraryAssetPage_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<PhotoLibraryAsset>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PhotoLibraryAsset>>`.
   */
  using std__shared_ptr_Promise_PhotoLibraryAsset__ = std::shared_ptr<Promise<PhotoLibraryAsset>>;
  inline std::shared_ptr<Promise<PhotoLibraryAsset>> create_std__shared_ptr_Promise_PhotoLibraryAsset__() noexcept {
    return Promise<PhotoLibraryAsset>::create();
  }
  inline PromiseHolder<PhotoLibraryAsset> wrap_std__shared_ptr_Promise_PhotoLibraryAsset__(std::shared_ptr<Promise<PhotoLibraryAsset>> promise) noexcept {
    return PromiseHolder<PhotoLibraryAsset>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const PhotoLibraryAsset& /* result */)>
  /**
   * Specialized version of `std::function<void(const PhotoLibraryAsset&)>`.
   */
  using Func_void_PhotoLibraryAsset = std::function<void(const PhotoLibraryAsset& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const PhotoLibraryAsset& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PhotoLibraryAsset_Wrapper final {
  public:
    explicit Func_void_PhotoLibraryAsset_Wrapper(std::function<void(const PhotoLibraryAsset& /* result */)>&& func): _function(std::make_unique<std::function<void(const PhotoLibraryAsset& /* result */)>>(std::move(func))) {}
    inline void call(PhotoLibraryAsset result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const PhotoLibraryAsset& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PhotoLibraryAsset create_Func_void_PhotoLibraryAsset(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PhotoLibraryAsset_Wrapper wrap_Func_void_PhotoLibraryAsset(Func_void_PhotoLibraryAsset value) noexcept {
    return Func_void_PhotoLibraryAsset_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<PhotoLibraryAlbum>
  /**
   * Specialized version of `std::vector<PhotoLibraryAlbum>`.
   */
  using std__vector_PhotoLibraryAlbum_ = std::vector<PhotoLibraryAlbum>;
  inline std::vector<PhotoLibraryAlbum> create_std__vector_PhotoLibraryAlbum_(size_t size) noexcept {
    std::vector<PhotoLibraryAlbum> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<PhotoLibraryAlbumPage>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PhotoLibraryAlbumPage>>`.
   */
  using std__shared_ptr_Promise_PhotoLibraryAlbumPage__ = std::shared_ptr<Promise<PhotoLibraryAlbumPage>>;
  inline std::shared_ptr<Promise<PhotoLibraryAlbumPage>> create_std__shared_ptr_Promise_PhotoLibraryAlbumPage__() noexcept {
    return Promise<PhotoLibraryAlbumPage>::create();
  }
  inline PromiseHolder<PhotoLibraryAlbumPage> wrap_std__shared_ptr_Promise_PhotoLibraryAlbumPage__(std::shared_ptr<Promise<PhotoLibraryAlbumPage>> promise) noexcept {
    return PromiseHolder<PhotoLibraryAlbumPage>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const PhotoLibraryAlbumPage& /* result */)>
  /**
   * Specialized version of `std::function<void(const PhotoLibraryAlbumPage&)>`.
   */
  using Func_void_PhotoLibraryAlbumPage = std::function<void(const PhotoLibraryAlbumPage& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const PhotoLibraryAlbumPage& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PhotoLibraryAlbumPage_Wrapper final {
  public:
    explicit Func_void_PhotoLibraryAlbumPage_Wrapper(std::function<void(const PhotoLibraryAlbumPage& /* result */)>&& func): _function(std::make_unique<std::function<void(const PhotoLibraryAlbumPage& /* result */)>>(std::move(func))) {}
    inline void call(PhotoLibraryAlbumPage result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const PhotoLibraryAlbumPage& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PhotoLibraryAlbumPage create_Func_void_PhotoLibraryAlbumPage(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PhotoLibraryAlbumPage_Wrapper wrap_Func_void_PhotoLibraryAlbumPage(Func_void_PhotoLibraryAlbumPage value) noexcept {
    return Func_void_PhotoLibraryAlbumPage_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<PhotoLibraryAlbum>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PhotoLibraryAlbum>>`.
   */
  using std__shared_ptr_Promise_PhotoLibraryAlbum__ = std::shared_ptr<Promise<PhotoLibraryAlbum>>;
  inline std::shared_ptr<Promise<PhotoLibraryAlbum>> create_std__shared_ptr_Promise_PhotoLibraryAlbum__() noexcept {
    return Promise<PhotoLibraryAlbum>::create();
  }
  inline PromiseHolder<PhotoLibraryAlbum> wrap_std__shared_ptr_Promise_PhotoLibraryAlbum__(std::shared_ptr<Promise<PhotoLibraryAlbum>> promise) noexcept {
    return PromiseHolder<PhotoLibraryAlbum>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const PhotoLibraryAlbum& /* result */)>
  /**
   * Specialized version of `std::function<void(const PhotoLibraryAlbum&)>`.
   */
  using Func_void_PhotoLibraryAlbum = std::function<void(const PhotoLibraryAlbum& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const PhotoLibraryAlbum& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PhotoLibraryAlbum_Wrapper final {
  public:
    explicit Func_void_PhotoLibraryAlbum_Wrapper(std::function<void(const PhotoLibraryAlbum& /* result */)>&& func): _function(std::make_unique<std::function<void(const PhotoLibraryAlbum& /* result */)>>(std::move(func))) {}
    inline void call(PhotoLibraryAlbum result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const PhotoLibraryAlbum& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PhotoLibraryAlbum create_Func_void_PhotoLibraryAlbum(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PhotoLibraryAlbum_Wrapper wrap_Func_void_PhotoLibraryAlbum(Func_void_PhotoLibraryAlbum value) noexcept {
    return Func_void_PhotoLibraryAlbum_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOnePhotoLibrarySpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOnePhotoLibrarySpec>`.
   */
  using std__shared_ptr_HybridOnePhotoLibrarySpec_ = std::shared_ptr<HybridOnePhotoLibrarySpec>;
  std::shared_ptr<HybridOnePhotoLibrarySpec> create_std__shared_ptr_HybridOnePhotoLibrarySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOnePhotoLibrarySpec_(std__shared_ptr_HybridOnePhotoLibrarySpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOnePhotoLibrarySpec>
  using std__weak_ptr_HybridOnePhotoLibrarySpec_ = std::weak_ptr<HybridOnePhotoLibrarySpec>;
  inline std__weak_ptr_HybridOnePhotoLibrarySpec_ weakify_std__shared_ptr_HybridOnePhotoLibrarySpec_(const std::shared_ptr<HybridOnePhotoLibrarySpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<PhotoLibraryPermissionStatus>
  using Result_PhotoLibraryPermissionStatus_ = Result<PhotoLibraryPermissionStatus>;
  inline Result_PhotoLibraryPermissionStatus_ create_Result_PhotoLibraryPermissionStatus_(PhotoLibraryPermissionStatus value) noexcept {
    return Result<PhotoLibraryPermissionStatus>::withValue(std::move(value));
  }
  inline Result_PhotoLibraryPermissionStatus_ create_Result_PhotoLibraryPermissionStatus_(const std::exception_ptr& error) noexcept {
    return Result<PhotoLibraryPermissionStatus>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PhotoLibraryPermissionStatus>>>
  using Result_std__shared_ptr_Promise_PhotoLibraryPermissionStatus___ = Result<std::shared_ptr<Promise<PhotoLibraryPermissionStatus>>>;
  inline Result_std__shared_ptr_Promise_PhotoLibraryPermissionStatus___ create_Result_std__shared_ptr_Promise_PhotoLibraryPermissionStatus___(const std::shared_ptr<Promise<PhotoLibraryPermissionStatus>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryPermissionStatus>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PhotoLibraryPermissionStatus___ create_Result_std__shared_ptr_Promise_PhotoLibraryPermissionStatus___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryPermissionStatus>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<std::string>>>>
  using Result_std__shared_ptr_Promise_std__vector_std__string____ = Result<std::shared_ptr<Promise<std::vector<std::string>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::shared_ptr<Promise<std::vector<std::string>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<std::string>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<std::string>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PhotoLibraryAssetPage>>>
  using Result_std__shared_ptr_Promise_PhotoLibraryAssetPage___ = Result<std::shared_ptr<Promise<PhotoLibraryAssetPage>>>;
  inline Result_std__shared_ptr_Promise_PhotoLibraryAssetPage___ create_Result_std__shared_ptr_Promise_PhotoLibraryAssetPage___(const std::shared_ptr<Promise<PhotoLibraryAssetPage>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryAssetPage>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PhotoLibraryAssetPage___ create_Result_std__shared_ptr_Promise_PhotoLibraryAssetPage___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryAssetPage>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PhotoLibraryAsset>>>
  using Result_std__shared_ptr_Promise_PhotoLibraryAsset___ = Result<std::shared_ptr<Promise<PhotoLibraryAsset>>>;
  inline Result_std__shared_ptr_Promise_PhotoLibraryAsset___ create_Result_std__shared_ptr_Promise_PhotoLibraryAsset___(const std::shared_ptr<Promise<PhotoLibraryAsset>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryAsset>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PhotoLibraryAsset___ create_Result_std__shared_ptr_Promise_PhotoLibraryAsset___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryAsset>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PhotoLibraryAlbumPage>>>
  using Result_std__shared_ptr_Promise_PhotoLibraryAlbumPage___ = Result<std::shared_ptr<Promise<PhotoLibraryAlbumPage>>>;
  inline Result_std__shared_ptr_Promise_PhotoLibraryAlbumPage___ create_Result_std__shared_ptr_Promise_PhotoLibraryAlbumPage___(const std::shared_ptr<Promise<PhotoLibraryAlbumPage>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryAlbumPage>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PhotoLibraryAlbumPage___ create_Result_std__shared_ptr_Promise_PhotoLibraryAlbumPage___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryAlbumPage>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PhotoLibraryAlbum>>>
  using Result_std__shared_ptr_Promise_PhotoLibraryAlbum___ = Result<std::shared_ptr<Promise<PhotoLibraryAlbum>>>;
  inline Result_std__shared_ptr_Promise_PhotoLibraryAlbum___ create_Result_std__shared_ptr_Promise_PhotoLibraryAlbum___(const std::shared_ptr<Promise<PhotoLibraryAlbum>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryAlbum>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PhotoLibraryAlbum___ create_Result_std__shared_ptr_Promise_PhotoLibraryAlbum___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PhotoLibraryAlbum>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<PrintResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PrintResult>>`.
   */
  using std__shared_ptr_Promise_PrintResult__ = std::shared_ptr<Promise<PrintResult>>;
  inline std::shared_ptr<Promise<PrintResult>> create_std__shared_ptr_Promise_PrintResult__() noexcept {
    return Promise<PrintResult>::create();
  }
  inline PromiseHolder<PrintResult> wrap_std__shared_ptr_Promise_PrintResult__(std::shared_ptr<Promise<PrintResult>> promise) noexcept {
    return PromiseHolder<PrintResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const PrintResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const PrintResult&)>`.
   */
  using Func_void_PrintResult = std::function<void(const PrintResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const PrintResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PrintResult_Wrapper final {
  public:
    explicit Func_void_PrintResult_Wrapper(std::function<void(const PrintResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const PrintResult& /* result */)>>(std::move(func))) {}
    inline void call(PrintResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const PrintResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PrintResult create_Func_void_PrintResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PrintResult_Wrapper wrap_Func_void_PrintResult(Func_void_PrintResult value) noexcept {
    return Func_void_PrintResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOnePrintSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOnePrintSpec>`.
   */
  using std__shared_ptr_HybridOnePrintSpec_ = std::shared_ptr<HybridOnePrintSpec>;
  std::shared_ptr<HybridOnePrintSpec> create_std__shared_ptr_HybridOnePrintSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOnePrintSpec_(std__shared_ptr_HybridOnePrintSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOnePrintSpec>
  using std__weak_ptr_HybridOnePrintSpec_ = std::weak_ptr<HybridOnePrintSpec>;
  inline std__weak_ptr_HybridOnePrintSpec_ weakify_std__shared_ptr_HybridOnePrintSpec_(const std::shared_ptr<HybridOnePrintSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PrintResult>>>
  using Result_std__shared_ptr_Promise_PrintResult___ = Result<std::shared_ptr<Promise<PrintResult>>>;
  inline Result_std__shared_ptr_Promise_PrintResult___ create_Result_std__shared_ptr_Promise_PrintResult___(const std::shared_ptr<Promise<PrintResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PrintResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PrintResult___ create_Result_std__shared_ptr_Promise_PrintResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PrintResult>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridOneProtectedStoreSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneProtectedStoreSpec>`.
   */
  using std__shared_ptr_HybridOneProtectedStoreSpec_ = std::shared_ptr<HybridOneProtectedStoreSpec>;
  std::shared_ptr<HybridOneProtectedStoreSpec> create_std__shared_ptr_HybridOneProtectedStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneProtectedStoreSpec_(std__shared_ptr_HybridOneProtectedStoreSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneProtectedStoreSpec>
  using std__weak_ptr_HybridOneProtectedStoreSpec_ = std::weak_ptr<HybridOneProtectedStoreSpec>;
  inline std__weak_ptr_HybridOneProtectedStoreSpec_ weakify_std__shared_ptr_HybridOneProtectedStoreSpec_(const std::shared_ptr<HybridOneProtectedStoreSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::vector<PurchaseProduct>
  /**
   * Specialized version of `std::vector<PurchaseProduct>`.
   */
  using std__vector_PurchaseProduct_ = std::vector<PurchaseProduct>;
  inline std::vector<PurchaseProduct> create_std__vector_PurchaseProduct_(size_t size) noexcept {
    std::vector<PurchaseProduct> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<PurchaseProduct>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<PurchaseProduct>>>`.
   */
  using std__shared_ptr_Promise_std__vector_PurchaseProduct___ = std::shared_ptr<Promise<std::vector<PurchaseProduct>>>;
  inline std::shared_ptr<Promise<std::vector<PurchaseProduct>>> create_std__shared_ptr_Promise_std__vector_PurchaseProduct___() noexcept {
    return Promise<std::vector<PurchaseProduct>>::create();
  }
  inline PromiseHolder<std::vector<PurchaseProduct>> wrap_std__shared_ptr_Promise_std__vector_PurchaseProduct___(std::shared_ptr<Promise<std::vector<PurchaseProduct>>> promise) noexcept {
    return PromiseHolder<std::vector<PurchaseProduct>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<PurchaseProduct>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<PurchaseProduct>&)>`.
   */
  using Func_void_std__vector_PurchaseProduct_ = std::function<void(const std::vector<PurchaseProduct>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<PurchaseProduct>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_PurchaseProduct__Wrapper final {
  public:
    explicit Func_void_std__vector_PurchaseProduct__Wrapper(std::function<void(const std::vector<PurchaseProduct>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<PurchaseProduct>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<PurchaseProduct> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<PurchaseProduct>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_PurchaseProduct_ create_Func_void_std__vector_PurchaseProduct_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_PurchaseProduct__Wrapper wrap_Func_void_std__vector_PurchaseProduct_(Func_void_std__vector_PurchaseProduct_ value) noexcept {
    return Func_void_std__vector_PurchaseProduct__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<PurchaseTransaction>
  /**
   * Specialized version of `std::optional<PurchaseTransaction>`.
   */
  using std__optional_PurchaseTransaction_ = std::optional<PurchaseTransaction>;
  inline std::optional<PurchaseTransaction> create_std__optional_PurchaseTransaction_(const PurchaseTransaction& value) noexcept {
    return std::optional<PurchaseTransaction>(value);
  }
  inline bool has_value_std__optional_PurchaseTransaction_(const std::optional<PurchaseTransaction>& optional) noexcept {
    return optional.has_value();
  }
  inline PurchaseTransaction get_std__optional_PurchaseTransaction_(const std::optional<PurchaseTransaction>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<PurchaseResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<PurchaseResult>>`.
   */
  using std__shared_ptr_Promise_PurchaseResult__ = std::shared_ptr<Promise<PurchaseResult>>;
  inline std::shared_ptr<Promise<PurchaseResult>> create_std__shared_ptr_Promise_PurchaseResult__() noexcept {
    return Promise<PurchaseResult>::create();
  }
  inline PromiseHolder<PurchaseResult> wrap_std__shared_ptr_Promise_PurchaseResult__(std::shared_ptr<Promise<PurchaseResult>> promise) noexcept {
    return PromiseHolder<PurchaseResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const PurchaseResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const PurchaseResult&)>`.
   */
  using Func_void_PurchaseResult = std::function<void(const PurchaseResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const PurchaseResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_PurchaseResult_Wrapper final {
  public:
    explicit Func_void_PurchaseResult_Wrapper(std::function<void(const PurchaseResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const PurchaseResult& /* result */)>>(std::move(func))) {}
    inline void call(PurchaseResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const PurchaseResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PurchaseResult create_Func_void_PurchaseResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PurchaseResult_Wrapper wrap_Func_void_PurchaseResult(Func_void_PurchaseResult value) noexcept {
    return Func_void_PurchaseResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<PurchaseTransaction>
  /**
   * Specialized version of `std::vector<PurchaseTransaction>`.
   */
  using std__vector_PurchaseTransaction_ = std::vector<PurchaseTransaction>;
  inline std::vector<PurchaseTransaction> create_std__vector_PurchaseTransaction_(size_t size) noexcept {
    std::vector<PurchaseTransaction> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<PurchaseTransaction>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<PurchaseTransaction>>>`.
   */
  using std__shared_ptr_Promise_std__vector_PurchaseTransaction___ = std::shared_ptr<Promise<std::vector<PurchaseTransaction>>>;
  inline std::shared_ptr<Promise<std::vector<PurchaseTransaction>>> create_std__shared_ptr_Promise_std__vector_PurchaseTransaction___() noexcept {
    return Promise<std::vector<PurchaseTransaction>>::create();
  }
  inline PromiseHolder<std::vector<PurchaseTransaction>> wrap_std__shared_ptr_Promise_std__vector_PurchaseTransaction___(std::shared_ptr<Promise<std::vector<PurchaseTransaction>>> promise) noexcept {
    return PromiseHolder<std::vector<PurchaseTransaction>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<PurchaseTransaction>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<PurchaseTransaction>&)>`.
   */
  using Func_void_std__vector_PurchaseTransaction_ = std::function<void(const std::vector<PurchaseTransaction>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<PurchaseTransaction>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_PurchaseTransaction__Wrapper final {
  public:
    explicit Func_void_std__vector_PurchaseTransaction__Wrapper(std::function<void(const std::vector<PurchaseTransaction>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<PurchaseTransaction>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<PurchaseTransaction> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<PurchaseTransaction>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_PurchaseTransaction_ create_Func_void_std__vector_PurchaseTransaction_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_PurchaseTransaction__Wrapper wrap_Func_void_std__vector_PurchaseTransaction_(Func_void_std__vector_PurchaseTransaction_ value) noexcept {
    return Func_void_std__vector_PurchaseTransaction__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::function<void(const PurchaseUpdate& /* update */)>
  /**
   * Specialized version of `std::function<void(const PurchaseUpdate&)>`.
   */
  using Func_void_PurchaseUpdate = std::function<void(const PurchaseUpdate& /* update */)>;
  /**
   * Wrapper class for a `std::function<void(const PurchaseUpdate& / * update * /)>`, this can be used from Swift.
   */
  class Func_void_PurchaseUpdate_Wrapper final {
  public:
    explicit Func_void_PurchaseUpdate_Wrapper(std::function<void(const PurchaseUpdate& /* update */)>&& func): _function(std::make_unique<std::function<void(const PurchaseUpdate& /* update */)>>(std::move(func))) {}
    inline void call(PurchaseUpdate update) const noexcept {
      _function->operator()(update);
    }
  private:
    std::unique_ptr<std::function<void(const PurchaseUpdate& /* update */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_PurchaseUpdate create_Func_void_PurchaseUpdate(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_PurchaseUpdate_Wrapper wrap_Func_void_PurchaseUpdate(Func_void_PurchaseUpdate value) noexcept {
    return Func_void_PurchaseUpdate_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOnePurchasesSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOnePurchasesSpec>`.
   */
  using std__shared_ptr_HybridOnePurchasesSpec_ = std::shared_ptr<HybridOnePurchasesSpec>;
  std::shared_ptr<HybridOnePurchasesSpec> create_std__shared_ptr_HybridOnePurchasesSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOnePurchasesSpec_(std__shared_ptr_HybridOnePurchasesSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOnePurchasesSpec>
  using std__weak_ptr_HybridOnePurchasesSpec_ = std::weak_ptr<HybridOnePurchasesSpec>;
  inline std__weak_ptr_HybridOnePurchasesSpec_ weakify_std__shared_ptr_HybridOnePurchasesSpec_(const std::shared_ptr<HybridOnePurchasesSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<PurchaseProduct>>>>
  using Result_std__shared_ptr_Promise_std__vector_PurchaseProduct____ = Result<std::shared_ptr<Promise<std::vector<PurchaseProduct>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_PurchaseProduct____ create_Result_std__shared_ptr_Promise_std__vector_PurchaseProduct____(const std::shared_ptr<Promise<std::vector<PurchaseProduct>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<PurchaseProduct>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_PurchaseProduct____ create_Result_std__shared_ptr_Promise_std__vector_PurchaseProduct____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<PurchaseProduct>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<PurchaseResult>>>
  using Result_std__shared_ptr_Promise_PurchaseResult___ = Result<std::shared_ptr<Promise<PurchaseResult>>>;
  inline Result_std__shared_ptr_Promise_PurchaseResult___ create_Result_std__shared_ptr_Promise_PurchaseResult___(const std::shared_ptr<Promise<PurchaseResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<PurchaseResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_PurchaseResult___ create_Result_std__shared_ptr_Promise_PurchaseResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<PurchaseResult>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<PurchaseTransaction>>>>
  using Result_std__shared_ptr_Promise_std__vector_PurchaseTransaction____ = Result<std::shared_ptr<Promise<std::vector<PurchaseTransaction>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_PurchaseTransaction____ create_Result_std__shared_ptr_Promise_std__vector_PurchaseTransaction____(const std::shared_ptr<Promise<std::vector<PurchaseTransaction>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<PurchaseTransaction>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_PurchaseTransaction____ create_Result_std__shared_ptr_Promise_std__vector_PurchaseTransaction____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<PurchaseTransaction>>>>::withError(error);
  }
  
  // pragma MARK: std::vector<QuickActionItem>
  /**
   * Specialized version of `std::vector<QuickActionItem>`.
   */
  using std__vector_QuickActionItem_ = std::vector<QuickActionItem>;
  inline std::vector<QuickActionItem> create_std__vector_QuickActionItem_(size_t size) noexcept {
    std::vector<QuickActionItem> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<QuickActionItem>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<QuickActionItem>>>`.
   */
  using std__shared_ptr_Promise_std__vector_QuickActionItem___ = std::shared_ptr<Promise<std::vector<QuickActionItem>>>;
  inline std::shared_ptr<Promise<std::vector<QuickActionItem>>> create_std__shared_ptr_Promise_std__vector_QuickActionItem___() noexcept {
    return Promise<std::vector<QuickActionItem>>::create();
  }
  inline PromiseHolder<std::vector<QuickActionItem>> wrap_std__shared_ptr_Promise_std__vector_QuickActionItem___(std::shared_ptr<Promise<std::vector<QuickActionItem>>> promise) noexcept {
    return PromiseHolder<std::vector<QuickActionItem>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<QuickActionItem>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<QuickActionItem>&)>`.
   */
  using Func_void_std__vector_QuickActionItem_ = std::function<void(const std::vector<QuickActionItem>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<QuickActionItem>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_QuickActionItem__Wrapper final {
  public:
    explicit Func_void_std__vector_QuickActionItem__Wrapper(std::function<void(const std::vector<QuickActionItem>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<QuickActionItem>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<QuickActionItem> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<QuickActionItem>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_QuickActionItem_ create_Func_void_std__vector_QuickActionItem_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_QuickActionItem__Wrapper wrap_Func_void_std__vector_QuickActionItem_(Func_void_std__vector_QuickActionItem_ value) noexcept {
    return Func_void_std__vector_QuickActionItem__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneQuickActionsSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneQuickActionsSpec>`.
   */
  using std__shared_ptr_HybridOneQuickActionsSpec_ = std::shared_ptr<HybridOneQuickActionsSpec>;
  std::shared_ptr<HybridOneQuickActionsSpec> create_std__shared_ptr_HybridOneQuickActionsSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneQuickActionsSpec_(std__shared_ptr_HybridOneQuickActionsSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneQuickActionsSpec>
  using std__weak_ptr_HybridOneQuickActionsSpec_ = std::weak_ptr<HybridOneQuickActionsSpec>;
  inline std__weak_ptr_HybridOneQuickActionsSpec_ weakify_std__shared_ptr_HybridOneQuickActionsSpec_(const std::shared_ptr<HybridOneQuickActionsSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<QuickActionItem>>>>
  using Result_std__shared_ptr_Promise_std__vector_QuickActionItem____ = Result<std::shared_ptr<Promise<std::vector<QuickActionItem>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_QuickActionItem____ create_Result_std__shared_ptr_Promise_std__vector_QuickActionItem____(const std::shared_ptr<Promise<std::vector<QuickActionItem>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<QuickActionItem>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_QuickActionItem____ create_Result_std__shared_ptr_Promise_std__vector_QuickActionItem____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<QuickActionItem>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::optional<std::string>>
  using Result_std__optional_std__string__ = Result<std::optional<std::string>>;
  inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::optional<std::string>& value) noexcept {
    return Result<std::optional<std::string>>::withValue(value);
  }
  inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::exception_ptr& error) noexcept {
    return Result<std::optional<std::string>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<ScreenCaptureState>>
  /**
   * Specialized version of `std::shared_ptr<Promise<ScreenCaptureState>>`.
   */
  using std__shared_ptr_Promise_ScreenCaptureState__ = std::shared_ptr<Promise<ScreenCaptureState>>;
  inline std::shared_ptr<Promise<ScreenCaptureState>> create_std__shared_ptr_Promise_ScreenCaptureState__() noexcept {
    return Promise<ScreenCaptureState>::create();
  }
  inline PromiseHolder<ScreenCaptureState> wrap_std__shared_ptr_Promise_ScreenCaptureState__(std::shared_ptr<Promise<ScreenCaptureState>> promise) noexcept {
    return PromiseHolder<ScreenCaptureState>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(ScreenCaptureState /* result */)>
  /**
   * Specialized version of `std::function<void(ScreenCaptureState)>`.
   */
  using Func_void_ScreenCaptureState = std::function<void(ScreenCaptureState /* result */)>;
  /**
   * Wrapper class for a `std::function<void(ScreenCaptureState / * result * /)>`, this can be used from Swift.
   */
  class Func_void_ScreenCaptureState_Wrapper final {
  public:
    explicit Func_void_ScreenCaptureState_Wrapper(std::function<void(ScreenCaptureState /* result */)>&& func): _function(std::make_unique<std::function<void(ScreenCaptureState /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<ScreenCaptureState>(result));
    }
  private:
    std::unique_ptr<std::function<void(ScreenCaptureState /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_ScreenCaptureState create_Func_void_ScreenCaptureState(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_ScreenCaptureState_Wrapper wrap_Func_void_ScreenCaptureState(Func_void_ScreenCaptureState value) noexcept {
    return Func_void_ScreenCaptureState_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<ScreenCaptureResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<ScreenCaptureResult>>`.
   */
  using std__shared_ptr_Promise_ScreenCaptureResult__ = std::shared_ptr<Promise<ScreenCaptureResult>>;
  inline std::shared_ptr<Promise<ScreenCaptureResult>> create_std__shared_ptr_Promise_ScreenCaptureResult__() noexcept {
    return Promise<ScreenCaptureResult>::create();
  }
  inline PromiseHolder<ScreenCaptureResult> wrap_std__shared_ptr_Promise_ScreenCaptureResult__(std::shared_ptr<Promise<ScreenCaptureResult>> promise) noexcept {
    return PromiseHolder<ScreenCaptureResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const ScreenCaptureResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const ScreenCaptureResult&)>`.
   */
  using Func_void_ScreenCaptureResult = std::function<void(const ScreenCaptureResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const ScreenCaptureResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_ScreenCaptureResult_Wrapper final {
  public:
    explicit Func_void_ScreenCaptureResult_Wrapper(std::function<void(const ScreenCaptureResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const ScreenCaptureResult& /* result */)>>(std::move(func))) {}
    inline void call(ScreenCaptureResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const ScreenCaptureResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_ScreenCaptureResult create_Func_void_ScreenCaptureResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_ScreenCaptureResult_Wrapper wrap_Func_void_ScreenCaptureResult(Func_void_ScreenCaptureResult value) noexcept {
    return Func_void_ScreenCaptureResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneScreenCaptureSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneScreenCaptureSpec>`.
   */
  using std__shared_ptr_HybridOneScreenCaptureSpec_ = std::shared_ptr<HybridOneScreenCaptureSpec>;
  std::shared_ptr<HybridOneScreenCaptureSpec> create_std__shared_ptr_HybridOneScreenCaptureSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneScreenCaptureSpec_(std__shared_ptr_HybridOneScreenCaptureSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneScreenCaptureSpec>
  using std__weak_ptr_HybridOneScreenCaptureSpec_ = std::weak_ptr<HybridOneScreenCaptureSpec>;
  inline std__weak_ptr_HybridOneScreenCaptureSpec_ weakify_std__shared_ptr_HybridOneScreenCaptureSpec_(const std::shared_ptr<HybridOneScreenCaptureSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<ScreenCaptureState>>>
  using Result_std__shared_ptr_Promise_ScreenCaptureState___ = Result<std::shared_ptr<Promise<ScreenCaptureState>>>;
  inline Result_std__shared_ptr_Promise_ScreenCaptureState___ create_Result_std__shared_ptr_Promise_ScreenCaptureState___(const std::shared_ptr<Promise<ScreenCaptureState>>& value) noexcept {
    return Result<std::shared_ptr<Promise<ScreenCaptureState>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_ScreenCaptureState___ create_Result_std__shared_ptr_Promise_ScreenCaptureState___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<ScreenCaptureState>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<ScreenCaptureResult>>>
  using Result_std__shared_ptr_Promise_ScreenCaptureResult___ = Result<std::shared_ptr<Promise<ScreenCaptureResult>>>;
  inline Result_std__shared_ptr_Promise_ScreenCaptureResult___ create_Result_std__shared_ptr_Promise_ScreenCaptureResult___(const std::shared_ptr<Promise<ScreenCaptureResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<ScreenCaptureResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_ScreenCaptureResult___ create_Result_std__shared_ptr_Promise_ScreenCaptureResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<ScreenCaptureResult>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<ScreenOrientationValue>>
  /**
   * Specialized version of `std::shared_ptr<Promise<ScreenOrientationValue>>`.
   */
  using std__shared_ptr_Promise_ScreenOrientationValue__ = std::shared_ptr<Promise<ScreenOrientationValue>>;
  inline std::shared_ptr<Promise<ScreenOrientationValue>> create_std__shared_ptr_Promise_ScreenOrientationValue__() noexcept {
    return Promise<ScreenOrientationValue>::create();
  }
  inline PromiseHolder<ScreenOrientationValue> wrap_std__shared_ptr_Promise_ScreenOrientationValue__(std::shared_ptr<Promise<ScreenOrientationValue>> promise) noexcept {
    return PromiseHolder<ScreenOrientationValue>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(ScreenOrientationValue /* result */)>
  /**
   * Specialized version of `std::function<void(ScreenOrientationValue)>`.
   */
  using Func_void_ScreenOrientationValue = std::function<void(ScreenOrientationValue /* result */)>;
  /**
   * Wrapper class for a `std::function<void(ScreenOrientationValue / * result * /)>`, this can be used from Swift.
   */
  class Func_void_ScreenOrientationValue_Wrapper final {
  public:
    explicit Func_void_ScreenOrientationValue_Wrapper(std::function<void(ScreenOrientationValue /* result */)>&& func): _function(std::make_unique<std::function<void(ScreenOrientationValue /* result */)>>(std::move(func))) {}
    inline void call(int result) const noexcept {
      _function->operator()(static_cast<ScreenOrientationValue>(result));
    }
  private:
    std::unique_ptr<std::function<void(ScreenOrientationValue /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_ScreenOrientationValue create_Func_void_ScreenOrientationValue(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_ScreenOrientationValue_Wrapper wrap_Func_void_ScreenOrientationValue(Func_void_ScreenOrientationValue value) noexcept {
    return Func_void_ScreenOrientationValue_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneScreenOrientationSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneScreenOrientationSpec>`.
   */
  using std__shared_ptr_HybridOneScreenOrientationSpec_ = std::shared_ptr<HybridOneScreenOrientationSpec>;
  std::shared_ptr<HybridOneScreenOrientationSpec> create_std__shared_ptr_HybridOneScreenOrientationSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneScreenOrientationSpec_(std__shared_ptr_HybridOneScreenOrientationSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneScreenOrientationSpec>
  using std__weak_ptr_HybridOneScreenOrientationSpec_ = std::weak_ptr<HybridOneScreenOrientationSpec>;
  inline std__weak_ptr_HybridOneScreenOrientationSpec_ weakify_std__shared_ptr_HybridOneScreenOrientationSpec_(const std::shared_ptr<HybridOneScreenOrientationSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<ScreenOrientationValue>>>
  using Result_std__shared_ptr_Promise_ScreenOrientationValue___ = Result<std::shared_ptr<Promise<ScreenOrientationValue>>>;
  inline Result_std__shared_ptr_Promise_ScreenOrientationValue___ create_Result_std__shared_ptr_Promise_ScreenOrientationValue___(const std::shared_ptr<Promise<ScreenOrientationValue>>& value) noexcept {
    return Result<std::shared_ptr<Promise<ScreenOrientationValue>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_ScreenOrientationValue___ create_Result_std__shared_ptr_Promise_ScreenOrientationValue___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<ScreenOrientationValue>>>::withError(error);
  }
  
  // pragma MARK: std::optional<SecureStoreAccessibility>
  /**
   * Specialized version of `std::optional<SecureStoreAccessibility>`.
   */
  using std__optional_SecureStoreAccessibility_ = std::optional<SecureStoreAccessibility>;
  inline std::optional<SecureStoreAccessibility> create_std__optional_SecureStoreAccessibility_(const SecureStoreAccessibility& value) noexcept {
    return std::optional<SecureStoreAccessibility>(value);
  }
  inline bool has_value_std__optional_SecureStoreAccessibility_(const std::optional<SecureStoreAccessibility>& optional) noexcept {
    return optional.has_value();
  }
  inline SecureStoreAccessibility get_std__optional_SecureStoreAccessibility_(const std::optional<SecureStoreAccessibility>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridOneSecureStoreSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneSecureStoreSpec>`.
   */
  using std__shared_ptr_HybridOneSecureStoreSpec_ = std::shared_ptr<HybridOneSecureStoreSpec>;
  std::shared_ptr<HybridOneSecureStoreSpec> create_std__shared_ptr_HybridOneSecureStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneSecureStoreSpec_(std__shared_ptr_HybridOneSecureStoreSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneSecureStoreSpec>
  using std__weak_ptr_HybridOneSecureStoreSpec_ = std::weak_ptr<HybridOneSecureStoreSpec>;
  inline std__weak_ptr_HybridOneSecureStoreSpec_ weakify_std__shared_ptr_HybridOneSecureStoreSpec_(const std::shared_ptr<HybridOneSecureStoreSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<Promise<ShareResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<ShareResult>>`.
   */
  using std__shared_ptr_Promise_ShareResult__ = std::shared_ptr<Promise<ShareResult>>;
  inline std::shared_ptr<Promise<ShareResult>> create_std__shared_ptr_Promise_ShareResult__() noexcept {
    return Promise<ShareResult>::create();
  }
  inline PromiseHolder<ShareResult> wrap_std__shared_ptr_Promise_ShareResult__(std::shared_ptr<Promise<ShareResult>> promise) noexcept {
    return PromiseHolder<ShareResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const ShareResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const ShareResult&)>`.
   */
  using Func_void_ShareResult = std::function<void(const ShareResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const ShareResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_ShareResult_Wrapper final {
  public:
    explicit Func_void_ShareResult_Wrapper(std::function<void(const ShareResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const ShareResult& /* result */)>>(std::move(func))) {}
    inline void call(ShareResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const ShareResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_ShareResult create_Func_void_ShareResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_ShareResult_Wrapper wrap_Func_void_ShareResult(Func_void_ShareResult value) noexcept {
    return Func_void_ShareResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<ShareItem>
  /**
   * Specialized version of `std::vector<ShareItem>`.
   */
  using std__vector_ShareItem_ = std::vector<ShareItem>;
  inline std::vector<ShareItem> create_std__vector_ShareItem_(size_t size) noexcept {
    std::vector<ShareItem> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<HybridOneShareSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneShareSpec>`.
   */
  using std__shared_ptr_HybridOneShareSpec_ = std::shared_ptr<HybridOneShareSpec>;
  std::shared_ptr<HybridOneShareSpec> create_std__shared_ptr_HybridOneShareSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneShareSpec_(std__shared_ptr_HybridOneShareSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneShareSpec>
  using std__weak_ptr_HybridOneShareSpec_ = std::weak_ptr<HybridOneShareSpec>;
  inline std__weak_ptr_HybridOneShareSpec_ weakify_std__shared_ptr_HybridOneShareSpec_(const std::shared_ptr<HybridOneShareSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<ShareResult>>>
  using Result_std__shared_ptr_Promise_ShareResult___ = Result<std::shared_ptr<Promise<ShareResult>>>;
  inline Result_std__shared_ptr_Promise_ShareResult___ create_Result_std__shared_ptr_Promise_ShareResult___(const std::shared_ptr<Promise<ShareResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<ShareResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_ShareResult___ create_Result_std__shared_ptr_Promise_ShareResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<ShareResult>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<SpeechPermissionResponse>>
  /**
   * Specialized version of `std::shared_ptr<Promise<SpeechPermissionResponse>>`.
   */
  using std__shared_ptr_Promise_SpeechPermissionResponse__ = std::shared_ptr<Promise<SpeechPermissionResponse>>;
  inline std::shared_ptr<Promise<SpeechPermissionResponse>> create_std__shared_ptr_Promise_SpeechPermissionResponse__() noexcept {
    return Promise<SpeechPermissionResponse>::create();
  }
  inline PromiseHolder<SpeechPermissionResponse> wrap_std__shared_ptr_Promise_SpeechPermissionResponse__(std::shared_ptr<Promise<SpeechPermissionResponse>> promise) noexcept {
    return PromiseHolder<SpeechPermissionResponse>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const SpeechPermissionResponse& /* result */)>
  /**
   * Specialized version of `std::function<void(const SpeechPermissionResponse&)>`.
   */
  using Func_void_SpeechPermissionResponse = std::function<void(const SpeechPermissionResponse& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const SpeechPermissionResponse& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_SpeechPermissionResponse_Wrapper final {
  public:
    explicit Func_void_SpeechPermissionResponse_Wrapper(std::function<void(const SpeechPermissionResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const SpeechPermissionResponse& /* result */)>>(std::move(func))) {}
    inline void call(SpeechPermissionResponse result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const SpeechPermissionResponse& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_SpeechPermissionResponse create_Func_void_SpeechPermissionResponse(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_SpeechPermissionResponse_Wrapper wrap_Func_void_SpeechPermissionResponse(Func_void_SpeechPermissionResponse value) noexcept {
    return Func_void_SpeechPermissionResponse_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::optional<SpeechErrorCode>
  /**
   * Specialized version of `std::optional<SpeechErrorCode>`.
   */
  using std__optional_SpeechErrorCode_ = std::optional<SpeechErrorCode>;
  inline std::optional<SpeechErrorCode> create_std__optional_SpeechErrorCode_(const SpeechErrorCode& value) noexcept {
    return std::optional<SpeechErrorCode>(value);
  }
  inline bool has_value_std__optional_SpeechErrorCode_(const std::optional<SpeechErrorCode>& optional) noexcept {
    return optional.has_value();
  }
  inline SpeechErrorCode get_std__optional_SpeechErrorCode_(const std::optional<SpeechErrorCode>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::function<void(const SpeechEvent& /* event */)>
  /**
   * Specialized version of `std::function<void(const SpeechEvent&)>`.
   */
  using Func_void_SpeechEvent = std::function<void(const SpeechEvent& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const SpeechEvent& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_SpeechEvent_Wrapper final {
  public:
    explicit Func_void_SpeechEvent_Wrapper(std::function<void(const SpeechEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const SpeechEvent& /* event */)>>(std::move(func))) {}
    inline void call(SpeechEvent event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const SpeechEvent& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_SpeechEvent create_Func_void_SpeechEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_SpeechEvent_Wrapper wrap_Func_void_SpeechEvent(Func_void_SpeechEvent value) noexcept {
    return Func_void_SpeechEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneSpeechSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneSpeechSpec>`.
   */
  using std__shared_ptr_HybridOneSpeechSpec_ = std::shared_ptr<HybridOneSpeechSpec>;
  std::shared_ptr<HybridOneSpeechSpec> create_std__shared_ptr_HybridOneSpeechSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneSpeechSpec_(std__shared_ptr_HybridOneSpeechSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneSpeechSpec>
  using std__weak_ptr_HybridOneSpeechSpec_ = std::weak_ptr<HybridOneSpeechSpec>;
  inline std__weak_ptr_HybridOneSpeechSpec_ weakify_std__shared_ptr_HybridOneSpeechSpec_(const std::shared_ptr<HybridOneSpeechSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<SpeechPermissionResponse>>>
  using Result_std__shared_ptr_Promise_SpeechPermissionResponse___ = Result<std::shared_ptr<Promise<SpeechPermissionResponse>>>;
  inline Result_std__shared_ptr_Promise_SpeechPermissionResponse___ create_Result_std__shared_ptr_Promise_SpeechPermissionResponse___(const std::shared_ptr<Promise<SpeechPermissionResponse>>& value) noexcept {
    return Result<std::shared_ptr<Promise<SpeechPermissionResponse>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_SpeechPermissionResponse___ create_Result_std__shared_ptr_Promise_SpeechPermissionResponse___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<SpeechPermissionResponse>>>::withError(error);
  }
  
  // pragma MARK: std::function<void(const SpeechSynthesisEvent& /* event */)>
  /**
   * Specialized version of `std::function<void(const SpeechSynthesisEvent&)>`.
   */
  using Func_void_SpeechSynthesisEvent = std::function<void(const SpeechSynthesisEvent& /* event */)>;
  /**
   * Wrapper class for a `std::function<void(const SpeechSynthesisEvent& / * event * /)>`, this can be used from Swift.
   */
  class Func_void_SpeechSynthesisEvent_Wrapper final {
  public:
    explicit Func_void_SpeechSynthesisEvent_Wrapper(std::function<void(const SpeechSynthesisEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const SpeechSynthesisEvent& /* event */)>>(std::move(func))) {}
    inline void call(SpeechSynthesisEvent event) const noexcept {
      _function->operator()(event);
    }
  private:
    std::unique_ptr<std::function<void(const SpeechSynthesisEvent& /* event */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_SpeechSynthesisEvent create_Func_void_SpeechSynthesisEvent(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_SpeechSynthesisEvent_Wrapper wrap_Func_void_SpeechSynthesisEvent(Func_void_SpeechSynthesisEvent value) noexcept {
    return Func_void_SpeechSynthesisEvent_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::vector<SpeechSynthesisVoice>
  /**
   * Specialized version of `std::vector<SpeechSynthesisVoice>`.
   */
  using std__vector_SpeechSynthesisVoice_ = std::vector<SpeechSynthesisVoice>;
  inline std::vector<SpeechSynthesisVoice> create_std__vector_SpeechSynthesisVoice_(size_t size) noexcept {
    std::vector<SpeechSynthesisVoice> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>>`.
   */
  using std__shared_ptr_Promise_std__vector_SpeechSynthesisVoice___ = std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>>;
  inline std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>> create_std__shared_ptr_Promise_std__vector_SpeechSynthesisVoice___() noexcept {
    return Promise<std::vector<SpeechSynthesisVoice>>::create();
  }
  inline PromiseHolder<std::vector<SpeechSynthesisVoice>> wrap_std__shared_ptr_Promise_std__vector_SpeechSynthesisVoice___(std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>> promise) noexcept {
    return PromiseHolder<std::vector<SpeechSynthesisVoice>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<SpeechSynthesisVoice>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<SpeechSynthesisVoice>&)>`.
   */
  using Func_void_std__vector_SpeechSynthesisVoice_ = std::function<void(const std::vector<SpeechSynthesisVoice>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<SpeechSynthesisVoice>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_SpeechSynthesisVoice__Wrapper final {
  public:
    explicit Func_void_std__vector_SpeechSynthesisVoice__Wrapper(std::function<void(const std::vector<SpeechSynthesisVoice>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<SpeechSynthesisVoice>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<SpeechSynthesisVoice> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<SpeechSynthesisVoice>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_SpeechSynthesisVoice_ create_Func_void_std__vector_SpeechSynthesisVoice_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_SpeechSynthesisVoice__Wrapper wrap_Func_void_std__vector_SpeechSynthesisVoice_(Func_void_std__vector_SpeechSynthesisVoice_ value) noexcept {
    return Func_void_std__vector_SpeechSynthesisVoice__Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneSpeechSynthesisSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneSpeechSynthesisSpec>`.
   */
  using std__shared_ptr_HybridOneSpeechSynthesisSpec_ = std::shared_ptr<HybridOneSpeechSynthesisSpec>;
  std::shared_ptr<HybridOneSpeechSynthesisSpec> create_std__shared_ptr_HybridOneSpeechSynthesisSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneSpeechSynthesisSpec_(std__shared_ptr_HybridOneSpeechSynthesisSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneSpeechSynthesisSpec>
  using std__weak_ptr_HybridOneSpeechSynthesisSpec_ = std::weak_ptr<HybridOneSpeechSynthesisSpec>;
  inline std__weak_ptr_HybridOneSpeechSynthesisSpec_ weakify_std__shared_ptr_HybridOneSpeechSynthesisSpec_(const std::shared_ptr<HybridOneSpeechSynthesisSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>>>
  using Result_std__shared_ptr_Promise_std__vector_SpeechSynthesisVoice____ = Result<std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_SpeechSynthesisVoice____ create_Result_std__shared_ptr_Promise_std__vector_SpeechSynthesisVoice____(const std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_SpeechSynthesisVoice____ create_Result_std__shared_ptr_Promise_std__vector_SpeechSynthesisVoice____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<SpeechSynthesisVoice>>>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<HybridOneStoreReviewSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneStoreReviewSpec>`.
   */
  using std__shared_ptr_HybridOneStoreReviewSpec_ = std::shared_ptr<HybridOneStoreReviewSpec>;
  std::shared_ptr<HybridOneStoreReviewSpec> create_std__shared_ptr_HybridOneStoreReviewSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneStoreReviewSpec_(std__shared_ptr_HybridOneStoreReviewSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneStoreReviewSpec>
  using std__weak_ptr_HybridOneStoreReviewSpec_ = std::weak_ptr<HybridOneStoreReviewSpec>;
  inline std__weak_ptr_HybridOneStoreReviewSpec_ weakify_std__shared_ptr_HybridOneStoreReviewSpec_(const std::shared_ptr<HybridOneStoreReviewSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::shared_ptr<Promise<OneUpdatesCheckResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<OneUpdatesCheckResult>>`.
   */
  using std__shared_ptr_Promise_OneUpdatesCheckResult__ = std::shared_ptr<Promise<OneUpdatesCheckResult>>;
  inline std::shared_ptr<Promise<OneUpdatesCheckResult>> create_std__shared_ptr_Promise_OneUpdatesCheckResult__() noexcept {
    return Promise<OneUpdatesCheckResult>::create();
  }
  inline PromiseHolder<OneUpdatesCheckResult> wrap_std__shared_ptr_Promise_OneUpdatesCheckResult__(std::shared_ptr<Promise<OneUpdatesCheckResult>> promise) noexcept {
    return PromiseHolder<OneUpdatesCheckResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const OneUpdatesCheckResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const OneUpdatesCheckResult&)>`.
   */
  using Func_void_OneUpdatesCheckResult = std::function<void(const OneUpdatesCheckResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const OneUpdatesCheckResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_OneUpdatesCheckResult_Wrapper final {
  public:
    explicit Func_void_OneUpdatesCheckResult_Wrapper(std::function<void(const OneUpdatesCheckResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const OneUpdatesCheckResult& /* result */)>>(std::move(func))) {}
    inline void call(OneUpdatesCheckResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const OneUpdatesCheckResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_OneUpdatesCheckResult create_Func_void_OneUpdatesCheckResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_OneUpdatesCheckResult_Wrapper wrap_Func_void_OneUpdatesCheckResult(Func_void_OneUpdatesCheckResult value) noexcept {
    return Func_void_OneUpdatesCheckResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<Promise<OneUpdatesFetchResult>>
  /**
   * Specialized version of `std::shared_ptr<Promise<OneUpdatesFetchResult>>`.
   */
  using std__shared_ptr_Promise_OneUpdatesFetchResult__ = std::shared_ptr<Promise<OneUpdatesFetchResult>>;
  inline std::shared_ptr<Promise<OneUpdatesFetchResult>> create_std__shared_ptr_Promise_OneUpdatesFetchResult__() noexcept {
    return Promise<OneUpdatesFetchResult>::create();
  }
  inline PromiseHolder<OneUpdatesFetchResult> wrap_std__shared_ptr_Promise_OneUpdatesFetchResult__(std::shared_ptr<Promise<OneUpdatesFetchResult>> promise) noexcept {
    return PromiseHolder<OneUpdatesFetchResult>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const OneUpdatesFetchResult& /* result */)>
  /**
   * Specialized version of `std::function<void(const OneUpdatesFetchResult&)>`.
   */
  using Func_void_OneUpdatesFetchResult = std::function<void(const OneUpdatesFetchResult& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const OneUpdatesFetchResult& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_OneUpdatesFetchResult_Wrapper final {
  public:
    explicit Func_void_OneUpdatesFetchResult_Wrapper(std::function<void(const OneUpdatesFetchResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const OneUpdatesFetchResult& /* result */)>>(std::move(func))) {}
    inline void call(OneUpdatesFetchResult result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const OneUpdatesFetchResult& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_OneUpdatesFetchResult create_Func_void_OneUpdatesFetchResult(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_OneUpdatesFetchResult_Wrapper wrap_Func_void_OneUpdatesFetchResult(Func_void_OneUpdatesFetchResult value) noexcept {
    return Func_void_OneUpdatesFetchResult_Wrapper(std::move(value));
  }
  
  // pragma MARK: std::shared_ptr<HybridOneUpdatesSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridOneUpdatesSpec>`.
   */
  using std__shared_ptr_HybridOneUpdatesSpec_ = std::shared_ptr<HybridOneUpdatesSpec>;
  std::shared_ptr<HybridOneUpdatesSpec> create_std__shared_ptr_HybridOneUpdatesSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridOneUpdatesSpec_(std__shared_ptr_HybridOneUpdatesSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridOneUpdatesSpec>
  using std__weak_ptr_HybridOneUpdatesSpec_ = std::weak_ptr<HybridOneUpdatesSpec>;
  inline std__weak_ptr_HybridOneUpdatesSpec_ weakify_std__shared_ptr_HybridOneUpdatesSpec_(const std::shared_ptr<HybridOneUpdatesSpec>& strong) noexcept { return strong; }
  
  // pragma MARK: Result<std::shared_ptr<Promise<OneUpdatesCheckResult>>>
  using Result_std__shared_ptr_Promise_OneUpdatesCheckResult___ = Result<std::shared_ptr<Promise<OneUpdatesCheckResult>>>;
  inline Result_std__shared_ptr_Promise_OneUpdatesCheckResult___ create_Result_std__shared_ptr_Promise_OneUpdatesCheckResult___(const std::shared_ptr<Promise<OneUpdatesCheckResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<OneUpdatesCheckResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_OneUpdatesCheckResult___ create_Result_std__shared_ptr_Promise_OneUpdatesCheckResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<OneUpdatesCheckResult>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<OneUpdatesFetchResult>>>
  using Result_std__shared_ptr_Promise_OneUpdatesFetchResult___ = Result<std::shared_ptr<Promise<OneUpdatesFetchResult>>>;
  inline Result_std__shared_ptr_Promise_OneUpdatesFetchResult___ create_Result_std__shared_ptr_Promise_OneUpdatesFetchResult___(const std::shared_ptr<Promise<OneUpdatesFetchResult>>& value) noexcept {
    return Result<std::shared_ptr<Promise<OneUpdatesFetchResult>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_OneUpdatesFetchResult___ create_Result_std__shared_ptr_Promise_OneUpdatesFetchResult___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<OneUpdatesFetchResult>>>::withError(error);
  }

} // namespace margelo::nitro::one::bridge::swift