@read-frog/api-contract 0.4.1 → 0.6.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { oc } from "@orpc/contract";
-import { BETA_FEATURE_KEYS, COLUMN_MAX_WIDTH, COLUMN_MIN_WIDTH, columnConfigSchema } from "@read-frog/definitions";
+import { BETA_FEATURE_KEYS, NOTEBASE_COLUMN_MAX_WIDTH, NOTEBASE_COLUMN_MIN_WIDTH, SRS_REVIEW_DURATION_MS_MAX, cardIdentityShape, cardMemoryStateShape, cardStateSchema, cardStateSchema as cardStateSchema$1, cardTemplateConfigSchema, fsrsReviewLogSnapshotSchema, notebaseColumnConfigSchema, reviewRatingSchema, scheduleStatusSchema, scheduleStatusSchema as scheduleStatusSchema$1, schedulingParamsSchema, schedulingParamsShape, srsStepSchema, srsWeightsSchema } from "@read-frog/definitions";
 import { z } from "zod";
 //#region src/schemas/beta-access.ts
 const BetaFeatureKeySchema = z.enum(BETA_FEATURE_KEYS);
@@ -19,7 +19,7 @@ const betaAccessContract = { status: oc.route({
 //#endregion
 //#region src/public-errors.ts
 const CellValidationFailureReasonSchema = z.enum([
-	"unknown_column",
+	"unknown_notebase_column",
 	"type_mismatch",
 	"invalid_select_option",
 	"invalid_date_format"
@@ -32,29 +32,59 @@ const CellValidationFailureDetailsSchema = z.object({
 	validOptions: z.array(z.string()).optional()
 }).strict();
 const CellValidationFailedDataSchema = z.object({
-	columnId: z.string(),
+	notebaseColumnId: z.string(),
 	details: CellValidationFailureDetailsSchema,
 	reason: CellValidationFailureReasonSchema
 }).strict();
+const CardTemplateInvalidColumnsDataSchema = z.object({ notebaseColumnIds: z.array(z.string()) }).strict();
 const PUBLIC_APP_ERROR_DEFS = {
 	NOTEBASE_BETA_RESTRICTED: {
 		message: "Notebase is currently in beta for selected accounts",
 		status: 403
 	},
-	TABLE_NOT_FOUND: {
-		message: "Table not found",
+	NOTEBASE_NOT_FOUND: {
+		message: "Notebase not found",
 		status: 404
 	},
-	COLUMN_NOT_FOUND: {
-		message: "Column not found",
+	NOTEBASE_COLUMN_NOT_FOUND: {
+		message: "Notebase column not found",
 		status: 404
 	},
-	ROW_NOT_FOUND: {
-		message: "Row not found",
+	NOTEBASE_ROW_NOT_FOUND: {
+		message: "Notebase row not found",
 		status: 404
 	},
-	VIEW_NOT_FOUND: {
-		message: "View not found",
+	CARD_NOT_FOUND: {
+		message: "Card not found",
+		status: 404
+	},
+	CARD_TEMPLATE_NOT_FOUND: {
+		message: "Card template not found",
+		status: 404
+	},
+	CARD_TEMPLATE_INVALID_NOTEBASE_COLUMNS: {
+		data: CardTemplateInvalidColumnsDataSchema,
+		message: "Card template references unknown notebase columns",
+		status: 422
+	},
+	CARD_TEMPLATE_NOTEBASE_COLUMN_IN_USE: {
+		message: "Notebase column is used by a card template",
+		status: 409
+	},
+	CARD_NOT_REVIEWABLE: {
+		message: "Card cannot be reviewed in its current state",
+		status: 409
+	},
+	CARD_REVIEW_STATE_STALE: {
+		message: "Card review state is stale",
+		status: 409
+	},
+	CARD_REVIEW_ROLLBACK_UNAVAILABLE: {
+		message: "Card review cannot be rolled back",
+		status: 409
+	},
+	NOTEBASE_VIEW_NOT_FOUND: {
+		message: "Notebase view not found",
 		status: 404
 	},
 	CELL_VALIDATION_FAILED: {
@@ -62,8 +92,8 @@ const PUBLIC_APP_ERROR_DEFS = {
 		message: "Cell validation failed",
 		status: 422
 	},
-	PRIMARY_COLUMN_DELETE_NOT_ALLOWED: {
-		message: "Cannot delete primary column",
+	PRIMARY_NOTEBASE_COLUMN_DELETE_NOT_ALLOWED: {
+		message: "Cannot delete primary notebase column",
 		status: 400
 	},
 	CONCURRENT_POSITION_CONFLICT: {
@@ -92,162 +122,246 @@ function pickPublicErrorMap(...codes) {
 	}));
 }
 //#endregion
-//#region src/schemas/column.ts
-const columnWidthSchema = z.number().int().min(COLUMN_MIN_WIDTH).max(COLUMN_MAX_WIDTH);
-const tableColumnSchema = z.object({
-	id: z.string(),
-	tableId: z.string(),
+//#region src/schemas/card.ts
+const cardTemplateSchema = z.object({
+	id: z.uuid(),
+	notebaseId: z.uuid(),
 	name: z.string(),
-	config: columnConfigSchema,
-	position: z.number(),
-	isPrimary: z.boolean(),
-	width: z.number().nullable(),
+	config: cardTemplateConfigSchema,
 	createdAt: z.coerce.date(),
 	updatedAt: z.coerce.date()
 });
-const columnCreateDataSchema = z.object({
+const CardTemplateListInputSchema = z.object({ notebaseId: z.uuid() });
+const CardTemplateListOutputSchema = z.array(cardTemplateSchema);
+const CardTemplateGetInputSchema = z.object({ id: z.uuid() });
+const CardTemplateGetOutputSchema = cardTemplateSchema;
+const CardTemplateCreateInputSchema = z.object({
 	id: z.uuid().optional(),
+	notebaseId: z.uuid(),
 	name: z.string().min(1),
-	config: columnConfigSchema
+	config: cardTemplateConfigSchema
 }).strict();
-const columnUpdateDataSchema = z.object({
+const CardTemplateCreateOutputSchema = cardTemplateSchema.extend({ txid: z.number() });
+const CardTemplateUpdateInputSchema = z.object({
+	id: z.uuid(),
 	name: z.string().min(1).optional(),
-	config: columnConfigSchema.optional(),
-	width: columnWidthSchema.nullable().optional()
+	config: cardTemplateConfigSchema.optional()
 }).strict();
-const ColumnCreateInputSchema = z.object({
-	tableId: z.uuid(),
-	data: columnCreateDataSchema
+const CardTemplateUpdateOutputSchema = cardTemplateSchema.extend({ txid: z.number() });
+const CardTemplateDeleteInputSchema = z.object({ id: z.uuid() });
+const CardTemplateDeleteOutputSchema = z.object({ txid: z.number() });
+const cardSchema = z.object({
+	...cardIdentityShape,
+	...cardMemoryStateShape,
+	createdAt: z.coerce.date(),
+	updatedAt: z.coerce.date()
 });
-const ColumnCreateOutputSchema = z.object({ txid: z.number() });
-const ColumnUpdateInputSchema = z.object({
-	columnId: z.uuid(),
-	data: columnUpdateDataSchema
+const renderedCardSchema = cardSchema.extend({
+	front: z.string(),
+	back: z.string()
 });
-const ColumnUpdateOutputSchema = z.object({ txid: z.number() });
-const ColumnDeleteInputSchema = z.object({ columnId: z.uuid() });
-const ColumnDeleteOutputSchema = z.object({ txid: z.number() });
-const ColumnReorderInputSchema = z.object({
-	tableId: z.uuid(),
-	ids: z.array(z.uuid())
+const CardListInputSchema = z.object({
+	notebaseId: z.uuid(),
+	templateId: z.uuid().optional(),
+	limit: z.number().int().min(1).max(500).optional(),
+	offset: z.number().int().min(0).optional()
+});
+const CardListOutputSchema = z.array(renderedCardSchema);
+const CardGetInputSchema = z.object({ id: z.uuid() });
+const CardGetOutputSchema = renderedCardSchema;
+const CardGenerateInputSchema = z.object({
+	notebaseId: z.uuid(),
+	templateId: z.uuid().optional()
+});
+const CardGenerateOutputSchema = z.object({
+	created: z.number().int().min(0),
+	txid: z.number()
 });
-const ColumnReorderOutputSchema = z.object({ txid: z.number() });
 //#endregion
 //#region src/contracts/shared.ts
 const notebaseProcedure = oc.errors(pickPublicErrorMap("NOTEBASE_BETA_RESTRICTED"));
 //#endregion
-//#region src/contracts/column.ts
-const columnContract = {
-	create: notebaseProcedure.errors(pickPublicErrorMap("TABLE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT")).route({
+//#region src/contracts/card.ts
+const cardContract = {
+	list: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND")).route({
+		method: "GET",
+		path: "/cards",
+		summary: "List rendered cards",
+		tags: ["Cards"]
+	}).input(CardListInputSchema).output(CardListOutputSchema),
+	get: notebaseProcedure.errors(pickPublicErrorMap("CARD_NOT_FOUND")).route({
+		method: "GET",
+		path: "/cards/{id}",
+		summary: "Get rendered card",
+		tags: ["Cards"]
+	}).input(CardGetInputSchema).output(CardGetOutputSchema),
+	generate: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND", "CARD_TEMPLATE_NOT_FOUND")).route({
+		method: "POST",
+		path: "/cards/generate",
+		summary: "Generate missing cards",
+		tags: ["Cards"]
+	}).input(CardGenerateInputSchema).output(CardGenerateOutputSchema)
+};
+//#endregion
+//#region src/contracts/card-template.ts
+const cardTemplateContract = {
+	list: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND")).route({
+		method: "GET",
+		path: "/card-templates",
+		summary: "List card templates",
+		tags: ["Card Templates"]
+	}).input(CardTemplateListInputSchema).output(CardTemplateListOutputSchema),
+	get: notebaseProcedure.errors(pickPublicErrorMap("CARD_TEMPLATE_NOT_FOUND")).route({
+		method: "GET",
+		path: "/card-templates/{id}",
+		summary: "Get card template",
+		tags: ["Card Templates"]
+	}).input(CardTemplateGetInputSchema).output(CardTemplateGetOutputSchema),
+	create: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND", "CARD_TEMPLATE_INVALID_NOTEBASE_COLUMNS")).route({
 		method: "POST",
-		path: "/columns",
-		summary: "Create column",
-		tags: ["Columns"]
-	}).input(ColumnCreateInputSchema).output(ColumnCreateOutputSchema),
-	update: notebaseProcedure.errors(pickPublicErrorMap("COLUMN_NOT_FOUND")).route({
+		path: "/card-templates",
+		summary: "Create card template",
+		tags: ["Card Templates"]
+	}).input(CardTemplateCreateInputSchema).output(CardTemplateCreateOutputSchema),
+	update: notebaseProcedure.errors(pickPublicErrorMap("CARD_TEMPLATE_NOT_FOUND", "CARD_TEMPLATE_INVALID_NOTEBASE_COLUMNS")).route({
 		method: "PATCH",
-		path: "/columns/{columnId}",
-		summary: "Update column",
-		tags: ["Columns"]
-	}).input(ColumnUpdateInputSchema).output(ColumnUpdateOutputSchema),
-	delete: notebaseProcedure.errors(pickPublicErrorMap("COLUMN_NOT_FOUND", "PRIMARY_COLUMN_DELETE_NOT_ALLOWED", "CONCURRENT_POSITION_CONFLICT")).route({
+		path: "/card-templates/{id}",
+		summary: "Update card template",
+		tags: ["Card Templates"]
+	}).input(CardTemplateUpdateInputSchema).output(CardTemplateUpdateOutputSchema),
+	delete: notebaseProcedure.errors(pickPublicErrorMap("CARD_TEMPLATE_NOT_FOUND")).route({
 		method: "DELETE",
-		path: "/columns/{columnId}",
-		summary: "Delete column",
-		tags: ["Columns"]
-	}).input(ColumnDeleteInputSchema).output(ColumnDeleteOutputSchema),
-	reorder: notebaseProcedure.errors(pickPublicErrorMap("TABLE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT")).route({
-		method: "POST",
-		path: "/columns/reorder",
-		summary: "Reorder columns in a table",
-		tags: ["Columns"]
-	}).input(ColumnReorderInputSchema).output(ColumnReorderOutputSchema)
+		path: "/card-templates/{id}",
+		summary: "Delete card template",
+		tags: ["Card Templates"]
+	}).input(CardTemplateDeleteInputSchema).output(CardTemplateDeleteOutputSchema)
 };
 //#endregion
-//#region src/schemas/row.ts
-const rowCellsSchema = z.record(z.string(), z.unknown());
-const tableRowSchema = z.object({
+//#region src/schemas/notebase-column.ts
+const notebaseColumnWidthSchema = z.number().int().min(NOTEBASE_COLUMN_MIN_WIDTH).max(NOTEBASE_COLUMN_MAX_WIDTH);
+const notebaseColumnSchema = z.object({
 	id: z.string(),
-	tableId: z.string(),
-	cells: rowCellsSchema,
+	notebaseId: z.string(),
+	name: z.string(),
+	config: notebaseColumnConfigSchema,
 	position: z.number(),
+	isPrimary: z.boolean(),
+	width: z.number().nullable(),
 	createdAt: z.coerce.date(),
 	updatedAt: z.coerce.date()
 });
-const rowCreateDataSchema = z.object({
+const notebaseColumnCreateDataSchema = z.object({
 	id: z.uuid().optional(),
-	cells: rowCellsSchema.optional()
+	name: z.string().min(1),
+	config: notebaseColumnConfigSchema
+}).strict();
+const notebaseColumnUpdateDataSchema = z.object({
+	name: z.string().min(1).optional(),
+	config: notebaseColumnConfigSchema.optional(),
+	width: notebaseColumnWidthSchema.nullable().optional()
 }).strict();
-const rowUpdateDataSchema = z.object({ cells: rowCellsSchema.optional() }).strict();
-const RowCreateInputSchema = z.object({
-	tableId: z.uuid(),
-	data: rowCreateDataSchema
+const NotebaseColumnCreateInputSchema = z.object({
+	notebaseId: z.uuid(),
+	data: notebaseColumnCreateDataSchema
+});
+const NotebaseColumnCreateOutputSchema = z.object({ txid: z.number() });
+const NotebaseColumnUpdateInputSchema = z.object({
+	notebaseColumnId: z.uuid(),
+	data: notebaseColumnUpdateDataSchema
 });
-const RowCreateOutputSchema = z.object({ txid: z.number() });
-const RowUpdateInputSchema = z.object({
-	rowId: z.uuid(),
-	data: rowUpdateDataSchema
+const NotebaseColumnUpdateOutputSchema = z.object({ txid: z.number() });
+const NotebaseColumnDeleteInputSchema = z.object({ notebaseColumnId: z.uuid() });
+const NotebaseColumnDeleteOutputSchema = z.object({ txid: z.number() });
+const NotebaseColumnReorderInputSchema = z.object({
+	notebaseId: z.uuid(),
+	ids: z.array(z.uuid())
 });
-const RowUpdateOutputSchema = z.object({
+const NotebaseColumnReorderOutputSchema = z.object({ txid: z.number() });
+//#endregion
+//#region src/schemas/notebase-row.ts
+const notebaseRowCellsSchema = z.record(z.string(), z.unknown());
+const notebaseRowSchema = z.object({
+	id: z.string(),
+	notebaseId: z.string(),
+	cells: notebaseRowCellsSchema,
+	position: z.number(),
+	createdAt: z.coerce.date(),
+	updatedAt: z.coerce.date()
+});
+const notebaseRowCreateDataSchema = z.object({
+	id: z.uuid().optional(),
+	cells: notebaseRowCellsSchema.optional()
+}).strict();
+const notebaseRowUpdateDataSchema = z.object({ cells: notebaseRowCellsSchema.optional() }).strict();
+const NotebaseRowCreateInputSchema = z.object({
+	notebaseId: z.uuid(),
+	data: notebaseRowCreateDataSchema
+});
+const NotebaseRowCreateOutputSchema = z.object({ txid: z.number() });
+const NotebaseRowUpdateInputSchema = z.object({
+	notebaseRowId: z.uuid(),
+	data: notebaseRowUpdateDataSchema
+});
+const NotebaseRowUpdateOutputSchema = z.object({
 	id: z.uuid(),
-	tableId: z.uuid(),
-	cells: rowCellsSchema,
+	notebaseId: z.uuid(),
+	cells: notebaseRowCellsSchema,
 	position: z.number().int(),
 	createdAt: z.date(),
 	updatedAt: z.date(),
 	txid: z.number()
 });
-const RowDeleteInputSchema = z.object({ rowId: z.uuid() });
-const RowDeleteOutputSchema = z.object({ txid: z.number() });
-const RowReorderInputSchema = z.object({
-	tableId: z.uuid(),
+const NotebaseRowDeleteInputSchema = z.object({ notebaseRowId: z.uuid() });
+const NotebaseRowDeleteOutputSchema = z.object({ txid: z.number() });
+const NotebaseRowReorderInputSchema = z.object({
+	notebaseId: z.uuid(),
 	ids: z.array(z.uuid())
 });
-const RowReorderOutputSchema = z.object({ txid: z.number() });
+const NotebaseRowReorderOutputSchema = z.object({ txid: z.number() });
 //#endregion
-//#region src/schemas/view.ts
-const tableViewTypeSchema = z.enum([
+//#region src/schemas/notebase-view.ts
+const notebaseViewTypeSchema = z.enum([
 	"table",
 	"kanban",
 	"gallery"
 ]);
-const viewConfigSchema = z.object({
-	columnWidths: z.record(z.string(), z.number()).optional(),
-	hiddenColumns: z.array(z.string()).optional(),
-	groupByColumnId: z.string().optional()
+const notebaseViewConfigSchema = z.object({
+	notebaseColumnWidths: z.record(z.string(), z.number()).optional(),
+	hiddenNotebaseColumns: z.array(z.string()).optional(),
+	groupByNotebaseColumnId: z.string().optional()
 }).catchall(z.unknown());
-const viewFilterSchema = z.object({
-	columnId: z.string(),
+const notebaseViewFilterSchema = z.object({
+	notebaseColumnId: z.string(),
 	operator: z.string(),
 	value: z.unknown()
 }).strict();
-const viewFiltersSchema = z.array(viewFilterSchema);
-const viewSortSchema = z.object({
-	columnId: z.string(),
+const notebaseViewFiltersSchema = z.array(notebaseViewFilterSchema);
+const notebaseViewSortSchema = z.object({
+	notebaseColumnId: z.string(),
 	direction: z.enum(["asc", "desc"])
 }).strict();
-const viewSortsSchema = z.array(viewSortSchema);
-const viewCreateDataSchema = z.object({
+const notebaseViewSortsSchema = z.array(notebaseViewSortSchema);
+const notebaseViewCreateDataSchema = z.object({
 	id: z.uuid().optional(),
 	name: z.string().min(1),
-	type: tableViewTypeSchema,
-	config: viewConfigSchema.optional(),
-	filters: viewFiltersSchema.optional(),
-	sorts: viewSortsSchema.optional()
+	type: notebaseViewTypeSchema,
+	config: notebaseViewConfigSchema.optional(),
+	filters: notebaseViewFiltersSchema.optional(),
+	sorts: notebaseViewSortsSchema.optional()
 }).strict();
-const viewUpdateDataSchema = z.object({
+const notebaseViewUpdateDataSchema = z.object({
 	name: z.string().min(1).optional(),
-	type: tableViewTypeSchema.optional(),
-	config: viewConfigSchema.optional(),
-	filters: viewFiltersSchema.optional(),
-	sorts: viewSortsSchema.optional()
+	type: notebaseViewTypeSchema.optional(),
+	config: notebaseViewConfigSchema.optional(),
+	filters: notebaseViewFiltersSchema.optional(),
+	sorts: notebaseViewSortsSchema.optional()
 }).strict();
-const tableViewSchema = z.object({
+const notebaseViewSchema = z.object({
 	id: z.string(),
-	tableId: z.string(),
+	notebaseId: z.string(),
 	name: z.string(),
-	type: tableViewTypeSchema,
-	config: viewConfigSchema.nullable(),
+	type: notebaseViewTypeSchema,
+	config: notebaseViewConfigSchema.nullable(),
 	filters: z.array(z.unknown()).nullable(),
 	sorts: z.array(z.unknown()).nullable(),
 	position: z.number(),
@@ -255,113 +369,283 @@ const tableViewSchema = z.object({
 	updatedAt: z.coerce.date()
 });
 //#endregion
-//#region src/schemas/custom-table.ts
-const CustomTableListInputSchema = z.object({});
-const CustomTableListItemSchema = z.object({
+//#region src/schemas/notebase.ts
+const NotebaseListInputSchema = z.object({});
+const NotebaseListItemSchema = z.object({
 	id: z.string(),
 	name: z.string()
 });
-const CustomTableListOutputSchema = z.array(CustomTableListItemSchema);
-const customTableCreateDataSchema = z.object({
-	id: z.uuid().optional(),
-	name: z.string().min(1)
-}).strict();
-const CustomTableCreateInputSchema = customTableCreateDataSchema;
-const CustomTableCreateOutputSchema = z.object({ txid: z.number() });
-const customTableUpdateDataSchema = z.object({ name: z.string().min(1).optional() }).strict();
-const CustomTableUpdateInputSchema = customTableUpdateDataSchema.extend({ id: z.uuid() });
-const CustomTableUpdateOutputSchema = z.object({ txid: z.number() });
-const CustomTableDeleteInputSchema = z.object({ id: z.uuid() });
-const CustomTableDeleteOutputSchema = z.object({ txid: z.number() });
-const CustomTableGetInputSchema = z.object({ id: z.uuid() });
-const CustomTableGetSchemaInputSchema = z.object({ id: z.uuid() });
-const CustomTableGetOutputSchema = z.object({
+const NotebaseListOutputSchema = z.array(NotebaseListItemSchema);
+const notebaseSchema = z.object({
 	id: z.string(),
 	userId: z.string(),
 	name: z.string(),
+	srsNewPerDay: schedulingParamsShape.newPerDay,
+	srsReviewsPerDay: schedulingParamsShape.reviewsPerDay,
+	srsDesiredRetention: schedulingParamsShape.desiredRetention,
+	srsEnableShortTerm: schedulingParamsShape.enableShortTerm,
+	srsMaximumInterval: schedulingParamsShape.maximumInterval,
+	srsLearningSteps: schedulingParamsShape.learningSteps,
+	srsRelearningSteps: schedulingParamsShape.relearningSteps,
+	srsLeechThreshold: schedulingParamsShape.leechThreshold,
+	srsEnableFuzz: schedulingParamsShape.enableFuzz,
+	srsWeights: srsWeightsSchema.nullable(),
+	createdAt: z.date(),
+	updatedAt: z.date()
+});
+const notebaseCreateDataSchema = z.object({
+	id: z.uuid().optional(),
+	name: z.string().min(1)
+}).strict();
+const NotebaseCreateInputSchema = notebaseCreateDataSchema;
+const NotebaseCreateOutputSchema = z.object({ txid: z.number() });
+const notebaseUpdateDataSchema = z.object({ name: z.string().min(1).optional() }).strict();
+const NotebaseUpdateInputSchema = notebaseUpdateDataSchema.extend({ id: z.uuid() });
+const NotebaseUpdateOutputSchema = z.object({ txid: z.number() });
+const NotebaseDeleteInputSchema = z.object({ id: z.uuid() });
+const NotebaseDeleteOutputSchema = z.object({ txid: z.number() });
+const NotebaseGetInputSchema = z.object({ id: z.uuid() });
+const NotebaseGetSchemaInputSchema = z.object({ id: z.uuid() });
+const NotebaseGetOutputSchema = notebaseSchema.extend({
 	createdAt: z.coerce.date(),
 	updatedAt: z.coerce.date(),
-	columns: z.array(tableColumnSchema),
-	rows: z.array(tableRowSchema),
-	views: z.array(tableViewSchema)
+	notebaseColumns: z.array(notebaseColumnSchema),
+	notebaseRows: z.array(notebaseRowSchema),
+	notebaseViews: z.array(notebaseViewSchema)
 });
-const CustomTableGetSchemaOutputSchema = z.object({
+const NotebaseGetSchemaOutputSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	updatedAt: z.coerce.date(),
-	columns: z.array(tableColumnSchema)
+	notebaseColumns: z.array(notebaseColumnSchema)
 });
 //#endregion
+//#region src/contracts/notebase.ts
+const notebaseContract = {
+	list: notebaseProcedure.route({
+		method: "GET",
+		path: "/notebases",
+		summary: "List notebases",
+		tags: ["Notebases"]
+	}).input(NotebaseListInputSchema).output(NotebaseListOutputSchema),
+	get: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND")).route({
+		method: "GET",
+		path: "/notebases/{id}",
+		summary: "Get notebase with notebase columns, rows, and views",
+		tags: ["Notebases"]
+	}).input(NotebaseGetInputSchema).output(NotebaseGetOutputSchema),
+	getSchema: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND")).route({
+		method: "GET",
+		path: "/notebases/{id}/schema",
+		summary: "Get notebase schema",
+		tags: ["Notebases"]
+	}).input(NotebaseGetSchemaInputSchema).output(NotebaseGetSchemaOutputSchema),
+	create: notebaseProcedure.route({
+		method: "POST",
+		path: "/notebases",
+		summary: "Create notebase",
+		tags: ["Notebases"]
+	}).input(NotebaseCreateInputSchema).output(NotebaseCreateOutputSchema),
+	update: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND")).route({
+		method: "PUT",
+		path: "/notebases/{id}",
+		summary: "Update notebase",
+		tags: ["Notebases"]
+	}).input(NotebaseUpdateInputSchema).output(NotebaseUpdateOutputSchema),
+	delete: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND")).route({
+		method: "DELETE",
+		path: "/notebases/{id}",
+		summary: "Delete notebase",
+		tags: ["Notebases"]
+	}).input(NotebaseDeleteInputSchema).output(NotebaseDeleteOutputSchema)
+};
+//#endregion
+//#region src/contracts/notebase-column.ts
+const notebaseColumnContract = {
+	create: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT")).route({
+		method: "POST",
+		path: "/notebase-columns",
+		summary: "Create notebase column",
+		tags: ["Notebase Columns"]
+	}).input(NotebaseColumnCreateInputSchema).output(NotebaseColumnCreateOutputSchema),
+	update: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_COLUMN_NOT_FOUND")).route({
+		method: "PATCH",
+		path: "/notebase-columns/{notebaseColumnId}",
+		summary: "Update notebase column",
+		tags: ["Notebase Columns"]
+	}).input(NotebaseColumnUpdateInputSchema).output(NotebaseColumnUpdateOutputSchema),
+	delete: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_COLUMN_NOT_FOUND", "PRIMARY_NOTEBASE_COLUMN_DELETE_NOT_ALLOWED", "CARD_TEMPLATE_NOTEBASE_COLUMN_IN_USE", "CONCURRENT_POSITION_CONFLICT")).route({
+		method: "DELETE",
+		path: "/notebase-columns/{notebaseColumnId}",
+		summary: "Delete notebase column",
+		tags: ["Notebase Columns"]
+	}).input(NotebaseColumnDeleteInputSchema).output(NotebaseColumnDeleteOutputSchema),
+	reorder: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT")).route({
+		method: "POST",
+		path: "/notebase-columns/reorder",
+		summary: "Reorder notebase columns",
+		tags: ["Notebase Columns"]
+	}).input(NotebaseColumnReorderInputSchema).output(NotebaseColumnReorderOutputSchema)
+};
+//#endregion
+//#region src/contracts/notebase-row.ts
+const notebaseRowContract = {
+	create: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND", "CELL_VALIDATION_FAILED", "CONCURRENT_POSITION_CONFLICT")).route({
+		method: "POST",
+		path: "/notebase-rows",
+		summary: "Create notebase row",
+		tags: ["Notebase Rows"]
+	}).input(NotebaseRowCreateInputSchema).output(NotebaseRowCreateOutputSchema),
+	update: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_ROW_NOT_FOUND", "CELL_VALIDATION_FAILED")).route({
+		method: "PATCH",
+		path: "/notebase-rows/{notebaseRowId}",
+		summary: "Update notebase row cells",
+		tags: ["Notebase Rows"]
+	}).input(NotebaseRowUpdateInputSchema).output(NotebaseRowUpdateOutputSchema),
+	delete: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_ROW_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT")).route({
+		method: "DELETE",
+		path: "/notebase-rows/{notebaseRowId}",
+		summary: "Delete notebase row",
+		tags: ["Notebase Rows"]
+	}).input(NotebaseRowDeleteInputSchema).output(NotebaseRowDeleteOutputSchema),
+	reorder: notebaseProcedure.errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT")).route({
+		method: "POST",
+		path: "/notebase-rows/reorder",
+		summary: "Reorder notebase rows",
+		tags: ["Notebase Rows"]
+	}).input(NotebaseRowReorderInputSchema).output(NotebaseRowReorderOutputSchema)
+};
+//#endregion
+//#region src/schemas/timezone.ts
+const localeTimeZoneFormatter = /* @__PURE__ */ new Map();
+function createTimezoneFormatter(timezone) {
+	let formatter = localeTimeZoneFormatter.get(timezone);
+	if (!formatter) {
+		formatter = new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+		localeTimeZoneFormatter.set(timezone, formatter);
+	}
+	return formatter;
+}
+const timezoneSchema = z.string().trim().min(1).refine((timezone) => {
+	try {
+		createTimezoneFormatter(timezone).format(/* @__PURE__ */ new Date());
+		return true;
+	} catch {
+		return false;
+	}
+}, "Invalid timezone");
+//#endregion
+//#region src/schemas/srs.ts
+const stepSchema = srsStepSchema;
+const SRS_REVIEW_CLIENT_ID_NAMESPACE = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+const srsReviewClientIdNamePrefix = "readfrog:srs-review";
+const nullLastReviewTimeSentinel = "null";
+async function createSrsReviewClientId(card) {
+	return uuidV5(`${srsReviewClientIdNamePrefix}:${card.id}:${formatLastReviewTime(card.lastReviewTime)}`, SRS_REVIEW_CLIENT_ID_NAMESPACE);
+}
+const srsReviewInputSchema = z.object({
+	cardId: z.uuid(),
+	id: z.uuid().optional(),
+	rating: reviewRatingSchema,
+	durationMs: z.number().int().min(0).max(SRS_REVIEW_DURATION_MS_MAX),
+	timezone: timezoneSchema
+}).strict();
+const srsRollbackReviewInputSchema = z.object({ cardId: z.uuid() }).strict();
+const srsRevlogSchema = z.object({
+	id: z.uuid(),
+	notebaseId: z.uuid(),
+	cardId: z.uuid(),
+	rating: reviewRatingSchema,
+	state: cardStateSchema$1,
+	afterScheduleStatus: scheduleStatusSchema$1,
+	reviewedAt: z.coerce.date(),
+	durationMs: z.number().int(),
+	fsrsReviewLogSnapshot: fsrsReviewLogSnapshotSchema,
+	createdAt: z.coerce.date()
+});
+const srsReviewOutputSchema = z.object({
+	card: cardSchema,
+	revlog: srsRevlogSchema,
+	txid: z.number()
+});
+const srsRollbackReviewOutputSchema = z.object({
+	card: cardSchema,
+	rolledBackRevlogId: z.uuid(),
+	txid: z.number()
+});
+function formatLastReviewTime(lastReviewTime) {
+	return lastReviewTime ? new Date(lastReviewTime).toISOString() : nullLastReviewTimeSentinel;
+}
+async function uuidV5(name, namespace) {
+	const namespaceBytes = uuidToBytes(namespace);
+	const nameBytes = new TextEncoder().encode(name);
+	const input = new Uint8Array(namespaceBytes.length + nameBytes.length);
+	input.set(namespaceBytes);
+	input.set(nameBytes, namespaceBytes.length);
+	const bytes = new Uint8Array(await crypto.subtle.digest("SHA-1", input)).slice(0, 16);
+	const versionByte = bytes[6];
+	const variantByte = bytes[8];
+	if (versionByte === void 0 || variantByte === void 0) throw new Error("SHA-1 digest was too short");
+	bytes[6] = versionByte & 15 | 80;
+	bytes[8] = variantByte & 63 | 128;
+	return bytesToUuid(bytes);
+}
+function uuidToBytes(uuid) {
+	const hex = uuid.replaceAll("-", "").toLowerCase();
+	if (!/^[0-9a-f]{32}$/.test(hex)) throw new Error("Invalid UUID namespace");
+	return new Uint8Array(Array.from({ length: 16 }, (_, index) => Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16)));
+}
+function bytesToUuid(bytes) {
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+	return [
+		hex.slice(0, 4).join(""),
+		hex.slice(4, 6).join(""),
+		hex.slice(6, 8).join(""),
+		hex.slice(8, 10).join(""),
+		hex.slice(10, 16).join("")
+	].join("-");
+}
+//#endregion
+//#region src/contracts/srs.ts
+const srsContract = {
+	review: notebaseProcedure.errors(pickPublicErrorMap("CARD_NOT_FOUND", "CARD_NOT_REVIEWABLE", "CARD_REVIEW_STATE_STALE")).route({
+		method: "POST",
+		path: "/srs/review",
+		summary: "Review a card with SRS scheduling",
+		tags: ["SRS"]
+	}).input(srsReviewInputSchema).output(srsReviewOutputSchema),
+	rollbackReview: notebaseProcedure.errors(pickPublicErrorMap("CARD_NOT_FOUND", "CARD_REVIEW_ROLLBACK_UNAVAILABLE")).route({
+		method: "POST",
+		path: "/srs/review/rollback",
+		summary: "Roll back the latest SRS review for a card",
+		tags: ["SRS"]
+	}).input(srsRollbackReviewInputSchema).output(srsRollbackReviewOutputSchema)
+};
+//#endregion
+//#region src/schemas/user.ts
+const userEnsureTimezoneInputSchema = z.object({ timezone: timezoneSchema }).strict();
+const userEnsureTimezoneOutputSchema = z.object({
+	timezone: timezoneSchema,
+	updated: z.boolean()
+}).strict();
+//#endregion
 //#region src/index.ts
 const contract = {
 	betaAccess: betaAccessContract,
-	customTable: {
-		list: notebaseProcedure.route({
-			method: "GET",
-			path: "/custom-tables",
-			summary: "List custom tables",
-			tags: ["Custom Tables"]
-		}).input(CustomTableListInputSchema).output(CustomTableListOutputSchema),
-		get: notebaseProcedure.errors(pickPublicErrorMap("TABLE_NOT_FOUND")).route({
-			method: "GET",
-			path: "/custom-tables/{id}",
-			summary: "Get custom table with columns, rows, and views",
-			tags: ["Custom Tables"]
-		}).input(CustomTableGetInputSchema).output(CustomTableGetOutputSchema),
-		getSchema: notebaseProcedure.errors(pickPublicErrorMap("TABLE_NOT_FOUND")).route({
-			method: "GET",
-			path: "/custom-tables/{id}/schema",
-			summary: "Get custom table schema",
-			tags: ["Custom Tables"]
-		}).input(CustomTableGetSchemaInputSchema).output(CustomTableGetSchemaOutputSchema),
-		create: notebaseProcedure.route({
-			method: "POST",
-			path: "/custom-tables",
-			summary: "Create custom table",
-			tags: ["Custom Tables"]
-		}).input(CustomTableCreateInputSchema).output(CustomTableCreateOutputSchema),
-		update: notebaseProcedure.errors(pickPublicErrorMap("TABLE_NOT_FOUND")).route({
-			method: "PUT",
-			path: "/custom-tables/{id}",
-			summary: "Update custom table",
-			tags: ["Custom Tables"]
-		}).input(CustomTableUpdateInputSchema).output(CustomTableUpdateOutputSchema),
-		delete: notebaseProcedure.errors(pickPublicErrorMap("TABLE_NOT_FOUND")).route({
-			method: "DELETE",
-			path: "/custom-tables/{id}",
-			summary: "Delete custom table",
-			tags: ["Custom Tables"]
-		}).input(CustomTableDeleteInputSchema).output(CustomTableDeleteOutputSchema)
-	},
-	column: columnContract,
-	row: {
-		create: notebaseProcedure.errors(pickPublicErrorMap("TABLE_NOT_FOUND", "CELL_VALIDATION_FAILED", "CONCURRENT_POSITION_CONFLICT")).route({
-			method: "POST",
-			path: "/rows",
-			summary: "Create row",
-			tags: ["Rows"]
-		}).input(RowCreateInputSchema).output(RowCreateOutputSchema),
-		update: notebaseProcedure.errors(pickPublicErrorMap("ROW_NOT_FOUND", "CELL_VALIDATION_FAILED")).route({
-			method: "PATCH",
-			path: "/rows/{rowId}",
-			summary: "Update row cells",
-			tags: ["Rows"]
-		}).input(RowUpdateInputSchema).output(RowUpdateOutputSchema),
-		delete: notebaseProcedure.errors(pickPublicErrorMap("ROW_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT")).route({
-			method: "DELETE",
-			path: "/rows/{rowId}",
-			summary: "Delete row",
-			tags: ["Rows"]
-		}).input(RowDeleteInputSchema).output(RowDeleteOutputSchema),
-		reorder: notebaseProcedure.errors(pickPublicErrorMap("TABLE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT")).route({
-			method: "POST",
-			path: "/rows/reorder",
-			summary: "Reorder rows in a table",
-			tags: ["Rows"]
-		}).input(RowReorderInputSchema).output(RowReorderOutputSchema)
-	}
+	card: cardContract,
+	cardTemplate: cardTemplateContract,
+	notebase: notebaseContract,
+	notebaseColumn: notebaseColumnContract,
+	notebaseRow: notebaseRowContract,
+	srs: srsContract,
+	user: { ensureTimezone: oc.route({
+		method: "POST",
+		path: "/users/me/timezone/ensure",
+		summary: "Ensure the authenticated user has a timezone",
+		tags: ["Users"]
+	}).input(userEnsureTimezoneInputSchema).output(userEnsureTimezoneOutputSchema) }
 };
 //#endregion
-export { BetaAccessStatusInputSchema, BetaAccessStatusOutputSchema, BetaFeatureKeySchema, CellValidationFailedDataSchema, CellValidationFailureDetailsSchema, CellValidationFailureReasonSchema, ColumnCreateInputSchema, ColumnCreateOutputSchema, ColumnDeleteInputSchema, ColumnDeleteOutputSchema, ColumnReorderInputSchema, ColumnReorderOutputSchema, ColumnUpdateInputSchema, ColumnUpdateOutputSchema, CustomTableCreateInputSchema, CustomTableCreateOutputSchema, CustomTableDeleteInputSchema, CustomTableDeleteOutputSchema, CustomTableGetInputSchema, CustomTableGetOutputSchema, CustomTableGetSchemaInputSchema, CustomTableGetSchemaOutputSchema, CustomTableListInputSchema, CustomTableListItemSchema, CustomTableListOutputSchema, CustomTableUpdateInputSchema, CustomTableUpdateOutputSchema, PUBLIC_APP_ERROR_DEFS, RowCreateInputSchema, RowCreateOutputSchema, RowDeleteInputSchema, RowDeleteOutputSchema, RowReorderInputSchema, RowReorderOutputSchema, RowUpdateInputSchema, RowUpdateOutputSchema, columnCreateDataSchema, columnUpdateDataSchema, columnWidthSchema, contract, customTableCreateDataSchema, customTableUpdateDataSchema, getPublicErrorDefinition, isPublicAppErrorCode, pickPublicErrorMap, rowCellsSchema, rowCreateDataSchema, rowUpdateDataSchema, tableColumnSchema, tableRowSchema, tableViewSchema, tableViewTypeSchema, viewConfigSchema, viewCreateDataSchema, viewFilterSchema, viewFiltersSchema, viewSortSchema, viewSortsSchema, viewUpdateDataSchema };
+export { BetaAccessStatusInputSchema, BetaAccessStatusOutputSchema, BetaFeatureKeySchema, CardGenerateInputSchema, CardGenerateOutputSchema, CardGetInputSchema, CardGetOutputSchema, CardListInputSchema, CardListOutputSchema, CardTemplateCreateInputSchema, CardTemplateCreateOutputSchema, CardTemplateDeleteInputSchema, CardTemplateDeleteOutputSchema, CardTemplateGetInputSchema, CardTemplateGetOutputSchema, CardTemplateInvalidColumnsDataSchema, CardTemplateListInputSchema, CardTemplateListOutputSchema, CardTemplateUpdateInputSchema, CardTemplateUpdateOutputSchema, CellValidationFailedDataSchema, CellValidationFailureDetailsSchema, CellValidationFailureReasonSchema, NotebaseColumnCreateInputSchema, NotebaseColumnCreateOutputSchema, NotebaseColumnDeleteInputSchema, NotebaseColumnDeleteOutputSchema, NotebaseColumnReorderInputSchema, NotebaseColumnReorderOutputSchema, NotebaseColumnUpdateInputSchema, NotebaseColumnUpdateOutputSchema, NotebaseCreateInputSchema, NotebaseCreateOutputSchema, NotebaseDeleteInputSchema, NotebaseDeleteOutputSchema, NotebaseGetInputSchema, NotebaseGetOutputSchema, NotebaseGetSchemaInputSchema, NotebaseGetSchemaOutputSchema, NotebaseListInputSchema, NotebaseListItemSchema, NotebaseListOutputSchema, NotebaseRowCreateInputSchema, NotebaseRowCreateOutputSchema, NotebaseRowDeleteInputSchema, NotebaseRowDeleteOutputSchema, NotebaseRowReorderInputSchema, NotebaseRowReorderOutputSchema, NotebaseRowUpdateInputSchema, NotebaseRowUpdateOutputSchema, NotebaseUpdateInputSchema, NotebaseUpdateOutputSchema, PUBLIC_APP_ERROR_DEFS, SRS_REVIEW_CLIENT_ID_NAMESPACE, SRS_REVIEW_DURATION_MS_MAX, cardSchema, cardStateSchema, cardTemplateSchema, contract, createSrsReviewClientId, getPublicErrorDefinition, isPublicAppErrorCode, notebaseColumnCreateDataSchema, notebaseColumnSchema, notebaseColumnUpdateDataSchema, notebaseColumnWidthSchema, notebaseCreateDataSchema, notebaseRowCellsSchema, notebaseRowCreateDataSchema, notebaseRowSchema, notebaseRowUpdateDataSchema, notebaseSchema, notebaseUpdateDataSchema, notebaseViewConfigSchema, notebaseViewCreateDataSchema, notebaseViewFilterSchema, notebaseViewFiltersSchema, notebaseViewSchema, notebaseViewSortSchema, notebaseViewSortsSchema, notebaseViewTypeSchema, notebaseViewUpdateDataSchema, pickPublicErrorMap, renderedCardSchema, reviewRatingSchema, scheduleStatusSchema, schedulingParamsSchema, srsReviewInputSchema, srsReviewOutputSchema, srsRevlogSchema, srsRollbackReviewInputSchema, srsRollbackReviewOutputSchema, stepSchema, timezoneSchema, userEnsureTimezoneInputSchema, userEnsureTimezoneOutputSchema };
 
 //# sourceMappingURL=index.js.map