diff --git a/Package.swift b/Package.swift
index bf3605f..51ecfad 100644
--- a/Package.swift
+++ b/Package.swift
@@ -47,8 +47,8 @@ let package = Package(
             ]
     ),
     .binaryTarget(name: "mavsdk_server",
-                      url: "https://github.com/mavlink/MAVSDK/releases/download/v1.0.8/mavsdk_server.xcframework.zip",
-                      checksum: "ac1cad61e9101f15725cbecb995a7be18ff87ee80d5aa67c91a70e9d0b43816f"),
+                      url: "https://github.com/mavlink/MAVSDK/releases/download/v1.4.0/mavsdk_server.xcframework.zip",
+                      checksum: "a38385a38d426a0d6b9700e142b4de978eddff5d6d33666c108fb35922f5c276"),
     .testTarget(name: "MavsdkTests",
                 dependencies: [
                   "Mavsdk",
diff --git a/Sources/Mavsdk/Generated/Action.swift b/Sources/Mavsdk/Generated/Action.swift
index 9e3aef6..54f9208 100644
--- a/Sources/Mavsdk/Generated/Action.swift
+++ b/Sources/Mavsdk/Generated/Action.swift
@@ -142,6 +142,8 @@ public class Action {
             case noVtolTransitionSupport
             ///  Error getting or setting parameter.
             case parameterError
+            ///  Action not supported.
+            case unsupported
             case UNRECOGNIZED(Int)
 
             internal var rpcResult: Mavsdk_Rpc_Action_ActionResult.Result {
@@ -170,6 +172,8 @@ public class Action {
                     return .noVtolTransitionSupport
                 case .parameterError:
                     return .parameterError
+                case .unsupported:
+                    return .unsupported
                 case .UNRECOGNIZED(let i):
                     return .UNRECOGNIZED(i)
                 }
@@ -201,6 +205,8 @@ public class Action {
                     return .noVtolTransitionSupport
                 case .parameterError:
                     return .parameterError
+                case .unsupported:
+                    return .unsupported
                 case .UNRECOGNIZED(let i):
                     return .UNRECOGNIZED(i)
                 }
@@ -1020,4 +1026,42 @@ public class Action {
             return Disposables.create()
         }
     }
+
+    /**
+     Set current speed.
+
+     This will set the speed during a mission, reposition, and similar.
+     It is ephemeral, so not stored on the drone and does not survive a reboot.
+
+     - Parameter speedMS: Speed in meters/second
+     
+     */
+    public func setCurrentSpeed(speedMS: Float) -> Completable {
+        return Completable.create { completable in
+            var request = Mavsdk_Rpc_Action_SetCurrentSpeedRequest()
+
+            
+                
+            request.speedMS = speedMS
+                
+            
+
+            do {
+                
+                let response = self.service.setCurrentSpeed(request)
+
+                let result = try response.response.wait().actionResult
+                if (result.result == Mavsdk_Rpc_Action_ActionResult.Result.success) {
+                    completable(.completed)
+                } else {
+                    completable(.error(ActionError(code: ActionResult.Result.translateFromRpc(result.result), description: result.resultStr)))
+                }
+                
+            } catch {
+                completable(.error(error))
+            }
+
+            return Disposables.create()
+        }
+    }
 }
\ No newline at end of file
diff --git a/Sources/Mavsdk/Generated/Calibration.swift b/Sources/Mavsdk/Generated/Calibration.swift
index 2097d86..3efd962 100644
--- a/Sources/Mavsdk/Generated/Calibration.swift
+++ b/Sources/Mavsdk/Generated/Calibration.swift
@@ -89,6 +89,8 @@ public class Calibration {
             case cancelled
             ///  Calibration process failed since the vehicle is armed.
             case failedArmed
+            ///  Functionality not supported.
+            case unsupported
             case UNRECOGNIZED(Int)
 
             internal var rpcResult: Mavsdk_Rpc_Calibration_CalibrationResult.Result {
@@ -115,6 +117,8 @@ public class Calibration {
                     return .cancelled
                 case .failedArmed:
                     return .failedArmed
+                case .unsupported:
+                    return .unsupported
                 case .UNRECOGNIZED(let i):
                     return .UNRECOGNIZED(i)
                 }
@@ -144,6 +148,8 @@ public class Calibration {
                     return .cancelled
                 case .failedArmed:
                     return .failedArmed
+                case .unsupported:
+                    return .unsupported
                 case .UNRECOGNIZED(let i):
                     return .UNRECOGNIZED(i)
                 }
diff --git a/Sources/Mavsdk/Generated/Camera.swift b/Sources/Mavsdk/Generated/Camera.swift
index d34fbb0..ad52fd2 100644
--- a/Sources/Mavsdk/Generated/Camera.swift
+++ b/Sources/Mavsdk/Generated/Camera.swift
@@ -2037,4 +2037,41 @@ public class Camera {
             return Disposables.create()
         }
     }
+
+    /**
+     Select current camera .
+
+     Bind the plugin instance to a specific camera_id
+
+     - Parameter cameraID: Id of camera to be selected
+     
+     */
+    public func selectCamera(cameraID: Int32) -> Completable {
+        return Completable.create { completable in
+            var request = Mavsdk_Rpc_Camera_SelectCameraRequest()
+
+            
+                
+            request.cameraID = cameraID
+                
+            
+
+            do {
+                
+                let response = self.service.selectCamera(request)
+
+                let result = try response.response.wait().cameraResult
+                if (result.result == Mavsdk_Rpc_Camera_CameraResult.Result.success) {
+                    completable(.completed)
+                } else {
+                    completable(.error(CameraError(code: CameraResult.Result.translateFromRpc(result.result), description: result.resultStr)))
+                }
+                
+            } catch {
+                completable(.error(error))
+            }
+
+            return Disposables.create()
+        }
+    }
 }
\ No newline at end of file
diff --git a/Sources/Mavsdk/Generated/ComponentInformation.swift b/Sources/Mavsdk/Generated/ComponentInformation.swift
new file mode 100644
index 0000000..020586f
--- /dev/null
+++ b/Sources/Mavsdk/Generated/ComponentInformation.swift
@@ -0,0 +1,394 @@
+import Foundation
+import RxSwift
+import GRPC
+import NIO
+
+/**
+ Access component information such as parameters.
+ */
+public class ComponentInformation {
+    private let service: Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClient
+    private let scheduler: SchedulerType
+    private let clientEventLoopGroup: EventLoopGroup
+
+    /**
+     Initializes a new `ComponentInformation` plugin.
+
+     Normally never created manually, but used from the `Drone` helper class instead.
+
+     - Parameters:
+        - address: The address of the `MavsdkServer` instance to connect to
+        - port: The port of the `MavsdkServer` instance to connect to
+        - scheduler: The scheduler to be used by `Observable`s
+     */
+    public convenience init(address: String = "localhost",
+                            port: Int32 = 50051,
+                            scheduler: SchedulerType = ConcurrentDispatchQueueScheduler(qos: .background)) {
+        let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 2)
+        let channel = ClientConnection.insecure(group: eventLoopGroup).connect(host: address, port: Int(port))
+        let service = Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClient(channel: channel)
+
+        self.init(service: service, scheduler: scheduler, eventLoopGroup: eventLoopGroup)
+    }
+
+    init(service: Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClient, scheduler: SchedulerType, eventLoopGroup: EventLoopGroup) {
+        self.service = service
+        self.scheduler = scheduler
+        self.clientEventLoopGroup = eventLoopGroup
+    }
+
+    public struct RuntimeComponentInformationError: Error {
+        public let description: String
+
+        init(_ description: String) {
+            self.description = description
+        }
+    }
+
+    
+    public struct ComponentInformationError: Error {
+        public let code: ComponentInformation.ComponentInformationResult.Result
+        public let description: String
+    }
+    
+
+
+    /**
+     Meta information for parameter of type float.
+     */
+    public struct FloatParam: Equatable {
+        public let name: String
+        public let shortDescription: String
+        public let longDescription: String
+        public let unit: String
+        public let decimalPlaces: Int32
+        public let startValue: Float
+        public let defaultValue: Float
+        public let minValue: Float
+        public let maxValue: Float
+
+        
+
+        /**
+         Initializes a new `FloatParam`.
+
+         
+         - Parameters:
+            
+            - name:  Name (max 16 chars)
+            
+            - shortDescription:  Short description
+            
+            - longDescription:  Long description
+            
+            - unit:  Unit
+            
+            - decimalPlaces:  Decimal places for user to show
+            
+            - startValue:  Current/starting value
+            
+            - defaultValue:  Default value
+            
+            - minValue:  Minimum value
+            
+            - maxValue:  Maximum value
+            
+         
+         */
+        public init(name: String, shortDescription: String, longDescription: String, unit: String, decimalPlaces: Int32, startValue: Float, defaultValue: Float, minValue: Float, maxValue: Float) {
+            self.name = name
+            self.shortDescription = shortDescription
+            self.longDescription = longDescription
+            self.unit = unit
+            self.decimalPlaces = decimalPlaces
+            self.startValue = startValue
+            self.defaultValue = defaultValue
+            self.minValue = minValue
+            self.maxValue = maxValue
+        }
+
+        internal var rpcFloatParam: Mavsdk_Rpc_ComponentInformation_FloatParam {
+            var rpcFloatParam = Mavsdk_Rpc_ComponentInformation_FloatParam()
+            
+                
+            rpcFloatParam.name = name
+                
+            
+            
+                
+            rpcFloatParam.shortDescription = shortDescription
+                
+            
+            
+                
+            rpcFloatParam.longDescription = longDescription
+                
+            
+            
+                
+            rpcFloatParam.unit = unit
+                
+            
+            
+                
+            rpcFloatParam.decimalPlaces = decimalPlaces
+                
+            
+            
+                
+            rpcFloatParam.startValue = startValue
+                
+            
+            
+                
+            rpcFloatParam.defaultValue = defaultValue
+                
+            
+            
+                
+            rpcFloatParam.minValue = minValue
+                
+            
+            
+                
+            rpcFloatParam.maxValue = maxValue
+                
+            
+
+            return rpcFloatParam
+        }
+
+        internal static func translateFromRpc(_ rpcFloatParam: Mavsdk_Rpc_ComponentInformation_FloatParam) -> FloatParam {
+            return FloatParam(name: rpcFloatParam.name, shortDescription: rpcFloatParam.shortDescription, longDescription: rpcFloatParam.longDescription, unit: rpcFloatParam.unit, decimalPlaces: rpcFloatParam.decimalPlaces, startValue: rpcFloatParam.startValue, defaultValue: rpcFloatParam.defaultValue, minValue: rpcFloatParam.minValue, maxValue: rpcFloatParam.maxValue)
+        }
+
+        public static func == (lhs: FloatParam, rhs: FloatParam) -> Bool {
+            return lhs.name == rhs.name
+                && lhs.shortDescription == rhs.shortDescription
+                && lhs.longDescription == rhs.longDescription
+                && lhs.unit == rhs.unit
+                && lhs.decimalPlaces == rhs.decimalPlaces
+                && lhs.startValue == rhs.startValue
+                && lhs.defaultValue == rhs.defaultValue
+                && lhs.minValue == rhs.minValue
+                && lhs.maxValue == rhs.maxValue
+        }
+    }
+
+    /**
+     A float param that has been updated.
+     */
+    public struct FloatParamUpdate: Equatable {
+        public let name: String
+        public let value: Float
+
+        
+
+        /**
+         Initializes a new `FloatParamUpdate`.
+
+         
+         - Parameters:
+            
+            - name:  Name of param that changed
+            
+            - value:  New value of param
+            
+         
+         */
+        public init(name: String, value: Float) {
+            self.name = name
+            self.value = value
+        }
+
+        internal var rpcFloatParamUpdate: Mavsdk_Rpc_ComponentInformation_FloatParamUpdate {
+            var rpcFloatParamUpdate = Mavsdk_Rpc_ComponentInformation_FloatParamUpdate()
+            
+                
+            rpcFloatParamUpdate.name = name
+                
+            
+            
+                
+            rpcFloatParamUpdate.value = value
+                
+            
+
+            return rpcFloatParamUpdate
+        }
+
+        internal static func translateFromRpc(_ rpcFloatParamUpdate: Mavsdk_Rpc_ComponentInformation_FloatParamUpdate) -> FloatParamUpdate {
+            return FloatParamUpdate(name: rpcFloatParamUpdate.name, value: rpcFloatParamUpdate.value)
+        }
+
+        public static func == (lhs: FloatParamUpdate, rhs: FloatParamUpdate) -> Bool {
+            return lhs.name == rhs.name
+                && lhs.value == rhs.value
+        }
+    }
+
+    /**
+     Result type.
+     */
+    public struct ComponentInformationResult: Equatable {
+        public let result: Result
+        public let resultStr: String
+
+        
+        
+
+        /**
+         Possible results returned for param requests.
+         */
+        public enum Result: Equatable {
+            ///  Unknown result.
+            case unknown
+            ///  Request succeeded.
+            case success
+            ///  No system is connected.
+            case noSystem
+            case UNRECOGNIZED(Int)
+
+            internal var rpcResult: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult.Result {
+                switch self {
+                case .unknown:
+                    return .unknown
+                case .success:
+                    return .success
+                case .noSystem:
+                    return .noSystem
+                case .UNRECOGNIZED(let i):
+                    return .UNRECOGNIZED(i)
+                }
+            }
+
+            internal static func translateFromRpc(_ rpcResult: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult.Result) -> Result {
+                switch rpcResult {
+                case .unknown:
+                    return .unknown
+                case .success:
+                    return .success
+                case .noSystem:
+                    return .noSystem
+                case .UNRECOGNIZED(let i):
+                    return .UNRECOGNIZED(i)
+                }
+            }
+        }
+        
+
+        /**
+         Initializes a new `ComponentInformationResult`.
+
+         
+         - Parameters:
+            
+            - result:  Result enum value
+            
+            - resultStr:  Human-readable English string describing the result
+            
+         
+         */
+        public init(result: Result, resultStr: String) {
+            self.result = result
+            self.resultStr = resultStr
+        }
+
+        internal var rpcComponentInformationResult: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult {
+            var rpcComponentInformationResult = Mavsdk_Rpc_ComponentInformation_ComponentInformationResult()
+            
+                
+            rpcComponentInformationResult.result = result.rpcResult
+                
+            
+            
+                
+            rpcComponentInformationResult.resultStr = resultStr
+                
+            
+
+            return rpcComponentInformationResult
+        }
+
+        internal static func translateFromRpc(_ rpcComponentInformationResult: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult) -> ComponentInformationResult {
+            return ComponentInformationResult(result: Result.translateFromRpc(rpcComponentInformationResult.result), resultStr: rpcComponentInformationResult.resultStr)
+        }
+
+        public static func == (lhs: ComponentInformationResult, rhs: ComponentInformationResult) -> Bool {
+            return lhs.result == rhs.result
+                && lhs.resultStr == rhs.resultStr
+        }
+    }
+
+
+    /**
+     List available float params.
+
+     
+     */
+    public func accessFloatParams() -> Single<[FloatParam]> {
+        return Single<[FloatParam]>.create { single in
+            let request = Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest()
+
+            
+
+            do {
+                let response = self.service.accessFloatParams(request)
+
+                
+                let result = try response.response.wait().componentInformationResult
+                if (result.result != Mavsdk_Rpc_ComponentInformation_ComponentInformationResult.Result.success) {
+                    single(.failure(ComponentInformationError(code: ComponentInformationResult.Result.translateFromRpc(result.result), description: result.resultStr)))
+
+                    return Disposables.create()
+                }
+                
+
+    	    
+                    let params = try response.response.wait().params.map{ FloatParam.translateFromRpc($0) }
+                
+                single(.success(params))
+            } catch {
+                single(.failure(error))
+            }
+
+            return Disposables.create()
+        }
+    }
+
+
+    /**
+     Subscribe to float param changes/updates.
+     */
+    public lazy var floatParam: Observable<FloatParamUpdate> = createFloatParamObservable()
+
+
+
+    private func createFloatParamObservable() -> Observable<FloatParamUpdate> {
+        return Observable.create { observer in
+            let request = Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest()
+
+            
+
+            _ = self.service.subscribeFloatParam(request, handler: { (response) in
+
+                
+                     
+                let floatParam = FloatParamUpdate.translateFromRpc(response.paramUpdate)
+                
+
+                
+                observer.onNext(floatParam)
+                
+            })
+
+            return Disposables.create()
+        }
+        .retry { error in
+            error.map {
+                guard $0 is RuntimeComponentInformationError else { throw $0 }
+            }
+        }
+        .share(replay: 1)
+    }
+}
\ No newline at end of file
diff --git a/Sources/Mavsdk/Generated/ComponentInformationServer.swift b/Sources/Mavsdk/Generated/ComponentInformationServer.swift
new file mode 100644
index 0000000..461c185
--- /dev/null
+++ b/Sources/Mavsdk/Generated/ComponentInformationServer.swift
@@ -0,0 +1,418 @@
+import Foundation
+import RxSwift
+import GRPC
+import NIO
+
+/**
+ Provide component information such as parameters.
+ */
+public class ComponentInformationServer {
+    private let service: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClient
+    private let scheduler: SchedulerType
+    private let clientEventLoopGroup: EventLoopGroup
+
+    /**
+     Initializes a new `ComponentInformationServer` plugin.
+
+     Normally never created manually, but used from the `Drone` helper class instead.
+
+     - Parameters:
+        - address: The address of the `MavsdkServer` instance to connect to
+        - port: The port of the `MavsdkServer` instance to connect to
+        - scheduler: The scheduler to be used by `Observable`s
+     */
+    public convenience init(address: String = "localhost",
+                            port: Int32 = 50051,
+                            scheduler: SchedulerType = ConcurrentDispatchQueueScheduler(qos: .background)) {
+        let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 2)
+        let channel = ClientConnection.insecure(group: eventLoopGroup).connect(host: address, port: Int(port))
+        let service = Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClient(channel: channel)
+
+        self.init(service: service, scheduler: scheduler, eventLoopGroup: eventLoopGroup)
+    }
+
+    init(service: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClient, scheduler: SchedulerType, eventLoopGroup: EventLoopGroup) {
+        self.service = service
+        self.scheduler = scheduler
+        self.clientEventLoopGroup = eventLoopGroup
+    }
+
+    public struct RuntimeComponentInformationServerError: Error {
+        public let description: String
+
+        init(_ description: String) {
+            self.description = description
+        }
+    }
+
+    
+    public struct ComponentInformationServerError: Error {
+        public let code: ComponentInformationServer.ComponentInformationServerResult.Result
+        public let description: String
+    }
+    
+
+
+    /**
+     Meta information for parameter of type float.
+     */
+    public struct FloatParam: Equatable {
+        public let name: String
+        public let shortDescription: String
+        public let longDescription: String
+        public let unit: String
+        public let decimalPlaces: Int32
+        public let startValue: Float
+        public let defaultValue: Float
+        public let minValue: Float
+        public let maxValue: Float
+
+        
+
+        /**
+         Initializes a new `FloatParam`.
+
+         
+         - Parameters:
+            
+            - name:  Name (max 16 chars)
+            
+            - shortDescription:  Short description
+            
+            - longDescription:  Long description
+            
+            - unit:  Unit
+            
+            - decimalPlaces:  Decimal places for user to show
+            
+            - startValue:  Current/starting value
+            
+            - defaultValue:  Default value
+            
+            - minValue:  Minimum value
+            
+            - maxValue:  Maximum value
+            
+         
+         */
+        public init(name: String, shortDescription: String, longDescription: String, unit: String, decimalPlaces: Int32, startValue: Float, defaultValue: Float, minValue: Float, maxValue: Float) {
+            self.name = name
+            self.shortDescription = shortDescription
+            self.longDescription = longDescription
+            self.unit = unit
+            self.decimalPlaces = decimalPlaces
+            self.startValue = startValue
+            self.defaultValue = defaultValue
+            self.minValue = minValue
+            self.maxValue = maxValue
+        }
+
+        internal var rpcFloatParam: Mavsdk_Rpc_ComponentInformationServer_FloatParam {
+            var rpcFloatParam = Mavsdk_Rpc_ComponentInformationServer_FloatParam()
+            
+                
+            rpcFloatParam.name = name
+                
+            
+            
+                
+            rpcFloatParam.shortDescription = shortDescription
+                
+            
+            
+                
+            rpcFloatParam.longDescription = longDescription
+                
+            
+            
+                
+            rpcFloatParam.unit = unit
+                
+            
+            
+                
+            rpcFloatParam.decimalPlaces = decimalPlaces
+                
+            
+            
+                
+            rpcFloatParam.startValue = startValue
+                
+            
+            
+                
+            rpcFloatParam.defaultValue = defaultValue
+                
+            
+            
+                
+            rpcFloatParam.minValue = minValue
+                
+            
+            
+                
+            rpcFloatParam.maxValue = maxValue
+                
+            
+
+            return rpcFloatParam
+        }
+
+        internal static func translateFromRpc(_ rpcFloatParam: Mavsdk_Rpc_ComponentInformationServer_FloatParam) -> FloatParam {
+            return FloatParam(name: rpcFloatParam.name, shortDescription: rpcFloatParam.shortDescription, longDescription: rpcFloatParam.longDescription, unit: rpcFloatParam.unit, decimalPlaces: rpcFloatParam.decimalPlaces, startValue: rpcFloatParam.startValue, defaultValue: rpcFloatParam.defaultValue, minValue: rpcFloatParam.minValue, maxValue: rpcFloatParam.maxValue)
+        }
+
+        public static func == (lhs: FloatParam, rhs: FloatParam) -> Bool {
+            return lhs.name == rhs.name
+                && lhs.shortDescription == rhs.shortDescription
+                && lhs.longDescription == rhs.longDescription
+                && lhs.unit == rhs.unit
+                && lhs.decimalPlaces == rhs.decimalPlaces
+                && lhs.startValue == rhs.startValue
+                && lhs.defaultValue == rhs.defaultValue
+                && lhs.minValue == rhs.minValue
+                && lhs.maxValue == rhs.maxValue
+        }
+    }
+
+    /**
+     A float param that has been updated.
+     */
+    public struct FloatParamUpdate: Equatable {
+        public let name: String
+        public let value: Float
+
+        
+
+        /**
+         Initializes a new `FloatParamUpdate`.
+
+         
+         - Parameters:
+            
+            - name:  Name of param that changed
+            
+            - value:  New value of param
+            
+         
+         */
+        public init(name: String, value: Float) {
+            self.name = name
+            self.value = value
+        }
+
+        internal var rpcFloatParamUpdate: Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate {
+            var rpcFloatParamUpdate = Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate()
+            
+                
+            rpcFloatParamUpdate.name = name
+                
+            
+            
+                
+            rpcFloatParamUpdate.value = value
+                
+            
+
+            return rpcFloatParamUpdate
+        }
+
+        internal static func translateFromRpc(_ rpcFloatParamUpdate: Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate) -> FloatParamUpdate {
+            return FloatParamUpdate(name: rpcFloatParamUpdate.name, value: rpcFloatParamUpdate.value)
+        }
+
+        public static func == (lhs: FloatParamUpdate, rhs: FloatParamUpdate) -> Bool {
+            return lhs.name == rhs.name
+                && lhs.value == rhs.value
+        }
+    }
+
+    /**
+     Result type.
+     */
+    public struct ComponentInformationServerResult: Equatable {
+        public let result: Result
+        public let resultStr: String
+
+        
+        
+
+        /**
+         Possible results returned for param requests.
+         */
+        public enum Result: Equatable {
+            ///  Unknown result.
+            case unknown
+            ///  Request succeeded.
+            case success
+            ///  Duplicate param.
+            case duplicateParam
+            ///  Invalid start param value.
+            case invalidParamStartValue
+            ///  Invalid default param value.
+            case invalidParamDefaultValue
+            ///  Invalid param name.
+            case invalidParamName
+            ///  No system is connected.
+            case noSystem
+            case UNRECOGNIZED(Int)
+
+            internal var rpcResult: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult.Result {
+                switch self {
+                case .unknown:
+                    return .unknown
+                case .success:
+                    return .success
+                case .duplicateParam:
+                    return .duplicateParam
+                case .invalidParamStartValue:
+                    return .invalidParamStartValue
+                case .invalidParamDefaultValue:
+                    return .invalidParamDefaultValue
+                case .invalidParamName:
+                    return .invalidParamName
+                case .noSystem:
+                    return .noSystem
+                case .UNRECOGNIZED(let i):
+                    return .UNRECOGNIZED(i)
+                }
+            }
+
+            internal static func translateFromRpc(_ rpcResult: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult.Result) -> Result {
+                switch rpcResult {
+                case .unknown:
+                    return .unknown
+                case .success:
+                    return .success
+                case .duplicateParam:
+                    return .duplicateParam
+                case .invalidParamStartValue:
+                    return .invalidParamStartValue
+                case .invalidParamDefaultValue:
+                    return .invalidParamDefaultValue
+                case .invalidParamName:
+                    return .invalidParamName
+                case .noSystem:
+                    return .noSystem
+                case .UNRECOGNIZED(let i):
+                    return .UNRECOGNIZED(i)
+                }
+            }
+        }
+        
+
+        /**
+         Initializes a new `ComponentInformationServerResult`.
+
+         
+         - Parameters:
+            
+            - result:  Result enum value
+            
+            - resultStr:  Human-readable English string describing the result
+            
+         
+         */
+        public init(result: Result, resultStr: String) {
+            self.result = result
+            self.resultStr = resultStr
+        }
+
+        internal var rpcComponentInformationServerResult: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult {
+            var rpcComponentInformationServerResult = Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult()
+            
+                
+            rpcComponentInformationServerResult.result = result.rpcResult
+                
+            
+            
+                
+            rpcComponentInformationServerResult.resultStr = resultStr
+                
+            
+
+            return rpcComponentInformationServerResult
+        }
+
+        internal static func translateFromRpc(_ rpcComponentInformationServerResult: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult) -> ComponentInformationServerResult {
+            return ComponentInformationServerResult(result: Result.translateFromRpc(rpcComponentInformationServerResult.result), resultStr: rpcComponentInformationServerResult.resultStr)
+        }
+
+        public static func == (lhs: ComponentInformationServerResult, rhs: ComponentInformationServerResult) -> Bool {
+            return lhs.result == rhs.result
+                && lhs.resultStr == rhs.resultStr
+        }
+    }
+
+
+    /**
+     Provide a param of type float.
+
+     - Parameter param: Float param definition
+     
+     */
+    public func provideFloatParam(param: FloatParam) -> Completable {
+        return Completable.create { completable in
+            var request = Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest()
+
+            
+                
+            request.param = param.rpcFloatParam
+                
+            
+
+            do {
+                
+                let response = self.service.provideFloatParam(request)
+
+                let result = try response.response.wait().componentInformationServerResult
+                if (result.result == Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult.Result.success) {
+                    completable(.completed)
+                } else {
+                    completable(.error(ComponentInformationServerError(code: ComponentInformationServerResult.Result.translateFromRpc(result.result), description: result.resultStr)))
+                }
+                
+            } catch {
+                completable(.error(error))
+            }
+
+            return Disposables.create()
+        }
+    }
+
+
+    /**
+     Subscribe to float param updates.
+     */
+    public lazy var floatParam: Observable<FloatParamUpdate> = createFloatParamObservable()
+
+
+
+    private func createFloatParamObservable() -> Observable<FloatParamUpdate> {
+        return Observable.create { observer in
+            let request = Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest()
+
+            
+
+            _ = self.service.subscribeFloatParam(request, handler: { (response) in
+
+                
+                     
+                let floatParam = FloatParamUpdate.translateFromRpc(response.paramUpdate)
+                
+
+                
+                observer.onNext(floatParam)
+                
+            })
+
+            return Disposables.create()
+        }
+        .retry { error in
+            error.map {
+                guard $0 is RuntimeComponentInformationServerError else { throw $0 }
+            }
+        }
+        .share(replay: 1)
+    }
+}
\ No newline at end of file
diff --git a/Sources/Mavsdk/Generated/LogFiles.swift b/Sources/Mavsdk/Generated/LogFiles.swift
index 3a2f89b..372cdb1 100644
--- a/Sources/Mavsdk/Generated/LogFiles.swift
+++ b/Sources/Mavsdk/Generated/LogFiles.swift
@@ -365,4 +365,80 @@ public class LogFiles {
         }
         .share(replay: 1)
     }
+
+    /**
+     Download log file synchronously.
+
+     - Parameters:
+        - entry: Entry of the log file to download.
+        - path: Path of where to download log file to.
+     
+     */
+    public func downloadLogFile(entry: Entry, path: String) -> Single<ProgressData> {
+        return Single<ProgressData>.create { single in
+            var request = Mavsdk_Rpc_LogFiles_DownloadLogFileRequest()
+
+            
+                
+            request.entry = entry.rpcEntry
+                
+            
+                
+            request.path = path
+                
+            
+
+            do {
+                let response = self.service.downloadLogFile(request)
+
+                
+                let result = try response.response.wait().logFilesResult
+                if (result.result != Mavsdk_Rpc_LogFiles_LogFilesResult.Result.success) {
+                    single(.failure(LogFilesError(code: LogFilesResult.Result.translateFromRpc(result.result), description: result.resultStr)))
+
+                    return Disposables.create()
+                }
+                
+
+    	    
+                    let progress = try ProgressData.translateFromRpc(response.response.wait().progress)
+                
+                single(.success(progress))
+            } catch {
+                single(.failure(error))
+            }
+
+            return Disposables.create()
+        }
+    }
+
+    /**
+     Erase all log files.
+
+     
+     */
+    public func eraseAllLogFiles() -> Completable {
+        return Completable.create { completable in
+            let request = Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest()
+
+            
+
+            do {
+                
+                let response = self.service.eraseAllLogFiles(request)
+
+                let result = try response.response.wait().logFilesResult
+                if (result.result == Mavsdk_Rpc_LogFiles_LogFilesResult.Result.success) {
+                    completable(.completed)
+                } else {
+                    completable(.error(LogFilesError(code: LogFilesResult.Result.translateFromRpc(result.result), description: result.resultStr)))
+                }
+                
+            } catch {
+                completable(.error(error))
+            }
+
+            return Disposables.create()
+        }
+    }
 }
\ No newline at end of file
diff --git a/Sources/Mavsdk/Generated/Mocap.swift b/Sources/Mavsdk/Generated/Mocap.swift
index 00c656c..f08e64a 100644
--- a/Sources/Mavsdk/Generated/Mocap.swift
+++ b/Sources/Mavsdk/Generated/Mocap.swift
@@ -740,6 +740,8 @@ public class Mocap {
             case connectionError
             ///  Invalid request data.
             case invalidRequestData
+            ///  Function unsupported.
+            case unsupported
             case UNRECOGNIZED(Int)
 
             internal var rpcResult: Mavsdk_Rpc_Mocap_MocapResult.Result {
@@ -754,6 +756,8 @@ public class Mocap {
                     return .connectionError
                 case .invalidRequestData:
                     return .invalidRequestData
+                case .unsupported:
+                    return .unsupported
                 case .UNRECOGNIZED(let i):
                     return .UNRECOGNIZED(i)
                 }
@@ -771,6 +775,8 @@ public class Mocap {
                     return .connectionError
                 case .invalidRequestData:
                     return .invalidRequestData
+                case .unsupported:
+                    return .unsupported
                 case .UNRECOGNIZED(let i):
                     return .UNRECOGNIZED(i)
                 }
diff --git a/Sources/Mavsdk/Generated/Transponder.swift b/Sources/Mavsdk/Generated/Transponder.swift
index af82f9f..fe949a1 100644
--- a/Sources/Mavsdk/Generated/Transponder.swift
+++ b/Sources/Mavsdk/Generated/Transponder.swift
@@ -209,6 +209,7 @@ public class Transponder {
         public let callsign: String
         public let emitterType: AdsbEmitterType
         public let squawk: UInt32
+        public let tslcS: UInt32
 
         
 
@@ -238,9 +239,11 @@ public class Transponder {
             
             - squawk:  Squawk code.
             
+            - tslcS:  Time Since Last Communication in seconds.
+            
          
          */
-        public init(icaoAddress: UInt32, latitudeDeg: Double, longitudeDeg: Double, absoluteAltitudeM: Float, headingDeg: Float, horizontalVelocityMS: Float, verticalVelocityMS: Float, callsign: String, emitterType: AdsbEmitterType, squawk: UInt32) {
+        public init(icaoAddress: UInt32, latitudeDeg: Double, longitudeDeg: Double, absoluteAltitudeM: Float, headingDeg: Float, horizontalVelocityMS: Float, verticalVelocityMS: Float, callsign: String, emitterType: AdsbEmitterType, squawk: UInt32, tslcS: UInt32) {
             self.icaoAddress = icaoAddress
             self.latitudeDeg = latitudeDeg
             self.longitudeDeg = longitudeDeg
@@ -251,6 +254,7 @@ public class Transponder {
             self.callsign = callsign
             self.emitterType = emitterType
             self.squawk = squawk
+            self.tslcS = tslcS
         }
 
         internal var rpcAdsbVehicle: Mavsdk_Rpc_Transponder_AdsbVehicle {
@@ -305,12 +309,17 @@ public class Transponder {
             rpcAdsbVehicle.squawk = squawk
                 
             
+            
+                
+            rpcAdsbVehicle.tslcS = tslcS
+                
+            
 
             return rpcAdsbVehicle
         }
 
         internal static func translateFromRpc(_ rpcAdsbVehicle: Mavsdk_Rpc_Transponder_AdsbVehicle) -> AdsbVehicle {
-            return AdsbVehicle(icaoAddress: rpcAdsbVehicle.icaoAddress, latitudeDeg: rpcAdsbVehicle.latitudeDeg, longitudeDeg: rpcAdsbVehicle.longitudeDeg, absoluteAltitudeM: rpcAdsbVehicle.absoluteAltitudeM, headingDeg: rpcAdsbVehicle.headingDeg, horizontalVelocityMS: rpcAdsbVehicle.horizontalVelocityMS, verticalVelocityMS: rpcAdsbVehicle.verticalVelocityMS, callsign: rpcAdsbVehicle.callsign, emitterType: AdsbEmitterType.translateFromRpc(rpcAdsbVehicle.emitterType), squawk: rpcAdsbVehicle.squawk)
+            return AdsbVehicle(icaoAddress: rpcAdsbVehicle.icaoAddress, latitudeDeg: rpcAdsbVehicle.latitudeDeg, longitudeDeg: rpcAdsbVehicle.longitudeDeg, absoluteAltitudeM: rpcAdsbVehicle.absoluteAltitudeM, headingDeg: rpcAdsbVehicle.headingDeg, horizontalVelocityMS: rpcAdsbVehicle.horizontalVelocityMS, verticalVelocityMS: rpcAdsbVehicle.verticalVelocityMS, callsign: rpcAdsbVehicle.callsign, emitterType: AdsbEmitterType.translateFromRpc(rpcAdsbVehicle.emitterType), squawk: rpcAdsbVehicle.squawk, tslcS: rpcAdsbVehicle.tslcS)
         }
 
         public static func == (lhs: AdsbVehicle, rhs: AdsbVehicle) -> Bool {
@@ -324,6 +333,7 @@ public class Transponder {
                 && lhs.callsign == rhs.callsign
                 && lhs.emitterType == rhs.emitterType
                 && lhs.squawk == rhs.squawk
+                && lhs.tslcS == rhs.tslcS
         }
     }
 
diff --git a/Sources/Mavsdk/Generated/action.grpc.swift b/Sources/Mavsdk/Generated/action.grpc.swift
index a0a3854..4a3aee6 100644
--- a/Sources/Mavsdk/Generated/action.grpc.swift
+++ b/Sources/Mavsdk/Generated/action.grpc.swift
@@ -136,6 +136,11 @@ internal protocol Mavsdk_Rpc_Action_ActionServiceClientProtocol: GRPCClient {
     _ request: Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeRequest,
     callOptions: CallOptions?
   ) -> UnaryCall<Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeRequest, Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeResponse>
+
+  func setCurrentSpeed(
+    _ request: Mavsdk_Rpc_Action_SetCurrentSpeedRequest,
+    callOptions: CallOptions?
+  ) -> UnaryCall<Mavsdk_Rpc_Action_SetCurrentSpeedRequest, Mavsdk_Rpc_Action_SetCurrentSpeedResponse>
 }
 
 extension Mavsdk_Rpc_Action_ActionServiceClientProtocol {
@@ -590,6 +595,28 @@ extension Mavsdk_Rpc_Action_ActionServiceClientProtocol {
       interceptors: self.interceptors?.makeSetReturnToLaunchAltitudeInterceptors() ?? []
     )
   }
+
+  ///
+  /// Set current speed.
+  ///
+  /// This will set the speed during a mission, reposition, and similar.
+  /// It is ephemeral, so not stored on the drone and does not survive a reboot.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to SetCurrentSpeed.
+  ///   - callOptions: Call options.
+  /// - Returns: A `UnaryCall` with futures for the metadata, status and response.
+  internal func setCurrentSpeed(
+    _ request: Mavsdk_Rpc_Action_SetCurrentSpeedRequest,
+    callOptions: CallOptions? = nil
+  ) -> UnaryCall<Mavsdk_Rpc_Action_SetCurrentSpeedRequest, Mavsdk_Rpc_Action_SetCurrentSpeedResponse> {
+    return self.makeUnaryCall(
+      path: "/mavsdk.rpc.action.ActionService/SetCurrentSpeed",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeSetCurrentSpeedInterceptors() ?? []
+    )
+  }
 }
 
 internal protocol Mavsdk_Rpc_Action_ActionServiceClientInterceptorFactoryProtocol {
@@ -656,6 +683,9 @@ internal protocol Mavsdk_Rpc_Action_ActionServiceClientInterceptorFactoryProtoco
 
   /// - Returns: Interceptors to use when invoking 'setReturnToLaunchAltitude'.
   func makeSetReturnToLaunchAltitudeInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeRequest, Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeResponse>]
+
+  /// - Returns: Interceptors to use when invoking 'setCurrentSpeed'.
+  func makeSetCurrentSpeedInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_Action_SetCurrentSpeedRequest, Mavsdk_Rpc_Action_SetCurrentSpeedResponse>]
 }
 
 internal final class Mavsdk_Rpc_Action_ActionServiceClient: Mavsdk_Rpc_Action_ActionServiceClientProtocol {
@@ -818,6 +848,13 @@ internal protocol Mavsdk_Rpc_Action_ActionServiceProvider: CallHandlerProvider {
   ///
   /// Set the return to launch minimum return altitude (in meters).
   func setReturnToLaunchAltitude(request: Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeRequest, context: StatusOnlyCallContext) -> EventLoopFuture<Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeResponse>
+
+  ///
+  /// Set current speed.
+  ///
+  /// This will set the speed during a mission, reposition, and similar.
+  /// It is ephemeral, so not stored on the drone and does not survive a reboot.
+  func setCurrentSpeed(request: Mavsdk_Rpc_Action_SetCurrentSpeedRequest, context: StatusOnlyCallContext) -> EventLoopFuture<Mavsdk_Rpc_Action_SetCurrentSpeedResponse>
 }
 
 extension Mavsdk_Rpc_Action_ActionServiceProvider {
@@ -1019,6 +1056,15 @@ extension Mavsdk_Rpc_Action_ActionServiceProvider {
         userFunction: self.setReturnToLaunchAltitude(request:context:)
       )
 
+    case "SetCurrentSpeed":
+      return UnaryServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Mavsdk_Rpc_Action_SetCurrentSpeedRequest>(),
+        responseSerializer: ProtobufSerializer<Mavsdk_Rpc_Action_SetCurrentSpeedResponse>(),
+        interceptors: self.interceptors?.makeSetCurrentSpeedInterceptors() ?? [],
+        userFunction: self.setCurrentSpeed(request:context:)
+      )
+
     default:
       return nil
     }
@@ -1110,4 +1156,8 @@ internal protocol Mavsdk_Rpc_Action_ActionServiceServerInterceptorFactoryProtoco
   /// - Returns: Interceptors to use when handling 'setReturnToLaunchAltitude'.
   ///   Defaults to calling `self.makeInterceptors()`.
   func makeSetReturnToLaunchAltitudeInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeRequest, Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeResponse>]
+
+  /// - Returns: Interceptors to use when handling 'setCurrentSpeed'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeSetCurrentSpeedInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_Action_SetCurrentSpeedRequest, Mavsdk_Rpc_Action_SetCurrentSpeedResponse>]
 }
diff --git a/Sources/Mavsdk/Generated/action.pb.swift b/Sources/Mavsdk/Generated/action.pb.swift
index e7d87c4..1fd6cb2 100644
--- a/Sources/Mavsdk/Generated/action.pb.swift
+++ b/Sources/Mavsdk/Generated/action.pb.swift
@@ -788,6 +788,40 @@ struct Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeResponse {
   fileprivate var _actionResult: Mavsdk_Rpc_Action_ActionResult? = nil
 }
 
+struct Mavsdk_Rpc_Action_SetCurrentSpeedRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Speed in meters/second
+  var speedMS: Float = 0
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_Action_SetCurrentSpeedResponse {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var actionResult: Mavsdk_Rpc_Action_ActionResult {
+    get {return _actionResult ?? Mavsdk_Rpc_Action_ActionResult()}
+    set {_actionResult = newValue}
+  }
+  /// Returns true if `actionResult` has been explicitly set.
+  var hasActionResult: Bool {return self._actionResult != nil}
+  /// Clears the value of `actionResult`. Subsequent reads from it will return its default value.
+  mutating func clearActionResult() {self._actionResult = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _actionResult: Mavsdk_Rpc_Action_ActionResult? = nil
+}
+
 /// Result type.
 struct Mavsdk_Rpc_Action_ActionResult {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
@@ -841,6 +875,9 @@ struct Mavsdk_Rpc_Action_ActionResult {
 
     /// Error getting or setting parameter
     case parameterError // = 11
+
+    /// Action not supported
+    case unsupported // = 12
     case UNRECOGNIZED(Int)
 
     init() {
@@ -861,6 +898,7 @@ struct Mavsdk_Rpc_Action_ActionResult {
       case 9: self = .vtolTransitionSupportUnknown
       case 10: self = .noVtolTransitionSupport
       case 11: self = .parameterError
+      case 12: self = .unsupported
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
@@ -879,6 +917,7 @@ struct Mavsdk_Rpc_Action_ActionResult {
       case .vtolTransitionSupportUnknown: return 9
       case .noVtolTransitionSupport: return 10
       case .parameterError: return 11
+      case .unsupported: return 12
       case .UNRECOGNIZED(let i): return i
       }
     }
@@ -905,11 +944,62 @@ extension Mavsdk_Rpc_Action_ActionResult.Result: CaseIterable {
     .vtolTransitionSupportUnknown,
     .noVtolTransitionSupport,
     .parameterError,
+    .unsupported,
   ]
 }
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Action_OrbitYawBehavior: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_ArmRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_ArmResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_DisarmRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_DisarmResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_TakeoffRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_TakeoffResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_LandRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_LandResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_RebootRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_RebootResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_ShutdownRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_ShutdownResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_TerminateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_TerminateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_KillRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_KillResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_ReturnToLaunchRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_ReturnToLaunchResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_GotoLocationRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_GotoLocationResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_DoOrbitRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_DoOrbitResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_HoldRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_HoldResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetActuatorRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetActuatorResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_TransitionToFixedwingRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_TransitionToFixedwingResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_TransitionToMulticopterRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_TransitionToMulticopterResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_GetTakeoffAltitudeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_GetTakeoffAltitudeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetTakeoffAltitudeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetTakeoffAltitudeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_GetMaximumSpeedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_GetMaximumSpeedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetMaximumSpeedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetMaximumSpeedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_GetReturnToLaunchAltitudeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_GetReturnToLaunchAltitudeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetCurrentSpeedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_SetCurrentSpeedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_ActionResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Action_ActionResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.action"
@@ -2229,6 +2319,74 @@ extension Mavsdk_Rpc_Action_SetReturnToLaunchAltitudeResponse: SwiftProtobuf.Mes
   }
 }
 
+extension Mavsdk_Rpc_Action_SetCurrentSpeedRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SetCurrentSpeedRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "speed_m_s"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularFloatField(value: &self.speedMS) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.speedMS != 0 {
+      try visitor.visitSingularFloatField(value: self.speedMS, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_Action_SetCurrentSpeedRequest, rhs: Mavsdk_Rpc_Action_SetCurrentSpeedRequest) -> Bool {
+    if lhs.speedMS != rhs.speedMS {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_Action_SetCurrentSpeedResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SetCurrentSpeedResponse"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "action_result"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._actionResult) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._actionResult {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_Action_SetCurrentSpeedResponse, rhs: Mavsdk_Rpc_Action_SetCurrentSpeedResponse) -> Bool {
+    if lhs._actionResult != rhs._actionResult {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension Mavsdk_Rpc_Action_ActionResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = _protobuf_package + ".ActionResult"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -2281,5 +2439,6 @@ extension Mavsdk_Rpc_Action_ActionResult.Result: SwiftProtobuf._ProtoNameProvidi
     9: .same(proto: "RESULT_VTOL_TRANSITION_SUPPORT_UNKNOWN"),
     10: .same(proto: "RESULT_NO_VTOL_TRANSITION_SUPPORT"),
     11: .same(proto: "RESULT_PARAMETER_ERROR"),
+    12: .same(proto: "RESULT_UNSUPPORTED"),
   ]
 }
diff --git a/Sources/Mavsdk/Generated/action_server.pb.swift b/Sources/Mavsdk/Generated/action_server.pb.swift
index d10401a..e8a7c7f 100644
--- a/Sources/Mavsdk/Generated/action_server.pb.swift
+++ b/Sources/Mavsdk/Generated/action_server.pb.swift
@@ -727,6 +727,38 @@ extension Mavsdk_Rpc_ActionServer_ActionServerResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_ActionServer_FlightMode: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SetAllowTakeoffRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SetArmableRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SetDisarmableRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SetAllowableFlightModesRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_GetAllowableFlightModesRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SubscribeArmDisarmRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SubscribeFlightModeChangeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SubscribeTakeoffRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SubscribeLandRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SubscribeRebootRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SubscribeShutdownRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SubscribeTerminateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_ArmDisarmResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_FlightModeChangeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_TakeoffResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_LandResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_RebootResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_ShutdownResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_TerminateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SetArmableResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SetDisarmableResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SetAllowableFlightModesResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_SetAllowTakeoffResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_GetAllowableFlightModesResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_AllowableFlightModes: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_ArmDisarm: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_ActionServerResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_ActionServer_ActionServerResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.action_server"
diff --git a/Sources/Mavsdk/Generated/calibration.pb.swift b/Sources/Mavsdk/Generated/calibration.pb.swift
index 21c2442..10099f1 100644
--- a/Sources/Mavsdk/Generated/calibration.pb.swift
+++ b/Sources/Mavsdk/Generated/calibration.pb.swift
@@ -311,6 +311,9 @@ struct Mavsdk_Rpc_Calibration_CalibrationResult {
 
     /// Calibration process failed since the vehicle is armed
     case failedArmed // = 10
+
+    /// Functionality not supported
+    case unsupported // = 11
     case UNRECOGNIZED(Int)
 
     init() {
@@ -330,6 +333,7 @@ struct Mavsdk_Rpc_Calibration_CalibrationResult {
       case 8: self = .timeout
       case 9: self = .cancelled
       case 10: self = .failedArmed
+      case 11: self = .unsupported
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
@@ -347,6 +351,7 @@ struct Mavsdk_Rpc_Calibration_CalibrationResult {
       case .timeout: return 8
       case .cancelled: return 9
       case .failedArmed: return 10
+      case .unsupported: return 11
       case .UNRECOGNIZED(let i): return i
       }
     }
@@ -372,6 +377,7 @@ extension Mavsdk_Rpc_Calibration_CalibrationResult.Result: CaseIterable {
     .timeout,
     .cancelled,
     .failedArmed,
+    .unsupported,
   ]
 }
 
@@ -403,6 +409,24 @@ struct Mavsdk_Rpc_Calibration_ProgressData {
   init() {}
 }
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Calibration_SubscribeCalibrateGyroRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CalibrateGyroResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_SubscribeCalibrateAccelerometerRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CalibrateAccelerometerResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_SubscribeCalibrateMagnetometerRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CalibrateMagnetometerResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_SubscribeCalibrateLevelHorizonRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CalibrateLevelHorizonResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_SubscribeCalibrateGimbalAccelerometerRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CalibrateGimbalAccelerometerResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CancelRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CancelResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CalibrationResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_CalibrationResult.Result: @unchecked Sendable {}
+extension Mavsdk_Rpc_Calibration_ProgressData: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.calibration"
@@ -818,6 +842,7 @@ extension Mavsdk_Rpc_Calibration_CalibrationResult.Result: SwiftProtobuf._ProtoN
     8: .same(proto: "RESULT_TIMEOUT"),
     9: .same(proto: "RESULT_CANCELLED"),
     10: .same(proto: "RESULT_FAILED_ARMED"),
+    11: .same(proto: "RESULT_UNSUPPORTED"),
   ]
 }
 
diff --git a/Sources/Mavsdk/Generated/camera.grpc.swift b/Sources/Mavsdk/Generated/camera.grpc.swift
index 83b9482..29a65df 100644
--- a/Sources/Mavsdk/Generated/camera.grpc.swift
+++ b/Sources/Mavsdk/Generated/camera.grpc.swift
@@ -145,6 +145,11 @@ internal protocol Mavsdk_Rpc_Camera_CameraServiceClientProtocol: GRPCClient {
     _ request: Mavsdk_Rpc_Camera_FormatStorageRequest,
     callOptions: CallOptions?
   ) -> UnaryCall<Mavsdk_Rpc_Camera_FormatStorageRequest, Mavsdk_Rpc_Camera_FormatStorageResponse>
+
+  func selectCamera(
+    _ request: Mavsdk_Rpc_Camera_SelectCameraRequest,
+    callOptions: CallOptions?
+  ) -> UnaryCall<Mavsdk_Rpc_Camera_SelectCameraRequest, Mavsdk_Rpc_Camera_SelectCameraResponse>
 }
 
 extension Mavsdk_Rpc_Camera_CameraServiceClientProtocol {
@@ -558,6 +563,27 @@ extension Mavsdk_Rpc_Camera_CameraServiceClientProtocol {
       interceptors: self.interceptors?.makeFormatStorageInterceptors() ?? []
     )
   }
+
+  ///
+  /// Select current camera .
+  ///
+  /// Bind the plugin instance to a specific camera_id 
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to SelectCamera.
+  ///   - callOptions: Call options.
+  /// - Returns: A `UnaryCall` with futures for the metadata, status and response.
+  internal func selectCamera(
+    _ request: Mavsdk_Rpc_Camera_SelectCameraRequest,
+    callOptions: CallOptions? = nil
+  ) -> UnaryCall<Mavsdk_Rpc_Camera_SelectCameraRequest, Mavsdk_Rpc_Camera_SelectCameraResponse> {
+    return self.makeUnaryCall(
+      path: "/mavsdk.rpc.camera.CameraService/SelectCamera",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeSelectCameraInterceptors() ?? []
+    )
+  }
 }
 
 internal protocol Mavsdk_Rpc_Camera_CameraServiceClientInterceptorFactoryProtocol {
@@ -621,6 +647,9 @@ internal protocol Mavsdk_Rpc_Camera_CameraServiceClientInterceptorFactoryProtoco
 
   /// - Returns: Interceptors to use when invoking 'formatStorage'.
   func makeFormatStorageInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_Camera_FormatStorageRequest, Mavsdk_Rpc_Camera_FormatStorageResponse>]
+
+  /// - Returns: Interceptors to use when invoking 'selectCamera'.
+  func makeSelectCameraInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_Camera_SelectCameraRequest, Mavsdk_Rpc_Camera_SelectCameraResponse>]
 }
 
 internal final class Mavsdk_Rpc_Camera_CameraServiceClient: Mavsdk_Rpc_Camera_CameraServiceClientProtocol {
@@ -743,6 +772,12 @@ internal protocol Mavsdk_Rpc_Camera_CameraServiceProvider: CallHandlerProvider {
   ///
   /// This will delete all content of the camera storage!
   func formatStorage(request: Mavsdk_Rpc_Camera_FormatStorageRequest, context: StatusOnlyCallContext) -> EventLoopFuture<Mavsdk_Rpc_Camera_FormatStorageResponse>
+
+  ///
+  /// Select current camera .
+  ///
+  /// Bind the plugin instance to a specific camera_id 
+  func selectCamera(request: Mavsdk_Rpc_Camera_SelectCameraRequest, context: StatusOnlyCallContext) -> EventLoopFuture<Mavsdk_Rpc_Camera_SelectCameraResponse>
 }
 
 extension Mavsdk_Rpc_Camera_CameraServiceProvider {
@@ -935,6 +970,15 @@ extension Mavsdk_Rpc_Camera_CameraServiceProvider {
         userFunction: self.formatStorage(request:context:)
       )
 
+    case "SelectCamera":
+      return UnaryServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Mavsdk_Rpc_Camera_SelectCameraRequest>(),
+        responseSerializer: ProtobufSerializer<Mavsdk_Rpc_Camera_SelectCameraResponse>(),
+        interceptors: self.interceptors?.makeSelectCameraInterceptors() ?? [],
+        userFunction: self.selectCamera(request:context:)
+      )
+
     default:
       return nil
     }
@@ -1022,4 +1066,8 @@ internal protocol Mavsdk_Rpc_Camera_CameraServiceServerInterceptorFactoryProtoco
   /// - Returns: Interceptors to use when handling 'formatStorage'.
   ///   Defaults to calling `self.makeInterceptors()`.
   func makeFormatStorageInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_Camera_FormatStorageRequest, Mavsdk_Rpc_Camera_FormatStorageResponse>]
+
+  /// - Returns: Interceptors to use when handling 'selectCamera'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeSelectCameraInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_Camera_SelectCameraRequest, Mavsdk_Rpc_Camera_SelectCameraResponse>]
 }
diff --git a/Sources/Mavsdk/Generated/camera.pb.swift b/Sources/Mavsdk/Generated/camera.pb.swift
index e43c05a..d3ce708 100644
--- a/Sources/Mavsdk/Generated/camera.pb.swift
+++ b/Sources/Mavsdk/Generated/camera.pb.swift
@@ -763,6 +763,40 @@ struct Mavsdk_Rpc_Camera_FormatStorageResponse {
   fileprivate var _cameraResult: Mavsdk_Rpc_Camera_CameraResult? = nil
 }
 
+struct Mavsdk_Rpc_Camera_SelectCameraResponse {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var cameraResult: Mavsdk_Rpc_Camera_CameraResult {
+    get {return _cameraResult ?? Mavsdk_Rpc_Camera_CameraResult()}
+    set {_cameraResult = newValue}
+  }
+  /// Returns true if `cameraResult` has been explicitly set.
+  var hasCameraResult: Bool {return self._cameraResult != nil}
+  /// Clears the value of `cameraResult`. Subsequent reads from it will return its default value.
+  mutating func clearCameraResult() {self._cameraResult = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _cameraResult: Mavsdk_Rpc_Camera_CameraResult? = nil
+}
+
+struct Mavsdk_Rpc_Camera_SelectCameraRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Id of camera to be selected
+  var cameraID: Int32 = 0
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
 /// Result type.
 struct Mavsdk_Rpc_Camera_CameraResult {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
@@ -1424,6 +1458,70 @@ struct Mavsdk_Rpc_Camera_Information {
   init() {}
 }
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Camera_Mode: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_PhotosRange: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_PrepareRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_PrepareResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_TakePhotoRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_TakePhotoResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StartPhotoIntervalRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StartPhotoIntervalResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StopPhotoIntervalRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StopPhotoIntervalResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StartVideoRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StartVideoResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StopVideoRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StopVideoResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StartVideoStreamingRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StartVideoStreamingResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StopVideoStreamingRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StopVideoStreamingResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SetModeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SetModeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_ListPhotosRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_ListPhotosResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SubscribeInformationRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_InformationResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SubscribeModeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_ModeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SubscribeVideoStreamInfoRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_VideoStreamInfoResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SubscribeCaptureInfoRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_CaptureInfoResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SubscribeStatusRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_StatusResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SubscribeCurrentSettingsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_CurrentSettingsResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SubscribePossibleSettingOptionsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_PossibleSettingOptionsResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SetSettingRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SetSettingResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_GetSettingRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_GetSettingResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_FormatStorageRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_FormatStorageResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SelectCameraResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SelectCameraRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_CameraResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_CameraResult.Result: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_Position: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_Quaternion: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_EulerAngle: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_CaptureInfo: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_VideoStreamSettings: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_VideoStreamInfo: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_VideoStreamInfo.VideoStreamStatus: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_VideoStreamInfo.VideoStreamSpectrum: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_Status: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_Status.StorageStatus: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_Status.StorageType: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_Option: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_Setting: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_SettingOptions: @unchecked Sendable {}
+extension Mavsdk_Rpc_Camera_Information: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.camera"
@@ -2616,6 +2714,74 @@ extension Mavsdk_Rpc_Camera_FormatStorageResponse: SwiftProtobuf.Message, SwiftP
   }
 }
 
+extension Mavsdk_Rpc_Camera_SelectCameraResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SelectCameraResponse"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "camera_result"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._cameraResult) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._cameraResult {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_Camera_SelectCameraResponse, rhs: Mavsdk_Rpc_Camera_SelectCameraResponse) -> Bool {
+    if lhs._cameraResult != rhs._cameraResult {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_Camera_SelectCameraRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SelectCameraRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "camera_id"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.cameraID) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.cameraID != 0 {
+      try visitor.visitSingularInt32Field(value: self.cameraID, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_Camera_SelectCameraRequest, rhs: Mavsdk_Rpc_Camera_SelectCameraRequest) -> Bool {
+    if lhs.cameraID != rhs.cameraID {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension Mavsdk_Rpc_Camera_CameraResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = _protobuf_package + ".CameraResult"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
diff --git a/Sources/Mavsdk/Generated/component_information.grpc.swift b/Sources/Mavsdk/Generated/component_information.grpc.swift
new file mode 100644
index 0000000..6bc3391
--- /dev/null
+++ b/Sources/Mavsdk/Generated/component_information.grpc.swift
@@ -0,0 +1,183 @@
+//
+// DO NOT EDIT.
+//
+// Generated by the protocol buffer compiler.
+// Source: component_information.proto
+//
+
+//
+// Copyright 2018, gRPC Authors All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+import GRPC
+import NIO
+import SwiftProtobuf
+
+
+/// Access component information such as parameters.
+///
+/// Usage: instantiate `Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClient`, then call methods of this protocol to make API calls.
+internal protocol Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClientProtocol: GRPCClient {
+  var serviceName: String { get }
+  var interceptors: Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClientInterceptorFactoryProtocol? { get }
+
+  func accessFloatParams(
+    _ request: Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest,
+    callOptions: CallOptions?
+  ) -> UnaryCall<Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest, Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse>
+
+  func subscribeFloatParam(
+    _ request: Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest,
+    callOptions: CallOptions?,
+    handler: @escaping (Mavsdk_Rpc_ComponentInformation_FloatParamResponse) -> Void
+  ) -> ServerStreamingCall<Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest, Mavsdk_Rpc_ComponentInformation_FloatParamResponse>
+}
+
+extension Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClientProtocol {
+  internal var serviceName: String {
+    return "mavsdk.rpc.component_information.ComponentInformationService"
+  }
+
+  ///
+  /// List available float params.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to AccessFloatParams.
+  ///   - callOptions: Call options.
+  /// - Returns: A `UnaryCall` with futures for the metadata, status and response.
+  internal func accessFloatParams(
+    _ request: Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest,
+    callOptions: CallOptions? = nil
+  ) -> UnaryCall<Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest, Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse> {
+    return self.makeUnaryCall(
+      path: "/mavsdk.rpc.component_information.ComponentInformationService/AccessFloatParams",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeAccessFloatParamsInterceptors() ?? []
+    )
+  }
+
+  ///
+  /// Subscribe to float param changes/updates.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to SubscribeFloatParam.
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ServerStreamingCall` with futures for the metadata and status.
+  internal func subscribeFloatParam(
+    _ request: Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest,
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Mavsdk_Rpc_ComponentInformation_FloatParamResponse) -> Void
+  ) -> ServerStreamingCall<Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest, Mavsdk_Rpc_ComponentInformation_FloatParamResponse> {
+    return self.makeServerStreamingCall(
+      path: "/mavsdk.rpc.component_information.ComponentInformationService/SubscribeFloatParam",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeSubscribeFloatParamInterceptors() ?? [],
+      handler: handler
+    )
+  }
+}
+
+internal protocol Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClientInterceptorFactoryProtocol {
+
+  /// - Returns: Interceptors to use when invoking 'accessFloatParams'.
+  func makeAccessFloatParamsInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest, Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse>]
+
+  /// - Returns: Interceptors to use when invoking 'subscribeFloatParam'.
+  func makeSubscribeFloatParamInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest, Mavsdk_Rpc_ComponentInformation_FloatParamResponse>]
+}
+
+internal final class Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClient: Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClientProtocol {
+  internal let channel: GRPCChannel
+  internal var defaultCallOptions: CallOptions
+  internal var interceptors: Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClientInterceptorFactoryProtocol?
+
+  /// Creates a client for the mavsdk.rpc.component_information.ComponentInformationService service.
+  ///
+  /// - Parameters:
+  ///   - channel: `GRPCChannel` to the service host.
+  ///   - defaultCallOptions: Options to use for each service call if the user doesn't provide them.
+  ///   - interceptors: A factory providing interceptors for each RPC.
+  internal init(
+    channel: GRPCChannel,
+    defaultCallOptions: CallOptions = CallOptions(),
+    interceptors: Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceClientInterceptorFactoryProtocol? = nil
+  ) {
+    self.channel = channel
+    self.defaultCallOptions = defaultCallOptions
+    self.interceptors = interceptors
+  }
+}
+
+/// Access component information such as parameters.
+///
+/// To build a server, implement a class that conforms to this protocol.
+internal protocol Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceProvider: CallHandlerProvider {
+  var interceptors: Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceServerInterceptorFactoryProtocol? { get }
+
+  ///
+  /// List available float params.
+  func accessFloatParams(request: Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest, context: StatusOnlyCallContext) -> EventLoopFuture<Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse>
+
+  ///
+  /// Subscribe to float param changes/updates.
+  func subscribeFloatParam(request: Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest, context: StreamingResponseCallContext<Mavsdk_Rpc_ComponentInformation_FloatParamResponse>) -> EventLoopFuture<GRPCStatus>
+}
+
+extension Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceProvider {
+  internal var serviceName: Substring { return "mavsdk.rpc.component_information.ComponentInformationService" }
+
+  /// Determines, calls and returns the appropriate request handler, depending on the request's method.
+  /// Returns nil for methods not handled by this service.
+  internal func handle(
+    method name: Substring,
+    context: CallHandlerContext
+  ) -> GRPCServerHandlerProtocol? {
+    switch name {
+    case "AccessFloatParams":
+      return UnaryServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest>(),
+        responseSerializer: ProtobufSerializer<Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse>(),
+        interceptors: self.interceptors?.makeAccessFloatParamsInterceptors() ?? [],
+        userFunction: self.accessFloatParams(request:context:)
+      )
+
+    case "SubscribeFloatParam":
+      return ServerStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest>(),
+        responseSerializer: ProtobufSerializer<Mavsdk_Rpc_ComponentInformation_FloatParamResponse>(),
+        interceptors: self.interceptors?.makeSubscribeFloatParamInterceptors() ?? [],
+        userFunction: self.subscribeFloatParam(request:context:)
+      )
+
+    default:
+      return nil
+    }
+  }
+}
+
+internal protocol Mavsdk_Rpc_ComponentInformation_ComponentInformationServiceServerInterceptorFactoryProtocol {
+
+  /// - Returns: Interceptors to use when handling 'accessFloatParams'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeAccessFloatParamsInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest, Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse>]
+
+  /// - Returns: Interceptors to use when handling 'subscribeFloatParam'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeSubscribeFloatParamInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest, Mavsdk_Rpc_ComponentInformation_FloatParamResponse>]
+}
diff --git a/Sources/Mavsdk/Generated/component_information.pb.swift b/Sources/Mavsdk/Generated/component_information.pb.swift
new file mode 100644
index 0000000..538ced5
--- /dev/null
+++ b/Sources/Mavsdk/Generated/component_information.pb.swift
@@ -0,0 +1,505 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: component_information.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+import Foundation
+import SwiftProtobuf
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
+  typealias Version = _2
+}
+
+/// Meta information for parameter of type float.
+struct Mavsdk_Rpc_ComponentInformation_FloatParam {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Name (max 16 chars)
+  var name: String = String()
+
+  /// Short description
+  var shortDescription: String = String()
+
+  /// Long description
+  var longDescription: String = String()
+
+  /// Unit
+  var unit: String = String()
+
+  /// Decimal places for user to show
+  var decimalPlaces: Int32 = 0
+
+  /// Current/starting value
+  var startValue: Float = 0
+
+  /// Default value
+  var defaultValue: Float = 0
+
+  /// Minimum value
+  var minValue: Float = 0
+
+  /// Maximum value
+  var maxValue: Float = 0
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var componentInformationResult: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult {
+    get {return _componentInformationResult ?? Mavsdk_Rpc_ComponentInformation_ComponentInformationResult()}
+    set {_componentInformationResult = newValue}
+  }
+  /// Returns true if `componentInformationResult` has been explicitly set.
+  var hasComponentInformationResult: Bool {return self._componentInformationResult != nil}
+  /// Clears the value of `componentInformationResult`. Subsequent reads from it will return its default value.
+  mutating func clearComponentInformationResult() {self._componentInformationResult = nil}
+
+  /// Float param definitions
+  var params: [Mavsdk_Rpc_ComponentInformation_FloatParam] = []
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _componentInformationResult: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult? = nil
+}
+
+/// A float param that has been updated.
+struct Mavsdk_Rpc_ComponentInformation_FloatParamUpdate {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Name of param that changed
+  var name: String = String()
+
+  /// New value of param
+  var value: Float = 0
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_ComponentInformation_FloatParamResponse {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// A param update
+  var paramUpdate: Mavsdk_Rpc_ComponentInformation_FloatParamUpdate {
+    get {return _paramUpdate ?? Mavsdk_Rpc_ComponentInformation_FloatParamUpdate()}
+    set {_paramUpdate = newValue}
+  }
+  /// Returns true if `paramUpdate` has been explicitly set.
+  var hasParamUpdate: Bool {return self._paramUpdate != nil}
+  /// Clears the value of `paramUpdate`. Subsequent reads from it will return its default value.
+  mutating func clearParamUpdate() {self._paramUpdate = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _paramUpdate: Mavsdk_Rpc_ComponentInformation_FloatParamUpdate? = nil
+}
+
+/// Result type.
+struct Mavsdk_Rpc_ComponentInformation_ComponentInformationResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Result enum value
+  var result: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult.Result = .unknown
+
+  /// Human-readable English string describing the result
+  var resultStr: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  /// Possible results returned for param requests.
+  enum Result: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+
+    /// Unknown result
+    case unknown // = 0
+
+    /// Request succeeded
+    case success // = 1
+
+    /// No system is connected
+    case noSystem // = 3
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .unknown
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .unknown
+      case 1: self = .success
+      case 3: self = .noSystem
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .unknown: return 0
+      case .success: return 1
+      case .noSystem: return 3
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+  }
+
+  init() {}
+}
+
+#if swift(>=4.2)
+
+extension Mavsdk_Rpc_ComponentInformation_ComponentInformationResult.Result: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Mavsdk_Rpc_ComponentInformation_ComponentInformationResult.Result] = [
+    .unknown,
+    .success,
+    .noSystem,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_ComponentInformation_FloatParam: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformation_FloatParamUpdate: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformation_FloatParamResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformation_ComponentInformationResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformation_ComponentInformationResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+fileprivate let _protobuf_package = "mavsdk.rpc.component_information"
+
+extension Mavsdk_Rpc_ComponentInformation_FloatParam: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FloatParam"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "name"),
+    2: .standard(proto: "short_description"),
+    3: .standard(proto: "long_description"),
+    4: .same(proto: "unit"),
+    5: .standard(proto: "decimal_places"),
+    6: .standard(proto: "start_value"),
+    7: .standard(proto: "default_value"),
+    8: .standard(proto: "min_value"),
+    9: .standard(proto: "max_value"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.name) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self.shortDescription) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self.longDescription) }()
+      case 4: try { try decoder.decodeSingularStringField(value: &self.unit) }()
+      case 5: try { try decoder.decodeSingularInt32Field(value: &self.decimalPlaces) }()
+      case 6: try { try decoder.decodeSingularFloatField(value: &self.startValue) }()
+      case 7: try { try decoder.decodeSingularFloatField(value: &self.defaultValue) }()
+      case 8: try { try decoder.decodeSingularFloatField(value: &self.minValue) }()
+      case 9: try { try decoder.decodeSingularFloatField(value: &self.maxValue) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.name.isEmpty {
+      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
+    }
+    if !self.shortDescription.isEmpty {
+      try visitor.visitSingularStringField(value: self.shortDescription, fieldNumber: 2)
+    }
+    if !self.longDescription.isEmpty {
+      try visitor.visitSingularStringField(value: self.longDescription, fieldNumber: 3)
+    }
+    if !self.unit.isEmpty {
+      try visitor.visitSingularStringField(value: self.unit, fieldNumber: 4)
+    }
+    if self.decimalPlaces != 0 {
+      try visitor.visitSingularInt32Field(value: self.decimalPlaces, fieldNumber: 5)
+    }
+    if self.startValue != 0 {
+      try visitor.visitSingularFloatField(value: self.startValue, fieldNumber: 6)
+    }
+    if self.defaultValue != 0 {
+      try visitor.visitSingularFloatField(value: self.defaultValue, fieldNumber: 7)
+    }
+    if self.minValue != 0 {
+      try visitor.visitSingularFloatField(value: self.minValue, fieldNumber: 8)
+    }
+    if self.maxValue != 0 {
+      try visitor.visitSingularFloatField(value: self.maxValue, fieldNumber: 9)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformation_FloatParam, rhs: Mavsdk_Rpc_ComponentInformation_FloatParam) -> Bool {
+    if lhs.name != rhs.name {return false}
+    if lhs.shortDescription != rhs.shortDescription {return false}
+    if lhs.longDescription != rhs.longDescription {return false}
+    if lhs.unit != rhs.unit {return false}
+    if lhs.decimalPlaces != rhs.decimalPlaces {return false}
+    if lhs.startValue != rhs.startValue {return false}
+    if lhs.defaultValue != rhs.defaultValue {return false}
+    if lhs.minValue != rhs.minValue {return false}
+    if lhs.maxValue != rhs.maxValue {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".AccessFloatParamsRequest"
+  static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let _ = try decoder.nextFieldNumber() {
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest, rhs: Mavsdk_Rpc_ComponentInformation_AccessFloatParamsRequest) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".AccessFloatParamsResponse"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "component_information_result"),
+    2: .same(proto: "params"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._componentInformationResult) }()
+      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.params) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._componentInformationResult {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    if !self.params.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.params, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse, rhs: Mavsdk_Rpc_ComponentInformation_AccessFloatParamsResponse) -> Bool {
+    if lhs._componentInformationResult != rhs._componentInformationResult {return false}
+    if lhs.params != rhs.params {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformation_FloatParamUpdate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FloatParamUpdate"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "name"),
+    2: .same(proto: "value"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.name) }()
+      case 2: try { try decoder.decodeSingularFloatField(value: &self.value) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.name.isEmpty {
+      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
+    }
+    if self.value != 0 {
+      try visitor.visitSingularFloatField(value: self.value, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformation_FloatParamUpdate, rhs: Mavsdk_Rpc_ComponentInformation_FloatParamUpdate) -> Bool {
+    if lhs.name != rhs.name {return false}
+    if lhs.value != rhs.value {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SubscribeFloatParamRequest"
+  static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let _ = try decoder.nextFieldNumber() {
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest, rhs: Mavsdk_Rpc_ComponentInformation_SubscribeFloatParamRequest) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformation_FloatParamResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FloatParamResponse"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "param_update"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._paramUpdate) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._paramUpdate {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformation_FloatParamResponse, rhs: Mavsdk_Rpc_ComponentInformation_FloatParamResponse) -> Bool {
+    if lhs._paramUpdate != rhs._paramUpdate {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformation_ComponentInformationResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ComponentInformationResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "result"),
+    2: .standard(proto: "result_str"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularEnumField(value: &self.result) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self.resultStr) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.result != .unknown {
+      try visitor.visitSingularEnumField(value: self.result, fieldNumber: 1)
+    }
+    if !self.resultStr.isEmpty {
+      try visitor.visitSingularStringField(value: self.resultStr, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult, rhs: Mavsdk_Rpc_ComponentInformation_ComponentInformationResult) -> Bool {
+    if lhs.result != rhs.result {return false}
+    if lhs.resultStr != rhs.resultStr {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformation_ComponentInformationResult.Result: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "RESULT_UNKNOWN"),
+    1: .same(proto: "RESULT_SUCCESS"),
+    3: .same(proto: "RESULT_NO_SYSTEM"),
+  ]
+}
diff --git a/Sources/Mavsdk/Generated/component_information_server.grpc.swift b/Sources/Mavsdk/Generated/component_information_server.grpc.swift
new file mode 100644
index 0000000..1b5961a
--- /dev/null
+++ b/Sources/Mavsdk/Generated/component_information_server.grpc.swift
@@ -0,0 +1,183 @@
+//
+// DO NOT EDIT.
+//
+// Generated by the protocol buffer compiler.
+// Source: component_information_server.proto
+//
+
+//
+// Copyright 2018, gRPC Authors All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+import GRPC
+import NIO
+import SwiftProtobuf
+
+
+/// Provide component information such as parameters.
+///
+/// Usage: instantiate `Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClient`, then call methods of this protocol to make API calls.
+internal protocol Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClientProtocol: GRPCClient {
+  var serviceName: String { get }
+  var interceptors: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClientInterceptorFactoryProtocol? { get }
+
+  func provideFloatParam(
+    _ request: Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest,
+    callOptions: CallOptions?
+  ) -> UnaryCall<Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest, Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse>
+
+  func subscribeFloatParam(
+    _ request: Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest,
+    callOptions: CallOptions?,
+    handler: @escaping (Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse) -> Void
+  ) -> ServerStreamingCall<Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest, Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse>
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClientProtocol {
+  internal var serviceName: String {
+    return "mavsdk.rpc.component_information_server.ComponentInformationServerService"
+  }
+
+  ///
+  /// Provide a param of type float.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to ProvideFloatParam.
+  ///   - callOptions: Call options.
+  /// - Returns: A `UnaryCall` with futures for the metadata, status and response.
+  internal func provideFloatParam(
+    _ request: Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest,
+    callOptions: CallOptions? = nil
+  ) -> UnaryCall<Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest, Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse> {
+    return self.makeUnaryCall(
+      path: "/mavsdk.rpc.component_information_server.ComponentInformationServerService/ProvideFloatParam",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeProvideFloatParamInterceptors() ?? []
+    )
+  }
+
+  ///
+  /// Subscribe to float param updates.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to SubscribeFloatParam.
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ServerStreamingCall` with futures for the metadata and status.
+  internal func subscribeFloatParam(
+    _ request: Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest,
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse) -> Void
+  ) -> ServerStreamingCall<Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest, Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse> {
+    return self.makeServerStreamingCall(
+      path: "/mavsdk.rpc.component_information_server.ComponentInformationServerService/SubscribeFloatParam",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeSubscribeFloatParamInterceptors() ?? [],
+      handler: handler
+    )
+  }
+}
+
+internal protocol Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClientInterceptorFactoryProtocol {
+
+  /// - Returns: Interceptors to use when invoking 'provideFloatParam'.
+  func makeProvideFloatParamInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest, Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse>]
+
+  /// - Returns: Interceptors to use when invoking 'subscribeFloatParam'.
+  func makeSubscribeFloatParamInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest, Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse>]
+}
+
+internal final class Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClient: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClientProtocol {
+  internal let channel: GRPCChannel
+  internal var defaultCallOptions: CallOptions
+  internal var interceptors: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClientInterceptorFactoryProtocol?
+
+  /// Creates a client for the mavsdk.rpc.component_information_server.ComponentInformationServerService service.
+  ///
+  /// - Parameters:
+  ///   - channel: `GRPCChannel` to the service host.
+  ///   - defaultCallOptions: Options to use for each service call if the user doesn't provide them.
+  ///   - interceptors: A factory providing interceptors for each RPC.
+  internal init(
+    channel: GRPCChannel,
+    defaultCallOptions: CallOptions = CallOptions(),
+    interceptors: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceClientInterceptorFactoryProtocol? = nil
+  ) {
+    self.channel = channel
+    self.defaultCallOptions = defaultCallOptions
+    self.interceptors = interceptors
+  }
+}
+
+/// Provide component information such as parameters.
+///
+/// To build a server, implement a class that conforms to this protocol.
+internal protocol Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceProvider: CallHandlerProvider {
+  var interceptors: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceServerInterceptorFactoryProtocol? { get }
+
+  ///
+  /// Provide a param of type float.
+  func provideFloatParam(request: Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest, context: StatusOnlyCallContext) -> EventLoopFuture<Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse>
+
+  ///
+  /// Subscribe to float param updates.
+  func subscribeFloatParam(request: Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest, context: StreamingResponseCallContext<Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse>) -> EventLoopFuture<GRPCStatus>
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceProvider {
+  internal var serviceName: Substring { return "mavsdk.rpc.component_information_server.ComponentInformationServerService" }
+
+  /// Determines, calls and returns the appropriate request handler, depending on the request's method.
+  /// Returns nil for methods not handled by this service.
+  internal func handle(
+    method name: Substring,
+    context: CallHandlerContext
+  ) -> GRPCServerHandlerProtocol? {
+    switch name {
+    case "ProvideFloatParam":
+      return UnaryServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest>(),
+        responseSerializer: ProtobufSerializer<Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse>(),
+        interceptors: self.interceptors?.makeProvideFloatParamInterceptors() ?? [],
+        userFunction: self.provideFloatParam(request:context:)
+      )
+
+    case "SubscribeFloatParam":
+      return ServerStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest>(),
+        responseSerializer: ProtobufSerializer<Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse>(),
+        interceptors: self.interceptors?.makeSubscribeFloatParamInterceptors() ?? [],
+        userFunction: self.subscribeFloatParam(request:context:)
+      )
+
+    default:
+      return nil
+    }
+  }
+}
+
+internal protocol Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerServiceServerInterceptorFactoryProtocol {
+
+  /// - Returns: Interceptors to use when handling 'provideFloatParam'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeProvideFloatParamInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest, Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse>]
+
+  /// - Returns: Interceptors to use when handling 'subscribeFloatParam'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeSubscribeFloatParamInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest, Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse>]
+}
diff --git a/Sources/Mavsdk/Generated/component_information_server.pb.swift b/Sources/Mavsdk/Generated/component_information_server.pb.swift
new file mode 100644
index 0000000..95fbcde
--- /dev/null
+++ b/Sources/Mavsdk/Generated/component_information_server.pb.swift
@@ -0,0 +1,553 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: component_information_server.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+import Foundation
+import SwiftProtobuf
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
+  typealias Version = _2
+}
+
+/// Meta information for parameter of type float.
+struct Mavsdk_Rpc_ComponentInformationServer_FloatParam {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Name (max 16 chars)
+  var name: String = String()
+
+  /// Short description
+  var shortDescription: String = String()
+
+  /// Long description
+  var longDescription: String = String()
+
+  /// Unit
+  var unit: String = String()
+
+  /// Decimal places for user to show
+  var decimalPlaces: Int32 = 0
+
+  /// Current/starting value
+  var startValue: Float = 0
+
+  /// Default value
+  var defaultValue: Float = 0
+
+  /// Minimum value
+  var minValue: Float = 0
+
+  /// Maximum value
+  var maxValue: Float = 0
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Float param definition
+  var param: Mavsdk_Rpc_ComponentInformationServer_FloatParam {
+    get {return _param ?? Mavsdk_Rpc_ComponentInformationServer_FloatParam()}
+    set {_param = newValue}
+  }
+  /// Returns true if `param` has been explicitly set.
+  var hasParam: Bool {return self._param != nil}
+  /// Clears the value of `param`. Subsequent reads from it will return its default value.
+  mutating func clearParam() {self._param = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _param: Mavsdk_Rpc_ComponentInformationServer_FloatParam? = nil
+}
+
+struct Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var componentInformationServerResult: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult {
+    get {return _componentInformationServerResult ?? Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult()}
+    set {_componentInformationServerResult = newValue}
+  }
+  /// Returns true if `componentInformationServerResult` has been explicitly set.
+  var hasComponentInformationServerResult: Bool {return self._componentInformationServerResult != nil}
+  /// Clears the value of `componentInformationServerResult`. Subsequent reads from it will return its default value.
+  mutating func clearComponentInformationServerResult() {self._componentInformationServerResult = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _componentInformationServerResult: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult? = nil
+}
+
+/// A float param that has been updated.
+struct Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Name of param that changed
+  var name: String = String()
+
+  /// New value of param
+  var value: Float = 0
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// A param update
+  var paramUpdate: Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate {
+    get {return _paramUpdate ?? Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate()}
+    set {_paramUpdate = newValue}
+  }
+  /// Returns true if `paramUpdate` has been explicitly set.
+  var hasParamUpdate: Bool {return self._paramUpdate != nil}
+  /// Clears the value of `paramUpdate`. Subsequent reads from it will return its default value.
+  mutating func clearParamUpdate() {self._paramUpdate = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _paramUpdate: Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate? = nil
+}
+
+/// Result type.
+struct Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Result enum value
+  var result: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult.Result = .unknown
+
+  /// Human-readable English string describing the result
+  var resultStr: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  /// Possible results returned for param requests.
+  enum Result: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+
+    /// Unknown result
+    case unknown // = 0
+
+    /// Request succeeded
+    case success // = 1
+
+    /// Duplicate param
+    case duplicateParam // = 2
+
+    /// Invalid start param value
+    case invalidParamStartValue // = 3
+
+    /// Invalid default param value
+    case invalidParamDefaultValue // = 4
+
+    /// Invalid param name
+    case invalidParamName // = 5
+
+    /// No system is connected
+    case noSystem // = 6
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .unknown
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .unknown
+      case 1: self = .success
+      case 2: self = .duplicateParam
+      case 3: self = .invalidParamStartValue
+      case 4: self = .invalidParamDefaultValue
+      case 5: self = .invalidParamName
+      case 6: self = .noSystem
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .unknown: return 0
+      case .success: return 1
+      case .duplicateParam: return 2
+      case .invalidParamStartValue: return 3
+      case .invalidParamDefaultValue: return 4
+      case .invalidParamName: return 5
+      case .noSystem: return 6
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+  }
+
+  init() {}
+}
+
+#if swift(>=4.2)
+
+extension Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult.Result: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult.Result] = [
+    .unknown,
+    .success,
+    .duplicateParam,
+    .invalidParamStartValue,
+    .invalidParamDefaultValue,
+    .invalidParamName,
+    .noSystem,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_ComponentInformationServer_FloatParam: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+fileprivate let _protobuf_package = "mavsdk.rpc.component_information_server"
+
+extension Mavsdk_Rpc_ComponentInformationServer_FloatParam: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FloatParam"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "name"),
+    2: .standard(proto: "short_description"),
+    3: .standard(proto: "long_description"),
+    4: .same(proto: "unit"),
+    5: .standard(proto: "decimal_places"),
+    6: .standard(proto: "start_value"),
+    7: .standard(proto: "default_value"),
+    8: .standard(proto: "min_value"),
+    9: .standard(proto: "max_value"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.name) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self.shortDescription) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self.longDescription) }()
+      case 4: try { try decoder.decodeSingularStringField(value: &self.unit) }()
+      case 5: try { try decoder.decodeSingularInt32Field(value: &self.decimalPlaces) }()
+      case 6: try { try decoder.decodeSingularFloatField(value: &self.startValue) }()
+      case 7: try { try decoder.decodeSingularFloatField(value: &self.defaultValue) }()
+      case 8: try { try decoder.decodeSingularFloatField(value: &self.minValue) }()
+      case 9: try { try decoder.decodeSingularFloatField(value: &self.maxValue) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.name.isEmpty {
+      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
+    }
+    if !self.shortDescription.isEmpty {
+      try visitor.visitSingularStringField(value: self.shortDescription, fieldNumber: 2)
+    }
+    if !self.longDescription.isEmpty {
+      try visitor.visitSingularStringField(value: self.longDescription, fieldNumber: 3)
+    }
+    if !self.unit.isEmpty {
+      try visitor.visitSingularStringField(value: self.unit, fieldNumber: 4)
+    }
+    if self.decimalPlaces != 0 {
+      try visitor.visitSingularInt32Field(value: self.decimalPlaces, fieldNumber: 5)
+    }
+    if self.startValue != 0 {
+      try visitor.visitSingularFloatField(value: self.startValue, fieldNumber: 6)
+    }
+    if self.defaultValue != 0 {
+      try visitor.visitSingularFloatField(value: self.defaultValue, fieldNumber: 7)
+    }
+    if self.minValue != 0 {
+      try visitor.visitSingularFloatField(value: self.minValue, fieldNumber: 8)
+    }
+    if self.maxValue != 0 {
+      try visitor.visitSingularFloatField(value: self.maxValue, fieldNumber: 9)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformationServer_FloatParam, rhs: Mavsdk_Rpc_ComponentInformationServer_FloatParam) -> Bool {
+    if lhs.name != rhs.name {return false}
+    if lhs.shortDescription != rhs.shortDescription {return false}
+    if lhs.longDescription != rhs.longDescription {return false}
+    if lhs.unit != rhs.unit {return false}
+    if lhs.decimalPlaces != rhs.decimalPlaces {return false}
+    if lhs.startValue != rhs.startValue {return false}
+    if lhs.defaultValue != rhs.defaultValue {return false}
+    if lhs.minValue != rhs.minValue {return false}
+    if lhs.maxValue != rhs.maxValue {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ProvideFloatParamRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "param"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._param) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._param {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest, rhs: Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamRequest) -> Bool {
+    if lhs._param != rhs._param {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ProvideFloatParamResponse"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "component_information_server_result"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._componentInformationServerResult) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._componentInformationServerResult {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse, rhs: Mavsdk_Rpc_ComponentInformationServer_ProvideFloatParamResponse) -> Bool {
+    if lhs._componentInformationServerResult != rhs._componentInformationServerResult {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FloatParamUpdate"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "name"),
+    2: .same(proto: "value"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.name) }()
+      case 2: try { try decoder.decodeSingularFloatField(value: &self.value) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.name.isEmpty {
+      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
+    }
+    if self.value != 0 {
+      try visitor.visitSingularFloatField(value: self.value, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate, rhs: Mavsdk_Rpc_ComponentInformationServer_FloatParamUpdate) -> Bool {
+    if lhs.name != rhs.name {return false}
+    if lhs.value != rhs.value {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SubscribeFloatParamRequest"
+  static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let _ = try decoder.nextFieldNumber() {
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest, rhs: Mavsdk_Rpc_ComponentInformationServer_SubscribeFloatParamRequest) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FloatParamResponse"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "param_update"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._paramUpdate) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._paramUpdate {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse, rhs: Mavsdk_Rpc_ComponentInformationServer_FloatParamResponse) -> Bool {
+    if lhs._paramUpdate != rhs._paramUpdate {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ComponentInformationServerResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "result"),
+    2: .standard(proto: "result_str"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularEnumField(value: &self.result) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self.resultStr) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.result != .unknown {
+      try visitor.visitSingularEnumField(value: self.result, fieldNumber: 1)
+    }
+    if !self.resultStr.isEmpty {
+      try visitor.visitSingularStringField(value: self.resultStr, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult, rhs: Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult) -> Bool {
+    if lhs.result != rhs.result {return false}
+    if lhs.resultStr != rhs.resultStr {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_ComponentInformationServer_ComponentInformationServerResult.Result: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "RESULT_UNKNOWN"),
+    1: .same(proto: "RESULT_SUCCESS"),
+    2: .same(proto: "RESULT_DUPLICATE_PARAM"),
+    3: .same(proto: "RESULT_INVALID_PARAM_START_VALUE"),
+    4: .same(proto: "RESULT_INVALID_PARAM_DEFAULT_VALUE"),
+    5: .same(proto: "RESULT_INVALID_PARAM_NAME"),
+    6: .same(proto: "RESULT_NO_SYSTEM"),
+  ]
+}
diff --git a/Sources/Mavsdk/Generated/core.pb.swift b/Sources/Mavsdk/Generated/core.pb.swift
index 531901e..b56d000 100644
--- a/Sources/Mavsdk/Generated/core.pb.swift
+++ b/Sources/Mavsdk/Generated/core.pb.swift
@@ -89,6 +89,14 @@ struct Mavsdk_Rpc_Core_ConnectionState {
   init() {}
 }
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Core_SubscribeConnectionStateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Core_ConnectionStateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Core_SetMavlinkTimeoutRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Core_SetMavlinkTimeoutResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Core_ConnectionState: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.core"
diff --git a/Sources/Mavsdk/Generated/failure.pb.swift b/Sources/Mavsdk/Generated/failure.pb.swift
index 2a6fa02..abc98b2 100644
--- a/Sources/Mavsdk/Generated/failure.pb.swift
+++ b/Sources/Mavsdk/Generated/failure.pb.swift
@@ -361,6 +361,15 @@ extension Mavsdk_Rpc_Failure_FailureResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Failure_FailureUnit: @unchecked Sendable {}
+extension Mavsdk_Rpc_Failure_FailureType: @unchecked Sendable {}
+extension Mavsdk_Rpc_Failure_InjectRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Failure_InjectResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Failure_FailureResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Failure_FailureResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.failure"
diff --git a/Sources/Mavsdk/Generated/follow_me.pb.swift b/Sources/Mavsdk/Generated/follow_me.pb.swift
index 74492b2..ece97fd 100644
--- a/Sources/Mavsdk/Generated/follow_me.pb.swift
+++ b/Sources/Mavsdk/Generated/follow_me.pb.swift
@@ -473,6 +473,28 @@ extension Mavsdk_Rpc_FollowMe_FollowMeResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_FollowMe_Config: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_Config.FollowDirection: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_TargetLocation: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_GetConfigRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_GetConfigResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_SetConfigRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_SetConfigResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_IsActiveRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_IsActiveResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_SetTargetLocationRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_SetTargetLocationResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_GetLastLocationRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_GetLastLocationResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_StartRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_StartResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_StopRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_StopResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_FollowMeResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_FollowMe_FollowMeResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.follow_me"
diff --git a/Sources/Mavsdk/Generated/ftp.pb.swift b/Sources/Mavsdk/Generated/ftp.pb.swift
index 333dedc..3301651 100644
--- a/Sources/Mavsdk/Generated/ftp.pb.swift
+++ b/Sources/Mavsdk/Generated/ftp.pb.swift
@@ -599,6 +599,36 @@ extension Mavsdk_Rpc_Ftp_FtpResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Ftp_ResetRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_ResetResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_SubscribeDownloadRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_DownloadResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_SubscribeUploadRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_UploadResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_ListDirectoryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_ListDirectoryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_CreateDirectoryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_CreateDirectoryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_RemoveDirectoryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_RemoveDirectoryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_RemoveFileRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_RemoveFileResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_RenameRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_RenameResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_AreFilesIdenticalRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_AreFilesIdenticalResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_SetRootDirectoryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_SetRootDirectoryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_SetTargetCompidRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_SetTargetCompidResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_GetOurCompidRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_GetOurCompidResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_ProgressData: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_FtpResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Ftp_FtpResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.ftp"
diff --git a/Sources/Mavsdk/Generated/geofence.pb.swift b/Sources/Mavsdk/Generated/geofence.pb.swift
index b6f893c..7366ac9 100644
--- a/Sources/Mavsdk/Generated/geofence.pb.swift
+++ b/Sources/Mavsdk/Generated/geofence.pb.swift
@@ -262,6 +262,18 @@ extension Mavsdk_Rpc_Geofence_GeofenceResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Geofence_Point: @unchecked Sendable {}
+extension Mavsdk_Rpc_Geofence_Polygon: @unchecked Sendable {}
+extension Mavsdk_Rpc_Geofence_Polygon.FenceType: @unchecked Sendable {}
+extension Mavsdk_Rpc_Geofence_UploadGeofenceRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Geofence_UploadGeofenceResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Geofence_ClearGeofenceRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Geofence_ClearGeofenceResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Geofence_GeofenceResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Geofence_GeofenceResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.geofence"
diff --git a/Sources/Mavsdk/Generated/gimbal.pb.swift b/Sources/Mavsdk/Generated/gimbal.pb.swift
index f6bf22e..96e317e 100644
--- a/Sources/Mavsdk/Generated/gimbal.pb.swift
+++ b/Sources/Mavsdk/Generated/gimbal.pb.swift
@@ -473,6 +473,28 @@ extension Mavsdk_Rpc_Gimbal_GimbalResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Gimbal_GimbalMode: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_ControlMode: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SetPitchAndYawRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SetPitchAndYawResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SetPitchRateAndYawRateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SetPitchRateAndYawRateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SetModeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SetModeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SetRoiLocationRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SetRoiLocationResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_TakeControlRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_TakeControlResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_ReleaseControlRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_ReleaseControlResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_SubscribeControlRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_ControlResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_ControlStatus: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_GimbalResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Gimbal_GimbalResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.gimbal"
diff --git a/Sources/Mavsdk/Generated/info.pb.swift b/Sources/Mavsdk/Generated/info.pb.swift
index 0b574b5..76d4711 100644
--- a/Sources/Mavsdk/Generated/info.pb.swift
+++ b/Sources/Mavsdk/Generated/info.pb.swift
@@ -397,6 +397,25 @@ extension Mavsdk_Rpc_Info_InfoResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Info_GetFlightInformationRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetFlightInformationResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetIdentificationRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetIdentificationResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetProductRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetProductResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetVersionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetVersionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetSpeedFactorRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_GetSpeedFactorResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_FlightInfo: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_Identification: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_Product: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_Version: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_InfoResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Info_InfoResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.info"
diff --git a/Sources/Mavsdk/Generated/log_files.grpc.swift b/Sources/Mavsdk/Generated/log_files.grpc.swift
index e657587..fe2e89e 100644
--- a/Sources/Mavsdk/Generated/log_files.grpc.swift
+++ b/Sources/Mavsdk/Generated/log_files.grpc.swift
@@ -43,6 +43,16 @@ internal protocol Mavsdk_Rpc_LogFiles_LogFilesServiceClientProtocol: GRPCClient
     callOptions: CallOptions?,
     handler: @escaping (Mavsdk_Rpc_LogFiles_DownloadLogFileResponse) -> Void
   ) -> ServerStreamingCall<Mavsdk_Rpc_LogFiles_SubscribeDownloadLogFileRequest, Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>
+
+  func downloadLogFile(
+    _ request: Mavsdk_Rpc_LogFiles_DownloadLogFileRequest,
+    callOptions: CallOptions?
+  ) -> UnaryCall<Mavsdk_Rpc_LogFiles_DownloadLogFileRequest, Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>
+
+  func eraseAllLogFiles(
+    _ request: Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest,
+    callOptions: CallOptions?
+  ) -> UnaryCall<Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest, Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse>
 }
 
 extension Mavsdk_Rpc_LogFiles_LogFilesServiceClientProtocol {
@@ -88,6 +98,42 @@ extension Mavsdk_Rpc_LogFiles_LogFilesServiceClientProtocol {
       handler: handler
     )
   }
+
+  /// Download log file synchronously.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to DownloadLogFile.
+  ///   - callOptions: Call options.
+  /// - Returns: A `UnaryCall` with futures for the metadata, status and response.
+  internal func downloadLogFile(
+    _ request: Mavsdk_Rpc_LogFiles_DownloadLogFileRequest,
+    callOptions: CallOptions? = nil
+  ) -> UnaryCall<Mavsdk_Rpc_LogFiles_DownloadLogFileRequest, Mavsdk_Rpc_LogFiles_DownloadLogFileResponse> {
+    return self.makeUnaryCall(
+      path: "/mavsdk.rpc.log_files.LogFilesService/DownloadLogFile",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDownloadLogFileInterceptors() ?? []
+    )
+  }
+
+  /// Erase all log files.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to EraseAllLogFiles.
+  ///   - callOptions: Call options.
+  /// - Returns: A `UnaryCall` with futures for the metadata, status and response.
+  internal func eraseAllLogFiles(
+    _ request: Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest,
+    callOptions: CallOptions? = nil
+  ) -> UnaryCall<Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest, Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse> {
+    return self.makeUnaryCall(
+      path: "/mavsdk.rpc.log_files.LogFilesService/EraseAllLogFiles",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeEraseAllLogFilesInterceptors() ?? []
+    )
+  }
 }
 
 internal protocol Mavsdk_Rpc_LogFiles_LogFilesServiceClientInterceptorFactoryProtocol {
@@ -97,6 +143,12 @@ internal protocol Mavsdk_Rpc_LogFiles_LogFilesServiceClientInterceptorFactoryPro
 
   /// - Returns: Interceptors to use when invoking 'subscribeDownloadLogFile'.
   func makeSubscribeDownloadLogFileInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_LogFiles_SubscribeDownloadLogFileRequest, Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>]
+
+  /// - Returns: Interceptors to use when invoking 'downloadLogFile'.
+  func makeDownloadLogFileInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_LogFiles_DownloadLogFileRequest, Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>]
+
+  /// - Returns: Interceptors to use when invoking 'eraseAllLogFiles'.
+  func makeEraseAllLogFilesInterceptors() -> [ClientInterceptor<Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest, Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse>]
 }
 
 internal final class Mavsdk_Rpc_LogFiles_LogFilesServiceClient: Mavsdk_Rpc_LogFiles_LogFilesServiceClientProtocol {
@@ -133,6 +185,12 @@ internal protocol Mavsdk_Rpc_LogFiles_LogFilesServiceProvider: CallHandlerProvid
 
   /// Download log file.
   func subscribeDownloadLogFile(request: Mavsdk_Rpc_LogFiles_SubscribeDownloadLogFileRequest, context: StreamingResponseCallContext<Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>) -> EventLoopFuture<GRPCStatus>
+
+  /// Download log file synchronously.
+  func downloadLogFile(request: Mavsdk_Rpc_LogFiles_DownloadLogFileRequest, context: StatusOnlyCallContext) -> EventLoopFuture<Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>
+
+  /// Erase all log files.
+  func eraseAllLogFiles(request: Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest, context: StatusOnlyCallContext) -> EventLoopFuture<Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse>
 }
 
 extension Mavsdk_Rpc_LogFiles_LogFilesServiceProvider {
@@ -163,6 +221,24 @@ extension Mavsdk_Rpc_LogFiles_LogFilesServiceProvider {
         userFunction: self.subscribeDownloadLogFile(request:context:)
       )
 
+    case "DownloadLogFile":
+      return UnaryServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Mavsdk_Rpc_LogFiles_DownloadLogFileRequest>(),
+        responseSerializer: ProtobufSerializer<Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>(),
+        interceptors: self.interceptors?.makeDownloadLogFileInterceptors() ?? [],
+        userFunction: self.downloadLogFile(request:context:)
+      )
+
+    case "EraseAllLogFiles":
+      return UnaryServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest>(),
+        responseSerializer: ProtobufSerializer<Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse>(),
+        interceptors: self.interceptors?.makeEraseAllLogFilesInterceptors() ?? [],
+        userFunction: self.eraseAllLogFiles(request:context:)
+      )
+
     default:
       return nil
     }
@@ -178,4 +254,12 @@ internal protocol Mavsdk_Rpc_LogFiles_LogFilesServiceServerInterceptorFactoryPro
   /// - Returns: Interceptors to use when handling 'subscribeDownloadLogFile'.
   ///   Defaults to calling `self.makeInterceptors()`.
   func makeSubscribeDownloadLogFileInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_LogFiles_SubscribeDownloadLogFileRequest, Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>]
+
+  /// - Returns: Interceptors to use when handling 'downloadLogFile'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeDownloadLogFileInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_LogFiles_DownloadLogFileRequest, Mavsdk_Rpc_LogFiles_DownloadLogFileResponse>]
+
+  /// - Returns: Interceptors to use when handling 'eraseAllLogFiles'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeEraseAllLogFilesInterceptors() -> [ServerInterceptor<Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest, Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse>]
 }
diff --git a/Sources/Mavsdk/Generated/log_files.pb.swift b/Sources/Mavsdk/Generated/log_files.pb.swift
index 7f1e87e..e7080f5 100644
--- a/Sources/Mavsdk/Generated/log_files.pb.swift
+++ b/Sources/Mavsdk/Generated/log_files.pb.swift
@@ -111,6 +111,62 @@ struct Mavsdk_Rpc_LogFiles_DownloadLogFileResponse {
   fileprivate var _progress: Mavsdk_Rpc_LogFiles_ProgressData? = nil
 }
 
+struct Mavsdk_Rpc_LogFiles_DownloadLogFileRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Entry of the log file to download.
+  var entry: Mavsdk_Rpc_LogFiles_Entry {
+    get {return _entry ?? Mavsdk_Rpc_LogFiles_Entry()}
+    set {_entry = newValue}
+  }
+  /// Returns true if `entry` has been explicitly set.
+  var hasEntry: Bool {return self._entry != nil}
+  /// Clears the value of `entry`. Subsequent reads from it will return its default value.
+  mutating func clearEntry() {self._entry = nil}
+
+  /// Path of where to download log file to.
+  var path: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _entry: Mavsdk_Rpc_LogFiles_Entry? = nil
+}
+
+struct Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var logFilesResult: Mavsdk_Rpc_LogFiles_LogFilesResult {
+    get {return _logFilesResult ?? Mavsdk_Rpc_LogFiles_LogFilesResult()}
+    set {_logFilesResult = newValue}
+  }
+  /// Returns true if `logFilesResult` has been explicitly set.
+  var hasLogFilesResult: Bool {return self._logFilesResult != nil}
+  /// Clears the value of `logFilesResult`. Subsequent reads from it will return its default value.
+  mutating func clearLogFilesResult() {self._logFilesResult = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _logFilesResult: Mavsdk_Rpc_LogFiles_LogFilesResult? = nil
+}
+
 ///
 /// Progress data coming when downloading a log file.
 struct Mavsdk_Rpc_LogFiles_ProgressData {
@@ -244,6 +300,20 @@ extension Mavsdk_Rpc_LogFiles_LogFilesResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_LogFiles_GetEntriesRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_GetEntriesResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_SubscribeDownloadLogFileRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_DownloadLogFileResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_DownloadLogFileRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_ProgressData: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_Entry: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_LogFilesResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_LogFiles_LogFilesResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.log_files"
@@ -393,6 +463,103 @@ extension Mavsdk_Rpc_LogFiles_DownloadLogFileResponse: SwiftProtobuf.Message, Sw
   }
 }
 
+extension Mavsdk_Rpc_LogFiles_DownloadLogFileRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".DownloadLogFileRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "entry"),
+    2: .same(proto: "path"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._entry) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self.path) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._entry {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    if !self.path.isEmpty {
+      try visitor.visitSingularStringField(value: self.path, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_LogFiles_DownloadLogFileRequest, rhs: Mavsdk_Rpc_LogFiles_DownloadLogFileRequest) -> Bool {
+    if lhs._entry != rhs._entry {return false}
+    if lhs.path != rhs.path {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".EraseAllLogFilesRequest"
+  static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let _ = try decoder.nextFieldNumber() {
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest, rhs: Mavsdk_Rpc_LogFiles_EraseAllLogFilesRequest) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".EraseAllLogFilesResponse"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "log_files_result"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._logFilesResult) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._logFilesResult {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse, rhs: Mavsdk_Rpc_LogFiles_EraseAllLogFilesResponse) -> Bool {
+    if lhs._logFilesResult != rhs._logFilesResult {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension Mavsdk_Rpc_LogFiles_ProgressData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = _protobuf_package + ".ProgressData"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
diff --git a/Sources/Mavsdk/Generated/manual_control.pb.swift b/Sources/Mavsdk/Generated/manual_control.pb.swift
index b6287f9..be496d6 100644
--- a/Sources/Mavsdk/Generated/manual_control.pb.swift
+++ b/Sources/Mavsdk/Generated/manual_control.pb.swift
@@ -229,6 +229,17 @@ extension Mavsdk_Rpc_ManualControl_ManualControlResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_ManualControl_StartPositionControlRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ManualControl_StartPositionControlResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ManualControl_StartAltitudeControlRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ManualControl_StartAltitudeControlResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ManualControl_SetManualControlInputRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ManualControl_SetManualControlInputResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ManualControl_ManualControlResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_ManualControl_ManualControlResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.manual_control"
diff --git a/Sources/Mavsdk/Generated/mission.pb.swift b/Sources/Mavsdk/Generated/mission.pb.swift
index 229d491..e04dba7 100644
--- a/Sources/Mavsdk/Generated/mission.pb.swift
+++ b/Sources/Mavsdk/Generated/mission.pb.swift
@@ -866,6 +866,45 @@ struct Mavsdk_Rpc_Mission_ProgressDataOrMission {
   fileprivate var _missionPlan: Mavsdk_Rpc_Mission_MissionPlan? = nil
 }
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Mission_UploadMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_UploadMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_SubscribeUploadMissionWithProgressRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_UploadMissionWithProgressResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_CancelMissionUploadRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_CancelMissionUploadResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_DownloadMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_DownloadMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_SubscribeDownloadMissionWithProgressRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_DownloadMissionWithProgressResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_CancelMissionDownloadRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_CancelMissionDownloadResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_StartMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_StartMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_PauseMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_PauseMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_ClearMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_ClearMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_SetCurrentMissionItemRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_SetCurrentMissionItemResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_IsMissionFinishedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_IsMissionFinishedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_SubscribeMissionProgressRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_MissionProgressResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_GetReturnToLaunchAfterMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_GetReturnToLaunchAfterMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_SetReturnToLaunchAfterMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_SetReturnToLaunchAfterMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_MissionItem: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_MissionItem.CameraAction: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_MissionPlan: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_MissionProgress: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_MissionResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_MissionResult.Result: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_ProgressData: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mission_ProgressDataOrMission: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.mission"
diff --git a/Sources/Mavsdk/Generated/mission_raw.pb.swift b/Sources/Mavsdk/Generated/mission_raw.pb.swift
index a7c5850..6a0f97a 100644
--- a/Sources/Mavsdk/Generated/mission_raw.pb.swift
+++ b/Sources/Mavsdk/Generated/mission_raw.pb.swift
@@ -592,6 +592,36 @@ extension Mavsdk_Rpc_MissionRaw_MissionRawResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_MissionRaw_UploadMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_UploadMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_CancelMissionUploadRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_CancelMissionUploadResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_DownloadMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_DownloadMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_CancelMissionDownloadRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_CancelMissionDownloadResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_StartMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_StartMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_PauseMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_PauseMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_ClearMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_ClearMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_SetCurrentMissionItemRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_SetCurrentMissionItemResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_SubscribeMissionProgressRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_MissionProgressResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_SubscribeMissionChangedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_MissionChangedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_ImportQgroundcontrolMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_ImportQgroundcontrolMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_MissionProgress: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_MissionItem: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_MissionImportData: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_MissionRawResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRaw_MissionRawResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.mission_raw"
diff --git a/Sources/Mavsdk/Generated/mission_raw_server.pb.swift b/Sources/Mavsdk/Generated/mission_raw_server.pb.swift
index 01b4676..28b8669 100644
--- a/Sources/Mavsdk/Generated/mission_raw_server.pb.swift
+++ b/Sources/Mavsdk/Generated/mission_raw_server.pb.swift
@@ -344,6 +344,22 @@ extension Mavsdk_Rpc_MissionRawServer_MissionRawServerResult.Result: CaseIterabl
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_MissionRawServer_SubscribeIncomingMissionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_IncomingMissionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_SubscribeCurrentItemChangedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_CurrentItemChangedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_SubscribeClearAllRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_ClearAllResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_SetCurrentItemCompleteRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_SetCurrentItemCompleteResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_MissionItem: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_MissionPlan: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_MissionProgress: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_MissionRawServerResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_MissionRawServer_MissionRawServerResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.mission_raw_server"
diff --git a/Sources/Mavsdk/Generated/mocap.pb.swift b/Sources/Mavsdk/Generated/mocap.pb.swift
index 0c54ca3..2c88073 100644
--- a/Sources/Mavsdk/Generated/mocap.pb.swift
+++ b/Sources/Mavsdk/Generated/mocap.pb.swift
@@ -535,6 +535,9 @@ struct Mavsdk_Rpc_Mocap_MocapResult {
 
     /// Invalid request data
     case invalidRequestData // = 4
+
+    /// Function unsupported
+    case unsupported // = 5
     case UNRECOGNIZED(Int)
 
     init() {
@@ -548,6 +551,7 @@ struct Mavsdk_Rpc_Mocap_MocapResult {
       case 2: self = .noSystem
       case 3: self = .connectionError
       case 4: self = .invalidRequestData
+      case 5: self = .unsupported
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
@@ -559,6 +563,7 @@ struct Mavsdk_Rpc_Mocap_MocapResult {
       case .noSystem: return 2
       case .connectionError: return 3
       case .invalidRequestData: return 4
+      case .unsupported: return 5
       case .UNRECOGNIZED(let i): return i
       }
     }
@@ -578,11 +583,33 @@ extension Mavsdk_Rpc_Mocap_MocapResult.Result: CaseIterable {
     .noSystem,
     .connectionError,
     .invalidRequestData,
+    .unsupported,
   ]
 }
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Mocap_SetVisionPositionEstimateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_SetVisionPositionEstimateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_SetAttitudePositionMocapRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_SetAttitudePositionMocapResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_SetOdometryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_SetOdometryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_PositionBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_AngleBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_SpeedBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_AngularVelocityBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_Covariance: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_Quaternion: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_VisionPositionEstimate: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_AttitudePositionMocap: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_Odometry: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_Odometry.MavFrame: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_MocapResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Mocap_MocapResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.mocap"
@@ -1345,5 +1372,6 @@ extension Mavsdk_Rpc_Mocap_MocapResult.Result: SwiftProtobuf._ProtoNameProviding
     2: .same(proto: "RESULT_NO_SYSTEM"),
     3: .same(proto: "RESULT_CONNECTION_ERROR"),
     4: .same(proto: "RESULT_INVALID_REQUEST_DATA"),
+    5: .same(proto: "RESULT_UNSUPPORTED"),
   ]
 }
diff --git a/Sources/Mavsdk/Generated/offboard.pb.swift b/Sources/Mavsdk/Generated/offboard.pb.swift
index 5acde94..96c9855 100644
--- a/Sources/Mavsdk/Generated/offboard.pb.swift
+++ b/Sources/Mavsdk/Generated/offboard.pb.swift
@@ -858,6 +858,45 @@ extension Mavsdk_Rpc_Offboard_OffboardResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Offboard_StartRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_StartResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_StopRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_StopResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_IsActiveRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_IsActiveResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetAttitudeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetAttitudeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetActuatorControlRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetActuatorControlResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetAttitudeRateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetAttitudeRateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetPositionNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetPositionNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetPositionGlobalRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetPositionGlobalResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetVelocityBodyRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetVelocityBodyResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetVelocityNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetVelocityNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetPositionVelocityNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetPositionVelocityNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetAccelerationNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_SetAccelerationNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_Attitude: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_ActuatorControlGroup: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_ActuatorControl: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_AttitudeRate: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_PositionNedYaw: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_PositionGlobalYaw: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_PositionGlobalYaw.AltitudeType: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_VelocityBodyYawspeed: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_VelocityNedYaw: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_AccelerationNed: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_OffboardResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Offboard_OffboardResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.offboard"
diff --git a/Sources/Mavsdk/Generated/param.pb.swift b/Sources/Mavsdk/Generated/param.pb.swift
index 9403c11..8a4bc6c 100644
--- a/Sources/Mavsdk/Generated/param.pb.swift
+++ b/Sources/Mavsdk/Generated/param.pb.swift
@@ -346,6 +346,24 @@ extension Mavsdk_Rpc_Param_ParamResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Param_GetParamIntRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_GetParamIntResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_SetParamIntRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_SetParamIntResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_GetParamFloatRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_GetParamFloatResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_SetParamFloatRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_SetParamFloatResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_GetAllParamsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_GetAllParamsResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_IntParam: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_FloatParam: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_AllParams: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_ParamResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Param_ParamResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.param"
diff --git a/Sources/Mavsdk/Generated/server_utility.pb.swift b/Sources/Mavsdk/Generated/server_utility.pb.swift
index 6f6871b..558a286 100644
--- a/Sources/Mavsdk/Generated/server_utility.pb.swift
+++ b/Sources/Mavsdk/Generated/server_utility.pb.swift
@@ -217,6 +217,14 @@ extension Mavsdk_Rpc_ServerUtility_ServerUtilityResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_ServerUtility_StatusTextType: @unchecked Sendable {}
+extension Mavsdk_Rpc_ServerUtility_SendStatusTextRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_ServerUtility_SendStatusTextResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_ServerUtility_ServerUtilityResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_ServerUtility_ServerUtilityResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.server_utility"
diff --git a/Sources/Mavsdk/Generated/shell.pb.swift b/Sources/Mavsdk/Generated/shell.pb.swift
index 3ea60f7..5423bec 100644
--- a/Sources/Mavsdk/Generated/shell.pb.swift
+++ b/Sources/Mavsdk/Generated/shell.pb.swift
@@ -163,6 +163,15 @@ extension Mavsdk_Rpc_Shell_ShellResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Shell_SendRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Shell_SendResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Shell_SubscribeReceiveRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Shell_ReceiveResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Shell_ShellResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Shell_ShellResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.shell"
diff --git a/Sources/Mavsdk/Generated/telemetry.pb.swift b/Sources/Mavsdk/Generated/telemetry.pb.swift
index 23bc7d7..70bace8 100644
--- a/Sources/Mavsdk/Generated/telemetry.pb.swift
+++ b/Sources/Mavsdk/Generated/telemetry.pb.swift
@@ -3205,6 +3205,163 @@ extension Mavsdk_Rpc_Telemetry_TelemetryResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Telemetry_FixType: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_FlightMode: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_StatusTextType: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_LandedState: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_VtolState: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribePositionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_PositionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeHomeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_HomeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeInAirRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_InAirResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeLandedStateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_LandedStateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeArmedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ArmedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeVtolStateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_VtolStateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeAttitudeQuaternionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_AttitudeQuaternionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeAttitudeEulerRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_AttitudeEulerResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeAttitudeAngularVelocityBodyRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_AttitudeAngularVelocityBodyResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeCameraAttitudeQuaternionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_CameraAttitudeQuaternionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeCameraAttitudeEulerRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_CameraAttitudeEulerResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeVelocityNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_VelocityNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeGpsInfoRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_GpsInfoResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeRawGpsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_RawGpsResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeBatteryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_BatteryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeFlightModeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_FlightModeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeHealthRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_HealthResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeRcStatusRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_RcStatusResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeStatusTextRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_StatusTextResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeActuatorControlTargetRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ActuatorControlTargetResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeActuatorOutputStatusRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ActuatorOutputStatusResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeOdometryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_OdometryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribePositionVelocityNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_PositionVelocityNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeGroundTruthRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_GroundTruthResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeFixedwingMetricsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_FixedwingMetricsResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeScaledImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ScaledImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeRawImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_RawImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeHealthAllOkRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_HealthAllOkResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeUnixEpochTimeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_UnixEpochTimeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeDistanceSensorRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_DistanceSensorResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeScaledPressureRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ScaledPressureResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SubscribeHeadingRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_HeadingResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRatePositionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRatePositionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateHomeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateHomeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateInAirRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateInAirResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateLandedStateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateLandedStateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateVtolStateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateVtolStateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateAttitudeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateAttitudeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateAttitudeAngularVelocityBodyRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateAttitudeAngularVelocityBodyResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateCameraAttitudeQuaternionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateCameraAttitudeQuaternionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateCameraAttitudeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateCameraAttitudeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateVelocityNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateVelocityNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateGpsInfoRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateGpsInfoResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateRawGpsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateBatteryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateBatteryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateRcStatusRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateRcStatusResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateActuatorControlTargetRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateActuatorControlTargetResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateActuatorOutputStatusRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateActuatorOutputStatusResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateOdometryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateOdometryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRatePositionVelocityNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRatePositionVelocityNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateGroundTruthRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateGroundTruthResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateFixedwingMetricsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateFixedwingMetricsResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateScaledImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateScaledImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateRawImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateRawImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateUnixEpochTimeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateUnixEpochTimeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateDistanceSensorRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_SetRateDistanceSensorResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_GetGpsGlobalOriginRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_GetGpsGlobalOriginResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Position: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Heading: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Quaternion: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_EulerAngle: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_AngularVelocityBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_GpsInfo: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_RawGps: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Battery: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Health: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_RcStatus: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_StatusText: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ActuatorControlTarget: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ActuatorOutputStatus: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Covariance: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_VelocityBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_PositionBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Odometry: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Odometry.MavFrame: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_DistanceSensor: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_ScaledPressure: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_PositionNed: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_VelocityNed: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_PositionVelocityNed: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_GroundTruth: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_FixedwingMetrics: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_AccelerationFrd: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_AngularVelocityFrd: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_MagneticFieldFrd: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_Imu: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_GpsGlobalOrigin: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_TelemetryResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Telemetry_TelemetryResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.telemetry"
diff --git a/Sources/Mavsdk/Generated/telemetry_server.pb.swift b/Sources/Mavsdk/Generated/telemetry_server.pb.swift
index 2bdd2e9..356a5e7 100644
--- a/Sources/Mavsdk/Generated/telemetry_server.pb.swift
+++ b/Sources/Mavsdk/Generated/telemetry_server.pb.swift
@@ -1837,6 +1837,74 @@ extension Mavsdk_Rpc_TelemetryServer_TelemetryServerResult.Result: CaseIterable
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_TelemetryServer_FixType: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_VtolState: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_StatusTextType: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_LandedState: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishPositionRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishHomeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishSysStatusRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishExtendedSysStateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishInAirRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishLandedStateRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishRawGpsRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishBatteryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishRcStatusRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishStatusTextRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishOdometryRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishPositionVelocityNedRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishGroundTruthRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishScaledImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishRawImuRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishUnixEpochTimeRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishPositionResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishHomeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishSysStatusResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishExtendedSysStateResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishRawGpsResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishBatteryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishStatusTextResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishOdometryResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishPositionVelocityNedResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishGroundTruthResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishScaledImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishRawImuResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PublishUnixEpochTimeResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_Position: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_Heading: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_Quaternion: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_EulerAngle: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_AngularVelocityBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_GpsInfo: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_RawGps: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_Battery: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_RcStatus: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_StatusText: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_ActuatorControlTarget: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_ActuatorOutputStatus: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_Covariance: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_VelocityBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PositionBody: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_Odometry: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_Odometry.MavFrame: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_DistanceSensor: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_ScaledPressure: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PositionNed: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_VelocityNed: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_PositionVelocityNed: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_GroundTruth: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_FixedwingMetrics: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_AccelerationFrd: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_AngularVelocityFrd: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_MagneticFieldFrd: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_Imu: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_TelemetryServerResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_TelemetryServer_TelemetryServerResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.telemetry_server"
diff --git a/Sources/Mavsdk/Generated/transponder.pb.swift b/Sources/Mavsdk/Generated/transponder.pb.swift
index 7878092..2909fa8 100644
--- a/Sources/Mavsdk/Generated/transponder.pb.swift
+++ b/Sources/Mavsdk/Generated/transponder.pb.swift
@@ -275,6 +275,9 @@ struct Mavsdk_Rpc_Transponder_AdsbVehicle {
   /// Squawk code.
   var squawk: UInt32 = 0
 
+  /// Time Since Last Communication in seconds.
+  var tslcS: UInt32 = 0
+
   var unknownFields = SwiftProtobuf.UnknownStorage()
 
   init() {}
@@ -372,6 +375,17 @@ extension Mavsdk_Rpc_Transponder_TransponderResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Transponder_AdsbEmitterType: @unchecked Sendable {}
+extension Mavsdk_Rpc_Transponder_SubscribeTransponderRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Transponder_TransponderResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Transponder_SetRateTransponderRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Transponder_SetRateTransponderResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Transponder_AdsbVehicle: @unchecked Sendable {}
+extension Mavsdk_Rpc_Transponder_TransponderResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Transponder_TransponderResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.transponder"
@@ -537,6 +551,7 @@ extension Mavsdk_Rpc_Transponder_AdsbVehicle: SwiftProtobuf.Message, SwiftProtob
     9: .same(proto: "callsign"),
     10: .standard(proto: "emitter_type"),
     13: .same(proto: "squawk"),
+    14: .standard(proto: "tslc_s"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -555,6 +570,7 @@ extension Mavsdk_Rpc_Transponder_AdsbVehicle: SwiftProtobuf.Message, SwiftProtob
       case 9: try { try decoder.decodeSingularStringField(value: &self.callsign) }()
       case 10: try { try decoder.decodeSingularEnumField(value: &self.emitterType) }()
       case 13: try { try decoder.decodeSingularUInt32Field(value: &self.squawk) }()
+      case 14: try { try decoder.decodeSingularUInt32Field(value: &self.tslcS) }()
       default: break
       }
     }
@@ -591,6 +607,9 @@ extension Mavsdk_Rpc_Transponder_AdsbVehicle: SwiftProtobuf.Message, SwiftProtob
     if self.squawk != 0 {
       try visitor.visitSingularUInt32Field(value: self.squawk, fieldNumber: 13)
     }
+    if self.tslcS != 0 {
+      try visitor.visitSingularUInt32Field(value: self.tslcS, fieldNumber: 14)
+    }
     try unknownFields.traverse(visitor: &visitor)
   }
 
@@ -605,6 +624,7 @@ extension Mavsdk_Rpc_Transponder_AdsbVehicle: SwiftProtobuf.Message, SwiftProtob
     if lhs.callsign != rhs.callsign {return false}
     if lhs.emitterType != rhs.emitterType {return false}
     if lhs.squawk != rhs.squawk {return false}
+    if lhs.tslcS != rhs.tslcS {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
diff --git a/Sources/Mavsdk/Generated/tune.pb.swift b/Sources/Mavsdk/Generated/tune.pb.swift
index 080d75f..9ce618e 100644
--- a/Sources/Mavsdk/Generated/tune.pb.swift
+++ b/Sources/Mavsdk/Generated/tune.pb.swift
@@ -324,6 +324,15 @@ extension Mavsdk_Rpc_Tune_TuneResult.Result: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Mavsdk_Rpc_Tune_SongElement: @unchecked Sendable {}
+extension Mavsdk_Rpc_Tune_PlayTuneRequest: @unchecked Sendable {}
+extension Mavsdk_Rpc_Tune_PlayTuneResponse: @unchecked Sendable {}
+extension Mavsdk_Rpc_Tune_TuneDescription: @unchecked Sendable {}
+extension Mavsdk_Rpc_Tune_TuneResult: @unchecked Sendable {}
+extension Mavsdk_Rpc_Tune_TuneResult.Result: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "mavsdk.rpc.tune"
diff --git a/Sources/Mavsdk/proto b/Sources/Mavsdk/proto
index 5cb33bb..e74179a 160000
--- a/Sources/Mavsdk/proto
+++ b/Sources/Mavsdk/proto
@@ -1 +1 @@
-Subproject commit 5cb33bbe09bae83105a2eff915a09e3438e9033f
+Subproject commit e74179a049fd74c570ece9fc19b95388cdc4068d