io.qt.bluetooth.QBluetoothDeviceInfo Maven / Gradle / Ivy

Go to download
package io.qt.bluetooth;

import io.qt.*;


/**
 * Stores information about the Bluetooth device
 * Java wrapper for Qt class QBluetoothDeviceInfo
 */
public class QBluetoothDeviceInfo extends QtObject
    implements java.lang.Cloneable
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::CoreConfiguration
     * 
     * @see CoreConfigurations
     */
    public enum CoreConfiguration implements QtFlagEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UnknownCoreConfiguration
         */
        UnknownCoreConfiguration(0),
        /**
         * Representing QBluetoothDeviceInfo::LowEnergyCoreConfiguration
         */
        LowEnergyCoreConfiguration(1),
        /**
         * Representing QBluetoothDeviceInfo::BaseRateCoreConfiguration
         */
        BaseRateCoreConfiguration(2),
        /**
         * Representing QBluetoothDeviceInfo::BaseRateAndLowEnergyCoreConfiguration
         */
        BaseRateAndLowEnergyCoreConfiguration(3);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private CoreConfiguration(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull CoreConfigurations asFlags() {
            return new CoreConfigurations(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull CoreConfigurations combined(@NonNull CoreConfiguration e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull CoreConfigurations cleared(@NonNull CoreConfiguration e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link CoreConfigurations} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull CoreConfigurations flags(@Nullable CoreConfiguration @NonNull... values) {
            return new CoreConfigurations(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull CoreConfiguration resolve(int value) {
            switch (value) {
            case 0: return UnknownCoreConfiguration;
            case 1: return LowEnergyCoreConfiguration;
            case 2: return BaseRateCoreConfiguration;
            case 3: return BaseRateAndLowEnergyCoreConfiguration;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link CoreConfiguration}
     */
    public static final class CoreConfigurations extends QFlags implements Comparable {
        private static final long serialVersionUID = 0xd5528baf0c4e9790L;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new CoreConfigurations where the flags in args are set.
         * @param args enum entries
         */
        public CoreConfigurations(@Nullable CoreConfiguration @NonNull... args){
            super(args);
        }

        /**
         * Creates a new CoreConfigurations with given value.
         * @param value
         */
        public CoreConfigurations(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new CoreConfigurations
         */
        @Override
        public final @NonNull CoreConfigurations combined(@StrictNonNull CoreConfiguration e){
            return new CoreConfigurations(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull CoreConfigurations setFlag(@Nullable CoreConfiguration e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull CoreConfigurations setFlag(@Nullable CoreConfiguration e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this CoreConfigurations.
         * @return array of enum entries
         */
        @Override
        public final @NonNull CoreConfiguration @NonNull[] flags(){
            return super.flags(CoreConfiguration.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull CoreConfigurations clone(){
            return new CoreConfigurations(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull CoreConfigurations other){
            return Integer.compare(value(), other.value());
        }
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::DataCompleteness
     */
    public enum DataCompleteness implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::DataComplete
         */
        DataComplete(0),
        /**
         * Representing QBluetoothDeviceInfo::DataIncomplete
         */
        DataIncomplete(1),
        /**
         * Representing QBluetoothDeviceInfo::DataUnavailable
         */
        DataUnavailable(2);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private DataCompleteness(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull DataCompleteness resolve(int value) {
            switch (value) {
            case 0: return DataComplete;
            case 1: return DataIncomplete;
            case 2: return DataUnavailable;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::Field
     * 
     * @see Fields
     */
    public enum Field implements QtFlagEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::Field::None
         */
        None(0),
        /**
         * Representing QBluetoothDeviceInfo::Field::RSSI
         */
        RSSI(1),
        /**
         * Representing QBluetoothDeviceInfo::Field::ManufacturerData
         */
        ManufacturerData(2),
        /**
         * Representing QBluetoothDeviceInfo::Field::All
         */
        All(32767);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private Field(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull Fields asFlags() {
            return new Fields(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull Fields combined(@NonNull Field e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull Fields cleared(@NonNull Field e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link Fields} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull Fields flags(@Nullable Field @NonNull... values) {
            return new Fields(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull Field resolve(int value) {
            switch (value) {
            case 0: return None;
            case 1: return RSSI;
            case 2: return ManufacturerData;
            case 32767: return All;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link Field}
     */
    public static final class Fields extends QFlags implements Comparable {
        private static final long serialVersionUID = 0xeff356ae66f683c3L;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new Fields where the flags in args are set.
         * @param args enum entries
         */
        public Fields(@Nullable Field @NonNull... args){
            super(args);
        }

        /**
         * Creates a new Fields with given value.
         * @param value
         */
        public Fields(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new Fields
         */
        @Override
        public final @NonNull Fields combined(@StrictNonNull Field e){
            return new Fields(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull Fields setFlag(@Nullable Field e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull Fields setFlag(@Nullable Field e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this Fields.
         * @return array of enum entries
         */
        @Override
        public final @NonNull Field @NonNull[] flags(){
            return super.flags(Field.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull Fields clone(){
            return new Fields(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull Fields other){
            return Integer.compare(value(), other.value());
        }
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MajorDeviceClass
     */
    @QtRejectedEntries({"NetworkDevice"})
    public enum MajorDeviceClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::MiscellaneousDevice
         */
        MiscellaneousDevice(0),
        /**
         * Representing QBluetoothDeviceInfo::ComputerDevice
         */
        ComputerDevice(1),
        /**
         * Representing QBluetoothDeviceInfo::PhoneDevice
         */
        PhoneDevice(2),
        /**
         * Representing QBluetoothDeviceInfo::LANAccessDevice
         */
        LANAccessDevice(3),
        /**
         * Representing QBluetoothDeviceInfo::NetworkDevice
         */
        NetworkDevice(3),
        /**
         * Representing QBluetoothDeviceInfo::AudioVideoDevice
         */
        AudioVideoDevice(4),
        /**
         * Representing QBluetoothDeviceInfo::PeripheralDevice
         */
        PeripheralDevice(5),
        /**
         * Representing QBluetoothDeviceInfo::ImagingDevice
         */
        ImagingDevice(6),
        /**
         * Representing QBluetoothDeviceInfo::WearableDevice
         */
        WearableDevice(7),
        /**
         * Representing QBluetoothDeviceInfo::ToyDevice
         */
        ToyDevice(8),
        /**
         * Representing QBluetoothDeviceInfo::HealthDevice
         */
        HealthDevice(9),
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedDevice
         */
        UncategorizedDevice(31);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MajorDeviceClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MajorDeviceClass resolve(int value) {
            switch (value) {
            case 0: return MiscellaneousDevice;
            case 1: return ComputerDevice;
            case 2: return PhoneDevice;
            case 3: return LANAccessDevice;
            case 4: return AudioVideoDevice;
            case 5: return PeripheralDevice;
            case 6: return ImagingDevice;
            case 7: return WearableDevice;
            case 8: return ToyDevice;
            case 9: return HealthDevice;
            case 31: return UncategorizedDevice;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorAudioVideoClass
     */
    public enum MinorAudioVideoClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedAudioVideoDevice
         */
        UncategorizedAudioVideoDevice(0),
        /**
         * Representing QBluetoothDeviceInfo::WearableHeadsetDevice
         */
        WearableHeadsetDevice(1),
        /**
         * Representing QBluetoothDeviceInfo::HandsFreeDevice
         */
        HandsFreeDevice(2),
        /**
         * Representing QBluetoothDeviceInfo::Microphone
         */
        Microphone(4),
        /**
         * Representing QBluetoothDeviceInfo::Loudspeaker
         */
        Loudspeaker(5),
        /**
         * Representing QBluetoothDeviceInfo::Headphones
         */
        Headphones(6),
        /**
         * Representing QBluetoothDeviceInfo::PortableAudioDevice
         */
        PortableAudioDevice(7),
        /**
         * Representing QBluetoothDeviceInfo::CarAudio
         */
        CarAudio(8),
        /**
         * Representing QBluetoothDeviceInfo::SetTopBox
         */
        SetTopBox(9),
        /**
         * Representing QBluetoothDeviceInfo::HiFiAudioDevice
         */
        HiFiAudioDevice(10),
        /**
         * Representing QBluetoothDeviceInfo::Vcr
         */
        Vcr(11),
        /**
         * Representing QBluetoothDeviceInfo::VideoCamera
         */
        VideoCamera(12),
        /**
         * Representing QBluetoothDeviceInfo::Camcorder
         */
        Camcorder(13),
        /**
         * Representing QBluetoothDeviceInfo::VideoMonitor
         */
        VideoMonitor(14),
        /**
         * Representing QBluetoothDeviceInfo::VideoDisplayAndLoudspeaker
         */
        VideoDisplayAndLoudspeaker(15),
        /**
         * Representing QBluetoothDeviceInfo::VideoConferencing
         */
        VideoConferencing(16),
        /**
         * Representing QBluetoothDeviceInfo::GamingDevice
         */
        GamingDevice(18);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorAudioVideoClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorAudioVideoClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedAudioVideoDevice;
            case 1: return WearableHeadsetDevice;
            case 2: return HandsFreeDevice;
            case 4: return Microphone;
            case 5: return Loudspeaker;
            case 6: return Headphones;
            case 7: return PortableAudioDevice;
            case 8: return CarAudio;
            case 9: return SetTopBox;
            case 10: return HiFiAudioDevice;
            case 11: return Vcr;
            case 12: return VideoCamera;
            case 13: return Camcorder;
            case 14: return VideoMonitor;
            case 15: return VideoDisplayAndLoudspeaker;
            case 16: return VideoConferencing;
            case 18: return GamingDevice;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorComputerClass
     */
    public enum MinorComputerClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedComputer
         */
        UncategorizedComputer(0),
        /**
         * Representing QBluetoothDeviceInfo::DesktopComputer
         */
        DesktopComputer(1),
        /**
         * Representing QBluetoothDeviceInfo::ServerComputer
         */
        ServerComputer(2),
        /**
         * Representing QBluetoothDeviceInfo::LaptopComputer
         */
        LaptopComputer(3),
        /**
         * Representing QBluetoothDeviceInfo::HandheldClamShellComputer
         */
        HandheldClamShellComputer(4),
        /**
         * Representing QBluetoothDeviceInfo::HandheldComputer
         */
        HandheldComputer(5),
        /**
         * Representing QBluetoothDeviceInfo::WearableComputer
         */
        WearableComputer(6);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorComputerClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorComputerClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedComputer;
            case 1: return DesktopComputer;
            case 2: return ServerComputer;
            case 3: return LaptopComputer;
            case 4: return HandheldClamShellComputer;
            case 5: return HandheldComputer;
            case 6: return WearableComputer;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorHealthClass
     */
    public enum MinorHealthClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedHealthDevice
         */
        UncategorizedHealthDevice(0),
        /**
         * Representing QBluetoothDeviceInfo::HealthBloodPressureMonitor
         */
        HealthBloodPressureMonitor(1),
        /**
         * Representing QBluetoothDeviceInfo::HealthThermometer
         */
        HealthThermometer(2),
        /**
         * Representing QBluetoothDeviceInfo::HealthWeightScale
         */
        HealthWeightScale(3),
        /**
         * Representing QBluetoothDeviceInfo::HealthGlucoseMeter
         */
        HealthGlucoseMeter(4),
        /**
         * Representing QBluetoothDeviceInfo::HealthPulseOximeter
         */
        HealthPulseOximeter(5),
        /**
         * Representing QBluetoothDeviceInfo::HealthDataDisplay
         */
        HealthDataDisplay(7),
        /**
         * Representing QBluetoothDeviceInfo::HealthStepCounter
         */
        HealthStepCounter(8);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorHealthClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorHealthClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedHealthDevice;
            case 1: return HealthBloodPressureMonitor;
            case 2: return HealthThermometer;
            case 3: return HealthWeightScale;
            case 4: return HealthGlucoseMeter;
            case 5: return HealthPulseOximeter;
            case 7: return HealthDataDisplay;
            case 8: return HealthStepCounter;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorImagingClass
     */
    public enum MinorImagingClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedImagingDevice
         */
        UncategorizedImagingDevice(0),
        /**
         * Representing QBluetoothDeviceInfo::ImageDisplay
         */
        ImageDisplay(4),
        /**
         * Representing QBluetoothDeviceInfo::ImageCamera
         */
        ImageCamera(8),
        /**
         * Representing QBluetoothDeviceInfo::ImageScanner
         */
        ImageScanner(16),
        /**
         * Representing QBluetoothDeviceInfo::ImagePrinter
         */
        ImagePrinter(32);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorImagingClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorImagingClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedImagingDevice;
            case 4: return ImageDisplay;
            case 8: return ImageCamera;
            case 16: return ImageScanner;
            case 32: return ImagePrinter;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorMiscellaneousClass
     */
    public enum MinorMiscellaneousClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedMiscellaneous
         */
        UncategorizedMiscellaneous(0);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorMiscellaneousClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorMiscellaneousClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedMiscellaneous;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorNetworkClass
     */
    public enum MinorNetworkClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::NetworkFullService
         */
        NetworkFullService(0),
        /**
         * Representing QBluetoothDeviceInfo::NetworkLoadFactorOne
         */
        NetworkLoadFactorOne(8),
        /**
         * Representing QBluetoothDeviceInfo::NetworkLoadFactorTwo
         */
        NetworkLoadFactorTwo(16),
        /**
         * Representing QBluetoothDeviceInfo::NetworkLoadFactorThree
         */
        NetworkLoadFactorThree(24),
        /**
         * Representing QBluetoothDeviceInfo::NetworkLoadFactorFour
         */
        NetworkLoadFactorFour(32),
        /**
         * Representing QBluetoothDeviceInfo::NetworkLoadFactorFive
         */
        NetworkLoadFactorFive(40),
        /**
         * Representing QBluetoothDeviceInfo::NetworkLoadFactorSix
         */
        NetworkLoadFactorSix(48),
        /**
         * Representing QBluetoothDeviceInfo::NetworkNoService
         */
        NetworkNoService(56);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorNetworkClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorNetworkClass resolve(int value) {
            switch (value) {
            case 0: return NetworkFullService;
            case 8: return NetworkLoadFactorOne;
            case 16: return NetworkLoadFactorTwo;
            case 24: return NetworkLoadFactorThree;
            case 32: return NetworkLoadFactorFour;
            case 40: return NetworkLoadFactorFive;
            case 48: return NetworkLoadFactorSix;
            case 56: return NetworkNoService;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorPeripheralClass
     */
    public enum MinorPeripheralClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedPeripheral
         */
        UncategorizedPeripheral(0),
        /**
         * Representing QBluetoothDeviceInfo::KeyboardPeripheral
         */
        KeyboardPeripheral(16),
        /**
         * Representing QBluetoothDeviceInfo::PointingDevicePeripheral
         */
        PointingDevicePeripheral(32),
        /**
         * Representing QBluetoothDeviceInfo::KeyboardWithPointingDevicePeripheral
         */
        KeyboardWithPointingDevicePeripheral(48),
        /**
         * Representing QBluetoothDeviceInfo::JoystickPeripheral
         */
        JoystickPeripheral(1),
        /**
         * Representing QBluetoothDeviceInfo::GamepadPeripheral
         */
        GamepadPeripheral(2),
        /**
         * Representing QBluetoothDeviceInfo::RemoteControlPeripheral
         */
        RemoteControlPeripheral(3),
        /**
         * Representing QBluetoothDeviceInfo::SensingDevicePeripheral
         */
        SensingDevicePeripheral(4),
        /**
         * Representing QBluetoothDeviceInfo::DigitizerTabletPeripheral
         */
        DigitizerTabletPeripheral(5),
        /**
         * Representing QBluetoothDeviceInfo::CardReaderPeripheral
         */
        CardReaderPeripheral(6);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorPeripheralClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorPeripheralClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedPeripheral;
            case 16: return KeyboardPeripheral;
            case 32: return PointingDevicePeripheral;
            case 48: return KeyboardWithPointingDevicePeripheral;
            case 1: return JoystickPeripheral;
            case 2: return GamepadPeripheral;
            case 3: return RemoteControlPeripheral;
            case 4: return SensingDevicePeripheral;
            case 5: return DigitizerTabletPeripheral;
            case 6: return CardReaderPeripheral;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorPhoneClass
     */
    public enum MinorPhoneClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedPhone
         */
        UncategorizedPhone(0),
        /**
         * Representing QBluetoothDeviceInfo::CellularPhone
         */
        CellularPhone(1),
        /**
         * Representing QBluetoothDeviceInfo::CordlessPhone
         */
        CordlessPhone(2),
        /**
         * Representing QBluetoothDeviceInfo::SmartPhone
         */
        SmartPhone(3),
        /**
         * Representing QBluetoothDeviceInfo::WiredModemOrVoiceGatewayPhone
         */
        WiredModemOrVoiceGatewayPhone(4),
        /**
         * Representing QBluetoothDeviceInfo::CommonIsdnAccessPhone
         */
        CommonIsdnAccessPhone(5);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorPhoneClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorPhoneClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedPhone;
            case 1: return CellularPhone;
            case 2: return CordlessPhone;
            case 3: return SmartPhone;
            case 4: return WiredModemOrVoiceGatewayPhone;
            case 5: return CommonIsdnAccessPhone;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorToyClass
     */
    public enum MinorToyClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedToy
         */
        UncategorizedToy(0),
        /**
         * Representing QBluetoothDeviceInfo::ToyRobot
         */
        ToyRobot(1),
        /**
         * Representing QBluetoothDeviceInfo::ToyVehicle
         */
        ToyVehicle(2),
        /**
         * Representing QBluetoothDeviceInfo::ToyDoll
         */
        ToyDoll(3),
        /**
         * Representing QBluetoothDeviceInfo::ToyController
         */
        ToyController(4),
        /**
         * Representing QBluetoothDeviceInfo::ToyGame
         */
        ToyGame(5);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorToyClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorToyClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedToy;
            case 1: return ToyRobot;
            case 2: return ToyVehicle;
            case 3: return ToyDoll;
            case 4: return ToyController;
            case 5: return ToyGame;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::MinorWearableClass
     */
    public enum MinorWearableClass implements QtEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::UncategorizedWearableDevice
         */
        UncategorizedWearableDevice(0),
        /**
         * Representing QBluetoothDeviceInfo::WearableWristWatch
         */
        WearableWristWatch(1),
        /**
         * Representing QBluetoothDeviceInfo::WearablePager
         */
        WearablePager(2),
        /**
         * Representing QBluetoothDeviceInfo::WearableJacket
         */
        WearableJacket(3),
        /**
         * Representing QBluetoothDeviceInfo::WearableHelmet
         */
        WearableHelmet(4),
        /**
         * Representing QBluetoothDeviceInfo::WearableGlasses
         */
        WearableGlasses(5);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private MinorWearableClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull MinorWearableClass resolve(int value) {
            switch (value) {
            case 0: return UncategorizedWearableDevice;
            case 1: return WearableWristWatch;
            case 2: return WearablePager;
            case 3: return WearableJacket;
            case 4: return WearableHelmet;
            case 5: return WearableGlasses;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QBluetoothDeviceInfo::ServiceClass
     * 
     * @see ServiceClasses
     */
    public enum ServiceClass implements QtFlagEnumerator {
        /**
         * Representing QBluetoothDeviceInfo::NoService
         */
        NoService(0),
        /**
         * Representing QBluetoothDeviceInfo::PositioningService
         */
        PositioningService(1),
        /**
         * Representing QBluetoothDeviceInfo::NetworkingService
         */
        NetworkingService(2),
        /**
         * Representing QBluetoothDeviceInfo::RenderingService
         */
        RenderingService(4),
        /**
         * Representing QBluetoothDeviceInfo::CapturingService
         */
        CapturingService(8),
        /**
         * Representing QBluetoothDeviceInfo::ObjectTransferService
         */
        ObjectTransferService(16),
        /**
         * Representing QBluetoothDeviceInfo::AudioService
         */
        AudioService(32),
        /**
         * Representing QBluetoothDeviceInfo::TelephonyService
         */
        TelephonyService(64),
        /**
         * Representing QBluetoothDeviceInfo::InformationService
         */
        InformationService(128),
        /**
         * Representing QBluetoothDeviceInfo::AllServices
         */
        AllServices(2047);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private ServiceClass(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull ServiceClasses asFlags() {
            return new ServiceClasses(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull ServiceClasses combined(@NonNull ServiceClass e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull ServiceClasses cleared(@NonNull ServiceClass e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link ServiceClasses} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull ServiceClasses flags(@Nullable ServiceClass @NonNull... values) {
            return new ServiceClasses(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull ServiceClass resolve(int value) {
            switch (value) {
            case 0: return NoService;
            case 1: return PositioningService;
            case 2: return NetworkingService;
            case 4: return RenderingService;
            case 8: return CapturingService;
            case 16: return ObjectTransferService;
            case 32: return AudioService;
            case 64: return TelephonyService;
            case 128: return InformationService;
            case 2047: return AllServices;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link ServiceClass}
     */
    public static final class ServiceClasses extends QFlags implements Comparable {
        private static final long serialVersionUID = 0xd2959bce5781129eL;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new ServiceClasses where the flags in args are set.
         * @param args enum entries
         */
        public ServiceClasses(@Nullable ServiceClass @NonNull... args){
            super(args);
        }

        /**
         * Creates a new ServiceClasses with given value.
         * @param value
         */
        public ServiceClasses(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new ServiceClasses
         */
        @Override
        public final @NonNull ServiceClasses combined(@StrictNonNull ServiceClass e){
            return new ServiceClasses(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull ServiceClasses setFlag(@Nullable ServiceClass e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull ServiceClasses setFlag(@Nullable ServiceClass e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this ServiceClasses.
         * @return array of enum entries
         */
        @Override
        public final @NonNull ServiceClass @NonNull[] flags(){
            return super.flags(ServiceClass.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull ServiceClasses clone(){
            return new ServiceClasses(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull ServiceClasses other){
            return Integer.compare(value(), other.value());
        }
    }
    
    
    /**
     * See QBluetoothDeviceInfo::QBluetoothDeviceInfo()
     */
    public QBluetoothDeviceInfo(){
        super((QPrivateConstructor)null);
        initialize_native(this);
    }
    
    private native static void initialize_native(QBluetoothDeviceInfo instance);
    
    /**
     * See QBluetoothDeviceInfo::QBluetoothDeviceInfo(QBluetoothAddress,QString,quint32)
     */
    public QBluetoothDeviceInfo(io.qt.bluetooth.@NonNull QBluetoothAddress address, java.lang.@NonNull String name, int classOfDevice){
        super((QPrivateConstructor)null);
        initialize_native(this, address, name, classOfDevice);
    }
    
    private native static void initialize_native(QBluetoothDeviceInfo instance, io.qt.bluetooth.QBluetoothAddress address, java.lang.String name, int classOfDevice);
    
    /**
     * See QBluetoothDeviceInfo::QBluetoothDeviceInfo(QBluetoothDeviceInfo)
     */
    public QBluetoothDeviceInfo(io.qt.bluetooth.@NonNull QBluetoothDeviceInfo other){
        super((QPrivateConstructor)null);
        initialize_native(this, other);
    }
    
    private native static void initialize_native(QBluetoothDeviceInfo instance, io.qt.bluetooth.QBluetoothDeviceInfo other);
    
    /**
     * See QBluetoothDeviceInfo::QBluetoothDeviceInfo(QBluetoothUuid,QString,quint32)
     */
    public QBluetoothDeviceInfo(io.qt.bluetooth.@NonNull QBluetoothUuid uuid, java.lang.@NonNull String name, int classOfDevice){
        super((QPrivateConstructor)null);
        initialize_native(this, uuid, name, classOfDevice);
    }
    
    private native static void initialize_native(QBluetoothDeviceInfo instance, io.qt.bluetooth.QBluetoothUuid uuid, java.lang.String name, int classOfDevice);
    
    /**
     * See QBluetoothDeviceInfo::address()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.@NonNull QBluetoothAddress address(){
        return address_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.bluetooth.QBluetoothAddress address_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::coreConfigurations()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.QBluetoothDeviceInfo.@NonNull CoreConfigurations coreConfigurations(){
        return new io.qt.bluetooth.QBluetoothDeviceInfo.CoreConfigurations(coreConfigurations_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int coreConfigurations_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::deviceUuid()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.@NonNull QBluetoothUuid deviceUuid(){
        return deviceUuid_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.bluetooth.QBluetoothUuid deviceUuid_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::isCached()const
     */
    @QtUninvokable
    public final boolean isCached(){
        return isCached_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isCached_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::isValid()const
     */
    @QtUninvokable
    public final boolean isValid(){
        return isValid_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isValid_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::majorDeviceClass()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.QBluetoothDeviceInfo.@NonNull MajorDeviceClass majorDeviceClass(){
        return io.qt.bluetooth.QBluetoothDeviceInfo.MajorDeviceClass.resolve(majorDeviceClass_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int majorDeviceClass_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::manufacturerData()const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QHash manufacturerData(){
        return manufacturerData_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QHash manufacturerData_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::manufacturerData(quint16)const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray manufacturerData(short manufacturerId){
        return manufacturerData_native_quint16_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), manufacturerId);
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray manufacturerData_native_quint16_constfct(long __this__nativeId, short manufacturerId);
    
    /**
     * See QBluetoothDeviceInfo::manufacturerIds()const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QVector manufacturerIds(){
        return manufacturerIds_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QVector manufacturerIds_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::minorDeviceClass()const
     */
    @QtUninvokable
    public final byte minorDeviceClass(){
        return minorDeviceClass_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native byte minorDeviceClass_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::name()const
     */
    @QtUninvokable
    public final java.lang.@NonNull String name(){
        return name_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String name_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::operator=(QBluetoothDeviceInfo)
     */
    @QtUninvokable
    public final void assign(io.qt.bluetooth.@NonNull QBluetoothDeviceInfo other){
        assign_native_cref_QBluetoothDeviceInfo(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(other));
    }
    
    @QtUninvokable
    private native void assign_native_cref_QBluetoothDeviceInfo(long __this__nativeId, long other);
    
    /**
     * See QBluetoothDeviceInfo::operator==(QBluetoothDeviceInfo)const
     */
    @QtUninvokable
    public final boolean equals(io.qt.bluetooth.@NonNull QBluetoothDeviceInfo other){
        return equals_native_cref_QBluetoothDeviceInfo_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(other));
    }
    
    @QtUninvokable
    private native boolean equals_native_cref_QBluetoothDeviceInfo_constfct(long __this__nativeId, long other);
    
    /**
     * See QBluetoothDeviceInfo::rssi()const
     */
    @QtUninvokable
    public final short rssi(){
        return rssi_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native short rssi_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::serviceClasses()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.QBluetoothDeviceInfo.@NonNull ServiceClasses serviceClasses(){
        return new io.qt.bluetooth.QBluetoothDeviceInfo.ServiceClasses(serviceClasses_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int serviceClasses_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::serviceUuids(QBluetoothDeviceInfo::DataCompleteness*)const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QList serviceUuids(){
        return serviceUuids_native_QBluetoothDeviceInfo_DataCompleteness_ptr_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QList serviceUuids_native_QBluetoothDeviceInfo_DataCompleteness_ptr_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::serviceUuidsCompleteness()const
     */
    @QtUninvokable
    public final io.qt.bluetooth.QBluetoothDeviceInfo.@NonNull DataCompleteness serviceUuidsCompleteness(){
        return io.qt.bluetooth.QBluetoothDeviceInfo.DataCompleteness.resolve(serviceUuidsCompleteness_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int serviceUuidsCompleteness_native_constfct(long __this__nativeId);
    
    /**
     * See QBluetoothDeviceInfo::setCached(bool)
     */
    @QtUninvokable
    public final void setCached(boolean cached){
        setCached_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), cached);
    }
    
    @QtUninvokable
    private native void setCached_native_bool(long __this__nativeId, boolean cached);
    
    /**
     * See QBluetoothDeviceInfo::setCoreConfigurations(QBluetoothDeviceInfo::CoreConfigurations)
     */
    @QtUninvokable
    public final void setCoreConfigurations(io.qt.bluetooth.QBluetoothDeviceInfo.@NonNull CoreConfigurations coreConfigs){
        setCoreConfigurations_native_QBluetoothDeviceInfo_CoreConfigurations(QtJambi_LibraryUtilities.internal.nativeId(this), coreConfigs.value());
    }
    
    @QtUninvokable
    private native void setCoreConfigurations_native_QBluetoothDeviceInfo_CoreConfigurations(long __this__nativeId, int coreConfigs);
    
    /**
     * See QBluetoothDeviceInfo::setDeviceUuid(QBluetoothUuid)
     */
    @QtUninvokable
    public final void setDeviceUuid(io.qt.bluetooth.@NonNull QBluetoothUuid uuid){
        setDeviceUuid_native_cref_QBluetoothUuid(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(uuid));
    }
    
    @QtUninvokable
    private native void setDeviceUuid_native_cref_QBluetoothUuid(long __this__nativeId, long uuid);
    
    /**
     * See QBluetoothDeviceInfo::setManufacturerData(quint16,QByteArray)
     */
    @QtUninvokable
    public final boolean setManufacturerData(short manufacturerId, io.qt.core.@NonNull QByteArray data){
        return setManufacturerData_native_quint16_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), manufacturerId, QtJambi_LibraryUtilities.internal.checkedNativeId(data));
    }
    
    @QtUninvokable
    private native boolean setManufacturerData_native_quint16_cref_QByteArray(long __this__nativeId, short manufacturerId, long data);
    
    /**
     * See QBluetoothDeviceInfo::setRssi(qint16)
     */
    @QtUninvokable
    public final void setRssi(short signal){
        setRssi_native_qint16(QtJambi_LibraryUtilities.internal.nativeId(this), signal);
    }
    
    @QtUninvokable
    private native void setRssi_native_qint16(long __this__nativeId, short signal);
    
    /**
     * See QBluetoothDeviceInfo::setServiceUuids(QList<QBluetoothUuid>,QBluetoothDeviceInfo::DataCompleteness)
     */
    @QtUninvokable
    public final void setServiceUuids(java.util.@NonNull Collection uuids, io.qt.bluetooth.QBluetoothDeviceInfo.@NonNull DataCompleteness completeness){
        setServiceUuids_native_cref_QList_QBluetoothDeviceInfo_DataCompleteness(QtJambi_LibraryUtilities.internal.nativeId(this), uuids, completeness.value());
    }
    
    @QtUninvokable
    private native void setServiceUuids_native_cref_QList_QBluetoothDeviceInfo_DataCompleteness(long __this__nativeId, java.util.Collection uuids, int completeness);
    
    /**
     * See QBluetoothDeviceInfo::setServiceUuids(QVector<QBluetoothUuid>)
     */
    @QtUninvokable
    public final void setServiceUuids(java.util.@NonNull Collection uuids){
        setServiceUuids_native_cref_QVector(QtJambi_LibraryUtilities.internal.nativeId(this), uuids);
    }
    
    @QtUninvokable
    private native void setServiceUuids_native_cref_QVector(long __this__nativeId, java.util.Collection uuids);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QBluetoothDeviceInfo(QPrivateConstructor p) { super(p); } 
    

    /**
     * See QBluetoothDeviceInfo::operator==(QBluetoothDeviceInfo)const
     */
    @Override
    @QtUninvokable
    public boolean equals(Object other) {
        if (other instanceof io.qt.bluetooth.QBluetoothDeviceInfo) {
            return equals((io.qt.bluetooth.QBluetoothDeviceInfo) other);
        }

        return false;
    }


    /**
     * Returns the objects's hash code computed by qHash(QBluetoothDeviceInfo).
     */
    @QtUninvokable
    @Override
    public int hashCode() {
        return hashCode_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    @QtUninvokable
    private native static int hashCode_native(long __this_nativeId);
    
    /**
     * Creates and returns a copy of this object.
    See QBluetoothDeviceInfo::QBluetoothDeviceInfo(QBluetoothDeviceInfo)
     */
    @QtUninvokable
    @Override
    public QBluetoothDeviceInfo clone() {
        return clone_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    private static native QBluetoothDeviceInfo clone_native(long __this_nativeId);
    
    /**
     * Overloaded constructor for {@link #QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid, java.lang.String, int)}.
     */
    public QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid.@NonNull ProtocolUuid uuid, java.lang.@NonNull String name, int classOfDevice) {
        this(new io.qt.bluetooth.QBluetoothUuid(uuid), name, classOfDevice);
    }
    
    /**
     * Overloaded constructor for {@link #QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid, java.lang.String, int)}.
     */
    public QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid.@NonNull ServiceClassUuid uuid, java.lang.@NonNull String name, int classOfDevice) {
        this(new io.qt.bluetooth.QBluetoothUuid(uuid), name, classOfDevice);
    }
    
    /**
     * Overloaded constructor for {@link #QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid, java.lang.String, int)}.
     */
    public QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid.@NonNull CharacteristicType uuid, java.lang.@NonNull String name, int classOfDevice) {
        this(new io.qt.bluetooth.QBluetoothUuid(uuid), name, classOfDevice);
    }
    
    /**
     * Overloaded constructor for {@link #QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid, java.lang.String, int)}.
     */
    public QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid.@NonNull DescriptorType uuid, java.lang.@NonNull String name, int classOfDevice) {
        this(new io.qt.bluetooth.QBluetoothUuid(uuid), name, classOfDevice);
    }
    
    /**
     * Overloaded constructor for {@link #QBluetoothDeviceInfo(io.qt.bluetooth.QBluetoothUuid, java.lang.String, int)}.
     */
    public QBluetoothDeviceInfo(io.qt.core.@NonNull QUuid uuid, java.lang.@NonNull String name, int classOfDevice) {
        this(new io.qt.bluetooth.QBluetoothUuid(uuid), name, classOfDevice);
    }
    
    /**
     * Overloaded function for {@link #setCoreConfigurations(io.qt.bluetooth.QBluetoothDeviceInfo.CoreConfigurations)}.
     */
    @QtUninvokable
    public final void setCoreConfigurations(io.qt.bluetooth.QBluetoothDeviceInfo.@NonNull CoreConfiguration @NonNull... coreConfigs) {
        setCoreConfigurations(new io.qt.bluetooth.QBluetoothDeviceInfo.CoreConfigurations(coreConfigs));
    }
    
    /**
     * Overloaded function for {@link #setDeviceUuid(io.qt.bluetooth.QBluetoothUuid)}.
     */
    @QtUninvokable
    public final void setDeviceUuid(io.qt.bluetooth.QBluetoothUuid.@NonNull ProtocolUuid uuid) {
        setDeviceUuid(new io.qt.bluetooth.QBluetoothUuid(uuid));
    }
    
    /**
     * Overloaded function for {@link #setDeviceUuid(io.qt.bluetooth.QBluetoothUuid)}.
     */
    @QtUninvokable
    public final void setDeviceUuid(io.qt.bluetooth.QBluetoothUuid.@NonNull ServiceClassUuid uuid) {
        setDeviceUuid(new io.qt.bluetooth.QBluetoothUuid(uuid));
    }
    
    /**
     * Overloaded function for {@link #setDeviceUuid(io.qt.bluetooth.QBluetoothUuid)}.
     */
    @QtUninvokable
    public final void setDeviceUuid(io.qt.bluetooth.QBluetoothUuid.@NonNull CharacteristicType uuid) {
        setDeviceUuid(new io.qt.bluetooth.QBluetoothUuid(uuid));
    }
    
    /**
     * Overloaded function for {@link #setDeviceUuid(io.qt.bluetooth.QBluetoothUuid)}.
     */
    @QtUninvokable
    public final void setDeviceUuid(io.qt.bluetooth.QBluetoothUuid.@NonNull DescriptorType uuid) {
        setDeviceUuid(new io.qt.bluetooth.QBluetoothUuid(uuid));
    }
    
    /**
     * Overloaded function for {@link #setDeviceUuid(io.qt.bluetooth.QBluetoothUuid)}.
     */
    @QtUninvokable
    public final void setDeviceUuid(io.qt.core.@NonNull QUuid uuid) {
        setDeviceUuid(new io.qt.bluetooth.QBluetoothUuid(uuid));
    }
    
    /**
     * Overloaded function for {@link #setManufacturerData(short, io.qt.core.QByteArray)}.
     */
    @QtUninvokable
    public final boolean setManufacturerData(short manufacturerId, byte @NonNull[] data) {
        return setManufacturerData(manufacturerId, new io.qt.core.QByteArray(data));
    }
}