@dazl/api-client 1.0.14 → 1.0.16

package/src/internal/types.gen.ts

@@ -480,29 +480,6 @@ export type PurgeUserAccountInput = {
     dryRun?: boolean;
 };
 
-export type CreateCommentInput = {
-    content: string;
-    mentions?: Array<UserMention>;
-    context?: CommentContext;
-    gitInfo?: CommentGitInfo;
-};
-
-export type EditCommentInput = {
-    content: string;
-    mentions?: Array<UserMention>;
-};
-
-export type CreateReplyInput = {
-    content: string;
-    mentions?: Array<UserMention>;
-    gitInfo?: CommentGitInfo;
-};
-
-export type EditReplyInput = {
-    content: string;
-    mentions?: Array<UserMention>;
-};
-
 export type FeatureToggle = {
     name: string;
     scope: 'RemoteAndEditor' | 'SiteAndEditor';
@@ -539,6 +516,29 @@ export type ConnectionStatus = {
     isConnected: boolean;
 };
 
+export type CreateCommentInput = {
+    content: string;
+    mentions?: Array<UserMention>;
+    context?: CommentContext;
+    gitInfo?: CommentGitInfo;
+};
+
+export type EditCommentInput = {
+    content: string;
+    mentions?: Array<UserMention>;
+};
+
+export type CreateReplyInput = {
+    content: string;
+    mentions?: Array<UserMention>;
+    gitInfo?: CommentGitInfo;
+};
+
+export type EditReplyInput = {
+    content: string;
+    mentions?: Array<UserMention>;
+};
+
 export type EnsureMyUserData = {
     body?: {
         name?: string;
@@ -2859,63 +2859,6 @@ export type InviteProjectMemberResponses = {
 
 export type InviteProjectMemberResponse = InviteProjectMemberResponses[keyof InviteProjectMemberResponses];
 
-export type AcceptProjectInvitationData = {
-    body: {
-        token: string;
-        userDazlId: string;
-    };
-    path?: never;
-    query?: never;
-    url: '/project/members/accept-invitation';
-};
-
-export type AcceptProjectInvitationErrors = {
-    /**
-     * Bad request - Invalid parameters or malformed JSON
-     */
-    400: {
-        message: string;
-        issues?: string;
-    };
-    /**
-     * Unauthorized
-     */
-    401: ErrorResponse;
-    /**
-     * Forbidden
-     */
-    403: ErrorResponse;
-    /**
-     * Not Found
-     */
-    404: ErrorResponse;
-    /**
-     * Conflict
-     */
-    409: ErrorResponse;
-    /**
-     * Internal server error
-     */
-    500: ErrorResponse;
-    /**
-     * Service Unavailable
-     */
-    503: ErrorResponse;
-};
-
-export type AcceptProjectInvitationError = AcceptProjectInvitationErrors[keyof AcceptProjectInvitationErrors];
-
-export type AcceptProjectInvitationResponses = {
-    /**
-     * Acknowledges that the invitation was accepted
-     */
-    200: {
-        status: 'accepted';
-    };
-};
-
-export type AcceptProjectInvitationResponse = AcceptProjectInvitationResponses[keyof AcceptProjectInvitationResponses];
-
 export type GetProjectCollaboratorsData = {
     body?: never;
     path: {
@@ -2973,20 +2916,20 @@ export type GetProjectCollaboratorsResponses = {
              * Dazl ID for the type = "user"
              */
             id: string;
-            role: 'admin' | 'contributor' | 'viewer' | 'workspace_member' | 'owner';
             email: string;
             name?: string;
             picture?: string;
+            role: 'admin' | 'contributor' | 'viewer' | 'owner';
         } | null;
         members: Array<{
             /**
              * Dazl ID for the type = "user"
              */
             id: string;
-            role: 'admin' | 'contributor' | 'viewer' | 'workspace_member' | 'owner';
             email: string;
             name?: string;
             picture?: string;
+            role: 'admin' | 'contributor' | 'viewer' | 'owner';
         }>;
         invited: Array<{
             role: 'admin' | 'contributor' | 'viewer';
@@ -6345,18 +6288,16 @@ export type GetUserActivePromotionsResponses = {
 
 export type GetUserActivePromotionsResponse = GetUserActivePromotionsResponses[keyof GetUserActivePromotionsResponses];
 
-export type DeleteCommentData = {
+export type GetFeatureTogglesData = {
     body?: never;
-    path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
-        commentId: string;
+    path?: never;
+    query?: {
+        scope?: 'RemoteAndEditor' | 'SiteAndEditor';
     };
-    query?: never;
-    url: '/comments/{hostType}/{hostId}/{commentId}';
+    url: '/env-config';
 };
 
-export type DeleteCommentErrors = {
+export type GetFeatureTogglesErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6390,31 +6331,27 @@ export type DeleteCommentErrors = {
     503: ErrorResponse;
 };
 
-export type DeleteCommentError = DeleteCommentErrors[keyof DeleteCommentErrors];
+export type GetFeatureTogglesError = GetFeatureTogglesErrors[keyof GetFeatureTogglesErrors];
 
-export type DeleteCommentResponses = {
+export type GetFeatureTogglesResponses = {
     /**
-     * Acknowledges that the comment was deleted
+     * Returns feature toggles, optionally filtered by scope
      */
     200: {
-        success: true;
+        toggles: Array<FeatureToggle>;
     };
 };
 
-export type DeleteCommentResponse = DeleteCommentResponses[keyof DeleteCommentResponses];
+export type GetFeatureTogglesResponse = GetFeatureTogglesResponses[keyof GetFeatureTogglesResponses];
 
-export type GetCommentData = {
+export type GetMyUserData = {
     body?: never;
-    path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
-        commentId: string;
-    };
+    path?: never;
     query?: never;
-    url: '/comments/{hostType}/{hostId}/{commentId}';
+    url: '/my-user/me';
 };
 
-export type GetCommentErrors = {
+export type GetMyUserErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6448,56 +6385,31 @@ export type GetCommentErrors = {
     503: ErrorResponse;
 };
 
-export type GetCommentError = GetCommentErrors[keyof GetCommentErrors];
+export type GetMyUserError = GetMyUserErrors[keyof GetMyUserErrors];
 
-export type GetCommentResponses = {
+export type GetMyUserResponses = {
     /**
-     * Returns comment by id for the host entity
+     * Returns the requested user
      */
     200: {
-        comment: {
-            commentId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
-            createdAt: string;
-            updatedAt: string;
-            lastActivityAt: string;
-            isEdited: boolean;
-            replies: Array<{
-                replyId: string;
-                author: {
-                    dazlUserId: string;
-                };
-                content: string;
-                mentions: Array<UserMention>;
-                createdAt: string;
-                updatedAt: string;
-                gitInfo?: CommentGitInfo;
-            }>;
-            resolved?: CommentResolved;
-            context?: CommentContext;
-            gitInfo?: CommentGitInfo;
-        };
+        user: UserRaw;
     };
 };
 
-export type GetCommentResponse = GetCommentResponses[keyof GetCommentResponses];
+export type GetMyUserResponse = GetMyUserResponses[keyof GetMyUserResponses];
 
-export type EditCommentData = {
-    body: EditCommentInput;
-    path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
-        commentId: string;
+export type UpdateMyUserData = {
+    body: {
+        picture?: string | null;
+        name?: string;
+        jobRole?: string | null;
     };
+    path?: never;
     query?: never;
-    url: '/comments/{hostType}/{hostId}/{commentId}';
+    url: '/my-user/me';
 };
 
-export type EditCommentErrors = {
+export type UpdateMyUserErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6531,55 +6443,29 @@ export type EditCommentErrors = {
     503: ErrorResponse;
 };
 
-export type EditCommentError = EditCommentErrors[keyof EditCommentErrors];
+export type UpdateMyUserError = UpdateMyUserErrors[keyof UpdateMyUserErrors];
 
-export type EditCommentResponses = {
+export type UpdateMyUserResponses = {
     /**
-     * Returns the updated comment
+     * Updates user information
      */
     200: {
-        comment: {
-            commentId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
-            createdAt: string;
-            updatedAt: string;
-            lastActivityAt: string;
-            isEdited: boolean;
-            replies: Array<{
-                replyId: string;
-                author: {
-                    dazlUserId: string;
-                };
-                content: string;
-                mentions: Array<UserMention>;
-                createdAt: string;
-                updatedAt: string;
-                gitInfo?: CommentGitInfo;
-            }>;
-            resolved?: CommentResolved;
-            context?: CommentContext;
-            gitInfo?: CommentGitInfo;
-        };
+        user: UserRaw;
     };
 };
 
-export type EditCommentResponse = EditCommentResponses[keyof EditCommentResponses];
+export type UpdateMyUserResponse = UpdateMyUserResponses[keyof UpdateMyUserResponses];
 
-export type ListCommentsData = {
-    body?: never;
-    path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
+export type CreateWorkspaceData = {
+    body: {
+        name: string;
     };
+    path?: never;
     query?: never;
-    url: '/comments/{hostType}/{hostId}';
+    url: '/workspace/create';
 };
 
-export type ListCommentsErrors = {
+export type CreateWorkspaceErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6613,55 +6499,32 @@ export type ListCommentsErrors = {
     503: ErrorResponse;
 };
 
-export type ListCommentsError = ListCommentsErrors[keyof ListCommentsErrors];
+export type CreateWorkspaceError = CreateWorkspaceErrors[keyof CreateWorkspaceErrors];
 
-export type ListCommentsResponses = {
+export type CreateWorkspaceResponses = {
     /**
-     * Returns the list of comments for the host entity
+     * Returns the created workspace
      */
     200: {
-        comments: Array<{
-            commentId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
-            createdAt: string;
-            updatedAt: string;
-            lastActivityAt: string;
-            isEdited: boolean;
-            replies: Array<{
-                replyId: string;
-                author: {
-                    dazlUserId: string;
-                };
-                content: string;
-                mentions: Array<UserMention>;
-                createdAt: string;
-                updatedAt: string;
-                gitInfo?: CommentGitInfo;
-            }>;
-            resolved?: CommentResolved;
-            context?: CommentContext;
-            gitInfo?: CommentGitInfo;
-        }>;
+        workspace: Workspace;
     };
 };
 
-export type ListCommentsResponse = ListCommentsResponses[keyof ListCommentsResponses];
+export type CreateWorkspaceResponse = CreateWorkspaceResponses[keyof CreateWorkspaceResponses];
 
-export type CreateCommentData = {
-    body: CreateCommentInput;
-    path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
+export type GetAllWorkspacesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Whether to include the members of each workspace
+         */
+        withMembers?: boolean;
     };
-    query?: never;
-    url: '/comments/{hostType}/{hostId}';
+    url: '/workspace/list-my';
 };
 
-export type CreateCommentErrors = {
+export type GetAllWorkspacesErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6695,56 +6558,61 @@ export type CreateCommentErrors = {
     503: ErrorResponse;
 };
 
-export type CreateCommentError = CreateCommentErrors[keyof CreateCommentErrors];
+export type GetAllWorkspacesError = GetAllWorkspacesErrors[keyof GetAllWorkspacesErrors];
 
-export type CreateCommentResponses = {
+export type GetAllWorkspacesResponses = {
     /**
-     * Returns the created comment
+     * Returns the list of workspaces that the user is a member of
      */
     200: {
-        comment: {
-            commentId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
+        workspaces: Array<{
+            id: string;
+            name: string;
+            /**
+             * The user which created the workspace. Null if the user was deleted.
+             */
+            dazlUserId: string | null;
             createdAt: string;
-            updatedAt: string;
-            lastActivityAt: string;
-            isEdited: boolean;
-            replies: Array<{
-                replyId: string;
-                author: {
-                    dazlUserId: string;
-                };
-                content: string;
-                mentions: Array<UserMention>;
-                createdAt: string;
-                updatedAt: string;
-                gitInfo?: CommentGitInfo;
+            isDefault: boolean;
+            owner?: {
+                /**
+                 * Dazl ID for the type = "user"
+                 */
+                id: string;
+                email: string;
+                name?: string;
+                picture?: string;
+                role: 'workspace_member' | 'owner';
+            } | null;
+            members?: Array<{
+                /**
+                 * Dazl ID for the type = "user"
+                 */
+                id: string;
+                email: string;
+                name?: string;
+                picture?: string;
+                role: 'workspace_member' | 'owner';
             }>;
-            resolved?: CommentResolved;
-            context?: CommentContext;
-            gitInfo?: CommentGitInfo;
-        };
+        }>;
     };
 };
 
-export type CreateCommentResponse = CreateCommentResponses[keyof CreateCommentResponses];
+export type GetAllWorkspacesResponse = GetAllWorkspacesResponses[keyof GetAllWorkspacesResponses];
 
-export type ResolveCommentData = {
-    body?: never;
+export type InviteWorkspaceMemberData = {
+    body: {
+        email: string;
+        role: 'workspace_member';
+    };
     path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
-        commentId: string;
+        workspaceId: string;
     };
     query?: never;
-    url: '/comments/{hostType}/{hostId}/{commentId}/resolve';
+    url: '/workspace/{workspaceId}/members/invite';
 };
 
-export type ResolveCommentErrors = {
+export type InviteWorkspaceMemberErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6778,56 +6646,29 @@ export type ResolveCommentErrors = {
     503: ErrorResponse;
 };
 
-export type ResolveCommentError = ResolveCommentErrors[keyof ResolveCommentErrors];
+export type InviteWorkspaceMemberError = InviteWorkspaceMemberErrors[keyof InviteWorkspaceMemberErrors];
 
-export type ResolveCommentResponses = {
+export type InviteWorkspaceMemberResponses = {
     /**
-     * Returns the resolved comment
+     * Returns the invitation token, or null if user was auto-added to workspace
      */
     200: {
-        comment: {
-            commentId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
-            createdAt: string;
-            updatedAt: string;
-            lastActivityAt: string;
-            isEdited: boolean;
-            replies: Array<{
-                replyId: string;
-                author: {
-                    dazlUserId: string;
-                };
-                content: string;
-                mentions: Array<UserMention>;
-                createdAt: string;
-                updatedAt: string;
-                gitInfo?: CommentGitInfo;
-            }>;
-            resolved?: CommentResolved;
-            context?: CommentContext;
-            gitInfo?: CommentGitInfo;
-        };
+        token: string | null;
     };
 };
 
-export type ResolveCommentResponse = ResolveCommentResponses[keyof ResolveCommentResponses];
+export type InviteWorkspaceMemberResponse = InviteWorkspaceMemberResponses[keyof InviteWorkspaceMemberResponses];
 
-export type ReopenCommentData = {
+export type GetWorkspaceMembersData = {
     body?: never;
     path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
-        commentId: string;
+        workspaceId: string;
     };
     query?: never;
-    url: '/comments/{hostType}/{hostId}/{commentId}/reopen';
+    url: '/workspace/{workspaceId}/all-members';
 };
 
-export type ReopenCommentErrors = {
+export type GetWorkspaceMembersErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6861,56 +6702,49 @@ export type ReopenCommentErrors = {
     503: ErrorResponse;
 };
 
-export type ReopenCommentError = ReopenCommentErrors[keyof ReopenCommentErrors];
+export type GetWorkspaceMembersError = GetWorkspaceMembersErrors[keyof GetWorkspaceMembersErrors];
 
-export type ReopenCommentResponses = {
+export type GetWorkspaceMembersResponses = {
     /**
-     * Returns the reopened comment
+     * Returns the list of workspace collaborators: members and owner
      */
     200: {
-        comment: {
-            commentId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
-            createdAt: string;
-            updatedAt: string;
-            lastActivityAt: string;
-            isEdited: boolean;
-            replies: Array<{
-                replyId: string;
-                author: {
-                    dazlUserId: string;
-                };
-                content: string;
-                mentions: Array<UserMention>;
-                createdAt: string;
-                updatedAt: string;
-                gitInfo?: CommentGitInfo;
-            }>;
-            resolved?: CommentResolved;
-            context?: CommentContext;
-            gitInfo?: CommentGitInfo;
-        };
+        owner: {
+            /**
+             * Dazl ID for the type = "user"
+             */
+            id: string;
+            email: string;
+            name?: string;
+            picture?: string;
+            role: 'workspace_member' | 'owner';
+        } | null;
+        members: Array<{
+            /**
+             * Dazl ID for the type = "user"
+             */
+            id: string;
+            email: string;
+            name?: string;
+            picture?: string;
+            role: 'workspace_member' | 'owner';
+        }>;
     };
 };
 
-export type ReopenCommentResponse = ReopenCommentResponses[keyof ReopenCommentResponses];
+export type GetWorkspaceMembersResponse = GetWorkspaceMembersResponses[keyof GetWorkspaceMembersResponses];
 
-export type CreateReplyData = {
-    body: CreateReplyInput;
+export type DeleteWorkspaceMemberData = {
+    body?: never;
     path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
-        commentId: string;
+        workspaceId: string;
+        memberId: string;
     };
     query?: never;
-    url: '/comments/{hostType}/{hostId}/{commentId}/replies';
+    url: '/workspace/{workspaceId}/members/{memberId}';
 };
 
-export type CreateReplyErrors = {
+export type DeleteWorkspaceMemberErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6944,42 +6778,30 @@ export type CreateReplyErrors = {
     503: ErrorResponse;
 };
 
-export type CreateReplyError = CreateReplyErrors[keyof CreateReplyErrors];
+export type DeleteWorkspaceMemberError = DeleteWorkspaceMemberErrors[keyof DeleteWorkspaceMemberErrors];
 
-export type CreateReplyResponses = {
+export type DeleteWorkspaceMemberResponses = {
     /**
-     * Returns the created reply
+     * Acknowledges that the workspace member was deleted
      */
     200: {
-        reply: {
-            replyId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
-            createdAt: string;
-            updatedAt: string;
-            gitInfo?: CommentGitInfo;
-        };
+        status: 'deleted';
     };
 };
 
-export type CreateReplyResponse = CreateReplyResponses[keyof CreateReplyResponses];
+export type DeleteWorkspaceMemberResponse = DeleteWorkspaceMemberResponses[keyof DeleteWorkspaceMemberResponses];
 
-export type DeleteReplyData = {
+export type DeleteWorkspaceInvitationData = {
     body?: never;
     path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
-        commentId: string;
-        replyId: string;
+        workspaceId: string;
+        invitationId: string;
     };
     query?: never;
-    url: '/comments/{hostType}/{hostId}/{commentId}/replies/{replyId}';
+    url: '/workspace/{workspaceId}/invitations/{invitationId}';
 };
 
-export type DeleteReplyErrors = {
+export type DeleteWorkspaceInvitationErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7013,32 +6835,32 @@ export type DeleteReplyErrors = {
     503: ErrorResponse;
 };
 
-export type DeleteReplyError = DeleteReplyErrors[keyof DeleteReplyErrors];
+export type DeleteWorkspaceInvitationError = DeleteWorkspaceInvitationErrors[keyof DeleteWorkspaceInvitationErrors];
 
-export type DeleteReplyResponses = {
+export type DeleteWorkspaceInvitationResponses = {
     /**
-     * Acknowledges that the reply was deleted
+     * Acknowledges that the workspace invitation was deleted
      */
     200: {
-        success: true;
+        status: 'deleted';
     };
 };
 
-export type DeleteReplyResponse = DeleteReplyResponses[keyof DeleteReplyResponses];
+export type DeleteWorkspaceInvitationResponse = DeleteWorkspaceInvitationResponses[keyof DeleteWorkspaceInvitationResponses];
 
-export type EditReplyData = {
-    body: EditReplyInput;
-    path: {
-        hostType: 'project' | 'workspace';
-        hostId: string;
-        commentId: string;
-        replyId: string;
+export type GetMyValuesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter results to this category
+         */
+        categ?: string;
     };
-    query?: never;
-    url: '/comments/{hostType}/{hostId}/{commentId}/replies/{replyId}';
+    url: '/my-user-key-value/values';
 };
 
-export type EditReplyErrors = {
+export type GetMyValuesErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7072,40 +6894,44 @@ export type EditReplyErrors = {
     503: ErrorResponse;
 };
 
-export type EditReplyError = EditReplyErrors[keyof EditReplyErrors];
+export type GetMyValuesError = GetMyValuesErrors[keyof GetMyValuesErrors];
 
-export type EditReplyResponses = {
+export type GetMyValuesResponses = {
     /**
-     * Returns the updated reply
+     * Returns key values for the current user
      */
     200: {
-        reply: {
-            replyId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
+        values: Array<{
+            id: string;
+            dazlUserId: string;
+            category: string;
+            name: string;
+            strVal: string | null;
+            encryptedValId: string | null;
             createdAt: string;
             updatedAt: string;
-            gitInfo?: CommentGitInfo;
-        };
+            encryptedValue: string | null;
+        }>;
     };
 };
 
-export type EditReplyResponse = EditReplyResponses[keyof EditReplyResponses];
+export type GetMyValuesResponse = GetMyValuesResponses[keyof GetMyValuesResponses];
 
-export type GetFeatureTogglesData = {
-    body?: never;
-    path?: never;
-    query?: {
-        scope?: 'RemoteAndEditor' | 'SiteAndEditor';
+export type SetMyValueData = {
+    body: {
+        value: string;
+        isSecret?: boolean;
     };
-    url: '/env-config';
-};
-
-export type GetFeatureTogglesErrors = {
-    /**
+    path: {
+        categ: string;
+        name: string;
+    };
+    query?: never;
+    url: '/my-user-key-value/values/{categ}/{name}';
+};
+
+export type SetMyValueErrors = {
+    /**
      * Bad request - Invalid parameters or malformed JSON
      */
     400: {
@@ -7138,27 +6964,29 @@ export type GetFeatureTogglesErrors = {
     503: ErrorResponse;
 };
 
-export type GetFeatureTogglesError = GetFeatureTogglesErrors[keyof GetFeatureTogglesErrors];
+export type SetMyValueError = SetMyValueErrors[keyof SetMyValueErrors];
 
-export type GetFeatureTogglesResponses = {
+export type SetMyValueResponses = {
     /**
-     * Returns feature toggles, optionally filtered by scope
+     * Sets a single key value and returns its id
      */
     200: {
-        toggles: Array<FeatureToggle>;
+        id: string;
     };
 };
 
-export type GetFeatureTogglesResponse = GetFeatureTogglesResponses[keyof GetFeatureTogglesResponses];
+export type SetMyValueResponse = SetMyValueResponses[keyof SetMyValueResponses];
 
-export type GetMyUserData = {
+export type DeleteMyCategValuesData = {
     body?: never;
-    path?: never;
+    path: {
+        categ: string;
+    };
     query?: never;
-    url: '/my-user/me';
+    url: '/my-user-key-value/values/{categ}';
 };
 
-export type GetMyUserErrors = {
+export type DeleteMyCategValuesErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7192,31 +7020,35 @@ export type GetMyUserErrors = {
     503: ErrorResponse;
 };
 
-export type GetMyUserError = GetMyUserErrors[keyof GetMyUserErrors];
+export type DeleteMyCategValuesError = DeleteMyCategValuesErrors[keyof DeleteMyCategValuesErrors];
 
-export type GetMyUserResponses = {
+export type DeleteMyCategValuesResponses = {
     /**
-     * Returns the requested user
+     * Deletes all values for the category
      */
     200: {
-        user: UserRaw;
+        categ: string;
     };
 };
 
-export type GetMyUserResponse = GetMyUserResponses[keyof GetMyUserResponses];
+export type DeleteMyCategValuesResponse = DeleteMyCategValuesResponses[keyof DeleteMyCategValuesResponses];
 
-export type UpdateMyUserData = {
+export type ReplaceMyCategValuesData = {
     body: {
-        picture?: string | null;
-        name?: string;
-        jobRole?: string | null;
+        values: Array<{
+            name: string;
+            value: string;
+            isSecret?: boolean;
+        }>;
+    };
+    path: {
+        categ: string;
     };
-    path?: never;
     query?: never;
-    url: '/my-user/me';
+    url: '/my-user-key-value/values/{categ}';
 };
 
-export type UpdateMyUserErrors = {
+export type ReplaceMyCategValuesErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7250,29 +7082,31 @@ export type UpdateMyUserErrors = {
     503: ErrorResponse;
 };
 
-export type UpdateMyUserError = UpdateMyUserErrors[keyof UpdateMyUserErrors];
+export type ReplaceMyCategValuesError = ReplaceMyCategValuesErrors[keyof ReplaceMyCategValuesErrors];
 
-export type UpdateMyUserResponses = {
+export type ReplaceMyCategValuesResponses = {
     /**
-     * Updates user information
+     * Replaces all values for the category and returns the upserted rows
      */
     200: {
-        user: UserRaw;
+        values: Array<{
+            id: string;
+            name: string;
+        }>;
+        replaced: boolean;
     };
 };
 
-export type UpdateMyUserResponse = UpdateMyUserResponses[keyof UpdateMyUserResponses];
+export type ReplaceMyCategValuesResponse = ReplaceMyCategValuesResponses[keyof ReplaceMyCategValuesResponses];
 
-export type CreateWorkspaceData = {
-    body: {
-        name: string;
-    };
+export type GetAllData = {
+    body?: never;
     path?: never;
     query?: never;
-    url: '/workspace/create';
+    url: '/my-user-settings';
 };
 
-export type CreateWorkspaceErrors = {
+export type GetAllErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7306,27 +7140,33 @@ export type CreateWorkspaceErrors = {
     503: ErrorResponse;
 };
 
-export type CreateWorkspaceError = CreateWorkspaceErrors[keyof CreateWorkspaceErrors];
+export type GetAllError = GetAllErrors[keyof GetAllErrors];
 
-export type CreateWorkspaceResponses = {
+export type GetAllResponses = {
     /**
-     * Returns the created workspace
+     * Returns user settings (empty object if none exist)
      */
     200: {
-        workspace: Workspace;
+        settings: {
+            [key: string]: unknown;
+        };
     };
 };
 
-export type CreateWorkspaceResponse = CreateWorkspaceResponses[keyof CreateWorkspaceResponses];
+export type GetAllResponse = GetAllResponses[keyof GetAllResponses];
 
-export type GetAllWorkspacesData = {
-    body?: never;
+export type OverrideAllData = {
+    body: {
+        settings: {
+            [key: string]: unknown;
+        };
+    };
     path?: never;
     query?: never;
-    url: '/workspace/list-my';
+    url: '/my-user-settings';
 };
 
-export type GetAllWorkspacesErrors = {
+export type OverrideAllErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7360,32 +7200,29 @@ export type GetAllWorkspacesErrors = {
     503: ErrorResponse;
 };
 
-export type GetAllWorkspacesError = GetAllWorkspacesErrors[keyof GetAllWorkspacesErrors];
+export type OverrideAllError = OverrideAllErrors[keyof OverrideAllErrors];
 
-export type GetAllWorkspacesResponses = {
+export type OverrideAllResponses = {
     /**
-     * Returns the list of workspaces for the current user
+     * Settings updated successfully
      */
     200: {
-        workspaces: Array<Workspace>;
+        success: boolean;
     };
 };
 
-export type GetAllWorkspacesResponse = GetAllWorkspacesResponses[keyof GetAllWorkspacesResponses];
+export type OverrideAllResponse = OverrideAllResponses[keyof OverrideAllResponses];
 
-export type GetMyValuesData = {
-    body?: never;
-    path?: never;
-    query?: {
-        /**
-         * Filter results to this category
-         */
-        categ?: string;
+export type CreateSessionData = {
+    body: {
+        integrationName: IntegrationName;
     };
-    url: '/my-user-key-value/values';
+    path?: never;
+    query?: never;
+    url: '/mcp/create-session';
 };
 
-export type GetMyValuesErrors = {
+export type CreateSessionErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7419,43 +7256,35 @@ export type GetMyValuesErrors = {
     503: ErrorResponse;
 };
 
-export type GetMyValuesError = GetMyValuesErrors[keyof GetMyValuesErrors];
+export type CreateSessionError = CreateSessionErrors[keyof CreateSessionErrors];
 
-export type GetMyValuesResponses = {
+export type CreateSessionResponses = {
     /**
-     * Returns key values for the current user
+     * An authorized MCP session (opaque access-token header) or an unauthorized marker
      */
-    200: {
-        values: Array<{
-            id: string;
-            dazlUserId: string;
-            category: string;
-            name: string;
-            strVal: string | null;
-            encryptedValId: string | null;
-            createdAt: string;
-            updatedAt: string;
-            encryptedValue: string | null;
-        }>;
-    };
+    200: ({
+        status: 'authorized';
+    } & CreateSessionAuthorized) | ({
+        status: 'unauthorized';
+    } & CreateSessionUnauthorized);
 };
 
-export type GetMyValuesResponse = GetMyValuesResponses[keyof GetMyValuesResponses];
+export type CreateSessionResponse = CreateSessionResponses[keyof CreateSessionResponses];
 
-export type SetMyValueData = {
+export type InitiateConnectionData = {
     body: {
-        value: string;
-        isSecret?: boolean;
-    };
-    path: {
-        categ: string;
-        name: string;
+        integrationName: IntegrationName;
+        /**
+         * Where the browser lands after OAuth; built by the caller
+         */
+        callbackUrl: string;
     };
+    path?: never;
     query?: never;
-    url: '/my-user-key-value/values/{categ}/{name}';
+    url: '/mcp/connections';
 };
 
-export type SetMyValueErrors = {
+export type InitiateConnectionErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7489,29 +7318,32 @@ export type SetMyValueErrors = {
     503: ErrorResponse;
 };
 
-export type SetMyValueError = SetMyValueErrors[keyof SetMyValueErrors];
+export type InitiateConnectionError = InitiateConnectionErrors[keyof InitiateConnectionErrors];
 
-export type SetMyValueResponses = {
+export type InitiateConnectionResponses = {
     /**
-     * Sets a single key value and returns its id
+     * The OAuth connection request id and the redirect URL to send the user to
      */
     200: {
-        id: string;
+        connectionRequestId: string;
+        redirectUrl: string;
     };
 };
 
-export type SetMyValueResponse = SetMyValueResponses[keyof SetMyValueResponses];
+export type InitiateConnectionResponse = InitiateConnectionResponses[keyof InitiateConnectionResponses];
 
-export type DeleteMyCategValuesData = {
-    body?: never;
+export type FinalizeConnectionData = {
+    body: {
+        integrationName: IntegrationName;
+    };
     path: {
-        categ: string;
+        connectionRequestId: string;
     };
     query?: never;
-    url: '/my-user-key-value/values/{categ}';
+    url: '/mcp/connections/{connectionRequestId}/finalize';
 };
 
-export type DeleteMyCategValuesErrors = {
+export type FinalizeConnectionErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7545,35 +7377,32 @@ export type DeleteMyCategValuesErrors = {
     503: ErrorResponse;
 };
 
-export type DeleteMyCategValuesError = DeleteMyCategValuesErrors[keyof DeleteMyCategValuesErrors];
+export type FinalizeConnectionError = FinalizeConnectionErrors[keyof FinalizeConnectionErrors];
 
-export type DeleteMyCategValuesResponses = {
+export type FinalizeConnectionResponses = {
     /**
-     * Deletes all values for the category
+     * The persisted connected-account id (ca_...)
      */
     200: {
-        categ: string;
+        connectionId: string;
     };
 };
 
-export type DeleteMyCategValuesResponse = DeleteMyCategValuesResponses[keyof DeleteMyCategValuesResponses];
+export type FinalizeConnectionResponse = FinalizeConnectionResponses[keyof FinalizeConnectionResponses];
 
-export type ReplaceMyCategValuesData = {
-    body: {
-        values: Array<{
-            name: string;
-            value: string;
-            isSecret?: boolean;
-        }>;
-    };
-    path: {
-        categ: string;
+export type GetConnectionStatusData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * If omitted, returns status for all integrations
+         */
+        integrationName?: 'confluence' | 'figma' | 'google-docs' | 'google-sheets' | 'google-slides' | 'jira' | 'linear' | 'miro' | 'notion';
     };
-    query?: never;
-    url: '/my-user-key-value/values/{categ}';
+    url: '/mcp/connections/status';
 };
 
-export type ReplaceMyCategValuesErrors = {
+export type GetConnectionStatusErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7607,31 +7436,334 @@ export type ReplaceMyCategValuesErrors = {
     503: ErrorResponse;
 };
 
-export type ReplaceMyCategValuesError = ReplaceMyCategValuesErrors[keyof ReplaceMyCategValuesErrors];
+export type GetConnectionStatusError = GetConnectionStatusErrors[keyof GetConnectionStatusErrors];
 
-export type ReplaceMyCategValuesResponses = {
+export type GetConnectionStatusResponses = {
     /**
-     * Replaces all values for the category and returns the upserted rows
+     * Active-connection status for the requested integration(s)
      */
-    200: {
-        values: Array<{
-            id: string;
-            name: string;
-        }>;
-        replaced: boolean;
-    };
+    200: Array<ConnectionStatus>;
 };
 
-export type ReplaceMyCategValuesResponse = ReplaceMyCategValuesResponses[keyof ReplaceMyCategValuesResponses];
+export type GetConnectionStatusResponse = GetConnectionStatusResponses[keyof GetConnectionStatusResponses];
 
-export type GetAllData = {
+export type DeleteCommentData = {
     body?: never;
-    path?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+    };
     query?: never;
-    url: '/my-user-settings';
+    url: '/comments/{hostType}/{hostId}/{commentId}';
+};
+
+export type DeleteCommentErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type DeleteCommentError = DeleteCommentErrors[keyof DeleteCommentErrors];
+
+export type DeleteCommentResponses = {
+    /**
+     * Acknowledges that the comment was deleted
+     */
+    200: {
+        success: true;
+    };
+};
+
+export type DeleteCommentResponse = DeleteCommentResponses[keyof DeleteCommentResponses];
+
+export type GetCommentData = {
+    body?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}/{commentId}';
+};
+
+export type GetCommentErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type GetCommentError = GetCommentErrors[keyof GetCommentErrors];
+
+export type GetCommentResponses = {
+    /**
+     * Returns comment by id for the host entity
+     */
+    200: {
+        comment: {
+            commentId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            lastActivityAt: string;
+            isEdited: boolean;
+            replies: Array<{
+                replyId: string;
+                author: {
+                    dazlUserId: string;
+                };
+                content: string;
+                mentions: Array<UserMention>;
+                createdAt: string;
+                updatedAt: string;
+                gitInfo?: CommentGitInfo;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+            gitInfo?: CommentGitInfo;
+        };
+    };
+};
+
+export type GetCommentResponse = GetCommentResponses[keyof GetCommentResponses];
+
+export type EditCommentData = {
+    body: EditCommentInput;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}/{commentId}';
+};
+
+export type EditCommentErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type EditCommentError = EditCommentErrors[keyof EditCommentErrors];
+
+export type EditCommentResponses = {
+    /**
+     * Returns the updated comment
+     */
+    200: {
+        comment: {
+            commentId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            lastActivityAt: string;
+            isEdited: boolean;
+            replies: Array<{
+                replyId: string;
+                author: {
+                    dazlUserId: string;
+                };
+                content: string;
+                mentions: Array<UserMention>;
+                createdAt: string;
+                updatedAt: string;
+                gitInfo?: CommentGitInfo;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+            gitInfo?: CommentGitInfo;
+        };
+    };
+};
+
+export type EditCommentResponse = EditCommentResponses[keyof EditCommentResponses];
+
+export type ListCommentsData = {
+    body?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}';
+};
+
+export type ListCommentsErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type ListCommentsError = ListCommentsErrors[keyof ListCommentsErrors];
+
+export type ListCommentsResponses = {
+    /**
+     * Returns the list of comments for the host entity
+     */
+    200: {
+        comments: Array<{
+            commentId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            lastActivityAt: string;
+            isEdited: boolean;
+            replies: Array<{
+                replyId: string;
+                author: {
+                    dazlUserId: string;
+                };
+                content: string;
+                mentions: Array<UserMention>;
+                createdAt: string;
+                updatedAt: string;
+                gitInfo?: CommentGitInfo;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+            gitInfo?: CommentGitInfo;
+        }>;
+    };
+};
+
+export type ListCommentsResponse = ListCommentsResponses[keyof ListCommentsResponses];
+
+export type CreateCommentData = {
+    body: CreateCommentInput;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}';
 };
 
-export type GetAllErrors = {
+export type CreateCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7665,33 +7797,56 @@ export type GetAllErrors = {
     503: ErrorResponse;
 };
 
-export type GetAllError = GetAllErrors[keyof GetAllErrors];
+export type CreateCommentError = CreateCommentErrors[keyof CreateCommentErrors];
 
-export type GetAllResponses = {
+export type CreateCommentResponses = {
     /**
-     * Returns user settings (empty object if none exist)
+     * Returns the created comment
      */
     200: {
-        settings: {
-            [key: string]: unknown;
+        comment: {
+            commentId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            lastActivityAt: string;
+            isEdited: boolean;
+            replies: Array<{
+                replyId: string;
+                author: {
+                    dazlUserId: string;
+                };
+                content: string;
+                mentions: Array<UserMention>;
+                createdAt: string;
+                updatedAt: string;
+                gitInfo?: CommentGitInfo;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+            gitInfo?: CommentGitInfo;
         };
     };
 };
 
-export type GetAllResponse = GetAllResponses[keyof GetAllResponses];
+export type CreateCommentResponse = CreateCommentResponses[keyof CreateCommentResponses];
 
-export type OverrideAllData = {
-    body: {
-        settings: {
-            [key: string]: unknown;
-        };
+export type ResolveCommentData = {
+    body?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
     };
-    path?: never;
     query?: never;
-    url: '/my-user-settings';
+    url: '/comments/{hostType}/{hostId}/{commentId}/resolve';
 };
 
-export type OverrideAllErrors = {
+export type ResolveCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7725,29 +7880,56 @@ export type OverrideAllErrors = {
     503: ErrorResponse;
 };
 
-export type OverrideAllError = OverrideAllErrors[keyof OverrideAllErrors];
+export type ResolveCommentError = ResolveCommentErrors[keyof ResolveCommentErrors];
 
-export type OverrideAllResponses = {
+export type ResolveCommentResponses = {
     /**
-     * Settings updated successfully
+     * Returns the resolved comment
      */
     200: {
-        success: boolean;
+        comment: {
+            commentId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            lastActivityAt: string;
+            isEdited: boolean;
+            replies: Array<{
+                replyId: string;
+                author: {
+                    dazlUserId: string;
+                };
+                content: string;
+                mentions: Array<UserMention>;
+                createdAt: string;
+                updatedAt: string;
+                gitInfo?: CommentGitInfo;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+            gitInfo?: CommentGitInfo;
+        };
     };
 };
 
-export type OverrideAllResponse = OverrideAllResponses[keyof OverrideAllResponses];
+export type ResolveCommentResponse = ResolveCommentResponses[keyof ResolveCommentResponses];
 
-export type CreateSessionData = {
-    body: {
-        integrationName: IntegrationName;
+export type ReopenCommentData = {
+    body?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
     };
-    path?: never;
     query?: never;
-    url: '/mcp/create-session';
+    url: '/comments/{hostType}/{hostId}/{commentId}/reopen';
 };
 
-export type CreateSessionErrors = {
+export type ReopenCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7781,35 +7963,56 @@ export type CreateSessionErrors = {
     503: ErrorResponse;
 };
 
-export type CreateSessionError = CreateSessionErrors[keyof CreateSessionErrors];
+export type ReopenCommentError = ReopenCommentErrors[keyof ReopenCommentErrors];
 
-export type CreateSessionResponses = {
+export type ReopenCommentResponses = {
     /**
-     * An authorized MCP session (opaque access-token header) or an unauthorized marker
+     * Returns the reopened comment
      */
-    200: ({
-        status: 'authorized';
-    } & CreateSessionAuthorized) | ({
-        status: 'unauthorized';
-    } & CreateSessionUnauthorized);
+    200: {
+        comment: {
+            commentId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            lastActivityAt: string;
+            isEdited: boolean;
+            replies: Array<{
+                replyId: string;
+                author: {
+                    dazlUserId: string;
+                };
+                content: string;
+                mentions: Array<UserMention>;
+                createdAt: string;
+                updatedAt: string;
+                gitInfo?: CommentGitInfo;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+            gitInfo?: CommentGitInfo;
+        };
+    };
 };
 
-export type CreateSessionResponse = CreateSessionResponses[keyof CreateSessionResponses];
+export type ReopenCommentResponse = ReopenCommentResponses[keyof ReopenCommentResponses];
 
-export type InitiateConnectionData = {
-    body: {
-        integrationName: IntegrationName;
-        /**
-         * Where the browser lands after OAuth; built by the caller
-         */
-        callbackUrl: string;
+export type CreateReplyData = {
+    body: CreateReplyInput;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
     };
-    path?: never;
     query?: never;
-    url: '/mcp/connections';
+    url: '/comments/{hostType}/{hostId}/{commentId}/replies';
 };
 
-export type InitiateConnectionErrors = {
+export type CreateReplyErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7843,32 +8046,42 @@ export type InitiateConnectionErrors = {
     503: ErrorResponse;
 };
 
-export type InitiateConnectionError = InitiateConnectionErrors[keyof InitiateConnectionErrors];
+export type CreateReplyError = CreateReplyErrors[keyof CreateReplyErrors];
 
-export type InitiateConnectionResponses = {
+export type CreateReplyResponses = {
     /**
-     * The OAuth connection request id and the redirect URL to send the user to
+     * Returns the created reply
      */
     200: {
-        connectionRequestId: string;
-        redirectUrl: string;
+        reply: {
+            replyId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            gitInfo?: CommentGitInfo;
+        };
     };
 };
 
-export type InitiateConnectionResponse = InitiateConnectionResponses[keyof InitiateConnectionResponses];
+export type CreateReplyResponse = CreateReplyResponses[keyof CreateReplyResponses];
 
-export type FinalizeConnectionData = {
-    body: {
-        integrationName: IntegrationName;
-    };
+export type DeleteReplyData = {
+    body?: never;
     path: {
-        connectionRequestId: string;
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+        replyId: string;
     };
     query?: never;
-    url: '/mcp/connections/{connectionRequestId}/finalize';
+    url: '/comments/{hostType}/{hostId}/{commentId}/replies/{replyId}';
 };
 
-export type FinalizeConnectionErrors = {
+export type DeleteReplyErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7902,32 +8115,32 @@ export type FinalizeConnectionErrors = {
     503: ErrorResponse;
 };
 
-export type FinalizeConnectionError = FinalizeConnectionErrors[keyof FinalizeConnectionErrors];
+export type DeleteReplyError = DeleteReplyErrors[keyof DeleteReplyErrors];
 
-export type FinalizeConnectionResponses = {
+export type DeleteReplyResponses = {
     /**
-     * The persisted connected-account id (ca_...)
+     * Acknowledges that the reply was deleted
      */
     200: {
-        connectionId: string;
+        success: true;
     };
 };
 
-export type FinalizeConnectionResponse = FinalizeConnectionResponses[keyof FinalizeConnectionResponses];
+export type DeleteReplyResponse = DeleteReplyResponses[keyof DeleteReplyResponses];
 
-export type GetConnectionStatusData = {
-    body?: never;
-    path?: never;
-    query?: {
-        /**
-         * If omitted, returns status for all integrations
-         */
-        integrationName?: 'confluence' | 'figma' | 'google-docs' | 'google-sheets' | 'google-slides' | 'jira' | 'linear' | 'miro' | 'notion';
+export type EditReplyData = {
+    body: EditReplyInput;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+        replyId: string;
     };
-    url: '/mcp/connections/status';
+    query?: never;
+    url: '/comments/{hostType}/{hostId}/{commentId}/replies/{replyId}';
 };
 
-export type GetConnectionStatusErrors = {
+export type EditReplyErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7961,13 +8174,25 @@ export type GetConnectionStatusErrors = {
     503: ErrorResponse;
 };
 
-export type GetConnectionStatusError = GetConnectionStatusErrors[keyof GetConnectionStatusErrors];
+export type EditReplyError = EditReplyErrors[keyof EditReplyErrors];
 
-export type GetConnectionStatusResponses = {
+export type EditReplyResponses = {
     /**
-     * Active-connection status for the requested integration(s)
+     * Returns the updated reply
      */
-    200: Array<ConnectionStatus>;
+    200: {
+        reply: {
+            replyId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            gitInfo?: CommentGitInfo;
+        };
+    };
 };
 
-export type GetConnectionStatusResponse = GetConnectionStatusResponses[keyof GetConnectionStatusResponses];
+export type EditReplyResponse = EditReplyResponses[keyof EditReplyResponses];