@dazl/internal-api-client 1.9.0 → 1.11.0

package/src/types.gen.ts

@@ -113,6 +113,44 @@ export type OwnerDazlId = {
     ownerDazlId: string;
 };
 
+export type UserMention = {
+    dazlUserId: string;
+};
+
+export type CommentResolved = {
+    dazlUserId: string;
+    resolvedAt: string;
+};
+
+export type CommentContext = {
+    type: 'stage';
+    page: string;
+    selection?: string;
+};
+
+export type InternalCreateCommentInput = {
+    content: string;
+    authorDazlUserId: string;
+    mentions?: Array<UserMention>;
+    context?: CommentContext;
+};
+
+export type InternalEditCommentInput = {
+    content: string;
+    mentions?: Array<UserMention>;
+};
+
+export type InternalCreateReplyInput = {
+    content: string;
+    mentions?: Array<UserMention>;
+    authorDazlUserId: string;
+};
+
+export type InternalEditReplyInput = {
+    content: string;
+    mentions?: Array<UserMention>;
+};
+
 export type TemplateRaw = {
     id: string;
     name: string;
@@ -2340,10 +2378,10 @@ export type InviteProjectMemberError = InviteProjectMemberErrors[keyof InvitePro
 
 export type InviteProjectMemberResponses = {
     /**
-     * Returns the invitation token
+     * Returns the invitation token, or null if user was auto-added to project
      */
     200: {
-        token: string;
+        token: string | null;
     };
 };
 
@@ -2406,16 +2444,18 @@ export type AcceptProjectInvitationResponses = {
 
 export type AcceptProjectInvitationResponse = AcceptProjectInvitationResponses[keyof AcceptProjectInvitationResponses];
 
-export type GetPublicTemplatesData = {
+export type GetProjectCollaboratorsData = {
     body?: never;
-    path?: never;
-    query?: {
-        withScreenshot?: boolean | null;
+    path: {
+        projectId: string;
     };
-    url: '/template/public-templates';
+    query: {
+        userDazlId: string;
+    };
+    url: '/project/{projectId}/collaborators';
 };
 
-export type GetPublicTemplatesErrors = {
+export type GetProjectCollaboratorsErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -2449,35 +2489,56 @@ export type GetPublicTemplatesErrors = {
     503: ErrorResponse;
 };
 
-export type GetPublicTemplatesError = GetPublicTemplatesErrors[keyof GetPublicTemplatesErrors];
+export type GetProjectCollaboratorsError = GetProjectCollaboratorsErrors[keyof GetProjectCollaboratorsErrors];
 
-export type GetPublicTemplatesResponses = {
+export type GetProjectCollaboratorsResponses = {
     /**
-     * Returns all public templates. Optionally includes screenshots when `withScreenshot` is true. Templates are ordered by the greatest of createdAt and lastUsedAt in descending order.
+     * Returns the list of project collaborators: both members and invitations
      */
     200: {
-        templates: Array<{
-            screenshotUrl: string | null;
-            originProjectName: string | null;
-        } & TemplateRaw>;
+        owner: {
+            /**
+             * Dazl ID for the type = "user"
+             */
+            id: string;
+            role: 'admin' | 'contributor' | 'viewer' | 'owner';
+            email: string;
+            name?: string;
+            picture?: string;
+        };
+        members: Array<{
+            /**
+             * Dazl ID for the type = "user"
+             */
+            id: string;
+            role: 'admin' | 'contributor' | 'viewer' | 'owner';
+            email: string;
+            name?: string;
+            picture?: string;
+        }>;
+        invited: Array<{
+            role: 'admin' | 'contributor' | 'viewer';
+            email?: string;
+            id: string;
+        }>;
     };
 };
 
-export type GetPublicTemplatesResponse = GetPublicTemplatesResponses[keyof GetPublicTemplatesResponses];
+export type GetProjectCollaboratorsResponse = GetProjectCollaboratorsResponses[keyof GetProjectCollaboratorsResponses];
 
-export type GetUserTemplatesData = {
+export type DeleteProjectMemberData = {
     body?: never;
     path: {
-        dazlId: string;
+        projectId: string;
+        memberId: string;
     };
-    query?: {
-        withScreenshot?: boolean | null;
-        withOriginProject?: boolean | null;
+    query: {
+        userDazlId: string;
     };
-    url: '/template/user/{dazlId}';
+    url: '/project/{projectId}/members/{memberId}';
 };
 
-export type GetUserTemplatesErrors = {
+export type DeleteProjectMemberErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -2511,37 +2572,32 @@ export type GetUserTemplatesErrors = {
     503: ErrorResponse;
 };
 
-export type GetUserTemplatesError = GetUserTemplatesErrors[keyof GetUserTemplatesErrors];
+export type DeleteProjectMemberError = DeleteProjectMemberErrors[keyof DeleteProjectMemberErrors];
 
-export type GetUserTemplatesResponses = {
+export type DeleteProjectMemberResponses = {
     /**
-     * Returns all templates for the specified user. Templates are ordered by the greatest of createdAt and lastUsedAt in descending order.
+     * Acknowledges that the project member was deleted
      */
     200: {
-        templates: Array<{
-            screenshotUrl: string | null;
-            originProjectName: string | null;
-        } & TemplateRaw>;
+        status: 'deleted';
     };
 };
 
-export type GetUserTemplatesResponse = GetUserTemplatesResponses[keyof GetUserTemplatesResponses];
+export type DeleteProjectMemberResponse = DeleteProjectMemberResponses[keyof DeleteProjectMemberResponses];
 
-export type DeleteTemplateData = {
-    /**
-     * Owner dazlId of the user attempting to delete the template
-     */
-    body?: {
-        ownerDazlId: string;
-    };
+export type DeleteProjectInvitationData = {
+    body?: never;
     path: {
-        templateId: string;
+        projectId: string;
+        invitationId: string;
     };
-    query?: never;
-    url: '/template/{templateId}';
+    query: {
+        userDazlId: string;
+    };
+    url: '/project/{projectId}/invitations/{invitationId}';
 };
 
-export type DeleteTemplateErrors = {
+export type DeleteProjectInvitationErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -2575,31 +2631,29 @@ export type DeleteTemplateErrors = {
     503: ErrorResponse;
 };
 
-export type DeleteTemplateError = DeleteTemplateErrors[keyof DeleteTemplateErrors];
+export type DeleteProjectInvitationError = DeleteProjectInvitationErrors[keyof DeleteProjectInvitationErrors];
 
-export type DeleteTemplateResponses = {
+export type DeleteProjectInvitationResponses = {
     /**
-     * Deletes the template with the specified ID.
+     * Acknowledges that the project invitation was deleted
      */
     200: {
-        templateId: string;
+        status: 'deleted';
     };
 };
 
-export type DeleteTemplateResponse = DeleteTemplateResponses[keyof DeleteTemplateResponses];
+export type DeleteProjectInvitationResponse = DeleteProjectInvitationResponses[keyof DeleteProjectInvitationResponses];
 
-export type GetTemplateData = {
+export type InternalListProjectCommentsData = {
     body?: never;
     path: {
-        templateId: string;
-    };
-    query?: {
-        withScreenshot?: boolean | null;
+        projectId: string;
     };
-    url: '/template/{templateId}';
+    query?: never;
+    url: '/project/{projectId}/comments';
 };
 
-export type GetTemplateErrors = {
+export type InternalListProjectCommentsErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -2633,36 +2687,60 @@ export type GetTemplateErrors = {
     503: ErrorResponse;
 };
 
-export type GetTemplateError = GetTemplateErrors[keyof GetTemplateErrors];
+export type InternalListProjectCommentsError = InternalListProjectCommentsErrors[keyof InternalListProjectCommentsErrors];
 
-export type GetTemplateResponses = {
+export type InternalListProjectCommentsResponses = {
     /**
-     * Returns the template with the specified ID.
+     * Returns the list of comments for the project
      */
     200: {
-        template: TemplateRaw;
+        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;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+        }>;
+        /**
+         * Authors and mentions from loaded comments with id, email and picture to render avatars
+         */
+        participants: Array<{
+            userId: string;
+            email: string;
+            picture?: string;
+        }>;
     };
 };
 
-export type GetTemplateResponse = GetTemplateResponses[keyof GetTemplateResponses];
+export type InternalListProjectCommentsResponse = InternalListProjectCommentsResponses[keyof InternalListProjectCommentsResponses];
 
-export type UpdateTemplateData = {
-    body: {
-        description?: string | null;
-        lastUsedAt?: string | null;
-        name?: string;
-        usageCount?: number;
-        isPublic?: boolean;
-        ownerDazlId?: string;
-    };
+export type InternalCreateCommentData = {
+    body: InternalCreateCommentInput;
     path: {
-        templateId: string;
+        projectId: string;
     };
     query?: never;
-    url: '/template/{templateId}';
+    url: '/project/{projectId}/comments';
 };
 
-export type UpdateTemplateErrors = {
+export type InternalCreateCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -2696,35 +2774,53 @@ export type UpdateTemplateErrors = {
     503: ErrorResponse;
 };
 
-export type UpdateTemplateError = UpdateTemplateErrors[keyof UpdateTemplateErrors];
+export type InternalCreateCommentError = InternalCreateCommentErrors[keyof InternalCreateCommentErrors];
 
-export type UpdateTemplateResponses = {
+export type InternalCreateCommentResponses = {
     /**
-     * Updates the template with the specified ID.
+     * Returns the created comment
      */
     200: {
-        template: TemplateRaw;
+        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;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+        };
     };
 };
 
-export type UpdateTemplateResponse = UpdateTemplateResponses[keyof UpdateTemplateResponses];
+export type InternalCreateCommentResponse = InternalCreateCommentResponses[keyof InternalCreateCommentResponses];
 
-export type CreateTemplateData = {
-    body: {
-        originProjectId: string;
-        userDazlId: string;
-    } & {
-        preserveChatHistory: boolean;
-        preserveEnvFile: boolean;
-        name: string;
-        description?: string;
+export type InternalDeleteCommentData = {
+    body?: never;
+    path: {
+        projectId: string;
+        commentId: string;
     };
-    path?: never;
     query?: never;
-    url: '/template/create';
+    url: '/project/{projectId}/comments/{commentId}';
 };
 
-export type CreateTemplateErrors = {
+export type InternalDeleteCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -2758,52 +2854,30 @@ export type CreateTemplateErrors = {
     503: ErrorResponse;
 };
 
-export type CreateTemplateError = CreateTemplateErrors[keyof CreateTemplateErrors];
+export type InternalDeleteCommentError = InternalDeleteCommentErrors[keyof InternalDeleteCommentErrors];
 
-export type CreateTemplateResponses = {
+export type InternalDeleteCommentResponses = {
     /**
-     * Creates a new template from the specified project for the specified user.
+     * Acknowledges that the comment was deleted
      */
     200: {
-        template: TemplateRaw;
+        success: true;
     };
 };
 
-export type CreateTemplateResponse = CreateTemplateResponses[keyof CreateTemplateResponses];
+export type InternalDeleteCommentResponse = InternalDeleteCommentResponses[keyof InternalDeleteCommentResponses];
 
-export type GetUploadConfigurationData = {
-    body: {
-        /**
-         * File path within the project
-         */
-        path: string;
-        /**
-         * Project identifier (optional for account-level uploads)
-         */
-        projectId?: string;
-        /**
-         * MIME type of the file to upload
-         */
-        mimeType?: string;
-        /**
-         * Access control level for the file
-         */
-        acl?: 'public' | 'private';
-        /**
-         * Callback URL to notify after upload completion
-         */
-        callback?: string;
-        /**
-         * Upload protocol to use
-         */
-        protocol?: 'tus';
+export type InternalEditCommentData = {
+    body: InternalEditCommentInput;
+    path: {
+        projectId: string;
+        commentId: string;
     };
-    path?: never;
     query?: never;
-    url: '/media/upload-configuration';
+    url: '/project/{projectId}/comments/{commentId}';
 };
 
-export type GetUploadConfigurationErrors = {
+export type InternalEditCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -2816,17 +2890,13 @@ export type GetUploadConfigurationErrors = {
      */
     401: ErrorResponse;
     /**
-     * Forbidden - Permission denied
+     * Forbidden
      */
-    403: {
-        message: string;
-    };
+    403: ErrorResponse;
     /**
-     * Not found
+     * Not Found
      */
-    404: {
-        message: string;
-    };
+    404: ErrorResponse;
     /**
      * Conflict
      */
@@ -2841,42 +2911,55 @@ export type GetUploadConfigurationErrors = {
     503: ErrorResponse;
 };
 
-export type GetUploadConfigurationError = GetUploadConfigurationErrors[keyof GetUploadConfigurationErrors];
+export type InternalEditCommentError = InternalEditCommentErrors[keyof InternalEditCommentErrors];
 
-export type GetUploadConfigurationResponses = {
+export type InternalEditCommentResponses = {
     /**
-     * Returns presigned upload URL and configuration
+     * Returns the updated comment
      */
-    200: UploadConfiguration;
+    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;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+        };
+    };
 };
 
-export type GetUploadConfigurationResponse = GetUploadConfigurationResponses[keyof GetUploadConfigurationResponses];
+export type InternalEditCommentResponse = InternalEditCommentResponses[keyof InternalEditCommentResponses];
 
-export type ListFilesData = {
+export type InternalResolveCommentData = {
     body?: never;
-    path?: never;
-    query: {
-        /**
-         * Project identifier
-         */
+    path: {
         projectId: string;
-        /**
-         * Filter by MIME type prefix (e.g., 'image/' for all images)
-         */
-        mimeType?: string;
-        /**
-         * Cursor token for fetching the next page of results
-         */
-        cursor?: string;
-        /**
-         * Number of items per page
-         */
-        pageSize?: number;
+        commentId: string;
     };
-    url: '/media/list';
+    query: {
+        resolvedByDazlUserId: string;
+    };
+    url: '/project/{projectId}/comments/{commentId}/resolve';
 };
 
-export type ListFilesErrors = {
+export type InternalResolveCommentErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -2889,17 +2972,13 @@ export type ListFilesErrors = {
      */
     401: ErrorResponse;
     /**
-     * Forbidden - Permission denied
+     * Forbidden
      */
-    403: {
-        message: string;
-    };
+    403: ErrorResponse;
     /**
-     * Not found
+     * Not Found
      */
-    404: {
-        message: string;
-    };
+    404: ErrorResponse;
     /**
      * Conflict
      */
@@ -2914,16 +2993,831 @@ export type ListFilesErrors = {
     503: ErrorResponse;
 };
 
-export type ListFilesError = ListFilesErrors[keyof ListFilesErrors];
+export type InternalResolveCommentError = InternalResolveCommentErrors[keyof InternalResolveCommentErrors];
 
-export type ListFilesResponses = {
+export type InternalResolveCommentResponses = {
     /**
-     * Returns paginated list of files in the project
+     * Returns the resolved comment
      */
-    200: MediaFileList;
+    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;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+        };
+    };
 };
 
-export type ListFilesResponse = ListFilesResponses[keyof ListFilesResponses];
+export type InternalResolveCommentResponse = InternalResolveCommentResponses[keyof InternalResolveCommentResponses];
+
+export type InternalReopenCommentData = {
+    body?: never;
+    path: {
+        projectId: string;
+        commentId: string;
+    };
+    query?: never;
+    url: '/project/{projectId}/comments/{commentId}/reopen';
+};
+
+export type InternalReopenCommentErrors = {
+    /**
+     * 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 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;
+            }>;
+            resolved?: CommentResolved;
+            context?: CommentContext;
+        };
+    };
+};
+
+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;
+        };
+    };
+};
+
+export type InternalCreateReplyResponse = InternalCreateReplyResponses[keyof InternalCreateReplyResponses];
+
+export type InternalDeleteReplyData = {
+    body?: never;
+    path: {
+        projectId: string;
+        commentId: string;
+        replyId: string;
+    };
+    query?: never;
+    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;
+        };
+    };
+};
+
+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;
+    };
+    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>;
+    };
+};
+
+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 GetTemplateErrors = {
+    /**
+     * 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 GetTemplateError = GetTemplateErrors[keyof GetTemplateErrors];
+
+export type GetTemplateResponses = {
+    /**
+     * Returns the template with the specified ID.
+     */
+    200: {
+        template: TemplateRaw;
+    };
+};
+
+export type GetTemplateResponse = GetTemplateResponses[keyof GetTemplateResponses];
+
+export type UpdateTemplateData = {
+    body: {
+        description?: string | null;
+        lastUsedAt?: string | null;
+        name?: string;
+        usageCount?: number;
+        isPublic?: boolean;
+        ownerDazlId?: string;
+    };
+    path: {
+        templateId: string;
+    };
+    query?: never;
+    url: '/template/{templateId}';
+};
+
+export type UpdateTemplateErrors = {
+    /**
+     * 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 UpdateTemplateError = UpdateTemplateErrors[keyof UpdateTemplateErrors];
+
+export type UpdateTemplateResponses = {
+    /**
+     * Updates the template with the specified ID.
+     */
+    200: {
+        template: TemplateRaw;
+    };
+};
+
+export type UpdateTemplateResponse = UpdateTemplateResponses[keyof UpdateTemplateResponses];
+
+export type CreateTemplateData = {
+    body: {
+        originProjectId: string;
+        userDazlId: string;
+    } & {
+        preserveChatHistory: boolean;
+        preserveEnvFile: boolean;
+        name: string;
+        description?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/template/create';
+};
+
+export type CreateTemplateErrors = {
+    /**
+     * 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 CreateTemplateError = CreateTemplateErrors[keyof CreateTemplateErrors];
+
+export type CreateTemplateResponses = {
+    /**
+     * Creates a new template from the specified project for the specified user.
+     */
+    200: {
+        template: TemplateRaw;
+    };
+};
+
+export type CreateTemplateResponse = CreateTemplateResponses[keyof CreateTemplateResponses];
+
+export type GetUploadConfigurationData = {
+    body: {
+        /**
+         * File path within the project
+         */
+        path: string;
+        /**
+         * Project identifier (optional for account-level uploads)
+         */
+        projectId?: string;
+        /**
+         * MIME type of the file to upload
+         */
+        mimeType?: string;
+        /**
+         * Access control level for the file
+         */
+        acl?: 'public' | 'private';
+        /**
+         * Callback URL to notify after upload completion
+         */
+        callback?: string;
+        /**
+         * Upload protocol to use
+         */
+        protocol?: 'tus';
+    };
+    path?: never;
+    query?: never;
+    url: '/media/upload-configuration';
+};
+
+export type GetUploadConfigurationErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden - Permission denied
+     */
+    403: {
+        message: string;
+    };
+    /**
+     * Not found
+     */
+    404: {
+        message: string;
+    };
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type GetUploadConfigurationError = GetUploadConfigurationErrors[keyof GetUploadConfigurationErrors];
+
+export type GetUploadConfigurationResponses = {
+    /**
+     * Returns presigned upload URL and configuration
+     */
+    200: UploadConfiguration;
+};
+
+export type GetUploadConfigurationResponse = GetUploadConfigurationResponses[keyof GetUploadConfigurationResponses];
+
+export type ListFilesData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Project identifier
+         */
+        projectId: string;
+        /**
+         * Filter by MIME type prefix (e.g., 'image/' for all images)
+         */
+        mimeType?: string;
+        /**
+         * Cursor token for fetching the next page of results
+         */
+        cursor?: string;
+        /**
+         * Number of items per page
+         */
+        pageSize?: number;
+    };
+    url: '/media/list';
+};
+
+export type ListFilesErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden - Permission denied
+     */
+    403: {
+        message: string;
+    };
+    /**
+     * Not found
+     */
+    404: {
+        message: string;
+    };
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type ListFilesError = ListFilesErrors[keyof ListFilesErrors];
+
+export type ListFilesResponses = {
+    /**
+     * Returns paginated list of files in the project
+     */
+    200: MediaFileList;
+};
+
+export type ListFilesResponse = ListFilesResponses[keyof ListFilesResponses];
 
 export type CreateMediaData = {
     body: {
@@ -3397,19 +4291,7 @@ export type ScrapePageContentResponses = {
             images?: {
                 [key: string]: unknown;
             } | null;
-            [key: string]: unknown | 'light' | 'dark' | null | string | null | {
-                [key: string]: unknown;
-            } | null | Array<{
-                [key: string]: unknown;
-            }> | null | {
-                [key: string]: unknown;
-            } | null | {
-                [key: string]: unknown;
-            } | null | {
-                [key: string]: unknown;
-            } | null | {
-                [key: string]: unknown;
-            } | null | undefined;
+            [key: string]: unknown;
         };
     };
 };