connected-spaces-platform.unity.core 5.13.1 → 5.14.1

package/Source/Multiplayer/Components/ConversationSpaceComponent.cs

@@ -26,7 +26,13 @@ namespace Csp.Multiplayer
         #region P/Invoke
 #pragma warning disable IDE1006
 
-
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_SetConversationUpdateCallback_void_ConversationUpdateCallbackHandler(
+            IntPtr @class,
+            SetConversationUpdateCallbackCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
@@ -69,57 +75,123 @@ namespace Csp.Multiplayer
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern void csp_multiplayer_ConversationSpaceComponent_GetMessage_void_StringRC_MessageResultCallback(
+        static extern void csp_multiplayer_ConversationSpaceComponent_GetMessagesFromConversation_void_intRC_intRC_MessageCollectionResultCallback(
+            IntPtr @class,
+            IntPtr ResultsSkipNumber,
+            IntPtr ResultsMaxNumber,
+            GetMessagesFromConversationCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_GetConversationInfo_void_ConversationResultCallback(
+            IntPtr @class,
+            GetConversationInfoCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_UpdateConversation_void_MessageUpdateParamsRC_ConversationResultCallback(
+            IntPtr @class,
+            IntPtr NewData,
+            UpdateConversationCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_GetMessageInfo_void_StringRC_MessageResultCallback(
             IntPtr @class,
             string MessageId,
-            GetMessageCallbackDelegate callback,
+            GetMessageInfoCallbackDelegate callback,
             IntPtr callbackStateObject
         );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern void csp_multiplayer_ConversationSpaceComponent_GetAllMessages_void_MessageCollectionResultCallback(
+        static extern void csp_multiplayer_ConversationSpaceComponent_UpdateMessage_void_StringRC_MessageUpdateParamsRC_MessageResultCallback(
             IntPtr @class,
-            GetAllMessagesCallbackDelegate callback,
+            string MessageId,
+            IntPtr NewData,
+            UpdateMessageCallbackDelegate callback,
             IntPtr callbackStateObject
         );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern void csp_multiplayer_ConversationSpaceComponent_GetConversationInfo_void_ConversationResultCallback(
+        static extern void csp_multiplayer_ConversationSpaceComponent_GetNumberOfReplies_void_NumberOfRepliesResultCallback(
             IntPtr @class,
-            GetConversationInfoCallbackDelegate callback,
+            GetNumberOfRepliesCallbackDelegate callback,
             IntPtr callbackStateObject
         );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern void csp_multiplayer_ConversationSpaceComponent_SetConversationInfo_void_ConversationInfoRC_ConversationResultCallback(
+        static extern void csp_multiplayer_ConversationSpaceComponent_GetConversationAnnotation_void_AnnotationResultCallback(
             IntPtr @class,
-            IntPtr ConversationData,
-            SetConversationInfoCallbackDelegate callback,
+            GetConversationAnnotationCallbackDelegate callback,
             IntPtr callbackStateObject
         );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern void csp_multiplayer_ConversationSpaceComponent_GetMessageInfo_void_StringRC_MessageResultCallback(
+        static extern void csp_multiplayer_ConversationSpaceComponent_SetConversationAnnotation_void_AnnotationUpdateParamsRC_BufferAssetDataSourceRC_BufferAssetDataSourceRC_AnnotationResultCallback(
+            IntPtr @class,
+            IntPtr AnnotationParams,
+            IntPtr Annotation,
+            IntPtr AnnotationThumbnail,
+            SetConversationAnnotationCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_DeleteConversationAnnotation_void_NullResultCallback(
+            IntPtr @class,
+            DeleteConversationAnnotationCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_GetAnnotation_void_StringRC_AnnotationResultCallback(
             IntPtr @class,
             string MessageId,
-            GetMessageInfoCallbackDelegate callback,
+            GetAnnotationCallbackDelegate callback,
             IntPtr callbackStateObject
         );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern void csp_multiplayer_ConversationSpaceComponent_SetMessageInfo_void_StringRC_MessageInfoRC_MessageResultCallback(
+        static extern void csp_multiplayer_ConversationSpaceComponent_SetAnnotation_void_StringRC_AnnotationUpdateParamsRC_BufferAssetDataSourceRC_BufferAssetDataSourceRC_AnnotationResultCallback(
             IntPtr @class,
             string MessageId,
-            IntPtr MessageData,
-            SetMessageInfoCallbackDelegate callback,
+            IntPtr UpdateParams,
+            IntPtr Annotation,
+            IntPtr AnnotationThumbnail,
+            SetAnnotationCallbackDelegate callback,
             IntPtr callbackStateObject
         );
 
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_DeleteAnnotation_void_StringRC_NullResultCallback(
+            IntPtr @class,
+            string MessageId,
+            DeleteAnnotationCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_GetAnnotationThumbnailsForConversation_void_AnnotationThumbnailCollectionResultCallback(
+            IntPtr @class,
+            _GetAnnotationThumbnailsForConversationCallbackDelegate Callback,
+            IntPtr CallbackStateObject
+        );
+
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
         static extern NativePointer csp_multiplayer_ConversationSpaceComponent_GetPositionC_Vector3RC(IntPtr @class);
@@ -158,13 +230,6 @@ namespace Csp.Multiplayer
         [SuppressUnmanagedCodeSecurity]
         static extern void csp_multiplayer_ConversationSpaceComponent_SetIsActive_void_bool(IntPtr @class, bool Value);
 
-        [DllImport(Csp.Constants.DllName)]
-        [SuppressUnmanagedCodeSecurity]
-        static extern bool csp_multiplayer_ConversationSpaceComponent_MoveConversationFromComponent_bool_ConversationSpaceComponentR(
-            IntPtr @class,
-            IntPtr OtherConversationComponent
-        );
-
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
         static extern void csp_multiplayer_ConversationSpaceComponent_SetTitle_void_StringRC(
@@ -178,25 +243,37 @@ namespace Csp.Multiplayer
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern void csp_multiplayer_ConversationSpaceComponent_SetDate_void_StringRC(
+        static extern void csp_multiplayer_ConversationSpaceComponent_SetResolved_void_bool(IntPtr @class, bool Value);
+
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern bool csp_multiplayer_ConversationSpaceComponent_GetResolvedC_bool(IntPtr @class);
+
+        [DllImport(Csp.Constants.DllName)]
+        [SuppressUnmanagedCodeSecurity]
+        static extern void csp_multiplayer_ConversationSpaceComponent_SetConversationCameraPosition_void_Vector3RC(
             IntPtr @class,
-            IntPtr Value
+            IntPtr InValue
         );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern IntPtr csp_multiplayer_ConversationSpaceComponent_GetDateC_StringRC(IntPtr @class);
+        static extern NativePointer csp_multiplayer_ConversationSpaceComponent_GetConversationCameraPositionC_Vector3RC(
+            IntPtr @class
+        );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern void csp_multiplayer_ConversationSpaceComponent_SetNumberOfReplies_void_int64_tC(
+        static extern void csp_multiplayer_ConversationSpaceComponent_SetConversationCameraRotation_void_Vector4RC(
             IntPtr @class,
-            long Value
+            IntPtr InValue
         );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
-        static extern long csp_multiplayer_ConversationSpaceComponent_GetNumberOfRepliesC_int64_tC(IntPtr @class);
+        static extern NativePointer csp_multiplayer_ConversationSpaceComponent_GetConversationCameraRotationC_Vector4RC(
+            IntPtr @class
+        );
 
         [DllImport(Csp.Constants.DllName)]
         [SuppressUnmanagedCodeSecurity]
@@ -222,20 +299,82 @@ namespace Csp.Multiplayer
 
         delegate void DeleteMessageCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
 
-        delegate void GetMessageCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
-
-        delegate void GetAllMessagesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+        delegate void GetMessagesFromConversationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
 
         delegate void GetConversationInfoCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
 
-        delegate void SetConversationInfoCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+        delegate void UpdateConversationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
 
         delegate void GetMessageInfoCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
 
-        delegate void SetMessageInfoCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+        delegate void UpdateMessageCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetNumberOfRepliesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetConversationAnnotationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void SetConversationAnnotationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void DeleteConversationAnnotationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetAnnotationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void SetAnnotationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void DeleteAnnotationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void _GetAnnotationThumbnailsForConversationCallbackDelegate(
+            IntPtr _StateObject__,
+            NativePointer Result
+        );
+
+        public delegate void GetAnnotationThumbnailsForConversationCallbackDelegate(
+            Csp.Multiplayer.AnnotationThumbnailCollectionResult Result
+        );
+        delegate void SetConversationUpdateCallbackCallbackDelegate(IntPtr _StateObject__, NativePointer arg1);
+
+        readonly List<GCHandle> eventHandles = new List<GCHandle>();
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (SetConversationUpdateCallbackCallbackDelegate))]
+#endif
+        static void SetConversationUpdateCallbackCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _arg1)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var _this = (ConversationSpaceComponent)_handle.Target;
+            _this.RealOnConversationUpdate?.Invoke(_this, new Csp.Multiplayer.ConversationEventParams(_arg1));
+        }
+
+        static readonly SetConversationUpdateCallbackCallbackDelegate OnConversationUpdateDelegateInstance =
+            SetConversationUpdateCallbackCallbackDelegateFunction;
+
+        bool OnConversationUpdateInitialised = false;
+        event EventHandler<Csp.Multiplayer.ConversationEventParams>? RealOnConversationUpdate;
+        public event EventHandler<Csp.Multiplayer.ConversationEventParams> OnConversationUpdate
+        {
+            add
+            {
+                if (!OnConversationUpdateInitialised)
+                {
+                    var handle = GCHandle.Alloc(this);
+                    csp_multiplayer_ConversationSpaceComponent_SetConversationUpdateCallback_void_ConversationUpdateCallbackHandler(
+                        _ptr,
+                        OnConversationUpdateDelegateInstance,
+                        (IntPtr)handle
+                    );
+                    eventHandles.Add(handle);
+                    OnConversationUpdateInitialised = true;
+                }
+
+                RealOnConversationUpdate += value;
+            }
+            remove { RealOnConversationUpdate -= value; }
+        }
 
         /// <summary>Constructs the conversation component, and associates it with the specified Parent space entity.</summary>
-        /// <param name="Parent">The Space entity that owns this component.</param>
+        /// <remarks>This constructor should not be called directly. Instead, use the SpaceEntity::AddComponent function.</remarks>
+        /// <param name="Parent">The Space entity that owns this component. This will also register the component to the entity.</param>
+        /// @pre Parent must not be null.
 
         public ConversationSpaceComponent(Csp.Multiplayer.SpaceEntity Parent)
         {
@@ -267,8 +406,12 @@ namespace Csp.Multiplayer
         static readonly CreateConversationCallbackDelegate CreateConversationDelegateInstance =
             CreateConversationCallbackDelegateFunction;
 
-        /// <summary>Create a new conversation</summary>
+        /// <summary>Creates a conversation represented by this component.</summary>
                 /// <param name="Message">The message to be stored.</param>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre The conversation must not already exist (component must not have a conversation id that isn't an empty string).
+                /// <remarks>A CSP error will be sent to the LogSystem if this condition is not met, with a EResultCode::Failed response.</remarks>
+                /// @post The ConversationId property is now internally set when the callback is fired.
                 /// <returns>The result for the request</returns>
 
         public Task<Csp.Systems.StringResult> CreateConversation(string Message)
@@ -309,7 +452,9 @@ namespace Csp.Multiplayer
         static readonly DeleteConversationCallbackDelegate DeleteConversationDelegateInstance =
             DeleteConversationCallbackDelegateFunction;
 
-        /// <summary>Deletes all the messages that are part of the conversation</summary>
+        /// <summary>Deletes this conversation, including all of its messages. This function is called internally when the component is deleted.</summary>
+                /// <param name="Callback">Callback when asynchronous task finishes</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
                 /// <returns>The result for the request</returns>
 
         public Task<Csp.Systems.NullResult> DeleteConversation()
@@ -348,9 +493,10 @@ namespace Csp.Multiplayer
 
         static readonly AddMessageCallbackDelegate AddMessageDelegateInstance = AddMessageCallbackDelegateFunction;
 
-        /// <summary>Adds a message to conversation</summary>
-                /// <remarks>Make sure that the user has entered a space through SpaceSystem::EnterSpace() before calling this.</remarks>
+        /// <summary>Adds a message to the conversation.</summary>
                 /// <param name="Message">The message to be stored.</param>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
                 /// <returns>The result for the request</returns>
 
         public Task<Csp.Multiplayer.MessageResult> AddMessage(string Message)
@@ -391,8 +537,14 @@ namespace Csp.Multiplayer
         static readonly DeleteMessageCallbackDelegate DeleteMessageDelegateInstance =
             DeleteMessageCallbackDelegateFunction;
 
-        /// <summary>Deletes a particular message</summary>
-                /// <param name="MessageId">If of the message that will be deleted</param>
+        /// <summary>Deletes a particular message.</summary>
+                /// <param name="MessageId">Id of the message to delete.</param>
+                /// <remarks>The id can be retreived from the result callback when the message was added.</remarks>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <remarks>A CSP error will be sent to the LogSystem if this condition is not met, with a EResultCode::Failed response.</remarks>
+                /// @pre Client should be logged in with the same user account that created the message (ClientId of the message should match the current logged
+                /// <remarks>in user).</remarks>
                 /// <returns>The result for the request</returns>
 
         public Task<Csp.Systems.NullResult> DeleteMessage(string MessageId)
@@ -411,9 +563,170 @@ namespace Csp.Multiplayer
         }
 
 #if !UNITY_EDITOR && ENABLE_IL2CPP
-        [AOT.MonoPInvokeCallback (typeof (GetMessageCallbackDelegate))]
+        [AOT.MonoPInvokeCallback (typeof (GetMessagesFromConversationCallbackDelegate))]
+#endif
+        static void GetMessagesFromConversationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.MessageCollectionResult>)_handle.Target;
+            var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Multiplayer.MessageCollectionResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetMessagesFromConversationCallbackDelegate GetMessagesFromConversationDelegateInstance =
+            GetMessagesFromConversationCallbackDelegateFunction;
+
+        /// <summary>Retrieves message details that are represented by this component.</summary>
+                /// <remarks>This doesn't include the original message that created the conversation.</remarks>
+                /// <param name="ResultsSkipNumber">Optional parameter representing the number of result entries that will be skipped</param>
+                /// <remarks>from the result. For no skip pass an empty optional.</remarks>
+                /// <param name="ResultsMaxNumber">Optional parameter representing the maximum number of result entries to be</param>
+                /// <remarks>retrieved. For all available result entries pass an empty optional.</remarks>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Multiplayer.MessageCollectionResult> GetMessagesFromConversation(
+            int? ResultsSkipNumber,
+            int? ResultsMaxNumber
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.MessageCollectionResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            var ResultsSkipNumberPointer = IntPtr.Zero;
+            unsafe
+            {
+                if (ResultsSkipNumber.HasValue)
+                {
+                    var ptr = stackalloc int[1];
+                    *ptr = ResultsSkipNumber.Value;
+                    ResultsSkipNumberPointer = (IntPtr)ptr;
+                }
+            }
+            var ResultsMaxNumberPointer = IntPtr.Zero;
+            unsafe
+            {
+                if (ResultsMaxNumber.HasValue)
+                {
+                    var ptr = stackalloc int[1];
+                    *ptr = ResultsMaxNumber.Value;
+                    ResultsMaxNumberPointer = (IntPtr)ptr;
+                }
+            }
+
+            csp_multiplayer_ConversationSpaceComponent_GetMessagesFromConversation_void_intRC_intRC_MessageCollectionResultCallback(
+                _ptr,
+                ResultsSkipNumberPointer,
+                ResultsMaxNumberPointer,
+                GetMessagesFromConversationDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetConversationInfoCallbackDelegate))]
+#endif
+        static void GetConversationInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.ConversationResult>)_handle.Target;
+            var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Multiplayer.ConversationResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetConversationInfoCallbackDelegate GetConversationInfoDelegateInstance =
+            GetConversationInfoCallbackDelegateFunction;
+
+        /// <summary>Retrieves message details for the root message in the conversation.</summary>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Multiplayer.ConversationResult> GetConversationInfo()
+        {
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.ConversationResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_multiplayer_ConversationSpaceComponent_GetConversationInfo_void_ConversationResultCallback(
+                _ptr,
+                GetConversationInfoDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateConversationCallbackDelegate))]
+#endif
+        static void UpdateConversationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.ConversationResult>)_handle.Target;
+            var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Multiplayer.ConversationResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly UpdateConversationCallbackDelegate UpdateConversationDelegateInstance =
+            UpdateConversationCallbackDelegateFunction;
+
+        /// <summary>Updates information for the root message in the conversation.</summary>
+                /// <param name="NewData">The information to update the root message with.</param>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <remarks>A CSP error will be sent to the LogSystem if this condition is not met, with a EResultCode::Failed response.</remarks>
+                /// @pre Client should be logged in with the same user account that created the message (ClientId of the message should match the current logged
+                /// <remarks>in user).</remarks>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Multiplayer.ConversationResult> UpdateConversation(Csp.Multiplayer.MessageUpdateParams NewData)
+        {
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.ConversationResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_multiplayer_ConversationSpaceComponent_UpdateConversation_void_MessageUpdateParamsRC_ConversationResultCallback(
+                _ptr,
+                NewData._ptr,
+                UpdateConversationDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetMessageInfoCallbackDelegate))]
 #endif
-        static void GetMessageCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        static void GetMessageInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
         {
             var _handle = (GCHandle)_StateObject__;
             var tcs = (TaskCompletionSource<Csp.Multiplayer.MessageResult>)_handle.Target;
@@ -430,21 +743,25 @@ namespace Csp.Multiplayer
             _handle.Free();
         }
 
-        static readonly GetMessageCallbackDelegate GetMessageDelegateInstance = GetMessageCallbackDelegateFunction;
+        static readonly GetMessageInfoCallbackDelegate GetMessageInfoDelegateInstance =
+            GetMessageInfoCallbackDelegateFunction;
 
-        /// <summary>Retrieves one particular message</summary>
-                /// <param name="MessageId">Id of the message to be retrieved</param>
+        /// <summary>Retrieves message details for a specified message in this conversation.</summary>
+                /// <param name="MessageId">The message id to retrieve information for.</param>
+                /// <remarks>The id can be retreived from the result callback when the message was added.</remarks>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
                 /// <returns>The result for the request</returns>
 
-        public Task<Csp.Multiplayer.MessageResult> GetMessage(string MessageId)
+        public Task<Csp.Multiplayer.MessageResult> GetMessageInfo(string MessageId)
         {
             var tcs = new TaskCompletionSource<Csp.Multiplayer.MessageResult>(this);
             var handle = GCHandle.Alloc(tcs);
 
-            csp_multiplayer_ConversationSpaceComponent_GetMessage_void_StringRC_MessageResultCallback(
+            csp_multiplayer_ConversationSpaceComponent_GetMessageInfo_void_StringRC_MessageResultCallback(
                 _ptr,
                 MessageId,
-                GetMessageDelegateInstance,
+                GetMessageInfoDelegateInstance,
                 (IntPtr)handle
             );
 
@@ -452,15 +769,15 @@ namespace Csp.Multiplayer
         }
 
 #if !UNITY_EDITOR && ENABLE_IL2CPP
-        [AOT.MonoPInvokeCallback (typeof (GetAllMessagesCallbackDelegate))]
+        [AOT.MonoPInvokeCallback (typeof (UpdateMessageCallbackDelegate))]
 #endif
-        static void GetAllMessagesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        static void UpdateMessageCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
         {
             var _handle = (GCHandle)_StateObject__;
-            var tcs = (TaskCompletionSource<Csp.Multiplayer.MessageCollectionResult>)_handle.Target;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.MessageResult>)_handle.Target;
             var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
 
-            var task_result = new Csp.Multiplayer.MessageCollectionResult(_Result);
+            var task_result = new Csp.Multiplayer.MessageResult(_Result);
 
             if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
             {
@@ -471,20 +788,74 @@ namespace Csp.Multiplayer
             _handle.Free();
         }
 
-        static readonly GetAllMessagesCallbackDelegate GetAllMessagesDelegateInstance =
-            GetAllMessagesCallbackDelegateFunction;
-
-        /// <summary>Retrieves all messages in conversation</summary>
+        static readonly UpdateMessageCallbackDelegate UpdateMessageDelegateInstance =
+            UpdateMessageCallbackDelegateFunction;
+
+        /// <summary>Updates information for a specified message in the conversation.</summary>
+                /// <param name="MessageId">The message id to update information for.</param>
+                /// <remarks>The id can be retreived from the result callback when the message was added.</remarks>
+                /// <param name="NewData">The information to update the specified message with.</param>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <remarks>A CSP error will be sent to the LogSystem if this condition is not met, with a EResultCode::Failed response.</remarks>
+                /// @pre Client should be logged in with the same user account that created the message (ClientId of the message should match the current logged
+                /// <remarks>in user).</remarks>
                 /// <returns>The result for the request</returns>
 
-        public Task<Csp.Multiplayer.MessageCollectionResult> GetAllMessages()
+        public Task<Csp.Multiplayer.MessageResult> UpdateMessage(
+            string MessageId,
+            Csp.Multiplayer.MessageUpdateParams NewData
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.MessageResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_multiplayer_ConversationSpaceComponent_UpdateMessage_void_StringRC_MessageUpdateParamsRC_MessageResultCallback(
+                _ptr,
+                MessageId,
+                NewData._ptr,
+                UpdateMessageDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetNumberOfRepliesCallbackDelegate))]
+#endif
+        static void GetNumberOfRepliesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
         {
-            var tcs = new TaskCompletionSource<Csp.Multiplayer.MessageCollectionResult>(this);
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.NumberOfRepliesResult>)_handle.Target;
+            var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Multiplayer.NumberOfRepliesResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetNumberOfRepliesCallbackDelegate GetNumberOfRepliesDelegateInstance =
+            GetNumberOfRepliesCallbackDelegateFunction;
+
+        /// <summary>Gets the Number Of Replies in the conversation.</summary>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Multiplayer.NumberOfRepliesResult> GetNumberOfReplies()
+        {
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.NumberOfRepliesResult>(this);
             var handle = GCHandle.Alloc(tcs);
 
-            csp_multiplayer_ConversationSpaceComponent_GetAllMessages_void_MessageCollectionResultCallback(
+            csp_multiplayer_ConversationSpaceComponent_GetNumberOfReplies_void_NumberOfRepliesResultCallback(
                 _ptr,
-                GetAllMessagesDelegateInstance,
+                GetNumberOfRepliesDelegateInstance,
                 (IntPtr)handle
             );
 
@@ -492,15 +863,15 @@ namespace Csp.Multiplayer
         }
 
 #if !UNITY_EDITOR && ENABLE_IL2CPP
-        [AOT.MonoPInvokeCallback (typeof (GetConversationInfoCallbackDelegate))]
+        [AOT.MonoPInvokeCallback (typeof (GetConversationAnnotationCallbackDelegate))]
 #endif
-        static void GetConversationInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        static void GetConversationAnnotationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
         {
             var _handle = (GCHandle)_StateObject__;
-            var tcs = (TaskCompletionSource<Csp.Multiplayer.ConversationResult>)_handle.Target;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.AnnotationResult>)_handle.Target;
             var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
 
-            var task_result = new Csp.Multiplayer.ConversationResult(_Result);
+            var task_result = new Csp.Multiplayer.AnnotationResult(_Result);
 
             if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
             {
@@ -511,20 +882,24 @@ namespace Csp.Multiplayer
             _handle.Free();
         }
 
-        static readonly GetConversationInfoCallbackDelegate GetConversationInfoDelegateInstance =
-            GetConversationInfoCallbackDelegateFunction;
+        static readonly GetConversationAnnotationCallbackDelegate GetConversationAnnotationDelegateInstance =
+            GetConversationAnnotationCallbackDelegateFunction;
 
-        /// <summary>Get Conversation Info</summary>
+        /// <summary>Gets the annotation for the root message in the conversation.</summary>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <remarks>A CSP error will be sent to the LogSystem if this condition is not met, with a EResultCode::Failed response.</remarks>
+                /// @pre The conversation must have an annotation previously attached using SetConversationAnnotation.
                 /// <returns>The result for the request</returns>
 
-        public Task<Csp.Multiplayer.ConversationResult> GetConversationInfo()
+        public Task<Csp.Multiplayer.AnnotationResult> GetConversationAnnotation()
         {
-            var tcs = new TaskCompletionSource<Csp.Multiplayer.ConversationResult>(this);
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.AnnotationResult>(this);
             var handle = GCHandle.Alloc(tcs);
 
-            csp_multiplayer_ConversationSpaceComponent_GetConversationInfo_void_ConversationResultCallback(
+            csp_multiplayer_ConversationSpaceComponent_GetConversationAnnotation_void_AnnotationResultCallback(
                 _ptr,
-                GetConversationInfoDelegateInstance,
+                GetConversationAnnotationDelegateInstance,
                 (IntPtr)handle
             );
 
@@ -532,15 +907,15 @@ namespace Csp.Multiplayer
         }
 
 #if !UNITY_EDITOR && ENABLE_IL2CPP
-        [AOT.MonoPInvokeCallback (typeof (SetConversationInfoCallbackDelegate))]
+        [AOT.MonoPInvokeCallback (typeof (SetConversationAnnotationCallbackDelegate))]
 #endif
-        static void SetConversationInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        static void SetConversationAnnotationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
         {
             var _handle = (GCHandle)_StateObject__;
-            var tcs = (TaskCompletionSource<Csp.Multiplayer.ConversationResult>)_handle.Target;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.AnnotationResult>)_handle.Target;
             var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
 
-            var task_result = new Csp.Multiplayer.ConversationResult(_Result);
+            var task_result = new Csp.Multiplayer.AnnotationResult(_Result);
 
             if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
             {
@@ -551,23 +926,32 @@ namespace Csp.Multiplayer
             _handle.Free();
         }
 
-        static readonly SetConversationInfoCallbackDelegate SetConversationInfoDelegateInstance =
-            SetConversationInfoCallbackDelegateFunction;
+        static readonly SetConversationAnnotationCallbackDelegate SetConversationAnnotationDelegateInstance =
+            SetConversationAnnotationCallbackDelegateFunction;
 
-        /// <summary>Set Conversation Info</summary>
-                /// <param name="ConversationData">Conversation Information</param>
+        /// <summary>Associates an annotation with the root message in the conversation.</summary>
+                /// <remarks>If an annotation already exists on the conversation, it will be overwritten.</remarks>
+                /// <param name="UpdateParams">The annotation data for this annotation.</param>
+                /// <param name="Annotation">The annotation image data for this annotation.</param>
+                /// <param name="AnnotationThumbnail">The annotation thumbnail image data for this annotation.</param>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
                 /// <returns>The result for the request</returns>
 
-        public Task<Csp.Multiplayer.ConversationResult> SetConversationInfo(
-            Csp.Multiplayer.ConversationInfo ConversationData
+        public Task<Csp.Multiplayer.AnnotationResult> SetConversationAnnotation(
+            Csp.Multiplayer.AnnotationUpdateParams AnnotationParams,
+            Csp.Systems.BufferAssetDataSource Annotation,
+            Csp.Systems.BufferAssetDataSource AnnotationThumbnail
         ) {
-            var tcs = new TaskCompletionSource<Csp.Multiplayer.ConversationResult>(this);
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.AnnotationResult>(this);
             var handle = GCHandle.Alloc(tcs);
 
-            csp_multiplayer_ConversationSpaceComponent_SetConversationInfo_void_ConversationInfoRC_ConversationResultCallback(
+            csp_multiplayer_ConversationSpaceComponent_SetConversationAnnotation_void_AnnotationUpdateParamsRC_BufferAssetDataSourceRC_BufferAssetDataSourceRC_AnnotationResultCallback(
                 _ptr,
-                ConversationData._ptr,
-                SetConversationInfoDelegateInstance,
+                AnnotationParams._ptr,
+                Annotation._ptr,
+                AnnotationThumbnail._ptr,
+                SetConversationAnnotationDelegateInstance,
                 (IntPtr)handle
             );
 
@@ -575,15 +959,15 @@ namespace Csp.Multiplayer
         }
 
 #if !UNITY_EDITOR && ENABLE_IL2CPP
-        [AOT.MonoPInvokeCallback (typeof (GetMessageInfoCallbackDelegate))]
+        [AOT.MonoPInvokeCallback (typeof (DeleteConversationAnnotationCallbackDelegate))]
 #endif
-        static void GetMessageInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        static void DeleteConversationAnnotationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
         {
             var _handle = (GCHandle)_StateObject__;
-            var tcs = (TaskCompletionSource<Csp.Multiplayer.MessageResult>)_handle.Target;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
             var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
 
-            var task_result = new Csp.Multiplayer.MessageResult(_Result);
+            var task_result = new Csp.Systems.NullResult(_Result);
 
             if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
             {
@@ -594,22 +978,23 @@ namespace Csp.Multiplayer
             _handle.Free();
         }
 
-        static readonly GetMessageInfoCallbackDelegate GetMessageInfoDelegateInstance =
-            GetMessageInfoCallbackDelegateFunction;
+        static readonly DeleteConversationAnnotationCallbackDelegate DeleteConversationAnnotationDelegateInstance =
+            DeleteConversationAnnotationCallbackDelegateFunction;
 
-        /// <summary>Get Message Info</summary>
-                /// <param name="MessageId">Message id</param>
+        /// <summary>Deletes an annotation associated with the root message in the conversation.</summary>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <remarks>A CSP error will be sent to the LogSystem if this condition is not met, with a EResultCode::Failed response. if this condition is not met,</remarks>
                 /// <returns>The result for the request</returns>
 
-        public Task<Csp.Multiplayer.MessageResult> GetMessageInfo(string MessageId)
+        public Task<Csp.Systems.NullResult> DeleteConversationAnnotation()
         {
-            var tcs = new TaskCompletionSource<Csp.Multiplayer.MessageResult>(this);
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
             var handle = GCHandle.Alloc(tcs);
 
-            csp_multiplayer_ConversationSpaceComponent_GetMessageInfo_void_StringRC_MessageResultCallback(
+            csp_multiplayer_ConversationSpaceComponent_DeleteConversationAnnotation_void_NullResultCallback(
                 _ptr,
-                MessageId,
-                GetMessageInfoDelegateInstance,
+                DeleteConversationAnnotationDelegateInstance,
                 (IntPtr)handle
             );
 
@@ -617,15 +1002,15 @@ namespace Csp.Multiplayer
         }
 
 #if !UNITY_EDITOR && ENABLE_IL2CPP
-        [AOT.MonoPInvokeCallback (typeof (SetMessageInfoCallbackDelegate))]
+        [AOT.MonoPInvokeCallback (typeof (GetAnnotationCallbackDelegate))]
 #endif
-        static void SetMessageInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        static void GetAnnotationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
         {
             var _handle = (GCHandle)_StateObject__;
-            var tcs = (TaskCompletionSource<Csp.Multiplayer.MessageResult>)_handle.Target;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.AnnotationResult>)_handle.Target;
             var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
 
-            var task_result = new Csp.Multiplayer.MessageResult(_Result);
+            var task_result = new Csp.Multiplayer.AnnotationResult(_Result);
 
             if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
             {
@@ -636,32 +1021,161 @@ namespace Csp.Multiplayer
             _handle.Free();
         }
 
-        static readonly SetMessageInfoCallbackDelegate SetMessageInfoDelegateInstance =
-            SetMessageInfoCallbackDelegateFunction;
+        static readonly GetAnnotationCallbackDelegate GetAnnotationDelegateInstance =
+            GetAnnotationCallbackDelegateFunction;
+
+        /// <summary>Gets an annotation associated with a message.</summary>
+                /// <param name="MessageId">The message id the annotation is associated with.</param>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <remarks>A CSP error will be sent to the LogSystem if this condition is not met, with a EResultCode::Failed response.</remarks>
+                /// @pre The message must have an annotation previously attached using SetAnnotation.
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Multiplayer.AnnotationResult> GetAnnotation(string MessageId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.AnnotationResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_multiplayer_ConversationSpaceComponent_GetAnnotation_void_StringRC_AnnotationResultCallback(
+                _ptr,
+                MessageId,
+                GetAnnotationDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (SetAnnotationCallbackDelegate))]
+#endif
+        static void SetAnnotationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Multiplayer.AnnotationResult>)_handle.Target;
+            var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Multiplayer.AnnotationResult(_Result);
 
-        /// <summary>Set Message Info</summary>
-                /// <param name="MessageId">Message id</param>
-                /// <param name="MessageData">Conversation Information</param>
+            if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly SetAnnotationCallbackDelegate SetAnnotationDelegateInstance =
+            SetAnnotationCallbackDelegateFunction;
+
+        /// <summary>Associates an annotation with a message.</summary>
+                /// <remarks>If an annotation already exists on the message, it will be overwritten.</remarks>
+                /// <param name="MessageId">The message id to attach an annotation to.</param>
+                /// <param name="UpdateParams">The annotation data for this annotation.</param>
+                /// <param name="Annotation">The annotation image data for this annotation.</param>
+                /// <param name="AnnotationThumbnail">The annotation thumbnail image data for this annotation.</param>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
                 /// <returns>The result for the request</returns>
 
-        public Task<Csp.Multiplayer.MessageResult> SetMessageInfo(
+        public Task<Csp.Multiplayer.AnnotationResult> SetAnnotation(
             string MessageId,
-            Csp.Multiplayer.MessageInfo MessageData
+            Csp.Multiplayer.AnnotationUpdateParams UpdateParams,
+            Csp.Systems.BufferAssetDataSource Annotation,
+            Csp.Systems.BufferAssetDataSource AnnotationThumbnail
         ) {
-            var tcs = new TaskCompletionSource<Csp.Multiplayer.MessageResult>(this);
+            var tcs = new TaskCompletionSource<Csp.Multiplayer.AnnotationResult>(this);
             var handle = GCHandle.Alloc(tcs);
 
-            csp_multiplayer_ConversationSpaceComponent_SetMessageInfo_void_StringRC_MessageInfoRC_MessageResultCallback(
+            csp_multiplayer_ConversationSpaceComponent_SetAnnotation_void_StringRC_AnnotationUpdateParamsRC_BufferAssetDataSourceRC_BufferAssetDataSourceRC_AnnotationResultCallback(
                 _ptr,
                 MessageId,
-                MessageData._ptr,
-                SetMessageInfoDelegateInstance,
+                UpdateParams._ptr,
+                Annotation._ptr,
+                AnnotationThumbnail._ptr,
+                SetAnnotationDelegateInstance,
                 (IntPtr)handle
             );
 
             return tcs.Task;
         }
 
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (DeleteAnnotationCallbackDelegate))]
+#endif
+        static void DeleteAnnotationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (ConversationSpaceComponent)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.NullResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Systems.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly DeleteAnnotationCallbackDelegate DeleteAnnotationDelegateInstance =
+            DeleteAnnotationCallbackDelegateFunction;
+
+        /// <summary>Deletes an annotation associated with a message.</summary>
+                /// <param name="MessageId">The message id whose annotation to delete.</param>
+                /// <param name="Callback">Callback when asynchronous task finishes.</param>
+                /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> DeleteAnnotation(string MessageId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_multiplayer_ConversationSpaceComponent_DeleteAnnotation_void_StringRC_NullResultCallback(
+                _ptr,
+                MessageId,
+                DeleteAnnotationDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+        /// <summary>Gets all thumbnails in the conversation.</summary>
+        /// <param name="Callback">Callback when asynchronous task finishes.</param>
+        /// @pre This component must contain a valid conversation id (component must have a conversation id that isn't an empty string).
+        /// <remarks>A CSP error will be sent to the LogSystem if this condition is not met, with a EResultCode::Failed response.</remarks>
+
+        static void GetAnnotationThumbnailsForConversationCallbackDelegateFunction(
+            IntPtr _StateObject__,
+            NativePointer Result
+        ) {
+            var _handle = (GCHandle)_StateObject__;
+            var _Callback = (GetAnnotationThumbnailsForConversationCallbackDelegate)_handle.Target;
+
+            var _Result = new Csp.Multiplayer.AnnotationThumbnailCollectionResult(Result);
+
+            _Callback(_Result);
+            // TODO: Queue persistent callback handles to be freed on exit
+            // _handle.Free();
+        }
+
+        public void GetAnnotationThumbnailsForConversation(
+            GetAnnotationThumbnailsForConversationCallbackDelegate Callback
+        ) {
+            var _Callback = GCHandle.Alloc(Callback);
+            csp_multiplayer_ConversationSpaceComponent_GetAnnotationThumbnailsForConversation_void_AnnotationThumbnailCollectionResultCallback(
+                _ptr,
+                GetAnnotationThumbnailsForConversationCallbackDelegateFunction,
+                (IntPtr)_Callback
+            );
+        }
+
         /// <remarks>\addtogroup IPositionComponent</remarks>
         /// @{
         /// @copydoc IPositionComponent::GetPosition()
@@ -742,24 +1256,6 @@ namespace Csp.Multiplayer
             csp_multiplayer_ConversationSpaceComponent_SetIsActive_void_bool(_ptr, Value);
         }
 
-        /// <summary>Moves the conversation associated with the other component to this one and remmove the association with the other component</summary>
-        /// <param name="OtherConversationComponent">- The component to move the conversation from.</param>
-        /// <returns>True if successful, false if there is already a conversation associated with this component</returns>
-
-
-        public bool MoveConversationFromComponent(Csp.Multiplayer.ConversationSpaceComponent OtherConversationComponent)
-        {
-            var _value =
-                csp_multiplayer_ConversationSpaceComponent_MoveConversationFromComponent_bool_ConversationSpaceComponentR(
-                    _ptr,
-                    OtherConversationComponent._ptr
-                );
-
-            var _result = _value;
-
-            return _result;
-        }
-
         /// <summary>Sets the Title of the conversation.</summary>
         /// <param name="Value">- The new title.</param>
 
@@ -787,50 +1283,71 @@ namespace Csp.Multiplayer
             return _resultString;
         }
 
-        /// <summary>Sets the Date of the conversation.</summary>
-        /// <param name="Value">- The new Date.</param>
+        /// <summary>Sets the resolved value for indicating that a conversation is resolved.</summary>
+        /// <param name="Value">- The resolved state.</param>
 
 
-        public void SetDate(string Value)
+        public void SetResolved(bool Value)
         {
-            csp_multiplayer_ConversationSpaceComponent_SetDate_void_StringRC(
-                _ptr,
-                WrapperHelper.StringToNativeUTF8(Value)
-            );
+            csp_multiplayer_ConversationSpaceComponent_SetResolved_void_bool(_ptr, Value);
         }
 
-        /// <summary>Gets the Date of the conversation.</summary>
+        /// <summary>Gets the resolved value of the conversation.</summary>
 
 
-        public string GetDate()
+        public bool GetResolved()
         {
-            var _value = csp_multiplayer_ConversationSpaceComponent_GetDateC_StringRC(_ptr);
+            var _value = csp_multiplayer_ConversationSpaceComponent_GetResolvedC_bool(_ptr);
 
             var _result = _value;
 
-            var _resultString = WrapperHelper.NativeUTF8ToString(_result);
-            Global.Free(_result);
+            return _result;
+        }
 
-            return _resultString;
+        /// <summary>Sets the value for the camera position used to view the conversation.</summary>
+        /// <param name="InValue">The position for the camera.</param>
+
+
+        public void SetConversationCameraPosition(Csp.Common.Vector3 InValue)
+        {
+            csp_multiplayer_ConversationSpaceComponent_SetConversationCameraPosition_void_Vector3RC(_ptr, InValue._ptr);
+        }
+
+        /// <summary>Gets the value for the camera position of the conversation.</summary>
+        /// <returns>The camera view position.</returns>
+
+
+        public Csp.Common.Vector3 GetConversationCameraPosition()
+        {
+            var _value = csp_multiplayer_ConversationSpaceComponent_GetConversationCameraPositionC_Vector3RC(_ptr);
+
+            WrapperHelper.CheckNativePointer(_value);
+            var _result = new Csp.Common.Vector3(_value);
+            ;
+
+            return _result;
         }
 
-        /// <summary>Sets the Number Of Replies of the conversation.</summary>
-        /// <param name="Value">- The new Number Of Replies.</param>
+        /// <summary>Sets the value for the camera rotation used to view the conversation.</summary>
+        /// <param name="InValue">The rotation for the camera.</param>
 
 
-        public void SetNumberOfReplies(long Value)
+        public void SetConversationCameraRotation(Csp.Common.Vector4 InValue)
         {
-            csp_multiplayer_ConversationSpaceComponent_SetNumberOfReplies_void_int64_tC(_ptr, Value);
+            csp_multiplayer_ConversationSpaceComponent_SetConversationCameraRotation_void_Vector4RC(_ptr, InValue._ptr);
         }
 
-        /// <summary>Gets the Number Of Replies of the conversation.</summary>
+        /// <summary>Gets the value for the camera rotation of the conversation.</summary>
+        /// <returns>The camera view rotation.</returns>
 
 
-        public long GetNumberOfReplies()
+        public Csp.Common.Vector4 GetConversationCameraRotation()
         {
-            var _value = csp_multiplayer_ConversationSpaceComponent_GetNumberOfRepliesC_int64_tC(_ptr);
+            var _value = csp_multiplayer_ConversationSpaceComponent_GetConversationCameraRotationC_Vector4RC(_ptr);
 
-            var _result = _value;
+            WrapperHelper.CheckNativePointer(_value);
+            var _result = new Csp.Common.Vector4(_value);
+            ;
 
             return _result;
         }