UnmanagedCascableCoreBasicAPI.cpp

// This is an auto-generated file. Do not modify.

#include "UnmanagedCascableCoreBasicAPI.hpp"
#include <CascableCoreBasicAPI-Swift.h>

// Implementation of UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::BasicPropertyIdentifier(std::shared_ptr<CascableCoreBasicAPI::BasicPropertyIdentifier> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::~BasicPropertyIdentifier() {}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isoSpeed() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::isoSpeed();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::shutterSpeed() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::shutterSpeed();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::aperture() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::aperture();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::exposureCompensation() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::exposureCompensation();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::batteryLevel() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::batteryLevel();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::powerSource() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::powerSource();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::afSystem() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::afSystem();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::focusMode() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::focusMode();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::driveMode() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::driveMode();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::autoExposureMode() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::autoExposureMode();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::inCameraBracketingEnabled() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::inCameraBracketingEnabled();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::mirrorLockupEnabled() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::mirrorLockupEnabled();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::mirrorLockupStage() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::mirrorLockupStage();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::dofPreviewEnabled() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::dofPreviewEnabled();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::shotsAvailable() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::shotsAvailable();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::lensStatus() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::lensStatus();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::colorTone() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::colorTone();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::artFilter() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::artFilter();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::digitalZoom() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::digitalZoom();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::whiteBalance() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::whiteBalance();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::noiseReduction() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::noiseReduction();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::imageQuality() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::imageQuality();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::lightMeterStatus() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::lightMeterStatus();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::lightMeterReading() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::lightMeterReading();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::exposureMeteringMode() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::exposureMeteringMode();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::readyForCapture() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::readyForCapture();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::imageDestination() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::imageDestination();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::videoRecordingFormat() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::videoRecordingFormat();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::liveViewZoomLevel() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::liveViewZoomLevel();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::maxValue() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::maxValue();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::unknown() {
    CascableCoreBasicAPI::BasicPropertyIdentifier value = CascableCoreBasicAPI::BasicPropertyIdentifier::unknown();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(value));
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::operator==(const UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier &other) const {
    return (*swiftObj.get() == *other.swiftObj.get());
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isIsoSpeed() {
    bool swiftResult = swiftObj->isIsoSpeed();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isShutterSpeed() {
    bool swiftResult = swiftObj->isShutterSpeed();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isAperture() {
    bool swiftResult = swiftObj->isAperture();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isExposureCompensation() {
    bool swiftResult = swiftObj->isExposureCompensation();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isBatteryLevel() {
    bool swiftResult = swiftObj->isBatteryLevel();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isPowerSource() {
    bool swiftResult = swiftObj->isPowerSource();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isAfSystem() {
    bool swiftResult = swiftObj->isAfSystem();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isFocusMode() {
    bool swiftResult = swiftObj->isFocusMode();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isDriveMode() {
    bool swiftResult = swiftObj->isDriveMode();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isAutoExposureMode() {
    bool swiftResult = swiftObj->isAutoExposureMode();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isInCameraBracketingEnabled() {
    bool swiftResult = swiftObj->isInCameraBracketingEnabled();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isMirrorLockupEnabled() {
    bool swiftResult = swiftObj->isMirrorLockupEnabled();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isMirrorLockupStage() {
    bool swiftResult = swiftObj->isMirrorLockupStage();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isDofPreviewEnabled() {
    bool swiftResult = swiftObj->isDofPreviewEnabled();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isShotsAvailable() {
    bool swiftResult = swiftObj->isShotsAvailable();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isLensStatus() {
    bool swiftResult = swiftObj->isLensStatus();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isColorTone() {
    bool swiftResult = swiftObj->isColorTone();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isArtFilter() {
    bool swiftResult = swiftObj->isArtFilter();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isDigitalZoom() {
    bool swiftResult = swiftObj->isDigitalZoom();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isWhiteBalance() {
    bool swiftResult = swiftObj->isWhiteBalance();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isNoiseReduction() {
    bool swiftResult = swiftObj->isNoiseReduction();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isImageQuality() {
    bool swiftResult = swiftObj->isImageQuality();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isLightMeterStatus() {
    bool swiftResult = swiftObj->isLightMeterStatus();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isLightMeterReading() {
    bool swiftResult = swiftObj->isLightMeterReading();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isExposureMeteringMode() {
    bool swiftResult = swiftObj->isExposureMeteringMode();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isReadyForCapture() {
    bool swiftResult = swiftObj->isReadyForCapture();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isImageDestination() {
    bool swiftResult = swiftObj->isImageDestination();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isVideoRecordingFormat() {
    bool swiftResult = swiftObj->isVideoRecordingFormat();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isLiveViewZoomLevel() {
    bool swiftResult = swiftObj->isLiveViewZoomLevel();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isMaxValue() {
    bool swiftResult = swiftObj->isMaxValue();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::isUnknown() {
    bool swiftResult = swiftObj->isUnknown();
    return swiftResult;
}

std::optional<UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier> UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::initWithRawValue(unsigned int rawValue) {
    swift::UInt arg0 = (swift::UInt)rawValue;
    swift::Optional<CascableCoreBasicAPI::BasicPropertyIdentifier> swiftResult = CascableCoreBasicAPI::BasicPropertyIdentifier::init(arg0);
    if (swiftResult) {
        CascableCoreBasicAPI::BasicPropertyIdentifier unwrapped = swiftResult.get();
        return std::optional<UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier>(UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(unwrapped)));
    } else {
        return std::nullopt;
    }
}

unsigned int UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier::getRawValue() {
    swift::UInt swiftResult = swiftObj->getRawValue();
    return (unsigned int)swiftResult;
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicCamera

UnmanagedCascableCoreBasicAPI::BasicCamera::BasicCamera(std::shared_ptr<CascableCoreBasicAPI::BasicCamera> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicCamera::~BasicCamera() {}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicCamera::getFriendlyIdentifier() {
    swift::Optional<swift::String> swiftResult = swiftObj->getFriendlyIdentifier();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

bool UnmanagedCascableCoreBasicAPI::BasicCamera::getConnected() {
    bool swiftResult = swiftObj->getConnected();
    return swiftResult;
}

std::optional<UnmanagedCascableCoreBasicAPI::BasicDeviceInfo> UnmanagedCascableCoreBasicAPI::BasicCamera::getDeviceInfo() {
    swift::Optional<CascableCoreBasicAPI::BasicDeviceInfo> swiftResult = swiftObj->getDeviceInfo();
    if (swiftResult) {
        CascableCoreBasicAPI::BasicDeviceInfo unwrapped = swiftResult.get();
        return std::optional<UnmanagedCascableCoreBasicAPI::BasicDeviceInfo>(UnmanagedCascableCoreBasicAPI::BasicDeviceInfo(std::make_shared<CascableCoreBasicAPI::BasicDeviceInfo>(unwrapped)));
    } else {
        return std::nullopt;
    }
}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicCamera::getFriendlyDisplayName() {
    swift::Optional<swift::String> swiftResult = swiftObj->getFriendlyDisplayName();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::connect() {
    swiftObj->connect();
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::disconnect() {
    swiftObj->disconnect();
}

bool UnmanagedCascableCoreBasicAPI::BasicCamera::getAutoFocusEngaged() {
    bool swiftResult = swiftObj->getAutoFocusEngaged();
    return swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::engageAutoFocus() {
    swiftObj->engageAutoFocus();
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::disengageAutoFocus() {
    swiftObj->disengageAutoFocus();
}

bool UnmanagedCascableCoreBasicAPI::BasicCamera::getShutterEngaged() {
    bool swiftResult = swiftObj->getShutterEngaged();
    return swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::engageShutter() {
    swiftObj->engageShutter();
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::disengageShutter() {
    swiftObj->disengageShutter();
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::invokeOneShotShutterExplicitlyEngagingAutoFocus(bool triggerAutoFocus) {
    bool arg0 = triggerAutoFocus;
    swiftObj->invokeOneShotShutterExplicitlyEngagingAutoFocus(arg0);
}

std::optional<UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult> UnmanagedCascableCoreBasicAPI::BasicCamera::getLastReceivedPreview() {
    swift::Optional<CascableCoreBasicAPI::BasicCameraInitiatedTransferResult> swiftResult = swiftObj->getLastReceivedPreview();
    if (swiftResult) {
        CascableCoreBasicAPI::BasicCameraInitiatedTransferResult unwrapped = swiftResult.get();
        return std::optional<UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult>(UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult(std::make_shared<CascableCoreBasicAPI::BasicCameraInitiatedTransferResult>(unwrapped)));
    } else {
        return std::nullopt;
    }
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::setLastReceivedPreview(const std::optional<UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult> & value) {
    swift::Optional<CascableCoreBasicAPI::BasicCameraInitiatedTransferResult> arg0 = (value.has_value() ? swift::Optional<CascableCoreBasicAPI::BasicCameraInitiatedTransferResult>::init(*value->swiftObj.get()) : swift::Optional<CascableCoreBasicAPI::BasicCameraInitiatedTransferResult>::none());
    swiftObj->setLastReceivedPreview(arg0);
}

bool UnmanagedCascableCoreBasicAPI::BasicCamera::getHandleCameraInitiatedPreviews() {
    bool swiftResult = swiftObj->getHandleCameraInitiatedPreviews();
    return swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::setHandleCameraInitiatedPreviews(bool newValue) {
    bool arg0 = newValue;
    swiftObj->setHandleCameraInitiatedPreviews(arg0);
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::beginLiveViewStream() {
    swiftObj->beginLiveViewStream();
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::endLiveViewStream() {
    swiftObj->endLiveViewStream();
}

bool UnmanagedCascableCoreBasicAPI::BasicCamera::getLiveViewStreamActive() {
    bool swiftResult = swiftObj->getLiveViewStreamActive();
    return swiftResult;
}

std::optional<UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame> UnmanagedCascableCoreBasicAPI::BasicCamera::getLastLiveViewFrame() {
    swift::Optional<CascableCoreBasicAPI::BasicLiveViewFrame> swiftResult = swiftObj->getLastLiveViewFrame();
    if (swiftResult) {
        CascableCoreBasicAPI::BasicLiveViewFrame unwrapped = swiftResult.get();
        return std::optional<UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame>(UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame(std::make_shared<CascableCoreBasicAPI::BasicLiveViewFrame>(unwrapped)));
    } else {
        return std::nullopt;
    }
}

void UnmanagedCascableCoreBasicAPI::BasicCamera::setLastLiveViewFrame(const std::optional<UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame> & value) {
    swift::Optional<CascableCoreBasicAPI::BasicLiveViewFrame> arg0 = (value.has_value() ? swift::Optional<CascableCoreBasicAPI::BasicLiveViewFrame>::init(*value->swiftObj.get()) : swift::Optional<CascableCoreBasicAPI::BasicLiveViewFrame>::none());
    swiftObj->setLastLiveViewFrame(arg0);
}

std::vector<UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier> UnmanagedCascableCoreBasicAPI::BasicCamera::getKnownPropertyIdentifiers() {
    swift::Array<CascableCoreBasicAPI::BasicPropertyIdentifier> swiftResult = swiftObj->getKnownPropertyIdentifiers();
    std::vector<UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier> resultArray;
    resultArray.reserve(swiftResult.getCount());
    for (auto element : swiftResult) {
        resultArray.push_back(UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(element)));
    }
    return resultArray;
}

UnmanagedCascableCoreBasicAPI::BasicCameraProperty UnmanagedCascableCoreBasicAPI::BasicCamera::property(const UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier & identifier) {
    const CascableCoreBasicAPI::BasicPropertyIdentifier & arg0 = *identifier.swiftObj.get();
    CascableCoreBasicAPI::BasicCameraProperty swiftResult = swiftObj->property(arg0);
    return UnmanagedCascableCoreBasicAPI::BasicCameraProperty(std::make_shared<CascableCoreBasicAPI::BasicCameraProperty>(swiftResult));
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery

UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery::BasicCameraDiscovery(std::shared_ptr<CascableCoreBasicAPI::BasicCameraDiscovery> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery::~BasicCameraDiscovery() {}

UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery::sharedInstance() {
    CascableCoreBasicAPI::BasicCameraDiscovery swiftResult = CascableCoreBasicAPI::BasicCameraDiscovery::sharedInstance();
    return UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery(std::make_shared<CascableCoreBasicAPI::BasicCameraDiscovery>(swiftResult));
}

bool UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery::getDiscoveryRunning() {
    bool swiftResult = swiftObj->getDiscoveryRunning();
    return swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery::setDiscoveryRunning(bool value) {
    bool arg0 = value;
    swiftObj->setDiscoveryRunning(arg0);
}

std::vector<UnmanagedCascableCoreBasicAPI::BasicCamera> UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery::getVisibleCameras() {
    swift::Array<CascableCoreBasicAPI::BasicCamera> swiftResult = swiftObj->getVisibleCameras();
    std::vector<UnmanagedCascableCoreBasicAPI::BasicCamera> resultArray;
    resultArray.reserve(swiftResult.getCount());
    for (auto element : swiftResult) {
        resultArray.push_back(UnmanagedCascableCoreBasicAPI::BasicCamera(std::make_shared<CascableCoreBasicAPI::BasicCamera>(element)));
    }
    return resultArray;
}

void UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery::startDiscovery(const std::string & clientName) {
    const swift::String & arg0 = (swift::String)clientName;
    swiftObj->startDiscovery(arg0);
}

void UnmanagedCascableCoreBasicAPI::BasicCameraDiscovery::stopDiscovery() {
    swiftObj->stopDiscovery();
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult

UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::BasicCameraInitiatedTransferResult(std::shared_ptr<CascableCoreBasicAPI::BasicCameraInitiatedTransferResult> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::~BasicCameraInitiatedTransferResult() {}

double UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::getDateProduced() {
    double swiftResult = swiftObj->getDateProduced();
    return swiftResult;
}

bool UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::isOnlyDestinationForImage() {
    bool swiftResult = swiftObj->isOnlyDestinationForImage();
    return swiftResult;
}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::getFileNameHint() {
    swift::Optional<swift::String> swiftResult = swiftObj->getFileNameHint();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::getSuggestedFileNameExtensionForRepresentation() {
    swift::Optional<swift::String> swiftResult = swiftObj->getSuggestedFileNameExtensionForRepresentation();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::getUtiForRepresentation() {
    swift::Optional<swift::String> swiftResult = swiftObj->getUtiForRepresentation();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

int UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::getRawImageDataLength() {
    swift::Int swiftResult = swiftObj->getRawImageDataLength();
    return (int)swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicCameraInitiatedTransferResult::copyPixelData(uint8_t* pointer) {
    uint8_t* arg0 = pointer;
    swiftObj->copyPixelData(arg0);
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicCameraProperty

UnmanagedCascableCoreBasicAPI::BasicCameraProperty::BasicCameraProperty(std::shared_ptr<CascableCoreBasicAPI::BasicCameraProperty> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicCameraProperty::~BasicCameraProperty() {}

UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier UnmanagedCascableCoreBasicAPI::BasicCameraProperty::getIdentifier() {
    CascableCoreBasicAPI::BasicPropertyIdentifier swiftResult = swiftObj->getIdentifier();
    return UnmanagedCascableCoreBasicAPI::BasicPropertyIdentifier(std::make_shared<CascableCoreBasicAPI::BasicPropertyIdentifier>(swiftResult));
}

std::optional<UnmanagedCascableCoreBasicAPI::BasicCamera> UnmanagedCascableCoreBasicAPI::BasicCameraProperty::getCamera() {
    swift::Optional<CascableCoreBasicAPI::BasicCamera> swiftResult = swiftObj->getCamera();
    if (swiftResult) {
        CascableCoreBasicAPI::BasicCamera unwrapped = swiftResult.get();
        return std::optional<UnmanagedCascableCoreBasicAPI::BasicCamera>(UnmanagedCascableCoreBasicAPI::BasicCamera(std::make_shared<CascableCoreBasicAPI::BasicCamera>(unwrapped)));
    } else {
        return std::nullopt;
    }
}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicCameraProperty::getLocalizedDisplayName() {
    swift::Optional<swift::String> swiftResult = swiftObj->getLocalizedDisplayName();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

std::optional<UnmanagedCascableCoreBasicAPI::BasicPropertyValue> UnmanagedCascableCoreBasicAPI::BasicCameraProperty::getCurrentValue() {
    swift::Optional<CascableCoreBasicAPI::BasicPropertyValue> swiftResult = swiftObj->getCurrentValue();
    if (swiftResult) {
        CascableCoreBasicAPI::BasicPropertyValue unwrapped = swiftResult.get();
        return std::optional<UnmanagedCascableCoreBasicAPI::BasicPropertyValue>(UnmanagedCascableCoreBasicAPI::BasicPropertyValue(std::make_shared<CascableCoreBasicAPI::BasicPropertyValue>(unwrapped)));
    } else {
        return std::nullopt;
    }
}

void UnmanagedCascableCoreBasicAPI::BasicCameraProperty::setCurrentValue(const std::optional<UnmanagedCascableCoreBasicAPI::BasicPropertyValue> & value) {
    swift::Optional<CascableCoreBasicAPI::BasicPropertyValue> arg0 = (value.has_value() ? swift::Optional<CascableCoreBasicAPI::BasicPropertyValue>::init(*value->swiftObj.get()) : swift::Optional<CascableCoreBasicAPI::BasicPropertyValue>::none());
    swiftObj->setCurrentValue(arg0);
}

std::optional<UnmanagedCascableCoreBasicAPI::BasicPropertyValue> UnmanagedCascableCoreBasicAPI::BasicCameraProperty::getPendingValue() {
    swift::Optional<CascableCoreBasicAPI::BasicPropertyValue> swiftResult = swiftObj->getPendingValue();
    if (swiftResult) {
        CascableCoreBasicAPI::BasicPropertyValue unwrapped = swiftResult.get();
        return std::optional<UnmanagedCascableCoreBasicAPI::BasicPropertyValue>(UnmanagedCascableCoreBasicAPI::BasicPropertyValue(std::make_shared<CascableCoreBasicAPI::BasicPropertyValue>(unwrapped)));
    } else {
        return std::nullopt;
    }
}

void UnmanagedCascableCoreBasicAPI::BasicCameraProperty::setPendingValue(const std::optional<UnmanagedCascableCoreBasicAPI::BasicPropertyValue> & value) {
    swift::Optional<CascableCoreBasicAPI::BasicPropertyValue> arg0 = (value.has_value() ? swift::Optional<CascableCoreBasicAPI::BasicPropertyValue>::init(*value->swiftObj.get()) : swift::Optional<CascableCoreBasicAPI::BasicPropertyValue>::none());
    swiftObj->setPendingValue(arg0);
}

std::vector<UnmanagedCascableCoreBasicAPI::BasicPropertyValue> UnmanagedCascableCoreBasicAPI::BasicCameraProperty::getValidSettableValues() {
    swift::Array<CascableCoreBasicAPI::BasicPropertyValue> swiftResult = swiftObj->getValidSettableValues();
    std::vector<UnmanagedCascableCoreBasicAPI::BasicPropertyValue> resultArray;
    resultArray.reserve(swiftResult.getCount());
    for (auto element : swiftResult) {
        resultArray.push_back(UnmanagedCascableCoreBasicAPI::BasicPropertyValue(std::make_shared<CascableCoreBasicAPI::BasicPropertyValue>(element)));
    }
    return resultArray;
}

void UnmanagedCascableCoreBasicAPI::BasicCameraProperty::setValidSettableValues(std::vector<UnmanagedCascableCoreBasicAPI::BasicPropertyValue> value) {
    swift::Array<CascableCoreBasicAPI::BasicPropertyValue> arg0Array = swift::Array<CascableCoreBasicAPI::BasicPropertyValue>::init();
    for (auto element: value) {
        arg0Array.append(*element.swiftObj.get());
    }
    swiftObj->setValidSettableValues(arg0Array);
}

void UnmanagedCascableCoreBasicAPI::BasicCameraProperty::setValue(const UnmanagedCascableCoreBasicAPI::BasicPropertyValue & newValue) {
    const CascableCoreBasicAPI::BasicPropertyValue & arg0 = *newValue.swiftObj.get();
    swiftObj->setValue(arg0);
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicDeviceInfo

UnmanagedCascableCoreBasicAPI::BasicDeviceInfo::BasicDeviceInfo(std::shared_ptr<CascableCoreBasicAPI::BasicDeviceInfo> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicDeviceInfo::~BasicDeviceInfo() {}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicDeviceInfo::getManufacturer() {
    swift::Optional<swift::String> swiftResult = swiftObj->getManufacturer();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicDeviceInfo::getModel() {
    swift::Optional<swift::String> swiftResult = swiftObj->getModel();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicDeviceInfo::getVersion() {
    swift::Optional<swift::String> swiftResult = swiftObj->getVersion();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicDeviceInfo::getSerialNumber() {
    swift::Optional<swift::String> swiftResult = swiftObj->getSerialNumber();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame

UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame::BasicLiveViewFrame(std::shared_ptr<CascableCoreBasicAPI::BasicLiveViewFrame> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame::~BasicLiveViewFrame() {}

double UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame::getDateProduced() {
    double swiftResult = swiftObj->getDateProduced();
    return swiftResult;
}

int UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame::getRawPixelDataLength() {
    swift::Int swiftResult = swiftObj->getRawPixelDataLength();
    return (int)swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame::copyPixelData(uint8_t* pointer) {
    uint8_t* arg0 = pointer;
    swiftObj->copyPixelData(arg0);
}

UnmanagedCascableCoreBasicAPI::BasicSize UnmanagedCascableCoreBasicAPI::BasicLiveViewFrame::getRawPixelSize() {
    CascableCoreBasicAPI::BasicSize swiftResult = swiftObj->getRawPixelSize();
    return UnmanagedCascableCoreBasicAPI::BasicSize(std::make_shared<CascableCoreBasicAPI::BasicSize>(swiftResult));
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicPropertyValue

UnmanagedCascableCoreBasicAPI::BasicPropertyValue::BasicPropertyValue(std::shared_ptr<CascableCoreBasicAPI::BasicPropertyValue> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicPropertyValue::~BasicPropertyValue() {}

std::optional<std::string> UnmanagedCascableCoreBasicAPI::BasicPropertyValue::getLocalizedDisplayValue() {
    swift::Optional<swift::String> swiftResult = swiftObj->getLocalizedDisplayValue();
    if (swiftResult) {
        swift::String unwrapped = swiftResult.get();
        return std::optional<std::string>((std::string)unwrapped);
    } else {
        return std::nullopt;
    }
}

std::string UnmanagedCascableCoreBasicAPI::BasicPropertyValue::getStringValue() {
    swift::String swiftResult = swiftObj->getStringValue();
    return (std::string)swiftResult;
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration

UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::BasicSimulatedCameraConfiguration(std::shared_ptr<CascableCoreBasicAPI::BasicSimulatedCameraConfiguration> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::~BasicSimulatedCameraConfiguration() {}

UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::defaultConfiguration() {
    CascableCoreBasicAPI::BasicSimulatedCameraConfiguration swiftResult = CascableCoreBasicAPI::BasicSimulatedCameraConfiguration::defaultConfiguration();
    return UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration(std::make_shared<CascableCoreBasicAPI::BasicSimulatedCameraConfiguration>(swiftResult));
}

std::string UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::getManufacturer() {
    swift::String swiftResult = swiftObj->getManufacturer();
    return (std::string)swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::setManufacturer(const std::string & value) {
    const swift::String & arg0 = (swift::String)value;
    swiftObj->setManufacturer(arg0);
}

std::string UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::getModel() {
    swift::String swiftResult = swiftObj->getModel();
    return (std::string)swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::setModel(const std::string & value) {
    const swift::String & arg0 = (swift::String)value;
    swiftObj->setModel(arg0);
}

std::string UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::getIdentifier() {
    swift::String swiftResult = swiftObj->getIdentifier();
    return (std::string)swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::setIdentifier(const std::string & value) {
    const swift::String & arg0 = (swift::String)value;
    swiftObj->setIdentifier(arg0);
}

std::string UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::getLiveViewImageContainerPath() {
    swift::String swiftResult = swiftObj->getLiveViewImageContainerPath();
    return (std::string)swiftResult;
}

void UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::setLiveViewImageContainerPath(const std::string & value) {
    const swift::String & arg0 = (swift::String)value;
    swiftObj->setLiveViewImageContainerPath(arg0);
}

void UnmanagedCascableCoreBasicAPI::BasicSimulatedCameraConfiguration::apply() {
    swiftObj->apply();
}

// Implementation of UnmanagedCascableCoreBasicAPI::BasicSize

UnmanagedCascableCoreBasicAPI::BasicSize::BasicSize(std::shared_ptr<CascableCoreBasicAPI::BasicSize> swiftObj) {
    this->swiftObj = swiftObj;
}

UnmanagedCascableCoreBasicAPI::BasicSize::~BasicSize() {}

double UnmanagedCascableCoreBasicAPI::BasicSize::getWidth() {
    double swiftResult = swiftObj->getWidth();
    return swiftResult;
}

double UnmanagedCascableCoreBasicAPI::BasicSize::getHeight() {
    double swiftResult = swiftObj->getHeight();
    return swiftResult;
}