@cravery/core 0.0.19 → 0.0.21

package/src/types/moderation/moderation.ts

@@ -1,20 +1,46 @@
 import { z } from "genkit";
 import type { Timestamp } from "firebase-admin/firestore";
-import { LocaleSchema } from "../core";
+import { LocaleSchema, type Locale } from "../core";
 import {
   ModerationStatusSchema,
   PrioritySchema,
   SeveritySchema,
   SuggestionCategorySchema,
+  type ModerationStatus,
+  type Priority,
+  type Severity,
+  type SuggestionCategory,
 } from "./enums";
 
+export interface ModerationSuggestion {
+  category: SuggestionCategory;
+  field: string;
+  severity: Severity;
+  suggestion: string;
+}
+
 export const ModerationSuggestionSchema = z.object({
   category: SuggestionCategorySchema,
   field: z.string(),
   severity: SeveritySchema,
   suggestion: z.string(),
-});
-export type ModerationSuggestion = z.infer<typeof ModerationSuggestionSchema>;
+}) satisfies z.ZodType<ModerationSuggestion>;
+
+export interface Moderation {
+  assessedAt?: Timestamp;
+  createdAt: Timestamp;
+  id: string;
+  originalLocale: Locale;
+  priority: Priority;
+  qualityScore?: number;
+  recipeId: string;
+  rejectionReason?: string;
+  reviewedAt?: Timestamp;
+  reviewedBy?: string;
+  status: ModerationStatus;
+  suggestions?: ModerationSuggestion[];
+  userId: string;
+}
 
 export const ModerationSchema = z.object({
   assessedAt: z.custom<Timestamp>().optional(),
@@ -31,14 +57,26 @@ export const ModerationSchema = z.object({
   suggestions: z.array(ModerationSuggestionSchema).optional(),
   userId: z.string(),
 });
-export type Moderation = z.infer<typeof ModerationSchema>;
+
+export interface ModerateRecipeInput {
+  moderationId: string;
+  recipeId: string;
+  userId: string;
+}
 
 export const ModerateRecipeInputSchema = z.object({
   moderationId: z.string(),
   recipeId: z.string(),
   userId: z.string(),
-});
-export type ModerateRecipeInput = z.infer<typeof ModerateRecipeInputSchema>;
+}) satisfies z.ZodType<ModerateRecipeInput>;
+
+export interface ModerateRecipeOutput {
+  autoApproved: boolean;
+  autoRejected: boolean;
+  qualityScore: number;
+  rejectionReason?: string;
+  suggestions: ModerationSuggestion[];
+}
 
 export const ModerateRecipeOutputSchema = z.object({
   autoApproved: z.boolean(),
@@ -46,5 +84,4 @@ export const ModerateRecipeOutputSchema = z.object({
   qualityScore: z.number().min(0).max(1),
   rejectionReason: z.string().optional(),
   suggestions: z.array(ModerationSuggestionSchema),
-});
-export type ModerateRecipeOutput = z.infer<typeof ModerateRecipeOutputSchema>;
+}) satisfies z.ZodType<ModerateRecipeOutput>;

package/src/types/recipe/equipment.ts

@@ -1,21 +1,31 @@
 import { z } from "genkit";
 import { SLUG_REGEX } from "../../config";
 
+export interface EquipmentMeta {
+  required?: boolean;
+  slug: string;
+}
+
 export const EquipmentMetaSchema = z.object({
   required: z.boolean().optional(),
   slug: z.string().regex(SLUG_REGEX),
-});
-export type EquipmentMeta = z.infer<typeof EquipmentMetaSchema>;
+}) satisfies z.ZodType<EquipmentMeta>;
+
+export interface EquipmentContent {
+  name: string;
+  notes?: string;
+  slug: string;
+}
 
 export const EquipmentContentSchema = z.object({
   name: z.string().min(1).max(100),
   notes: z.string().max(200).optional(),
   slug: z.string().regex(SLUG_REGEX),
-});
-export type EquipmentContent = z.infer<typeof EquipmentContentSchema>;
+}) satisfies z.ZodType<EquipmentContent>;
+
+export interface Equipment extends EquipmentMeta, EquipmentContent {}
 
 export const EquipmentSchema = z.object({
   ...EquipmentMetaSchema.shape,
   ...EquipmentContentSchema.shape,
-});
-export type Equipment = z.infer<typeof EquipmentSchema>;
+}) satisfies z.ZodType<Equipment>;

package/src/types/recipe/filters.ts

@@ -5,8 +5,24 @@ import {
   DifficultySchema,
   MealTypeSchema,
   SpicinessSchema,
+  type Cuisine,
+  type DietaryTag,
+  type Difficulty,
+  type MealType,
+  type Spiciness,
 } from "./enums";
 
+export interface RecipeFilters {
+  cuisines?: Cuisine[];
+  dietaryTags?: DietaryTag[];
+  difficulty?: Difficulty;
+  excludeIngredients?: string[];
+  includeIngredients?: string[];
+  mealTypes?: MealType[];
+  spiciness?: Spiciness;
+  timeLimit?: number;
+}
+
 export const RecipeFiltersSchema = z.object({
   cuisines: z.array(CuisineSchema).optional(),
   dietaryTags: z.array(DietaryTagSchema).optional(),
@@ -16,5 +32,4 @@ export const RecipeFiltersSchema = z.object({
   mealTypes: z.array(MealTypeSchema).optional(),
   spiciness: SpicinessSchema.optional(),
   timeLimit: z.number().int().min(5).max(300).optional(),
-});
-export type RecipeFilters = z.infer<typeof RecipeFiltersSchema>;
+}) satisfies z.ZodType<RecipeFilters>;

package/src/types/recipe/ingredient.ts

@@ -1,46 +1,70 @@
 import { z } from "genkit";
 import { SLUG_REGEX } from "../../config";
-import { UnitSchema } from "./enums";
+import { UnitSchema, type Unit } from "./enums";
+
+export interface IngredientMeta {
+  quantity?: number;
+  required?: boolean;
+  slug: string;
+  unit?: Unit;
+}
 
 export const IngredientMetaSchema = z.object({
   quantity: z.number().positive().optional(),
   required: z.boolean().optional(),
   slug: z.string().regex(SLUG_REGEX),
   unit: UnitSchema.optional(),
-});
-export type IngredientMeta = z.infer<typeof IngredientMetaSchema>;
+}) satisfies z.ZodType<IngredientMeta>;
+
+export interface IngredientContent {
+  name: string;
+  notes?: string;
+  slug: string;
+}
 
 export const IngredientContentSchema = z.object({
   name: z.string().min(1).max(100),
   notes: z.string().max(200).optional(),
   slug: z.string().regex(SLUG_REGEX),
-});
-export type IngredientContent = z.infer<typeof IngredientContentSchema>;
+}) satisfies z.ZodType<IngredientContent>;
+
+export interface Ingredient extends IngredientMeta, IngredientContent {}
 
 export const IngredientSchema = z.object({
   ...IngredientMetaSchema.shape,
   ...IngredientContentSchema.shape,
-});
-export type Ingredient = z.infer<typeof IngredientSchema>;
+}) satisfies z.ZodType<Ingredient>;
+
+export interface IngredientSectionMeta {
+  ingredients: IngredientMeta[];
+  slug: string;
+}
 
 export const IngredientSectionMetaSchema = z.object({
   ingredients: z.array(IngredientMetaSchema).min(1),
   slug: z.string().regex(SLUG_REGEX),
-});
-export type IngredientSectionMeta = z.infer<typeof IngredientSectionMetaSchema>;
+}) satisfies z.ZodType<IngredientSectionMeta>;
+
+export interface IngredientSectionContent {
+  ingredients: IngredientContent[];
+  slug: string;
+  title?: string;
+}
 
 export const IngredientSectionContentSchema = z.object({
   ingredients: z.array(IngredientContentSchema).min(1),
   slug: z.string().regex(SLUG_REGEX),
   title: z.string().max(100).optional(),
-});
-export type IngredientSectionContent = z.infer<
-  typeof IngredientSectionContentSchema
->;
+}) satisfies z.ZodType<IngredientSectionContent>;
+
+export interface IngredientSection {
+  ingredients: Ingredient[];
+  slug: string;
+  title?: string;
+}
 
 export const IngredientSectionSchema = z.object({
   ingredients: z.array(IngredientSchema).min(1),
   slug: z.string().regex(SLUG_REGEX),
   title: z.string().max(100).optional(),
-});
-export type IngredientSection = z.infer<typeof IngredientSectionSchema>;
+}) satisfies z.ZodType<IngredientSection>;

package/src/types/recipe/instruction.ts

@@ -1,21 +1,31 @@
 import { z } from "genkit";
-import { TemperatureSchema } from "./temperature";
+import { TemperatureSchema, type Temperature } from "./temperature";
+
+export interface InstructionMeta {
+  duration?: number;
+  step: number;
+  temperature?: Temperature;
+}
 
 export const InstructionMetaSchema = z.object({
   duration: z.number().int().positive().optional(),
   step: z.number().int().positive(),
   temperature: TemperatureSchema.optional(),
-});
-export type InstructionMeta = z.infer<typeof InstructionMetaSchema>;
+}) satisfies z.ZodType<InstructionMeta>;
+
+export interface InstructionContent {
+  step: number;
+  text: string;
+}
 
 export const InstructionContentSchema = z.object({
   step: z.number().int().positive(),
   text: z.string().min(1).max(1000),
-});
-export type InstructionContent = z.infer<typeof InstructionContentSchema>;
+}) satisfies z.ZodType<InstructionContent>;
+
+export interface Instruction extends InstructionMeta, InstructionContent {}
 
 export const InstructionSchema = z.object({
   ...InstructionMetaSchema.shape,
   ...InstructionContentSchema.shape,
-});
-export type Instruction = z.infer<typeof InstructionSchema>;
+}) satisfies z.ZodType<Instruction>;

package/src/types/recipe/nutrition.ts

@@ -4,6 +4,18 @@ import { z } from "genkit";
  * Nutrition data per serving.
  * Units: calories (kcal), fat/carbs/protein/fiber/sugar (g), cholesterol/sodium (mg)
  */
+export interface Nutrition {
+  calories: number;
+  carbs?: number;
+  cholesterol?: number;
+  fat?: number;
+  fiber?: number;
+  protein?: number;
+  saturatedFat?: number;
+  sodium?: number;
+  sugar?: number;
+}
+
 export const NutritionSchema = z.object({
   calories: z.number().nonnegative(),
   carbs: z.number().nonnegative().optional(),
@@ -14,5 +26,4 @@ export const NutritionSchema = z.object({
   saturatedFat: z.number().nonnegative().optional(),
   sodium: z.number().nonnegative().optional(),
   sugar: z.number().nonnegative().optional(),
-});
-export type Nutrition = z.infer<typeof NutritionSchema>;
+}) satisfies z.ZodType<Nutrition>;

package/src/types/recipe/recipe.ts

@@ -1,6 +1,6 @@
 import { z } from "genkit";
 import type { Timestamp } from "firebase-admin/firestore";
-import { LocaleSchema } from "../core";
+import { LocaleSchema, type Locale } from "../core";
 import {
   AllergenSchema,
   CuisineSchema,
@@ -10,23 +10,66 @@ import {
   RecipeSourceSchema,
   RecipeStatusSchema,
   SpicinessSchema,
+  type Allergen,
+  type Cuisine,
+  type DietaryTag,
+  type Difficulty,
+  type MealType,
+  type RecipeSource,
+  type RecipeStatus,
+  type Spiciness,
 } from "./enums";
 import {
   EquipmentContentSchema,
   EquipmentMetaSchema,
   EquipmentSchema,
+  type Equipment,
+  type EquipmentContent,
+  type EquipmentMeta,
 } from "./equipment";
 import {
   IngredientSectionContentSchema,
   IngredientSectionMetaSchema,
   IngredientSectionSchema,
+  type IngredientSection,
+  type IngredientSectionContent,
+  type IngredientSectionMeta,
 } from "./ingredient";
 import {
   InstructionContentSchema,
   InstructionMetaSchema,
   InstructionSchema,
+  type Instruction,
+  type InstructionContent,
+  type InstructionMeta,
 } from "./instruction";
-import { NutritionSchema } from "./nutrition";
+import { NutritionSchema, type Nutrition } from "./nutrition";
+
+export interface RecipeMeta {
+  allergens: Allergen[];
+  confidence: number;
+  createdAt: Timestamp;
+  createdBy: string;
+  cuisine: Cuisine;
+  deletedAt?: Timestamp;
+  dietaryTags: DietaryTag[];
+  difficulty: Difficulty;
+  equipment?: EquipmentMeta[];
+  id: string;
+  imageUrl?: string;
+  ingredientSections: IngredientSectionMeta[];
+  instructions: InstructionMeta[];
+  mealTypes: MealType[];
+  nutrition?: Nutrition;
+  originalLocale: Locale;
+  servings: number;
+  source: RecipeSource;
+  sourceUrl?: string;
+  spiciness: Spiciness;
+  status: RecipeStatus;
+  time: number;
+  updatedAt: Timestamp;
+}
 
 export const RecipeMetaSchema = z.object({
   allergens: z.array(AllergenSchema),
@@ -53,7 +96,16 @@ export const RecipeMetaSchema = z.object({
   time: z.number().int().min(1).max(1440),
   updatedAt: z.custom<Timestamp>(),
 });
-export type RecipeMeta = z.infer<typeof RecipeMetaSchema>;
+
+export interface RecipeContent {
+  description: string;
+  equipment?: EquipmentContent[];
+  ingredientSections: IngredientSectionContent[];
+  instructions: InstructionContent[];
+  locale: Locale;
+  tips?: string[];
+  title: string;
+}
 
 export const RecipeContentSchema = z.object({
   description: z.string().min(10).max(2000),
@@ -63,8 +115,37 @@ export const RecipeContentSchema = z.object({
   locale: LocaleSchema,
   tips: z.array(z.string().max(500)).max(20).optional(),
   title: z.string().min(3).max(200),
-});
-export type RecipeContent = z.infer<typeof RecipeContentSchema>;
+}) satisfies z.ZodType<RecipeContent>;
+
+export interface Recipe {
+  allergens: Allergen[];
+  confidence: number;
+  createdAt: Timestamp;
+  createdBy: string;
+  cuisine: Cuisine;
+  deletedAt?: Timestamp;
+  description: string;
+  dietaryTags: DietaryTag[];
+  difficulty: Difficulty;
+  equipment?: Equipment[];
+  id: string;
+  imageUrl?: string;
+  ingredientSections: IngredientSection[];
+  instructions: Instruction[];
+  locale: Locale;
+  mealTypes: MealType[];
+  nutrition?: Nutrition;
+  originalLocale: Locale;
+  servings: number;
+  source: RecipeSource;
+  sourceUrl?: string;
+  spiciness: Spiciness;
+  status: RecipeStatus;
+  time: number;
+  tips?: string[];
+  title: string;
+  updatedAt: Timestamp;
+}
 
 export const RecipeSchema = z.object({
   allergens: z.array(AllergenSchema),
@@ -95,7 +176,16 @@ export const RecipeSchema = z.object({
   title: z.string().min(3).max(200),
   updatedAt: z.custom<Timestamp>(),
 });
-export type Recipe = z.infer<typeof RecipeSchema>;
+
+export interface RecipeStats {
+  comments: number;
+  likes: number;
+  rating: number;
+  ratingCount: number;
+  saves: number;
+  updatedAt: number;
+  views: number;
+}
 
 export const RecipeStatsSchema = z.object({
   comments: z.number().int().nonnegative(),
@@ -105,5 +195,4 @@ export const RecipeStatsSchema = z.object({
   saves: z.number().int().nonnegative(),
   updatedAt: z.number().int(),
   views: z.number().int().nonnegative(),
-});
-export type RecipeStats = z.infer<typeof RecipeStatsSchema>;
+}) satisfies z.ZodType<RecipeStats>;

package/src/types/recipe/temperature.ts

@@ -1,8 +1,12 @@
 import { z } from "genkit";
-import { TemperatureUnitSchema } from "./enums";
+import { TemperatureUnitSchema, type TemperatureUnit } from "./enums";
+
+export interface Temperature {
+  unit: TemperatureUnit;
+  value: number;
+}
 
 export const TemperatureSchema = z.object({
   unit: TemperatureUnitSchema,
   value: z.number().min(-50).max(1000),
-});
-export type Temperature = z.infer<typeof TemperatureSchema>;
+}) satisfies z.ZodType<Temperature>;

package/src/types/report/report.ts

@@ -5,15 +5,46 @@ import {
   ReportStatusSchema,
   ReportTargetTypeSchema,
   ReportTypeSchema,
+  type ReportPriority,
+  type ReportStatus,
+  type ReportTargetType,
+  type ReportType,
 } from "./enums";
 
+export interface ReportEvidence {
+  aiScore?: number;
+  aiSuggestions?: Record<string, unknown>[];
+  contentSnapshot?: string;
+  imageHashes?: string[];
+}
+
 export const ReportEvidenceSchema = z.object({
   aiScore: z.number().min(0).max(1).optional(),
   aiSuggestions: z.array(z.record(z.string(), z.unknown())).optional(),
   contentSnapshot: z.string().optional(),
   imageHashes: z.array(z.string()).optional(),
-});
-export type ReportEvidence = z.infer<typeof ReportEvidenceSchema>;
+}) satisfies z.ZodType<ReportEvidence>;
+
+export interface Report {
+  categories: string[];
+  createdAt: Timestamp;
+  description: string;
+  evidence?: ReportEvidence;
+  id: string;
+  notes?: string;
+  priority: ReportPriority;
+  reason: string;
+  reportedBy?: string;
+  resolution?: string;
+  reviewedAt?: Timestamp;
+  reviewedBy?: string;
+  status: ReportStatus;
+  targetId: string;
+  targetType: ReportTargetType;
+  type: ReportType;
+  updatedAt: Timestamp;
+  userId: string;
+}
 
 export const ReportSchema = z.object({
   categories: z.array(z.string()),
@@ -35,4 +66,3 @@ export const ReportSchema = z.object({
   updatedAt: z.custom<Timestamp>(),
   userId: z.string(),
 });
-export type Report = z.infer<typeof ReportSchema>;