@teardown/schemas 0.1.21 → 0.1.23

package/package.json

@@ -1,101 +1,98 @@
 {
 	"name": "@teardown/schemas",
-	"version": "0.1.21",
+	"version": "0.1.23",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
 	},
 	"type": "module",
 	"files": [
-		"dist/**/*"
+		"src/**/*"
 	],
-	"main": "./dist/index.js",
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts",
+	"main": "./src/index.ts",
+	"module": "./src/index.ts",
+	"types": "./src/index.ts",
 	"exports": {
 		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js",
-			"default": "./dist/index.js"
+			"types": "./src/index.ts",
+			"import": "./src/index.ts",
+			"default": "./src/index.ts"
 		},
 		"./common": {
-			"types": "./dist/common/index.d.ts",
-			"import": "./dist/common/index.js",
-			"default": "./dist/common/index.js"
+			"types": "./src/common/index.ts",
+			"import": "./src/common/index.ts",
+			"default": "./src/common/index.ts"
 		},
 		"./devices": {
-			"types": "./dist/modules/devices/index.d.ts",
-			"import": "./dist/modules/devices/index.js",
-			"default": "./dist/modules/devices/index.js"
+			"types": "./src/modules/devices/index.ts",
+			"import": "./src/modules/devices/index.ts",
+			"default": "./src/modules/devices/index.ts"
 		},
 		"./environment": {
-			"types": "./dist/modules/environment/index.d.ts",
-			"import": "./dist/modules/environment/index.js",
-			"default": "./dist/modules/environment/index.js"
+			"types": "./src/modules/environment/index.ts",
+			"import": "./src/modules/environment/index.ts",
+			"default": "./src/modules/environment/index.ts"
 		},
 		"./identify": {
-			"types": "./dist/modules/identify/index.d.ts",
-			"import": "./dist/modules/identify/index.js",
-			"default": "./dist/modules/identify/index.js"
+			"types": "./src/modules/identify/index.ts",
+			"import": "./src/modules/identify/index.ts",
+			"default": "./src/modules/identify/index.ts"
 		},
 		"./me": {
-			"types": "./dist/modules/me/index.d.ts",
-			"import": "./dist/modules/me/index.js",
-			"default": "./dist/modules/me/index.js"
+			"types": "./src/modules/me/index.ts",
+			"import": "./src/modules/me/index.ts",
+			"default": "./src/modules/me/index.ts"
 		},
 		"./orgs": {
-			"types": "./dist/modules/orgs/index.d.ts",
-			"import": "./dist/modules/orgs/index.js",
-			"default": "./dist/modules/orgs/index.js"
+			"types": "./src/modules/orgs/index.ts",
+			"import": "./src/modules/orgs/index.ts",
+			"default": "./src/modules/orgs/index.ts"
 		},
 		"./personas": {
-			"types": "./dist/modules/personas/index.d.ts",
-			"import": "./dist/modules/personas/index.js",
-			"default": "./dist/modules/personas/index.js"
+			"types": "./src/modules/personas/index.ts",
+			"import": "./src/modules/personas/index.ts",
+			"default": "./src/modules/personas/index.ts"
 		},
 		"./projects": {
-			"types": "./dist/modules/projects/index.d.ts",
-			"import": "./dist/modules/projects/index.js",
-			"default": "./dist/modules/projects/index.js"
+			"types": "./src/modules/projects/index.ts",
+			"import": "./src/modules/projects/index.ts",
+			"default": "./src/modules/projects/index.ts"
 		},
 		"./sessions": {
-			"types": "./dist/modules/sessions/index.d.ts",
-			"import": "./dist/modules/sessions/index.js",
-			"default": "./dist/modules/sessions/index.js"
+			"types": "./src/modules/sessions/index.ts",
+			"import": "./src/modules/sessions/index.ts",
+			"default": "./src/modules/sessions/index.ts"
 		},
 		"./versions": {
-			"types": "./dist/modules/versions/index.d.ts",
-			"import": "./dist/modules/versions/index.js",
-			"default": "./dist/modules/versions/index.js"
+			"types": "./src/modules/versions/index.ts",
+			"import": "./src/modules/versions/index.ts",
+			"default": "./src/modules/versions/index.ts"
 		},
 		"./builds": {
-			"types": "./dist/modules/builds/index.d.ts",
-			"import": "./dist/modules/builds/index.js",
-			"default": "./dist/modules/builds/index.js"
+			"types": "./src/modules/builds/index.ts",
+			"import": "./src/modules/builds/index.ts",
+			"default": "./src/modules/builds/index.ts"
 		},
 		"./analytics": {
-			"types": "./dist/modules/analytics/index.d.ts",
-			"import": "./dist/modules/analytics/index.js",
-			"default": "./dist/modules/analytics/index.js"
+			"types": "./src/modules/analytics/index.ts",
+			"import": "./src/modules/analytics/index.ts",
+			"default": "./src/modules/analytics/index.ts"
 		},
 		"./events": {
-			"types": "./dist/modules/events/index.d.ts",
-			"import": "./dist/modules/events/index.js",
-			"default": "./dist/modules/events/index.js"
+			"types": "./src/modules/events/index.ts",
+			"import": "./src/modules/events/index.ts",
+			"default": "./src/modules/events/index.ts"
 		}
 	},
 	"scripts": {
-		"dev": "tsc --project ./tsconfig.json --watch",
-		"build": "tsc --project ./tsconfig.json",
 		"typecheck": "tsc --noEmit --project ./tsconfig.json",
 		"lint": "bun x biome lint .",
 		"fmt": "bun x biome format --write .",
-		"check": "bun x biome check .",
-		"prepublishOnly": "bun x turbo run build"
+		"check": "bun x biome check ."
 	},
 	"dependencies": {
 		"@sinclair/typebox": "^0.34.41",
-		"@teardown/types": "0.1.21"
+		"@teardown/types": "0.1.23"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.3.7",

package/src/common/primitives.ts

@@ -0,0 +1,21 @@
+import { type Static, Type } from "@sinclair/typebox";
+
+export const UUIDSchema = Type.String({ format: "uuid", error: "Invalid UUID" });
+export const SlugSchema = Type.String({ pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$", error: "Invalid slug" });
+
+export const URLSchema = Type.String({ format: "uri", error: "Invalid URL" });
+export const TimestampSchema = Type.String({ format: "date-time", error: "Invalid timestamp" });
+
+export type UUID = Static<typeof UUIDSchema>;
+export type Slug = Static<typeof SlugSchema>;
+export type URL = Static<typeof URLSchema>;
+export type Timestamp = Static<typeof TimestampSchema>;
+
+export const EmailSchema = Type.Transform(
+	Type.Optional(
+		Type.Union([Type.String({ format: "email", error: "Invalid email address" }), Type.Literal(""), Type.Undefined()])
+	)
+)
+	.Decode((value) => (value === "" ? undefined : value))
+	.Encode((value) => value ?? "");
+export type Email = Static<typeof EmailSchema>;

package/src/common/responses.ts

@@ -0,0 +1,25 @@
+import { type Static, type TSchema, Type } from "@sinclair/typebox";
+
+export const SuccessResponseSchema = <T extends TSchema>(dataSchema: T) =>
+	Type.Object({
+		success: Type.Literal(true),
+		data: dataSchema,
+	});
+
+export const ErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: Type.Object({
+		message: Type.String(),
+		code: Type.Optional(Type.String()),
+	}),
+});
+
+export type SuccessResponse<T> = {
+	success: true;
+	data: T;
+};
+
+export type ErrorResponse = Static<typeof ErrorResponseSchema>;
+
+export const RequestResponseSchema = <Success extends TSchema>(successSchema: Success) =>
+	Type.Union([SuccessResponseSchema(successSchema), ErrorResponseSchema]);

package/{dist/common/type-checks.d.ts → src/common/type-checks.ts}

@@ -1,4 +1,5 @@
 import type { Insert, Tables, Update } from "@teardown/types";
+
 /**
  * Forces TypeScript to error if T is not `true`.
  * Wrap assertion types with this to ensure compile-time validation.
@@ -9,6 +10,7 @@ import type { Insert, Tables, Update } from "@teardown/types";
  * ```
  */
 export type AssertTrue<T extends true> = T;
+
 /**
  * Type-level assertion that ensures SchemaType is compatible with DbType.
  * This will cause a TypeScript error if SchemaType cannot be assigned to DbType.
@@ -18,7 +20,12 @@ export type AssertTrue<T extends true> = T;
  * type _Check = AssertTrue<AssertCompatible<Project, Tables<"projects">["Row"]>>;
  * ```
  */
-export type AssertCompatible<SchemaType, DbType> = SchemaType extends DbType ? DbType extends SchemaType ? true : never : never;
+export type AssertCompatible<SchemaType, DbType> = SchemaType extends DbType
+	? DbType extends SchemaType
+		? true
+		: never
+	: never;
+
 /**
  * Type-level assertion that ensures SchemaType can be assigned to DbType.
  * This is less strict than AssertCompatible - it only checks one-way assignment.
@@ -29,6 +36,7 @@ export type AssertCompatible<SchemaType, DbType> = SchemaType extends DbType ? D
  * ```
  */
 export type AssertAssignable<SchemaType, DbType> = SchemaType extends DbType ? true : never;
+
 /**
  * Helper to check if a schema type is compatible with a database Row type
  *
@@ -37,7 +45,11 @@ export type AssertAssignable<SchemaType, DbType> = SchemaType extends DbType ? t
  * export type _CheckProjectRow = AssertSchemaCompatibleWithRow<Project, "projects">;
  * ```
  */
-export type AssertSchemaCompatibleWithRow<SchemaType, TableName extends keyof Tables> = AssertCompatible<SchemaType, Tables[TableName]["Row"]>;
+export type AssertSchemaCompatibleWithRow<SchemaType, TableName extends keyof Tables> = AssertCompatible<
+	SchemaType,
+	Tables[TableName]["Row"]
+>;
+
 /**
  * Helper to check if a create schema type is compatible with a database Insert type
  *
@@ -46,7 +58,11 @@ export type AssertSchemaCompatibleWithRow<SchemaType, TableName extends keyof Ta
  * type _CheckCreateProject = AssertSchemaCompatibleWithInsert<CreateProject, "projects">;
  * ```
  */
-export type AssertSchemaCompatibleWithInsert<SchemaType, TableName extends keyof Tables> = AssertAssignable<SchemaType, Insert<TableName>>;
+export type AssertSchemaCompatibleWithInsert<SchemaType, TableName extends keyof Tables> = AssertAssignable<
+	SchemaType,
+	Insert<TableName>
+>;
+
 /**
  * Helper to check if an update schema type is compatible with a database Update type
  *
@@ -55,4 +71,7 @@ export type AssertSchemaCompatibleWithInsert<SchemaType, TableName extends keyof
  * type _CheckUpdateProject = AssertSchemaCompatibleWithUpdate<UpdateProject, "projects">;
  * ```
  */
-export type AssertSchemaCompatibleWithUpdate<SchemaType, TableName extends keyof Tables> = AssertAssignable<SchemaType, Update<TableName>>;
+export type AssertSchemaCompatibleWithUpdate<SchemaType, TableName extends keyof Tables> = AssertAssignable<
+	SchemaType,
+	Update<TableName>
+>;

package/{dist/index.js → src/index.ts}

@@ -1,4 +1,5 @@
 // Module schemas
+
 export * from "./common";
 export * from "./modules/analytics";
 export * from "./modules/builds";

package/src/modules/analytics/schemas.ts

@@ -0,0 +1,178 @@
+import { type Static, Type } from "@sinclair/typebox";
+
+/**
+ * Version adoption schema
+ */
+export const VersionAdoptionPointSchema = Type.Object({
+	date: Type.String(), // YYYY-MM-DD
+	versions: Type.Record(Type.String(), Type.Number()), // version -> count
+});
+export type VersionAdoptionPoint = Static<typeof VersionAdoptionPointSchema>;
+
+export const VersionAdoptionResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: Type.Array(VersionAdoptionPointSchema),
+});
+export type VersionAdoptionResponse = Static<typeof VersionAdoptionResponseSchema>;
+
+/**
+ * Active sessions trend schema
+ */
+export const ActiveSessionsPointSchema = Type.Object({
+	date: Type.String(), // YYYY-MM-DD
+	count: Type.Integer({ minimum: 0 }),
+});
+export type ActiveSessionsPoint = Static<typeof ActiveSessionsPointSchema>;
+
+export const ActiveSessionsTrendResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: Type.Array(ActiveSessionsPointSchema),
+});
+export type ActiveSessionsTrendResponse = Static<typeof ActiveSessionsTrendResponseSchema>;
+
+/**
+ * Active users schema (with platform breakdown)
+ */
+export const ActiveUsersSchema = Type.Object({
+	total: Type.Integer({ minimum: 0 }),
+	ios: Type.Integer({ minimum: 0 }),
+	android: Type.Integer({ minimum: 0 }),
+	trend: Type.Number(), // percentage change vs previous period
+});
+export type ActiveUsers = Static<typeof ActiveUsersSchema>;
+
+export const ActiveUsersResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: ActiveUsersSchema,
+});
+export type ActiveUsersResponse = Static<typeof ActiveUsersResponseSchema>;
+
+/**
+ * Active users query params schema
+ */
+export const ActiveUsersQuerySchema = Type.Object({
+	start_date: Type.String({ format: "date-time" }),
+	end_date: Type.String({ format: "date-time" }),
+});
+export type ActiveUsersQuery = Static<typeof ActiveUsersQuerySchema>;
+
+/**
+ * Build adoption schema (with platform breakdown)
+ */
+export const BuildStatsSchema = Type.Object({
+	total: Type.Integer({ minimum: 0 }),
+	ios: Type.Integer({ minimum: 0 }),
+	android: Type.Integer({ minimum: 0 }),
+});
+export type BuildStats = Static<typeof BuildStatsSchema>;
+
+export const BuildAdoptionPointSchema = Type.Object({
+	date: Type.String(), // YYYY-MM-DD
+	builds: Type.Record(Type.String(), BuildStatsSchema), // build_number -> stats
+});
+export type BuildAdoptionPoint = Static<typeof BuildAdoptionPointSchema>;
+
+export const BuildAdoptionResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: Type.Array(BuildAdoptionPointSchema),
+});
+export type BuildAdoptionResponse = Static<typeof BuildAdoptionResponseSchema>;
+
+/**
+ * Date range query params schema (shared)
+ */
+export const DateRangeQuerySchema = Type.Object({
+	start_date: Type.String({ format: "date-time" }),
+	end_date: Type.String({ format: "date-time" }),
+});
+export type DateRangeQuery = Static<typeof DateRangeQuerySchema>;
+
+/**
+ * Active versions/builds query params schema (with optional search)
+ */
+export const ActiveVersionsQuerySchema = Type.Object({
+	start_date: Type.String({ format: "date-time" }),
+	end_date: Type.String({ format: "date-time" }),
+	search: Type.Optional(Type.String()),
+});
+export type ActiveVersionsQuery = Static<typeof ActiveVersionsQuerySchema>;
+
+/**
+ * Active versions & builds analytics schema
+ * Aggregated session counts by version and build for a date range
+ */
+export const ActiveBuildStatsSchema = Type.Object({
+	build_id: Type.String(),
+	build_number: Type.Integer({ minimum: 0 }),
+	platform: Type.Union([Type.Literal("IOS"), Type.Literal("ANDROID")]),
+	session_count: Type.Integer({ minimum: 0 }),
+	device_count: Type.Integer({ minimum: 0 }),
+});
+export type ActiveBuildStats = Static<typeof ActiveBuildStatsSchema>;
+
+export const ActiveVersionStatsSchema = Type.Object({
+	version_id: Type.String(),
+	version_name: Type.String(),
+	session_count: Type.Integer({ minimum: 0 }),
+	device_count: Type.Integer({ minimum: 0 }),
+	ios_count: Type.Integer({ minimum: 0 }),
+	android_count: Type.Integer({ minimum: 0 }),
+	builds: Type.Array(ActiveBuildStatsSchema),
+});
+export type ActiveVersionStats = Static<typeof ActiveVersionStatsSchema>;
+
+export const ActiveVersionsBuildsSchema = Type.Object({
+	versions: Type.Array(ActiveVersionStatsSchema),
+});
+export type ActiveVersionsBuilds = Static<typeof ActiveVersionsBuildsSchema>;
+
+export const ActiveVersionsBuildsResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: ActiveVersionsBuildsSchema,
+});
+export type ActiveVersionsBuildsResponse = Static<typeof ActiveVersionsBuildsResponseSchema>;
+
+/**
+ * Session with user/device data for build sessions endpoint
+ */
+export const SessionDeviceSchema = Type.Object({
+	id: Type.String(),
+	device_name: Type.Union([Type.String(), Type.Null()]),
+	device_brand: Type.Union([Type.String(), Type.Null()]),
+});
+export type SessionDevice = Static<typeof SessionDeviceSchema>;
+
+export const SessionUserSchema = Type.Object({
+	id: Type.String(),
+	user_id: Type.Union([Type.String(), Type.Null()]),
+	email: Type.Union([Type.String(), Type.Null()]),
+	name: Type.Union([Type.String(), Type.Null()]),
+});
+export type SessionUser = Static<typeof SessionUserSchema>;
+
+export const SessionWithUserSchema = Type.Object({
+	id: Type.String(),
+	started_at: Type.String(),
+	os_version: Type.Union([Type.String(), Type.Null()]),
+	device: SessionDeviceSchema,
+	user: Type.Union([SessionUserSchema, Type.Null()]),
+});
+export type SessionWithUser = Static<typeof SessionWithUserSchema>;
+
+export const BuildSessionsQuerySchema = Type.Object({
+	start_date: Type.String({ format: "date-time" }),
+	end_date: Type.String({ format: "date-time" }),
+	cursor: Type.Optional(Type.String()),
+	limit: Type.Optional(Type.String({ default: "20" })),
+	search: Type.Optional(Type.String()),
+});
+export type BuildSessionsQuery = Static<typeof BuildSessionsQuerySchema>;
+
+export const BuildSessionsResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: Type.Object({
+		sessions: Type.Array(SessionWithUserSchema),
+		next_cursor: Type.Union([Type.String(), Type.Null()]),
+	}),
+});
+export type BuildSessionsResponse = Static<typeof BuildSessionsResponseSchema>;

package/src/modules/builds/schemas.ts

@@ -0,0 +1,171 @@
+import { VersionBuildStatusEnum } from "@teardown/types";
+import { type Static, Type } from "@sinclair/typebox";
+import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
+import { DevicePlatformSchema } from "../devices/schemas";
+
+/**
+ * Build status enum matching database (reuses VersionBuildStatusEnum)
+ */
+export const BuildStatusSchema = Type.Enum(VersionBuildStatusEnum);
+export type BuildStatus = Static<typeof BuildStatusSchema>;
+
+/**
+ * Base build schema
+ * Represents version_builds table structure
+ */
+export const BuildSchema = Type.Object({
+	id: Type.String({ format: "uuid" }),
+	version_id: Type.String({ format: "uuid" }),
+	build_number: Type.Integer({ minimum: 0 }),
+	name: Type.Union([Type.String(), Type.Null()]),
+	summary: Type.Union([Type.String(), Type.Null()]),
+	commit_sha: Type.Union([Type.String(), Type.Null()]),
+	platform: DevicePlatformSchema,
+	status: BuildStatusSchema,
+	fingerprint: Type.Union([Type.String(), Type.Null()]),
+	created_at: Type.String(),
+	updated_at: Type.String(),
+});
+export type Build = Static<typeof BuildSchema>;
+
+/**
+ * Build params schema
+ */
+export const BuildParamsSchema = Type.Object({
+	build_id: Type.String({ format: "uuid" }),
+});
+export type BuildParams = Static<typeof BuildParamsSchema>;
+
+/**
+ * Search builds query schema
+ * Supports pagination, search, and sorting
+ */
+export const SearchBuildsQuerySchema = Type.Object({
+	project_id: Type.String({ format: "uuid" }),
+	page: Type.Number({ minimum: 1, default: 1 }),
+	limit: Type.Number({ minimum: 1, maximum: 100, default: 20 }),
+	search: Type.Optional(Type.String()),
+	sort_by: Type.Union(
+		[
+			Type.Literal("created_at"),
+			Type.Literal("updated_at"),
+			Type.Literal("build_number"),
+			Type.Literal("platform"),
+			Type.Literal("name"),
+		],
+		{ default: "created_at" }
+	),
+	sort_order: Type.Union([Type.Literal("asc"), Type.Literal("desc")], { default: "desc" }),
+});
+export type SearchBuildsQuery = Static<typeof SearchBuildsQuerySchema>;
+
+/**
+ * Search builds query schema without project_id (injected from headers)
+ */
+export const SearchBuildsQueryParamsSchema = Type.Omit(SearchBuildsQuerySchema, ["project_id"]);
+export type SearchBuildsQueryParams = Static<typeof SearchBuildsQueryParamsSchema>;
+
+/**
+ * Builds by IDs request schema
+ */
+export const BuildsByIdsSchema = Type.Object({
+	build_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+});
+export type BuildsByIds = Static<typeof BuildsByIdsSchema>;
+
+/**
+ * Paginated builds response schema
+ */
+export const BuildsResponseSchema = Type.Object({
+	builds: Type.Array(BuildSchema),
+	pagination: Type.Object({
+		page: Type.Integer({ minimum: 1 }),
+		limit: Type.Integer({ minimum: 1 }),
+		total: Type.Integer({ minimum: 0 }),
+		total_pages: Type.Integer({ minimum: 0 }),
+	}),
+});
+export type BuildsResponse = Static<typeof BuildsResponseSchema>;
+
+/**
+ * Single build response schema
+ */
+export const BuildResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: BuildSchema,
+});
+export type BuildResponse = Static<typeof BuildResponseSchema>;
+
+/**
+ * Build error response schema
+ * Discriminated union by error code
+ */
+export const BuildErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("BUILD_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("PROJECT_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FORBIDDEN"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FETCH_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("INVALID_PARAMS"),
+		message: Type.String(),
+	}),
+]);
+export type BuildError = Static<typeof BuildErrorSchema>;
+
+/**
+ * Build error response wrapper
+ */
+export const BuildErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: BuildErrorSchema,
+});
+export type BuildErrorResponse = Static<typeof BuildErrorResponseSchema>;
+
+/**
+ * Build request response schema
+ */
+export const BuildRequestResponseSchema = Type.Union([BuildResponseSchema, BuildErrorResponseSchema]);
+export type BuildRequestResponse = Static<typeof BuildRequestResponseSchema>;
+
+export type _CheckBuildRow = AssertTrue<AssertSchemaCompatibleWithRow<Build, "version_builds">>;
+
+/**
+ * Update build status request body schema
+ */
+export const UpdateBuildStatusBodySchema = Type.Object({
+	status: BuildStatusSchema,
+});
+export type UpdateBuildStatusBody = Static<typeof UpdateBuildStatusBodySchema>;
+
+/**
+ * Add UPDATE_FAILED error code for update operations
+ */
+export const BuildErrorSchemaWithUpdate = Type.Union([
+	BuildErrorSchema,
+	Type.Object({
+		code: Type.Literal("UPDATE_FAILED"),
+		message: Type.String(),
+	}),
+]);
+export type BuildErrorWithUpdate = Static<typeof BuildErrorSchemaWithUpdate>;
+
+/**
+ * Build error response wrapper with update error
+ */
+export const BuildErrorResponseWithUpdateSchema = Type.Object({
+	success: Type.Literal(false),
+	error: BuildErrorSchemaWithUpdate,
+});
+export type BuildErrorResponseWithUpdate = Static<typeof BuildErrorResponseWithUpdateSchema>;