@dazl/api-client 1.0.14 → 1.0.16

package/src/public/types.gen.ts

@@ -60,6 +60,96 @@ export type ConnectionStatus = {
     isConnected: boolean;
 };
 
+export type UserMention = {
+    dazlUserId: string;
+};
+
+export type CommentGitInfo = {
+    repoFullName?: string;
+    branch?: string;
+    /**
+     * Git commit SHA
+     */
+    commit?: string | string;
+};
+
+export type CommentResolved = {
+    dazlUserId: string;
+    resolvedAt: string;
+};
+
+export type CommentContext = ({
+    type: 'page';
+} & PageCommentContext) | ({
+    type: 'stage';
+} & StageCommentContext) | ({
+    type: 'plan';
+} & PlanCommentContext) | ({
+    type: 'file';
+} & FileCommentContext);
+
+export type PageCommentContext = {
+    type: 'page';
+    pagePath: string;
+};
+
+export type StageCommentContext = {
+    type: 'stage';
+    pagePath: string;
+    anchor: {
+        targetSelectors?: Array<{
+            tagName?: string;
+            classes?: Array<string>;
+            attributes?: {
+                [key: string]: string;
+            };
+            nthChild?: number;
+        }>;
+        ancestors?: Array<{
+            tagName?: string;
+            classes?: Array<string>;
+            attributes?: {
+                [key: string]: string;
+            };
+            nthChild?: number;
+        }>;
+        text?: string;
+    };
+};
+
+export type PlanCommentContext = {
+    type: 'plan';
+};
+
+export type FileCommentContext = {
+    type: 'file';
+    filePath: string;
+    anchor?: string;
+};
+
+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;
@@ -346,7 +436,12 @@ export type CreateWorkspaceResponse = CreateWorkspaceResponses[keyof CreateWorks
 export type GetAllWorkspacesData = {
     body?: never;
     path?: never;
-    query?: never;
+    query?: {
+        /**
+         * Whether to include the members of each workspace
+         */
+        withMembers?: boolean;
+    };
     url: '/workspace/list-my';
 };
 
@@ -388,15 +483,292 @@ export type GetAllWorkspacesError = GetAllWorkspacesErrors[keyof GetAllWorkspace
 
 export type GetAllWorkspacesResponses = {
     /**
-     * Returns the list of workspaces for the current user
+     * Returns the list of workspaces that the user is a member of
      */
     200: {
-        workspaces: Array<Workspace>;
+        workspaces: Array<{
+            id: string;
+            name: string;
+            /**
+             * The user which created the workspace. Null if the user was deleted.
+             */
+            dazlUserId: string | null;
+            createdAt: string;
+            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';
+            }>;
+        }>;
     };
 };
 
 export type GetAllWorkspacesResponse = GetAllWorkspacesResponses[keyof GetAllWorkspacesResponses];
 
+export type InviteWorkspaceMemberData = {
+    body: {
+        email: string;
+        role: 'workspace_member';
+    };
+    path: {
+        workspaceId: string;
+    };
+    query?: never;
+    url: '/workspace/{workspaceId}/members/invite';
+};
+
+export type InviteWorkspaceMemberErrors = {
+    /**
+     * 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 InviteWorkspaceMemberError = InviteWorkspaceMemberErrors[keyof InviteWorkspaceMemberErrors];
+
+export type InviteWorkspaceMemberResponses = {
+    /**
+     * Returns the invitation token, or null if user was auto-added to workspace
+     */
+    200: {
+        token: string | null;
+    };
+};
+
+export type InviteWorkspaceMemberResponse = InviteWorkspaceMemberResponses[keyof InviteWorkspaceMemberResponses];
+
+export type GetWorkspaceMembersData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+    };
+    query?: never;
+    url: '/workspace/{workspaceId}/all-members';
+};
+
+export type GetWorkspaceMembersErrors = {
+    /**
+     * 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 GetWorkspaceMembersError = GetWorkspaceMembersErrors[keyof GetWorkspaceMembersErrors];
+
+export type GetWorkspaceMembersResponses = {
+    /**
+     * Returns the list of workspace collaborators: members and owner
+     */
+    200: {
+        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 GetWorkspaceMembersResponse = GetWorkspaceMembersResponses[keyof GetWorkspaceMembersResponses];
+
+export type DeleteWorkspaceMemberData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        memberId: string;
+    };
+    query?: never;
+    url: '/workspace/{workspaceId}/members/{memberId}';
+};
+
+export type DeleteWorkspaceMemberErrors = {
+    /**
+     * 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 DeleteWorkspaceMemberError = DeleteWorkspaceMemberErrors[keyof DeleteWorkspaceMemberErrors];
+
+export type DeleteWorkspaceMemberResponses = {
+    /**
+     * Acknowledges that the workspace member was deleted
+     */
+    200: {
+        status: 'deleted';
+    };
+};
+
+export type DeleteWorkspaceMemberResponse = DeleteWorkspaceMemberResponses[keyof DeleteWorkspaceMemberResponses];
+
+export type DeleteWorkspaceInvitationData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        invitationId: string;
+    };
+    query?: never;
+    url: '/workspace/{workspaceId}/invitations/{invitationId}';
+};
+
+export type DeleteWorkspaceInvitationErrors = {
+    /**
+     * 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 DeleteWorkspaceInvitationError = DeleteWorkspaceInvitationErrors[keyof DeleteWorkspaceInvitationErrors];
+
+export type DeleteWorkspaceInvitationResponses = {
+    /**
+     * Acknowledges that the workspace invitation was deleted
+     */
+    200: {
+        status: 'deleted';
+    };
+};
+
+export type DeleteWorkspaceInvitationResponse = DeleteWorkspaceInvitationResponses[keyof DeleteWorkspaceInvitationResponses];
+
 export type GetMyValuesData = {
     body?: never;
     path?: never;
@@ -996,6 +1368,756 @@ export type GetConnectionStatusResponses = {
 
 export type GetConnectionStatusResponse = GetConnectionStatusResponses[keyof GetConnectionStatusResponses];
 
+export type DeleteCommentData = {
+    body?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+    };
+    query?: never;
+    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 CreateCommentErrors = {
+    /**
+     * 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 CreateCommentError = CreateCommentErrors[keyof CreateCommentErrors];
+
+export type CreateCommentResponses = {
+    /**
+     * Returns the created 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 CreateCommentResponse = CreateCommentResponses[keyof CreateCommentResponses];
+
+export type ResolveCommentData = {
+    body?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}/{commentId}/resolve';
+};
+
+export type ResolveCommentErrors = {
+    /**
+     * 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 ResolveCommentError = ResolveCommentErrors[keyof ResolveCommentErrors];
+
+export type ResolveCommentResponses = {
+    /**
+     * Returns the resolved 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 ResolveCommentResponse = ResolveCommentResponses[keyof ResolveCommentResponses];
+
+export type ReopenCommentData = {
+    body?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}/{commentId}/reopen';
+};
+
+export type ReopenCommentErrors = {
+    /**
+     * 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 ReopenCommentError = ReopenCommentErrors[keyof ReopenCommentErrors];
+
+export type ReopenCommentResponses = {
+    /**
+     * Returns the reopened 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 ReopenCommentResponse = ReopenCommentResponses[keyof ReopenCommentResponses];
+
+export type CreateReplyData = {
+    body: CreateReplyInput;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}/{commentId}/replies';
+};
+
+export type CreateReplyErrors = {
+    /**
+     * 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 CreateReplyError = CreateReplyErrors[keyof CreateReplyErrors];
+
+export type CreateReplyResponses = {
+    /**
+     * Returns the created reply
+     */
+    200: {
+        reply: {
+            replyId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            gitInfo?: CommentGitInfo;
+        };
+    };
+};
+
+export type CreateReplyResponse = CreateReplyResponses[keyof CreateReplyResponses];
+
+export type DeleteReplyData = {
+    body?: never;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+        replyId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}/{commentId}/replies/{replyId}';
+};
+
+export type DeleteReplyErrors = {
+    /**
+     * 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 DeleteReplyError = DeleteReplyErrors[keyof DeleteReplyErrors];
+
+export type DeleteReplyResponses = {
+    /**
+     * Acknowledges that the reply was deleted
+     */
+    200: {
+        success: true;
+    };
+};
+
+export type DeleteReplyResponse = DeleteReplyResponses[keyof DeleteReplyResponses];
+
+export type EditReplyData = {
+    body: EditReplyInput;
+    path: {
+        hostType: 'project' | 'workspace';
+        hostId: string;
+        commentId: string;
+        replyId: string;
+    };
+    query?: never;
+    url: '/comments/{hostType}/{hostId}/{commentId}/replies/{replyId}';
+};
+
+export type EditReplyErrors = {
+    /**
+     * 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 EditReplyError = EditReplyErrors[keyof EditReplyErrors];
+
+export type EditReplyResponses = {
+    /**
+     * Returns the updated reply
+     */
+    200: {
+        reply: {
+            replyId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            gitInfo?: CommentGitInfo;
+        };
+    };
+};
+
+export type EditReplyResponse = EditReplyResponses[keyof EditReplyResponses];
+
 export type GetPingData = {
     body?: never;
     path?: never;