@dazl/api-client 1.0.30 → 1.0.32

package/src/internal/types.gen.ts

@@ -2043,6 +2043,69 @@ export type GetRepoInfoResponses = {
 
 export type GetRepoInfoResponse = GetRepoInfoResponses[keyof GetRepoInfoResponses];
 
+export type GetProjectRepoInfoData = {
+    body?: never;
+    path: {
+        projectId: string;
+        repoId: string;
+    };
+    query?: never;
+    url: '/github/repo/project/{projectId}/{repoId}/info';
+};
+
+export type GetProjectRepoInfoErrors = {
+    /**
+     * 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 GetProjectRepoInfoError = GetProjectRepoInfoErrors[keyof GetProjectRepoInfoErrors];
+
+export type GetProjectRepoInfoResponses = {
+    /**
+     * Returns GitHub info for one of the project's linked repositories
+     */
+    200: {
+        repoFullName: string;
+        token: string | null;
+        id: string;
+        installationId: number | null;
+        createdAt: string;
+        updatedAt: string;
+        dirName: string | null;
+    };
+};
+
+export type GetProjectRepoInfoResponse = GetProjectRepoInfoResponses[keyof GetProjectRepoInfoResponses];
+
 export type CreateRepositoryData = {
     body?: {
         dazlId: string;
@@ -3067,6 +3130,65 @@ export type UpdateProjectResponses = {
 
 export type UpdateProjectResponse = UpdateProjectResponses[keyof UpdateProjectResponses];
 
+export type DownloadProjectData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query: {
+        /**
+         * The dazl ID of the requesting user, used for permission checks
+         */
+        ownerDazlId: string;
+    };
+    url: '/project/{projectId}/download';
+};
+
+export type DownloadProjectErrors = {
+    /**
+     * 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 DownloadProjectError = DownloadProjectErrors[keyof DownloadProjectErrors];
+
+export type DownloadProjectResponses = {
+    /**
+     * Streams the project's latest snapshot as a gzipped tarball
+     */
+    200: Blob | File;
+};
+
+export type DownloadProjectResponse = DownloadProjectResponses[keyof DownloadProjectResponses];
+
 export type MarkProjectAsInitializedData = {
     body: {
         /**
@@ -3184,37 +3306,48 @@ export type GetProjectInitDataResponses = {
      */
     200: {
         projectId: string;
-        gitRepoURL: string;
+        gitRepoURL: string | null;
         gitBranchToClone: string | null;
         gitBranchToCreate: string | null;
-        createdAt: string;
-        updatedAt: string;
+        createdAt: string | null;
+        updatedAt: string | null;
+        repos: Array<{
+            id: string;
+            projectId: string;
+            repoId: string | null;
+            gitRepoURL: string;
+            gitBranchToClone: string | null;
+            gitBranchToCreate: string | null;
+            dirName: string;
+            attemptCount: number;
+            position: number;
+            createdAt: string;
+            updatedAt: string;
+        }>;
     };
 };
 
 export type GetProjectInitDataResponse = GetProjectInitDataResponses[keyof GetProjectInitDataResponses];
 
-export type CreateProjectData = {
+export type MarkRepoAsInitializedData = {
     body: {
-        name: string;
-        userDazlId: string;
-        latestScreenshot?: string | null;
-        originTemplateId?: string | null;
-        createdAt?: string;
-        workspaceId?: string;
-        remoteEnvConfigId?: string | null;
-        projectInitData?: {
-            gitRepoURL: string;
-            gitBranchToClone?: string | null;
-            gitBranchToCreate?: string | null;
-        };
+        /**
+         * The dazl ID of the requesting user, used for permission checks
+         */
+        ownerDazlId: string;
+    };
+    path: {
+        projectId: string;
+        /**
+         * The pending init repo entry that has been cloned
+         */
+        initRepoId: string;
     };
-    path?: never;
     query?: never;
-    url: '/project';
+    url: '/project/{projectId}/project-init-data/{initRepoId}';
 };
 
-export type CreateProjectErrors = {
+export type MarkRepoAsInitializedErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3248,53 +3381,40 @@ export type CreateProjectErrors = {
     503: ErrorResponse;
 };
 
-export type CreateProjectError = CreateProjectErrors[keyof CreateProjectErrors];
+export type MarkRepoAsInitializedError = MarkRepoAsInitializedErrors[keyof MarkRepoAsInitializedErrors];
 
-export type CreateProjectResponses = {
+export type MarkRepoAsInitializedResponses = {
     /**
-     * Returns the created project
+     * Confirms the repo was cloned: the pending entry is removed and its directory recorded on the repo link
      */
     200: {
-        project: ProjectRaw;
+        projectId: string;
+        initRepoId: string;
+        dirName: string;
     };
 };
 
-export type CreateProjectResponse = CreateProjectResponses[keyof CreateProjectResponses];
+export type MarkRepoAsInitializedResponse = MarkRepoAsInitializedResponses[keyof MarkRepoAsInitializedResponses];
 
-export type GetUserProjectsData = {
-    body?: never;
-    path: {
+export type ReportRepoInitFailureData = {
+    body: {
         /**
          * The dazl ID of the requesting user, used for permission checks
          */
         ownerDazlId: string;
     };
-    query?: {
-        /**
-         * Filter projects by workspace ID
-         */
-        workspaceId?: string;
-        /**
-         * Include deployed projects info in the response
-         */
-        withDeploy?: boolean | null;
-        /**
-         * Include project screenshots url in the response
-         */
-        withScreenshot?: boolean | null;
-        /**
-         * filter by origin template when provided
-         */
-        originTemplateId?: string;
+    path: {
+        projectId: string;
         /**
-         * Include associated users metadata in the response
+         * The pending init repo entry whose clone failed
          */
-        withAssociatedUsers?: boolean | null;
+        initRepoId: string;
     };
-    url: '/project/user/{ownerDazlId}';
+    query?: never;
+    url: '/project/{projectId}/project-init-data/{initRepoId}/failure';
 };
 
-export type GetUserProjectsErrors = {
+export type ReportRepoInitFailureErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3328,42 +3448,53 @@ export type GetUserProjectsErrors = {
     503: ErrorResponse;
 };
 
-export type GetUserProjectsError = GetUserProjectsErrors[keyof GetUserProjectsErrors];
+export type ReportRepoInitFailureError = ReportRepoInitFailureErrors[keyof ReportRepoInitFailureErrors];
 
-export type GetUserProjectsResponses = {
+export type ReportRepoInitFailureResponses = {
     /**
-     * Returns the list of projects for the specified user
+     * Records a failed clone attempt; the entry is abandoned once the attempt cap is reached
      */
     200: {
-        projects: Array<ProjectRaw & {
-            deploy: {
-                publishedAt: string;
-                productionURL: string;
-                netlifyDeployId: string;
-            } | null;
-            screenshotUrl: string | null;
-            productName: string | null;
-        }>;
-        users?: Array<UserDisplayInfoResponse>;
+        projectId: string;
+        initRepoId: string;
+        dirName: string;
+        attemptCount: number;
+        maxAttempts: number;
+        /**
+         * True when the attempt cap was reached: the pending entry was removed and will not be retried
+         */
+        abandoned: boolean;
     };
 };
 
-export type GetUserProjectsResponse = GetUserProjectsResponses[keyof GetUserProjectsResponses];
+export type ReportRepoInitFailureResponse = ReportRepoInitFailureResponses[keyof ReportRepoInitFailureResponses];
 
-export type InviteProjectMemberData = {
+export type CreateProjectData = {
     body: {
-        email: string;
-        invitedByDazlId: string;
-        role: 'admin' | 'contributor' | 'viewer';
-    };
-    path: {
-        projectId: string;
+        name: string;
+        userDazlId: string;
+        latestScreenshot?: string | null;
+        originTemplateId?: string | null;
+        createdAt?: string;
+        workspaceId?: string;
+        remoteEnvConfigId?: string | null;
+        projectInitData?: {
+            gitRepoURL: string;
+            gitBranchToClone?: string | null;
+            gitBranchToCreate?: string | null;
+        };
+        projectInitRepos?: Array<{
+            gitRepoURL: string;
+            gitBranchToClone?: string | null;
+            gitBranchToCreate?: string | null;
+        }>;
     };
+    path?: never;
     query?: never;
-    url: '/project/{projectId}/members/invite';
+    url: '/project';
 };
 
-export type InviteProjectMemberErrors = {
+export type CreateProjectErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3397,31 +3528,34 @@ export type InviteProjectMemberErrors = {
     503: ErrorResponse;
 };
 
-export type InviteProjectMemberError = InviteProjectMemberErrors[keyof InviteProjectMemberErrors];
+export type CreateProjectError = CreateProjectErrors[keyof CreateProjectErrors];
 
-export type InviteProjectMemberResponses = {
+export type CreateProjectResponses = {
     /**
-     * Returns the invitation token, or null if user was auto-added to project
+     * Returns the created project
      */
     200: {
-        token: string | null;
+        project: ProjectRaw;
     };
 };
 
-export type InviteProjectMemberResponse = InviteProjectMemberResponses[keyof InviteProjectMemberResponses];
+export type CreateProjectResponse = CreateProjectResponses[keyof CreateProjectResponses];
 
-export type GetProjectCollaboratorsData = {
+export type ListProjectReposData = {
     body?: never;
     path: {
         projectId: string;
     };
     query: {
-        userDazlId: string;
+        /**
+         * The dazl ID of the requesting user, used for permission checks
+         */
+        ownerDazlId: string;
     };
-    url: '/project/{projectId}/collaborators';
+    url: '/project/{projectId}/repos';
 };
 
-export type GetProjectCollaboratorsErrors = {
+export type ListProjectReposErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3455,56 +3589,62 @@ export type GetProjectCollaboratorsErrors = {
     503: ErrorResponse;
 };
 
-export type GetProjectCollaboratorsError = GetProjectCollaboratorsErrors[keyof GetProjectCollaboratorsErrors];
+export type ListProjectReposError = ListProjectReposErrors[keyof ListProjectReposErrors];
 
-export type GetProjectCollaboratorsResponses = {
+export type ListProjectReposResponses = {
     /**
-     * Returns the list of project collaborators: both members and invitations
+     * Returns the project's linked and pending git repositories
      */
     200: {
-        owner: {
+        repos: Array<{
+            repoId: string;
+            repoFullName: string;
+            host: string;
             /**
-             * Dazl ID for the type = "user"
+             * Directory under the project root the repo was cloned into; null for legacy root-layout repos
              */
+            dirName: string | null;
+            hasActiveInstallation: boolean;
+        }>;
+        /**
+         * Repos awaiting their clone by the session container
+         */
+        pending: Array<{
             id: string;
-            email: string;
-            name?: string;
-            picture?: string;
-            role: 'admin' | 'contributor' | 'viewer' | 'owner';
-        } | null;
-        members: Array<{
-            /**
-             * Dazl ID for the type = "user"
-             */
-            id: string;
-            email: string;
-            name?: string;
-            picture?: string;
-            role: 'admin' | 'contributor' | 'viewer' | 'owner';
-        }>;
-        invited: Array<{
-            role: 'admin' | 'contributor' | 'viewer';
-            email?: string;
-            id: string;
+            projectId: string;
+            repoId: string | null;
+            gitRepoURL: string;
+            gitBranchToClone: string | null;
+            gitBranchToCreate: string | null;
+            dirName: string;
+            attemptCount: number;
+            position: number;
+            createdAt: string;
+            updatedAt: string;
         }>;
     };
 };
 
-export type GetProjectCollaboratorsResponse = GetProjectCollaboratorsResponses[keyof GetProjectCollaboratorsResponses];
+export type ListProjectReposResponse = ListProjectReposResponses[keyof ListProjectReposResponses];
 
-export type DeleteProjectMemberData = {
-    body?: never;
+export type AddProjectRepoData = {
+    body: {
+        /**
+         * The dazl ID of the requesting user, used for permission checks
+         */
+        ownerDazlId: string;
+        gitRepoURL: string;
+        gitBranchToClone?: string | null;
+        gitBranchToCreate?: string | null;
+    };
     path: {
         projectId: string;
-        memberId: string;
-    };
-    query: {
-        userDazlId: string;
     };
-    url: '/project/{projectId}/members/{memberId}';
+    query?: never;
+    url: '/project/{projectId}/repos';
 };
 
-export type DeleteProjectMemberErrors = {
+export type AddProjectRepoErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3538,32 +3678,65 @@ export type DeleteProjectMemberErrors = {
     503: ErrorResponse;
 };
 
-export type DeleteProjectMemberError = DeleteProjectMemberErrors[keyof DeleteProjectMemberErrors];
+export type AddProjectRepoError = AddProjectRepoErrors[keyof AddProjectRepoErrors];
 
-export type DeleteProjectMemberResponses = {
+export type AddProjectRepoResponses = {
     /**
-     * Acknowledges that the project member was deleted
+     * Attaches another git repository to the project; it is cloned into its dirName by the running session or on the next session start
      */
     200: {
-        status: 'deleted';
+        repo: {
+            id: string;
+            projectId: string;
+            repoId: string | null;
+            gitRepoURL: string;
+            gitBranchToClone: string | null;
+            gitBranchToCreate: string | null;
+            dirName: string;
+            attemptCount: number;
+            position: number;
+            createdAt: string;
+            updatedAt: string;
+        };
     };
 };
 
-export type DeleteProjectMemberResponse = DeleteProjectMemberResponses[keyof DeleteProjectMemberResponses];
+export type AddProjectRepoResponse = AddProjectRepoResponses[keyof AddProjectRepoResponses];
 
-export type DeleteProjectInvitationData = {
+export type GetUserProjectsData = {
     body?: never;
     path: {
-        projectId: string;
-        invitationId: string;
+        /**
+         * The dazl ID of the requesting user, used for permission checks
+         */
+        ownerDazlId: string;
     };
-    query: {
-        userDazlId: string;
+    query?: {
+        /**
+         * Filter projects by workspace ID
+         */
+        workspaceId?: string;
+        /**
+         * Include deployed projects info in the response
+         */
+        withDeploy?: boolean | null;
+        /**
+         * Include project screenshots url in the response
+         */
+        withScreenshot?: boolean | null;
+        /**
+         * filter by origin template when provided
+         */
+        originTemplateId?: string;
+        /**
+         * Include associated users metadata in the response
+         */
+        withAssociatedUsers?: boolean | null;
     };
-    url: '/project/{projectId}/invitations/{invitationId}';
+    url: '/project/user/{ownerDazlId}';
 };
 
-export type DeleteProjectInvitationErrors = {
+export type GetUserProjectsErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3597,32 +3770,42 @@ export type DeleteProjectInvitationErrors = {
     503: ErrorResponse;
 };
 
-export type DeleteProjectInvitationError = DeleteProjectInvitationErrors[keyof DeleteProjectInvitationErrors];
+export type GetUserProjectsError = GetUserProjectsErrors[keyof GetUserProjectsErrors];
 
-export type DeleteProjectInvitationResponses = {
+export type GetUserProjectsResponses = {
     /**
-     * Acknowledges that the project invitation was deleted
+     * Returns the list of projects for the specified user
      */
     200: {
-        status: 'deleted';
+        projects: Array<ProjectRaw & {
+            deploy: {
+                publishedAt: string;
+                productionURL: string;
+                netlifyDeployId: string;
+            } | null;
+            screenshotUrl: string | null;
+            productName: string | null;
+        }>;
+        users?: Array<UserDisplayInfoResponse>;
     };
 };
 
-export type DeleteProjectInvitationResponse = DeleteProjectInvitationResponses[keyof DeleteProjectInvitationResponses];
+export type GetUserProjectsResponse = GetUserProjectsResponses[keyof GetUserProjectsResponses];
 
-export type InternalDeleteCommentData = {
-    body?: never;
+export type InviteProjectMemberData = {
+    body: {
+        email: string;
+        invitedByDazlId: string;
+        role: 'admin' | 'contributor' | 'viewer';
+    };
     path: {
         projectId: string;
-        commentId: string;
-    };
-    query?: {
-        editorDazlUserId?: string;
     };
-    url: '/project/{projectId}/comments/{commentId}';
+    query?: never;
+    url: '/project/{projectId}/members/invite';
 };
 
-export type InternalDeleteCommentErrors = {
+export type InviteProjectMemberErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3656,30 +3839,31 @@ export type InternalDeleteCommentErrors = {
     503: ErrorResponse;
 };
 
-export type InternalDeleteCommentError = InternalDeleteCommentErrors[keyof InternalDeleteCommentErrors];
+export type InviteProjectMemberError = InviteProjectMemberErrors[keyof InviteProjectMemberErrors];
 
-export type InternalDeleteCommentResponses = {
+export type InviteProjectMemberResponses = {
     /**
-     * Acknowledges that the comment was deleted
+     * Returns the invitation token, or null if user was auto-added to project
      */
     200: {
-        success: true;
+        token: string | null;
     };
 };
 
-export type InternalDeleteCommentResponse = InternalDeleteCommentResponses[keyof InternalDeleteCommentResponses];
+export type InviteProjectMemberResponse = InviteProjectMemberResponses[keyof InviteProjectMemberResponses];
 
-export type InternalGetProjectCommentData = {
+export type GetProjectCollaboratorsData = {
     body?: never;
     path: {
         projectId: string;
-        commentId: string;
     };
-    query?: never;
-    url: '/project/{projectId}/comments/{commentId}';
+    query: {
+        userDazlId: string;
+    };
+    url: '/project/{projectId}/collaborators';
 };
 
-export type InternalGetProjectCommentErrors = {
+export type GetProjectCollaboratorsErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3713,55 +3897,56 @@ export type InternalGetProjectCommentErrors = {
     503: ErrorResponse;
 };
 
-export type InternalGetProjectCommentError = InternalGetProjectCommentErrors[keyof InternalGetProjectCommentErrors];
+export type GetProjectCollaboratorsError = GetProjectCollaboratorsErrors[keyof GetProjectCollaboratorsErrors];
 
-export type InternalGetProjectCommentResponses = {
+export type GetProjectCollaboratorsResponses = {
     /**
-     * Returns comment by id for the project
+     * Returns the list of project collaborators: both members and invitations
      */
     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: 'admin' | 'contributor' | 'viewer' | 'owner';
+        } | null;
+        members: Array<{
+            /**
+             * Dazl ID for the type = "user"
+             */
+            id: string;
+            email: string;
+            name?: string;
+            picture?: string;
+            role: 'admin' | 'contributor' | 'viewer' | 'owner';
+        }>;
+        invited: Array<{
+            role: 'admin' | 'contributor' | 'viewer';
+            email?: string;
+            id: string;
+        }>;
     };
 };
 
-export type InternalGetProjectCommentResponse = InternalGetProjectCommentResponses[keyof InternalGetProjectCommentResponses];
+export type GetProjectCollaboratorsResponse = GetProjectCollaboratorsResponses[keyof GetProjectCollaboratorsResponses];
 
-export type InternalEditCommentData = {
-    body: InternalEditCommentInput;
+export type DeleteProjectMemberData = {
+    body?: never;
     path: {
         projectId: string;
-        commentId: string;
+        memberId: string;
     };
-    query?: never;
-    url: '/project/{projectId}/comments/{commentId}';
+    query: {
+        userDazlId: string;
+    };
+    url: '/project/{projectId}/members/{memberId}';
 };
 
-export type InternalEditCommentErrors = {
+export type DeleteProjectMemberErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3795,54 +3980,32 @@ export type InternalEditCommentErrors = {
     503: ErrorResponse;
 };
 
-export type InternalEditCommentError = InternalEditCommentErrors[keyof InternalEditCommentErrors];
+export type DeleteProjectMemberError = DeleteProjectMemberErrors[keyof DeleteProjectMemberErrors];
 
-export type InternalEditCommentResponses = {
+export type DeleteProjectMemberResponses = {
     /**
-     * Returns the updated comment
+     * Acknowledges that the project member was deleted
      */
     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;
-        };
+        status: 'deleted';
     };
 };
 
-export type InternalEditCommentResponse = InternalEditCommentResponses[keyof InternalEditCommentResponses];
+export type DeleteProjectMemberResponse = DeleteProjectMemberResponses[keyof DeleteProjectMemberResponses];
 
-export type InternalListProjectCommentsData = {
+export type DeleteProjectInvitationData = {
     body?: never;
     path: {
         projectId: string;
+        invitationId: string;
     };
-    query?: never;
-    url: '/project/{projectId}/comments';
+    query: {
+        userDazlId: string;
+    };
+    url: '/project/{projectId}/invitations/{invitationId}';
 };
 
-export type InternalListProjectCommentsErrors = {
+export type DeleteProjectInvitationErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3876,14 +4039,130 @@ export type InternalListProjectCommentsErrors = {
     503: ErrorResponse;
 };
 
-export type InternalListProjectCommentsError = InternalListProjectCommentsErrors[keyof InternalListProjectCommentsErrors];
+export type DeleteProjectInvitationError = DeleteProjectInvitationErrors[keyof DeleteProjectInvitationErrors];
 
-export type InternalListProjectCommentsResponses = {
+export type DeleteProjectInvitationResponses = {
     /**
-     * Returns the list of comments for the project
+     * Acknowledges that the project invitation was deleted
      */
     200: {
-        comments: Array<{
+        status: 'deleted';
+    };
+};
+
+export type DeleteProjectInvitationResponse = DeleteProjectInvitationResponses[keyof DeleteProjectInvitationResponses];
+
+export type InternalDeleteCommentData = {
+    body?: never;
+    path: {
+        projectId: string;
+        commentId: string;
+    };
+    query?: {
+        editorDazlUserId?: string;
+    };
+    url: '/project/{projectId}/comments/{commentId}';
+};
+
+export type InternalDeleteCommentErrors = {
+    /**
+     * 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 InternalDeleteCommentError = InternalDeleteCommentErrors[keyof InternalDeleteCommentErrors];
+
+export type InternalDeleteCommentResponses = {
+    /**
+     * Acknowledges that the comment was deleted
+     */
+    200: {
+        success: true;
+    };
+};
+
+export type InternalDeleteCommentResponse = InternalDeleteCommentResponses[keyof InternalDeleteCommentResponses];
+
+export type InternalGetProjectCommentData = {
+    body?: never;
+    path: {
+        projectId: string;
+        commentId: string;
+    };
+    query?: never;
+    url: '/project/{projectId}/comments/{commentId}';
+};
+
+export type InternalGetProjectCommentErrors = {
+    /**
+     * 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 InternalGetProjectCommentError = InternalGetProjectCommentErrors[keyof InternalGetProjectCommentErrors];
+
+export type InternalGetProjectCommentResponses = {
+    /**
+     * Returns comment by id for the project
+     */
+    200: {
+        comment: {
             commentId: string;
             author: {
                 dazlUserId: string;
@@ -3908,22 +4187,23 @@ export type InternalListProjectCommentsResponses = {
             resolved?: CommentResolved;
             context?: CommentContext;
             gitInfo?: CommentGitInfo;
-        }>;
+        };
     };
 };
 
-export type InternalListProjectCommentsResponse = InternalListProjectCommentsResponses[keyof InternalListProjectCommentsResponses];
+export type InternalGetProjectCommentResponse = InternalGetProjectCommentResponses[keyof InternalGetProjectCommentResponses];
 
-export type InternalCreateCommentData = {
-    body: InternalCreateCommentInput;
+export type InternalEditCommentData = {
+    body: InternalEditCommentInput;
     path: {
         projectId: string;
+        commentId: string;
     };
     query?: never;
-    url: '/project/{projectId}/comments';
+    url: '/project/{projectId}/comments/{commentId}';
 };
 
-export type InternalCreateCommentErrors = {
+export type InternalEditCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -3957,11 +4237,11 @@ export type InternalCreateCommentErrors = {
     503: ErrorResponse;
 };
 
-export type InternalCreateCommentError = InternalCreateCommentErrors[keyof InternalCreateCommentErrors];
+export type InternalEditCommentError = InternalEditCommentErrors[keyof InternalEditCommentErrors];
 
-export type InternalCreateCommentResponses = {
+export type InternalEditCommentResponses = {
     /**
-     * Returns the created comment
+     * Returns the updated comment
      */
     200: {
         comment: {
@@ -3993,21 +4273,18 @@ export type InternalCreateCommentResponses = {
     };
 };
 
-export type InternalCreateCommentResponse = InternalCreateCommentResponses[keyof InternalCreateCommentResponses];
+export type InternalEditCommentResponse = InternalEditCommentResponses[keyof InternalEditCommentResponses];
 
-export type InternalResolveCommentData = {
+export type InternalListProjectCommentsData = {
     body?: never;
     path: {
         projectId: string;
-        commentId: string;
-    };
-    query: {
-        resolvedByDazlUserId: string;
     };
-    url: '/project/{projectId}/comments/{commentId}/resolve';
+    query?: never;
+    url: '/project/{projectId}/comments';
 };
 
-export type InternalResolveCommentErrors = {
+export type InternalListProjectCommentsErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4041,14 +4318,14 @@ export type InternalResolveCommentErrors = {
     503: ErrorResponse;
 };
 
-export type InternalResolveCommentError = InternalResolveCommentErrors[keyof InternalResolveCommentErrors];
+export type InternalListProjectCommentsError = InternalListProjectCommentsErrors[keyof InternalListProjectCommentsErrors];
 
-export type InternalResolveCommentResponses = {
+export type InternalListProjectCommentsResponses = {
     /**
-     * Returns the resolved comment
+     * Returns the list of comments for the project
      */
     200: {
-        comment: {
+        comments: Array<{
             commentId: string;
             author: {
                 dazlUserId: string;
@@ -4073,23 +4350,22 @@ export type InternalResolveCommentResponses = {
             resolved?: CommentResolved;
             context?: CommentContext;
             gitInfo?: CommentGitInfo;
-        };
+        }>;
     };
 };
 
-export type InternalResolveCommentResponse = InternalResolveCommentResponses[keyof InternalResolveCommentResponses];
+export type InternalListProjectCommentsResponse = InternalListProjectCommentsResponses[keyof InternalListProjectCommentsResponses];
 
-export type InternalReopenCommentData = {
-    body?: never;
+export type InternalCreateCommentData = {
+    body: InternalCreateCommentInput;
     path: {
         projectId: string;
-        commentId: string;
     };
     query?: never;
-    url: '/project/{projectId}/comments/{commentId}/reopen';
+    url: '/project/{projectId}/comments';
 };
 
-export type InternalReopenCommentErrors = {
+export type InternalCreateCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4123,11 +4399,11 @@ export type InternalReopenCommentErrors = {
     503: ErrorResponse;
 };
 
-export type InternalReopenCommentError = InternalReopenCommentErrors[keyof InternalReopenCommentErrors];
+export type InternalCreateCommentError = InternalCreateCommentErrors[keyof InternalCreateCommentErrors];
 
-export type InternalReopenCommentResponses = {
+export type InternalCreateCommentResponses = {
     /**
-     * Returns the reopened comment
+     * Returns the created comment
      */
     200: {
         comment: {
@@ -4159,19 +4435,21 @@ export type InternalReopenCommentResponses = {
     };
 };
 
-export type InternalReopenCommentResponse = InternalReopenCommentResponses[keyof InternalReopenCommentResponses];
+export type InternalCreateCommentResponse = InternalCreateCommentResponses[keyof InternalCreateCommentResponses];
 
-export type InternalCreateReplyData = {
-    body: InternalCreateReplyInput;
+export type InternalResolveCommentData = {
+    body?: never;
     path: {
         projectId: string;
         commentId: string;
     };
-    query?: never;
-    url: '/project/{projectId}/comments/{commentId}/replies';
+    query: {
+        resolvedByDazlUserId: string;
+    };
+    url: '/project/{projectId}/comments/{commentId}/resolve';
 };
 
-export type InternalCreateReplyErrors = {
+export type InternalResolveCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4205,15 +4483,15 @@ export type InternalCreateReplyErrors = {
     503: ErrorResponse;
 };
 
-export type InternalCreateReplyError = InternalCreateReplyErrors[keyof InternalCreateReplyErrors];
+export type InternalResolveCommentError = InternalResolveCommentErrors[keyof InternalResolveCommentErrors];
 
-export type InternalCreateReplyResponses = {
+export type InternalResolveCommentResponses = {
     /**
-     * Returns the created reply
+     * Returns the resolved comment
      */
     200: {
-        reply: {
-            replyId: string;
+        comment: {
+            commentId: string;
             author: {
                 dazlUserId: string;
             };
@@ -4221,27 +4499,501 @@ export type InternalCreateReplyResponses = {
             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 InternalCreateReplyResponse = InternalCreateReplyResponses[keyof InternalCreateReplyResponses];
+export type InternalResolveCommentResponse = InternalResolveCommentResponses[keyof InternalResolveCommentResponses];
 
-export type InternalDeleteReplyData = {
+export type InternalReopenCommentData = {
     body?: never;
     path: {
         projectId: string;
         commentId: string;
-        replyId: string;
     };
-    query?: {
-        editorDazlUserId?: string;
+    query?: never;
+    url: '/project/{projectId}/comments/{commentId}/reopen';
+};
+
+export type InternalReopenCommentErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
     };
-    url: '/project/{projectId}/comments/{commentId}/replies/{replyId}';
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type InternalReopenCommentError = InternalReopenCommentErrors[keyof InternalReopenCommentErrors];
+
+export type InternalReopenCommentResponses = {
+    /**
+     * 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 InternalReopenCommentResponse = InternalReopenCommentResponses[keyof InternalReopenCommentResponses];
+
+export type InternalCreateReplyData = {
+    body: InternalCreateReplyInput;
+    path: {
+        projectId: string;
+        commentId: string;
+    };
+    query?: never;
+    url: '/project/{projectId}/comments/{commentId}/replies';
+};
+
+export type InternalCreateReplyErrors = {
+    /**
+     * 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 InternalCreateReplyError = InternalCreateReplyErrors[keyof InternalCreateReplyErrors];
+
+export type InternalCreateReplyResponses = {
+    /**
+     * Returns the created reply
+     */
+    200: {
+        reply: {
+            replyId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            gitInfo?: CommentGitInfo;
+        };
+    };
+};
+
+export type InternalCreateReplyResponse = InternalCreateReplyResponses[keyof InternalCreateReplyResponses];
+
+export type InternalDeleteReplyData = {
+    body?: never;
+    path: {
+        projectId: string;
+        commentId: string;
+        replyId: string;
+    };
+    query?: {
+        editorDazlUserId?: string;
+    };
+    url: '/project/{projectId}/comments/{commentId}/replies/{replyId}';
+};
+
+export type InternalDeleteReplyErrors = {
+    /**
+     * 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 InternalDeleteReplyError = InternalDeleteReplyErrors[keyof InternalDeleteReplyErrors];
+
+export type InternalDeleteReplyResponses = {
+    /**
+     * Acknowledges that the reply was deleted
+     */
+    200: {
+        success: true;
+    };
+};
+
+export type InternalDeleteReplyResponse = InternalDeleteReplyResponses[keyof InternalDeleteReplyResponses];
+
+export type InternalEditReplyData = {
+    body: InternalEditReplyInput;
+    path: {
+        projectId: string;
+        commentId: string;
+        replyId: string;
+    };
+    query?: never;
+    url: '/project/{projectId}/comments/{commentId}/replies/{replyId}';
+};
+
+export type InternalEditReplyErrors = {
+    /**
+     * 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 InternalEditReplyError = InternalEditReplyErrors[keyof InternalEditReplyErrors];
+
+export type InternalEditReplyResponses = {
+    /**
+     * Returns the updated reply
+     */
+    200: {
+        reply: {
+            replyId: string;
+            author: {
+                dazlUserId: string;
+            };
+            content: string;
+            mentions: Array<UserMention>;
+            createdAt: string;
+            updatedAt: string;
+            gitInfo?: CommentGitInfo;
+        };
+    };
+};
+
+export type InternalEditReplyResponse = InternalEditReplyResponses[keyof InternalEditReplyResponses];
+
+export type GetPublicTemplatesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        withScreenshot?: boolean | null;
+    };
+    url: '/template/public-templates';
+};
+
+export type GetPublicTemplatesErrors = {
+    /**
+     * 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 GetPublicTemplatesError = GetPublicTemplatesErrors[keyof GetPublicTemplatesErrors];
+
+export type GetPublicTemplatesResponses = {
+    /**
+     * Returns all public templates. Optionally includes screenshots when `withScreenshot` is true. Templates are ordered by the greatest of createdAt and lastUsedAt in descending order.
+     */
+    200: {
+        templates: Array<{
+            screenshotUrl: string | null;
+            originProjectName: string | null;
+        } & TemplateRaw>;
+    };
+};
+
+export type GetPublicTemplatesResponse = GetPublicTemplatesResponses[keyof GetPublicTemplatesResponses];
+
+export type GetUserTemplatesData = {
+    body?: never;
+    path: {
+        dazlId: string;
+    };
+    query?: {
+        withScreenshot?: boolean | null;
+        withOriginProject?: boolean | null;
+        withAssociatedUsers?: boolean | null;
+    };
+    url: '/template/user/{dazlId}';
+};
+
+export type GetUserTemplatesErrors = {
+    /**
+     * 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 GetUserTemplatesError = GetUserTemplatesErrors[keyof GetUserTemplatesErrors];
+
+export type GetUserTemplatesResponses = {
+    /**
+     * Returns all templates for the specified user. Templates are ordered by the greatest of createdAt and lastUsedAt in descending order.
+     */
+    200: {
+        templates: Array<{
+            screenshotUrl: string | null;
+            originProjectName: string | null;
+        } & TemplateRaw>;
+        users?: Array<UserDisplayInfoResponse>;
+    };
+};
+
+export type GetUserTemplatesResponse = GetUserTemplatesResponses[keyof GetUserTemplatesResponses];
+
+export type DeleteTemplateData = {
+    /**
+     * Owner dazlId of the user attempting to delete the template
+     */
+    body?: {
+        ownerDazlId: string;
+    };
+    path: {
+        templateId: string;
+    };
+    query?: never;
+    url: '/template/{templateId}';
+};
+
+export type DeleteTemplateErrors = {
+    /**
+     * 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 DeleteTemplateError = DeleteTemplateErrors[keyof DeleteTemplateErrors];
+
+export type DeleteTemplateResponses = {
+    /**
+     * Deletes the template with the specified ID.
+     */
+    200: {
+        templateId: string;
+    };
+};
+
+export type DeleteTemplateResponse = DeleteTemplateResponses[keyof DeleteTemplateResponses];
+
+export type GetTemplateData = {
+    body?: never;
+    path: {
+        templateId: string;
+    };
+    query?: {
+        withScreenshot?: boolean | null;
+    };
+    url: '/template/{templateId}';
 };
 
-export type InternalDeleteReplyErrors = {
+export type GetTemplateErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4275,31 +5027,37 @@ export type InternalDeleteReplyErrors = {
     503: ErrorResponse;
 };
 
-export type InternalDeleteReplyError = InternalDeleteReplyErrors[keyof InternalDeleteReplyErrors];
+export type GetTemplateError = GetTemplateErrors[keyof GetTemplateErrors];
 
-export type InternalDeleteReplyResponses = {
+export type GetTemplateResponses = {
     /**
-     * Acknowledges that the reply was deleted
+     * Returns the template with the specified ID.
      */
     200: {
-        success: true;
+        template: TemplateRaw;
     };
 };
 
-export type InternalDeleteReplyResponse = InternalDeleteReplyResponses[keyof InternalDeleteReplyResponses];
+export type GetTemplateResponse = GetTemplateResponses[keyof GetTemplateResponses];
 
-export type InternalEditReplyData = {
-    body: InternalEditReplyInput;
+export type UpdateTemplateData = {
+    body: {
+        description?: string | null;
+        lastUsedAt?: string | null;
+        name?: string;
+        usageCount?: number;
+        isPublic?: boolean;
+        remoteEnvConfigId?: string | null;
+        ownerDazlId?: string;
+    };
     path: {
-        projectId: string;
-        commentId: string;
-        replyId: string;
+        templateId: string;
     };
     query?: never;
-    url: '/project/{projectId}/comments/{commentId}/replies/{replyId}';
+    url: '/template/{templateId}';
 };
 
-export type InternalEditReplyErrors = {
+export type UpdateTemplateErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4333,39 +5091,36 @@ export type InternalEditReplyErrors = {
     503: ErrorResponse;
 };
 
-export type InternalEditReplyError = InternalEditReplyErrors[keyof InternalEditReplyErrors];
+export type UpdateTemplateError = UpdateTemplateErrors[keyof UpdateTemplateErrors];
 
-export type InternalEditReplyResponses = {
+export type UpdateTemplateResponses = {
     /**
-     * Returns the updated reply
+     * Updates the template with the specified ID.
      */
     200: {
-        reply: {
-            replyId: string;
-            author: {
-                dazlUserId: string;
-            };
-            content: string;
-            mentions: Array<UserMention>;
-            createdAt: string;
-            updatedAt: string;
-            gitInfo?: CommentGitInfo;
-        };
+        template: TemplateRaw;
     };
 };
 
-export type InternalEditReplyResponse = InternalEditReplyResponses[keyof InternalEditReplyResponses];
+export type UpdateTemplateResponse = UpdateTemplateResponses[keyof UpdateTemplateResponses];
 
-export type GetPublicTemplatesData = {
-    body?: never;
-    path?: never;
-    query?: {
-        withScreenshot?: boolean | null;
+export type CreateTemplateData = {
+    body: {
+        originProjectId: string;
+        userDazlId: string;
+    } & {
+        preserveChatHistory: boolean;
+        preserveEnvFile: boolean;
+        name: string;
+        description?: string;
+        emails?: Array<string>;
     };
-    url: '/template/public-templates';
+    path?: never;
+    query?: never;
+    url: '/template/create';
 };
 
-export type GetPublicTemplatesErrors = {
+export type CreateTemplateErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4399,36 +5154,32 @@ export type GetPublicTemplatesErrors = {
     503: ErrorResponse;
 };
 
-export type GetPublicTemplatesError = GetPublicTemplatesErrors[keyof GetPublicTemplatesErrors];
+export type CreateTemplateError = CreateTemplateErrors[keyof CreateTemplateErrors];
 
-export type GetPublicTemplatesResponses = {
+export type CreateTemplateResponses = {
     /**
-     * Returns all public templates. Optionally includes screenshots when `withScreenshot` is true. Templates are ordered by the greatest of createdAt and lastUsedAt in descending order.
+     * Creates a new template from the specified project for the specified user.
      */
     200: {
-        templates: Array<{
-            screenshotUrl: string | null;
-            originProjectName: string | null;
-        } & TemplateRaw>;
+        template: TemplateRaw;
     };
 };
 
-export type GetPublicTemplatesResponse = GetPublicTemplatesResponses[keyof GetPublicTemplatesResponses];
+export type CreateTemplateResponse = CreateTemplateResponses[keyof CreateTemplateResponses];
 
-export type GetUserTemplatesData = {
-    body?: never;
-    path: {
-        dazlId: string;
+export type AddTemplateSharedWithData = {
+    body: {
+        email: string;
+        ownerDazlId: string;
     };
-    query?: {
-        withScreenshot?: boolean | null;
-        withOriginProject?: boolean | null;
-        withAssociatedUsers?: boolean | null;
+    path: {
+        templateId: string;
     };
-    url: '/template/user/{dazlId}';
+    query?: never;
+    url: '/template/{templateId}/shared-with';
 };
 
-export type GetUserTemplatesErrors = {
+export type AddTemplateSharedWithErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4462,38 +5213,32 @@ export type GetUserTemplatesErrors = {
     503: ErrorResponse;
 };
 
-export type GetUserTemplatesError = GetUserTemplatesErrors[keyof GetUserTemplatesErrors];
+export type AddTemplateSharedWithError = AddTemplateSharedWithErrors[keyof AddTemplateSharedWithErrors];
 
-export type GetUserTemplatesResponses = {
+export type AddTemplateSharedWithResponses = {
     /**
-     * Returns all templates for the specified user. Templates are ordered by the greatest of createdAt and lastUsedAt in descending order.
+     * Adds a shared-with email to the template.
      */
     200: {
-        templates: Array<{
-            screenshotUrl: string | null;
-            originProjectName: string | null;
-        } & TemplateRaw>;
-        users?: Array<UserDisplayInfoResponse>;
+        template: TemplateRaw;
     };
 };
 
-export type GetUserTemplatesResponse = GetUserTemplatesResponses[keyof GetUserTemplatesResponses];
+export type AddTemplateSharedWithResponse = AddTemplateSharedWithResponses[keyof AddTemplateSharedWithResponses];
 
-export type DeleteTemplateData = {
-    /**
-     * Owner dazlId of the user attempting to delete the template
-     */
-    body?: {
+export type RemoveTemplateSharedWithData = {
+    body: {
         ownerDazlId: string;
     };
     path: {
         templateId: string;
+        email: string;
     };
     query?: never;
-    url: '/template/{templateId}';
+    url: '/template/{templateId}/shared-with/{email}';
 };
 
-export type DeleteTemplateErrors = {
+export type RemoveTemplateSharedWithErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4527,31 +5272,33 @@ export type DeleteTemplateErrors = {
     503: ErrorResponse;
 };
 
-export type DeleteTemplateError = DeleteTemplateErrors[keyof DeleteTemplateErrors];
+export type RemoveTemplateSharedWithError = RemoveTemplateSharedWithErrors[keyof RemoveTemplateSharedWithErrors];
 
-export type DeleteTemplateResponses = {
+export type RemoveTemplateSharedWithResponses = {
     /**
-     * Deletes the template with the specified ID.
+     * Removes a shared-with email from the template.
      */
     200: {
-        templateId: string;
+        template: TemplateRaw;
     };
 };
 
-export type DeleteTemplateResponse = DeleteTemplateResponses[keyof DeleteTemplateResponses];
+export type RemoveTemplateSharedWithResponse = RemoveTemplateSharedWithResponses[keyof RemoveTemplateSharedWithResponses];
 
-export type GetTemplateData = {
-    body?: never;
-    path: {
-        templateId: string;
-    };
-    query?: {
-        withScreenshot?: boolean | null;
+export type CreateChatData = {
+    body: {
+        projectId: string;
+        ownerDazlId: string;
+        type: string;
+        createdByUserId: string;
+        schemaVersion: number;
     };
-    url: '/template/{templateId}';
+    path?: never;
+    query?: never;
+    url: '/chat/create';
 };
 
-export type GetTemplateErrors = {
+export type CreateChatErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4585,37 +5332,46 @@ export type GetTemplateErrors = {
     503: ErrorResponse;
 };
 
-export type GetTemplateError = GetTemplateErrors[keyof GetTemplateErrors];
+export type CreateChatError = CreateChatErrors[keyof CreateChatErrors];
 
-export type GetTemplateResponses = {
+export type CreateChatResponses = {
     /**
-     * Returns the template with the specified ID.
+     * Creates a new chat for the specified project.
      */
     200: {
-        template: TemplateRaw;
+        chat: {
+            id: string;
+            projectId: string;
+            type: string;
+            title: string | null;
+            archived: boolean;
+            createdByUserId: string;
+            schemaVersion: number;
+            createdAt: string;
+            updatedAt: string;
+            pinnedContext?: unknown;
+            agentSession?: unknown;
+            messages: Array<unknown>;
+            oldestSequence: number | null;
+            hasMore: boolean;
+        };
     };
 };
 
-export type GetTemplateResponse = GetTemplateResponses[keyof GetTemplateResponses];
+export type CreateChatResponse = CreateChatResponses[keyof CreateChatResponses];
 
-export type UpdateTemplateData = {
-    body: {
-        description?: string | null;
-        lastUsedAt?: string | null;
-        name?: string;
-        usageCount?: number;
-        isPublic?: boolean;
-        remoteEnvConfigId?: string | null;
-        ownerDazlId?: string;
-    };
+export type ListProjectChatsData = {
+    body?: never;
     path: {
-        templateId: string;
+        projectId: string;
     };
-    query?: never;
-    url: '/template/{templateId}';
+    query: {
+        ownerDazlId: string;
+    };
+    url: '/chat/project/{projectId}';
 };
 
-export type UpdateTemplateErrors = {
+export type ListProjectChatsErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4649,36 +5405,41 @@ export type UpdateTemplateErrors = {
     503: ErrorResponse;
 };
 
-export type UpdateTemplateError = UpdateTemplateErrors[keyof UpdateTemplateErrors];
+export type ListProjectChatsError = ListProjectChatsErrors[keyof ListProjectChatsErrors];
 
-export type UpdateTemplateResponses = {
+export type ListProjectChatsResponses = {
     /**
-     * Updates the template with the specified ID.
+     * Lists non-deleted chats for the project, ordered by updatedAt descending. Does not include messages.
      */
     200: {
-        template: TemplateRaw;
+        chats: Array<{
+            id: string;
+            projectId: string;
+            type: string;
+            title: string | null;
+            archived: boolean;
+            createdByUserId: string;
+            schemaVersion: number;
+            createdAt: string;
+            updatedAt: string;
+        }>;
     };
 };
 
-export type UpdateTemplateResponse = UpdateTemplateResponses[keyof UpdateTemplateResponses];
+export type ListProjectChatsResponse = ListProjectChatsResponses[keyof ListProjectChatsResponses];
 
-export type CreateTemplateData = {
+export type DeleteChatData = {
     body: {
-        originProjectId: string;
-        userDazlId: string;
-    } & {
-        preserveChatHistory: boolean;
-        preserveEnvFile: boolean;
-        name: string;
-        description?: string;
-        emails?: Array<string>;
+        ownerDazlId: string;
+    };
+    path: {
+        chatId: string;
     };
-    path?: never;
     query?: never;
-    url: '/template/create';
+    url: '/chat/{chatId}';
 };
 
-export type CreateTemplateErrors = {
+export type DeleteChatErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4712,32 +5473,33 @@ export type CreateTemplateErrors = {
     503: ErrorResponse;
 };
 
-export type CreateTemplateError = CreateTemplateErrors[keyof CreateTemplateErrors];
+export type DeleteChatError = DeleteChatErrors[keyof DeleteChatErrors];
 
-export type CreateTemplateResponses = {
+export type DeleteChatResponses = {
     /**
-     * Creates a new template from the specified project for the specified user.
+     * Soft-deletes the chat with the specified ID.
      */
     200: {
-        template: TemplateRaw;
+        chatId: string;
     };
 };
 
-export type CreateTemplateResponse = CreateTemplateResponses[keyof CreateTemplateResponses];
+export type DeleteChatResponse = DeleteChatResponses[keyof DeleteChatResponses];
 
-export type AddTemplateSharedWithData = {
-    body: {
-        email: string;
-        ownerDazlId: string;
-    };
+export type GetChatData = {
+    body?: never;
     path: {
-        templateId: string;
+        chatId: string;
     };
-    query?: never;
-    url: '/template/{templateId}/shared-with';
+    query: {
+        ownerDazlId: string;
+        limit?: number;
+        before?: number | null;
+    };
+    url: '/chat/{chatId}';
 };
 
-export type AddTemplateSharedWithErrors = {
+export type GetChatErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4771,32 +5533,55 @@ export type AddTemplateSharedWithErrors = {
     503: ErrorResponse;
 };
 
-export type AddTemplateSharedWithError = AddTemplateSharedWithErrors[keyof AddTemplateSharedWithErrors];
+export type GetChatError = GetChatErrors[keyof GetChatErrors];
 
-export type AddTemplateSharedWithResponses = {
+export type GetChatResponses = {
     /**
-     * Adds a shared-with email to the template.
+     * Returns the chat with a page of its messages. Without `limit`, returns every message. With `limit`, returns the `hasMore` flag and `oldestSequence` cursor — pass `oldestSequence` back as `before` to fetch the previous (older) page.
      */
     200: {
-        template: TemplateRaw;
+        chat: {
+            id: string;
+            projectId: string;
+            type: string;
+            title: string | null;
+            archived: boolean;
+            createdByUserId: string;
+            schemaVersion: number;
+            createdAt: string;
+            updatedAt: string;
+            pinnedContext?: unknown;
+            agentSession?: unknown;
+            messages: Array<unknown>;
+            oldestSequence: number | null;
+            hasMore: boolean;
+        };
     };
 };
 
-export type AddTemplateSharedWithResponse = AddTemplateSharedWithResponses[keyof AddTemplateSharedWithResponses];
+export type GetChatResponse = GetChatResponses[keyof GetChatResponses];
 
-export type RemoveTemplateSharedWithData = {
+export type UpdateChatData = {
     body: {
         ownerDazlId: string;
+        title?: string;
+        archived: boolean;
+        pinnedContext?: unknown;
+        agentSession?: unknown;
+        schemaVersion: number;
+        messages: Array<{
+            id: string;
+            [key: string]: unknown;
+        }>;
     };
     path: {
-        templateId: string;
-        email: string;
+        chatId: string;
     };
     query?: never;
-    url: '/template/{templateId}/shared-with/{email}';
+    url: '/chat/{chatId}';
 };
 
-export type RemoveTemplateSharedWithErrors = {
+export type UpdateChatErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -4830,18 +5615,33 @@ export type RemoveTemplateSharedWithErrors = {
     503: ErrorResponse;
 };
 
-export type RemoveTemplateSharedWithError = RemoveTemplateSharedWithErrors[keyof RemoveTemplateSharedWithErrors];
+export type UpdateChatError = UpdateChatErrors[keyof UpdateChatErrors];
 
-export type RemoveTemplateSharedWithResponses = {
+export type UpdateChatResponses = {
     /**
-     * Removes a shared-with email from the template.
+     * Replaces the chat's metadata and full message list (whole-document semantics, matching the caller's in-memory chat state).
      */
     200: {
-        template: TemplateRaw;
+        chat: {
+            id: string;
+            projectId: string;
+            type: string;
+            title: string | null;
+            archived: boolean;
+            createdByUserId: string;
+            schemaVersion: number;
+            createdAt: string;
+            updatedAt: string;
+            pinnedContext?: unknown;
+            agentSession?: unknown;
+            messages: Array<unknown>;
+            oldestSequence: number | null;
+            hasMore: boolean;
+        };
     };
 };
 
-export type RemoveTemplateSharedWithResponse = RemoveTemplateSharedWithResponses[keyof RemoveTemplateSharedWithResponses];
+export type UpdateChatResponse = UpdateChatResponses[keyof UpdateChatResponses];
 
 export type GetUploadConfigurationData = {
     body: {