One typed model for every app that shares your data

// @generated by @metaobjectsdev/codegen-ts — hand edits are kept by a three-way merge on regeneration; meta verify --codegen checks only the generated parts.
// Source metadata: Subscriber (Subscriber)
// Extend in your own module (e.g. Subscriber.extra.ts) — nothing imports it for you.
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
import { check, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
import { z } from "zod";

export const subscribers = sqliteTable(
  "subscribers",
  {
    id: integer("id").primaryKey({ autoIncrement: true }),
    email: text("email").notNull(),
    name: text("name"),
    status: text("status", {
      enum: ["active", "paused", "cancelled"] as const,
    }).notNull(),
    createdAt: text("created_at").$defaultFn(() => new Date().toISOString()),
  },
  (table) => [
    check(
      "subscribers_status_chk",
      sql`status IN ('active', 'paused', 'cancelled')`,
    ),
  ],
);
export type Subscriber = InferSelectModel<typeof subscribers>;
export type SubscriberInsert = InferInsertModel<typeof subscribers>;
export type SubscriberUpdate = Partial<SubscriberInsert>;
export type SubscriberStatus = "active" | "paused" | "cancelled";
export const SubscriberStatusEnum = z.enum(["active", "paused", "cancelled"]);
/** A field.timestamp instant in UTC (`YYYY-MM-DDTHH:MM:SS[.fff]Z`): a value already spelled so is kept
 *  as sent, an offset is applied, a zoneless value is UTC and a date alone is midnight UTC.
 *  SQLite/D1 compare timestamps as text, so instants are stored in UTC. Generated. */
function utcIsoTimestamp(v: string): string {
  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(v)) {
    return v;
  }
  const m =
    /^(\d{4}-\d{2}-\d{2})(?:[Tt ](\d{2}:\d{2})(?::(\d{2})(?:\.(\d+))?)?(?:([Zz])|([+-]\d{2}):?(\d{2})?)?)?$/.exec(
      v,
    );
  if (m === null) {
    return v;
  }
  const t = Date.parse(
    `${m[1]}T${m[2] ?? "00:00"}:${m[3] ?? "00"}.${(m[4] ?? "").slice(0, 3).padEnd(3, "0")}${
      m[6] === undefined ? "Z" : `${m[6]}:${m[7] ?? "00"}`
    }`,
  );
  return Number.isNaN(t)
    ? v
    : new Date(t).toISOString().replace(/\.?0+Z$/, "Z");
}

export const SubscriberInsertSchema = z.object({
  email: z.string().min(1).max(320),
  name: z.string().optional(),
  status: z.enum(["active", "paused", "cancelled"]),
  createdAt: z
    .string()
    .optional()
    .transform(() => new Date().toISOString()),
});

export const SubscriberUpdateSchema = z.object({
  email: z.string().min(1).max(320).optional(),
  name: z.string().optional().nullable(),
  status: z.enum(["active", "paused", "cancelled"]).optional(),
});

/** Typed create shape for Subscriber: the insert schema's INPUT (pre-transform) type. A
 * renamed/dropped/misspelt field is a compile error at every `createSubscriber` call site;
 * the schema still validates at runtime. */
export type SubscriberCreate = z.input<typeof SubscriberInsertSchema>;

/** Typed patch shape for Subscriber: every settable field, optional (FR-035 PATCH). A
 * renamed/dropped field is a compile error at every `updateSubscriber` call site. */
export type SubscriberPatch = z.input<typeof SubscriberUpdateSchema>;

/** Insert-shape for import / restore / replication of Subscriber: identical to
 * SubscriberInsertSchema, but the @autoSet timestamp columns are written VERBATIM
 * (no create-time now() stamp) so the caller's original values are preserved. */
export const SubscriberInsertPreservingSchema = z.object({
  email: z.string().min(1).max(320),
  name: z.string().optional(),
  status: z.enum(["active", "paused", "cancelled"]),
  createdAt: z
    .string()
    .regex(
      /^(?:\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|02-(?:0[1-9]|1\d|2[0-8]))|(?:\d{2}(?:0[48]|[2468][048]|[13579][26])|(?:[02468][048]|[13579][26])00)-02-29)(?:[Tt ](?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?(?:[Zz]|[+-](?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?$/,
      "must be an ISO 8601 timestamp (YYYY-MM-DD[THH:MM[:SS[.fff]]][Z|±HH:MM])",
    )
    .transform(utcIsoTimestamp)
    .optional(),
});

/** Typed input of `insertPreservingSubscriber` — SubscriberInsertPreservingSchema's pre-transform shape. */
export type SubscriberCreatePreserving = z.input<
  typeof SubscriberInsertPreservingSchema
>;
/**
 * Metadata constants for Subscriber.
 *
 * Use these instead of magic strings so TS catches typos and refactors stay
 * coherent. Each non-dollar-prefixed key is a per-field object carrying
 * name, label, view, an htmlType where the field's view maps to one, and the
 * RHF-shaped validation rules derived from the field's validator children.
 *
 * placeholder and helpText are NOT emitted — no provider registers an attribute
 * for them, so nothing here could derive one. (htmlType is emitted, but derived
 * from the view subtype; the @htmlType override was removed for the same reason.)
 * useEntityForm still honours placeholder if you add it: this file is generated,
 * hand edits inside it survive regeneration through the three-way merge, and the
 * consumers read this const rather than the metadata. That is the intended way
 * to set it.
 *
 * Typical usage with the metaobjects React form helper:
 *
 *   import { useEntityForm } from '@metaobjectsdev/react';
 *   const form = useEntityForm(Subscriber, SubscriberInsertSchema);
 *   <input {...form.input.id} />
 */
export const Subscriber = {
  $entity: "Subscriber",
  $table: "subscribers",
  $path: "/subscribers",
  id: { name: "id", label: "Id", view: "number", htmlType: "number" },
  email: {
    name: "email",
    label: "Email",
    view: "text",
    htmlType: "text",
    rules: {
      required: "Email is required",
      maxLength: { value: 320, message: "Must be 320 characters or fewer" },
    },
  },
  name: { name: "name", label: "Name", view: "text", htmlType: "text" },
  status: {
    name: "status",
    label: "Status",
    view: "dropdown",
    rules: { required: "Status is required" },
    options: ["active", "paused", "cancelled"] as const,
  },
  createdAt: {
    name: "createdAt",
    label: "Created At",
    view: "date",
    htmlType: "datetime-local",
  },
} as const;
import type { FilterAllowlist } from "../../codegen/runtime/drizzle-fastify/filter-allowlist";

export const SubscriberFilterAllowlist = {} as const satisfies FilterAllowlist;
import type { SortAllowlist } from "../../codegen/runtime/drizzle-fastify/filter-allowlist";

export const SubscriberSortAllowlist = {} as const satisfies SortAllowlist;
export type SubscriberFilter = {
  limit?: number;
  offset?: number;
  sort?: string;
  or?: SubscriberFilter[];
  and?: SubscriberFilter[];
};

package acme;

import jakarta.validation.constraints.*;

/** GENERATED — wire DTO for Subscriber. Do not hand-edit; regenerated from metadata. */
public record SubscriberDto(
    Long id,
    @NotNull @Size(min = 1, max = 320) String email,
    String name,
    @NotNull SubscriberStatus status,
    java.time.Instant createdAt
) {
    public enum SubscriberStatus { active, paused, cancelled }

    /** Issue #203 @autoSet: a copy with every @autoSet column (onCreate AND onUpdate) stamped to now() on insert (the model value is ignored; a fresh row's updated_at equals its created_at). */
    public static SubscriberDto stampForInsert(SubscriberDto dto) {
        java.time.Instant __nowInstant = java.time.Instant.now();
        return new SubscriberDto(
            dto.id(),
            dto.email(),
            dto.name(),
            dto.status(),
            __nowInstant
        );
    }

    /** Issue #203 @autoSet: a copy with @autoSet onUpdate columns stamped to now(); onCreate columns are preserved (never rewrites created_at — the full-DTO update path). */
    public static SubscriberDto stampForUpdate(SubscriberDto dto) {
        return new SubscriberDto(
            dto.id(),
            dto.email(),
            dto.name(),
            dto.status(),
            dto.createdAt()
        );
    }

    /** Issue #203 @autoSet escape hatch: the DTO written VERBATIM (import/restore/replication). */
    public static SubscriberDto insertPreserving(SubscriberDto dto) { return dto; }

    /** A fluent builder, so a caller can set a subset of the components. */
    public static Builder builder() { return new Builder(); }

    /** Builds a {@link SubscriberDto}; an unset component stays null. */
    public static final class Builder {
        private Long id;
        private String email;
        private String name;
        private SubscriberStatus status;
        private java.time.Instant createdAt;

        private Builder() {}

        public Builder id(Long v) { this.id = v; return this; }
        public Builder email(String v) { this.email = v; return this; }
        public Builder name(String v) { this.name = v; return this; }
        public Builder status(SubscriberStatus v) { this.status = v; return this; }
        public Builder createdAt(java.time.Instant v) { this.createdAt = v; return this; }

        public SubscriberDto build() { return new SubscriberDto(id, email, name, status, createdAt); }
    }
}

package acme

import jakarta.validation.constraints.NotNull
import jakarta.validation.constraints.Size
import java.time.Instant
import kotlin.Long
import kotlin.String
import kotlin.jvm.JvmStatic

/**
 * GENERATED — do not hand-edit. Regenerated from metadata.
 */
public data class Subscriber(
  public val id: Long? = null,
  @field:NotNull
  @field:Size(min = 1, max = 320)
  public val email: String,
  public val name: String? = null,
  @field:NotNull
  public val status: SubscriberStatus,
  public val createdAt: Instant? = null,
) {
  /**
   * Fluent builder — lets a JAVA caller set a subset of properties.
   */
  public class Builder {
    private var id: Long? = null

    private var email: String? = null

    private var name: String? = null

    private var status: SubscriberStatus? = null

    private var createdAt: Instant? = null

    public fun id(v: Long?): Builder {
      this.id = v
      return this
    }

    public fun email(v: String?): Builder {
      this.email = v
      return this
    }

    public fun name(v: String?): Builder {
      this.name = v
      return this
    }

    public fun status(v: SubscriberStatus?): Builder {
      this.status = v
      return this
    }

    public fun createdAt(v: Instant?): Builder {
      this.createdAt = v
      return this
    }

    public fun build(): Subscriber = Subscriber(
      id = id,
      email = requireNotNull(email) { "email is required" },
      name = name,
      status = requireNotNull(status) { "status is required" },
      createdAt = createdAt
    )
  }

  public companion object {
    @JvmStatic
    public fun builder(): Builder = Builder()
  }
}

// <auto-generated/>
// Generated by MetaObjects entity-generator. Do not edit by hand.
#nullable enable
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace Generated;

[Table(SubscriberNames.SourcePrimaryTable)]
public class Subscriber
{
    public enum SubscriberStatus { active, paused, cancelled }
    [Key]
    [Column(SubscriberNames.IdColumn)]
    public long Id { get; set; }
    [Column(SubscriberNames.EmailColumn)]
    [Required(AllowEmptyStrings = true)]
    [MaxLength(320)]
    [MinLength(1)]
    public string Email { get; set; } = default!;
    [Column(SubscriberNames.NameColumn)]
    public string? Name { get; set; }
    [Column(SubscriberNames.StatusColumn)]
    public SubscriberStatus Status { get; set; }
    [Column(SubscriberNames.CreatedAtColumn)]
    public DateTimeOffset? CreatedAt { get; set; }
}

# @generated by metaobjects — DO NOT EDIT.
# Source metadata: Subscriber (acme::Subscriber)
# Extend in your own module (e.g. Subscriber_extra.py) — nothing imports it for you.

from __future__ import annotations

import datetime
from typing import Literal

from pydantic import BaseModel, Field


class Subscriber(BaseModel):
    id: int | None = None
    email: str = Field(max_length=320)
    name: str | None = None
    status: Literal["active", "paused", "cancelled"]
    createdAt: datetime.datetime | None = None


class SubscriberCreate(BaseModel):
    """GENERATED — CREATE input: auto-gen PK / @mutability readOnly omitted (writeOnce is settable here, once); @default/@autoSet optional; present values validated (FR-036)."""

    email: str = Field(min_length=1, max_length=320)
    name: str | None = None
    status: Literal["active", "paused", "cancelled"]
    createdAt: datetime.datetime | None = None


class SubscriberPatch(BaseModel):
    """GENERATED — PATCH input: all fields optional (PK, @mutability readOnly and writeOnce excluded); present values validated (FR-036)."""

    email: str | None = Field(default=None, min_length=1, max_length=320)
    name: str | None = None
    status: Literal["active", "paused", "cancelled"] | None = None
    createdAt: datetime.datetime | None = None

// @generated by @metaobjectsdev/codegen-ts — hand edits are kept by a three-way merge on regeneration; meta verify --codegen checks only the generated parts.
// Source metadata: Author (Author)
// Extend in your own module (e.g. Author.extra.ts) — nothing imports it for you.
import type { InferInsertModel, InferSelectModel } from "drizzle-orm";
import { pgTable, uuid, varchar } from "drizzle-orm/pg-core";
import { z } from "zod";

export const authors = pgTable("authors", {
  id: uuid("id").primaryKey().defaultRandom(),
  name: varchar("name", { length: 120 }).notNull(),
  email: varchar("email", { length: 320 }).notNull(),
  bio: varchar("bio", { length: 2000 }),
});
export type Author = InferSelectModel<typeof authors>;
export type AuthorInsert = InferInsertModel<typeof authors>;
export type AuthorUpdate = Partial<AuthorInsert>;
export const AuthorInsertSchema = z.object({
  name: z.string().min(1).max(120),
  email: z.string().min(1).max(320).regex(new RegExp("^(?:[^@]+@[^@]+)$")),
  bio: z.string().max(500).optional(),
});

export const AuthorUpdateSchema = z.object({
  name: z.string().min(1).max(120).optional(),
  email: z
    .string()
    .min(1)
    .max(320)
    .regex(new RegExp("^(?:[^@]+@[^@]+)$"))
    .optional(),
  bio: z.string().max(500).optional().nullable(),
});

/** Typed create shape for Author: the insert schema's INPUT (pre-transform) type. A
 * renamed/dropped/misspelt field is a compile error at every `createAuthor` call site;
 * the schema still validates at runtime. */
export type AuthorCreate = z.input<typeof AuthorInsertSchema>;

/** Typed patch shape for Author: every settable field, optional (FR-035 PATCH). A
 * renamed/dropped field is a compile error at every `updateAuthor` call site. */
export type AuthorPatch = z.input<typeof AuthorUpdateSchema>;
/**
 * Metadata constants for Author.
 *
 * Use these instead of magic strings so TS catches typos and refactors stay
 * coherent. Each non-dollar-prefixed key is a per-field object carrying
 * name, label, view, an htmlType where the field's view maps to one, and the
 * RHF-shaped validation rules derived from the field's validator children.
 *
 * placeholder and helpText are NOT emitted — no provider registers an attribute
 * for them, so nothing here could derive one. (htmlType is emitted, but derived
 * from the view subtype; the @htmlType override was removed for the same reason.)
 * useEntityForm still honours placeholder if you add it: this file is generated,
 * hand edits inside it survive regeneration through the three-way merge, and the
 * consumers read this const rather than the metadata. That is the intended way
 * to set it.
 *
 * Typical usage with the metaobjects React form helper:
 *
 *   import { useEntityForm } from '@metaobjectsdev/react';
 *   const form = useEntityForm(Author, AuthorInsertSchema);
 *   <input {...form.input.id} />
 */
export const Author = {
  $entity: "Author",
  $table: "authors",
  $path: "/authors",
  id: { name: "id", label: "Id", view: "text", htmlType: "text" },
  name: {
    name: "name",
    label: "Name",
    view: "text",
    htmlType: "text",
    rules: {
      required: "Name is required",
      maxLength: { value: 120, message: "Must be 120 characters or fewer" },
    },
  },
  email: {
    name: "email",
    label: "Email",
    view: "text",
    htmlType: "text",
    rules: {
      pattern: { value: /[^@]+@[^@]+/, message: "Invalid format" },
      required: "Email is required",
      maxLength: { value: 320, message: "Must be 320 characters or fewer" },
    },
  },
  bio: {
    name: "bio",
    label: "Bio",
    view: "text",
    htmlType: "text",
    rules: {
      minLength: { value: 0, message: "Must be at least 0 characters" },
      maxLength: { value: 500, message: "Must be 500 characters or fewer" },
    },
  },
} as const;
import type { FilterAllowlist } from "../../codegen/runtime/drizzle-fastify/filter-allowlist";

export const AuthorFilterAllowlist = {} as const satisfies FilterAllowlist;
import type { SortAllowlist } from "../../codegen/runtime/drizzle-fastify/filter-allowlist";

export const AuthorSortAllowlist = {} as const satisfies SortAllowlist;
export type AuthorFilter = {
  limit?: number;
  offset?: number;
  sort?: string;
  or?: AuthorFilter[];
  and?: AuthorFilter[];
};

// @generated by @metaobjectsdev/codegen-ts — hand edits are kept by a three-way merge on regeneration; meta verify --codegen checks only the generated parts.
// Source metadata: Program (Program)
// Extend in your own module (e.g. Program.extra.ts) — nothing imports it for you.
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
import {
  type AnyPgColumn,
  bigint,
  check,
  jsonb,
  pgTable,
  text,
  uuid,
  varchar,
} from "drizzle-orm/pg-core";
import { z } from "zod";
import { authors } from "./Author";
import {
  type InstructorProfile,
  InstructorProfileInsertSchema,
} from "./InstructorProfile";
import {
  type SyllabusSection,
  SyllabusSectionInsertSchema,
} from "./SyllabusSection";

export const programs = pgTable(
  "programs",
  {
    id: uuid("id").primaryKey().defaultRandom(),
    title: varchar("title", { length: 200 }).notNull(),
    status: text("status", {
      enum: ["draft", "published", "archived"] as const,
    }),
    summary: varchar("summary", { length: 2000 }),
    priceCents: bigint("price_cents", { mode: "number" }),
    coverKey: varchar("cover_key", { length: 80 }),
    authorId: uuid("author_id")
      .notNull()
      .references((): AnyPgColumn => authors.id),
    syllabus: jsonb("syllabus").$type<SyllabusSection[]>(),
    instructorProfile: jsonb("instructor_profile").$type<InstructorProfile>(),
  },
  (table) => [
    check(
      "programs_status_chk",
      sql`status IN ('draft', 'published', 'archived')`,
    ),
  ],
);
export type Program = InferSelectModel<typeof programs>;
export type ProgramInsert = InferInsertModel<typeof programs>;
export type ProgramUpdate = Partial<ProgramInsert>;
export type ProgramStatus = "draft" | "published" | "archived";
export const ProgramStatusEnum = z.enum(["draft", "published", "archived"]);
export const ProgramInsertSchema = z.object({
  title: z.string().min(1).max(200),
  status: z.enum(["draft", "published", "archived"]).optional(),
  summary: z.string().max(2000).optional(),
  priceCents: z.number().int().optional(),
  coverKey: z.string().max(80).optional(),
  authorId: z.string(),
  syllabus: z.array(SyllabusSectionInsertSchema).optional(),
  instructorProfile: InstructorProfileInsertSchema.optional(),
});

export const ProgramUpdateSchema = z.object({
  title: z.string().min(1).max(200).optional(),
  status: z.enum(["draft", "published", "archived"]).optional().nullable(),
  summary: z.string().max(2000).optional().nullable(),
  priceCents: z.number().int().optional().nullable(),
  coverKey: z.string().max(80).optional().nullable(),
  authorId: z.string().optional(),
  syllabus: z.array(SyllabusSectionInsertSchema).optional().nullable(),
  instructorProfile: InstructorProfileInsertSchema.optional().nullable(),
});

/** Typed create shape for Program: the insert schema's INPUT (pre-transform) type. A
 * renamed/dropped/misspelt field is a compile error at every `createProgram` call site;
 * the schema still validates at runtime. */
export type ProgramCreate = z.input<typeof ProgramInsertSchema>;

/** Typed patch shape for Program: every settable field, optional (FR-035 PATCH). A
 * renamed/dropped field is a compile error at every `updateProgram` call site. */
export type ProgramPatch = z.input<typeof ProgramUpdateSchema>;
/**
 * Metadata constants for Program.
 *
 * Use these instead of magic strings so TS catches typos and refactors stay
 * coherent. Each non-dollar-prefixed key is a per-field object carrying
 * name, label, view, an htmlType where the field's view maps to one, and the
 * RHF-shaped validation rules derived from the field's validator children.
 *
 * placeholder and helpText are NOT emitted — no provider registers an attribute
 * for them, so nothing here could derive one. (htmlType is emitted, but derived
 * from the view subtype; the @htmlType override was removed for the same reason.)
 * useEntityForm still honours placeholder if you add it: this file is generated,
 * hand edits inside it survive regeneration through the three-way merge, and the
 * consumers read this const rather than the metadata. That is the intended way
 * to set it.
 *
 * Typical usage with the metaobjects React form helper:
 *
 *   import { useEntityForm } from '@metaobjectsdev/react';
 *   const form = useEntityForm(Program, ProgramInsertSchema);
 *   <input {...form.input.id} />
 */
export const Program = {
  $entity: "Program",
  $table: "programs",
  $path: "/programs",
  id: { name: "id", label: "Id", view: "text", htmlType: "text" },
  title: {
    name: "title",
    label: "Title",
    view: "text",
    htmlType: "text",
    rules: {
      required: "Title is required",
      maxLength: { value: 200, message: "Must be 200 characters or fewer" },
    },
  },
  status: {
    name: "status",
    label: "Status",
    view: "dropdown",
    options: ["draft", "published", "archived"] as const,
  },
  summary: {
    name: "summary",
    label: "Summary",
    view: "textarea",
    rules: {
      maxLength: { value: 2000, message: "Must be 2000 characters or fewer" },
    },
  },
  priceCents: {
    name: "priceCents",
    label: "Price Cents",
    view: "currency",
    currency: "USD",
    locale: "en-US",
  },
  coverKey: {
    name: "coverKey",
    label: "Cover Key",
    view: "image",
    rules: {
      maxLength: { value: 80, message: "Must be 80 characters or fewer" },
    },
  },
  authorId: {
    name: "authorId",
    label: "Author Id",
    view: "text",
    htmlType: "text",
    rules: { required: "Author Id is required" },
  },
  syllabus: {
    name: "syllabus",
    label: "Syllabus",
    view: "text",
    htmlType: "text",
  },
  instructorProfile: {
    name: "instructorProfile",
    label: "Instructor Profile",
    view: "text",
    htmlType: "text",
  },
} as const;
import type { FilterAllowlist } from "../../codegen/runtime/drizzle-fastify/filter-allowlist";

export const ProgramFilterAllowlist = {} as const satisfies FilterAllowlist;
import type { SortAllowlist } from "../../codegen/runtime/drizzle-fastify/filter-allowlist";

export const ProgramSortAllowlist = {} as const satisfies SortAllowlist;
export type ProgramFilter = {
  limit?: number;
  offset?: number;
  sort?: string;
  or?: ProgramFilter[];
  and?: ProgramFilter[];
};

// @generated by @metaobjectsdev/codegen-ts — hand edits are kept by a three-way merge on regeneration; meta verify --codegen checks only the generated parts.
// Source metadata: ProgramSummary (ProgramSummary)
import {
  bigint,
  boolean,
  pgView,
  text,
  uuid,
  varchar,
} from "drizzle-orm/pg-core";
import { z } from "zod";

// View declaration — Drizzle uses this for typed SELECT queries.
// The SQL view is created/managed by migrate-ts; .existing() tells Drizzle
// not to attempt DDL for this declaration.
export const programSummaryView = pgView("v_program_summary", {
  id: uuid("id").notNull(),
  title: varchar("title", { length: 200 }).notNull(),
  authorName: text("author_name"),
  lessonCount: bigint("lesson_count", { mode: "number" }),
  completedRevenueCents: bigint("completed_revenue_cents", { mode: "number" }),
  hasCoverArt: boolean("has_cover_art"),
}).existing();
export const ProgramSummarySchema = z.object({
  id: z.string(),
  title: z.string(),
  authorName: z.string().nullable(),
  lessonCount: z.number().int().nullable(),
  completedRevenueCents: z.number().int().nullable(),
  hasCoverArt: z.boolean().nullable(),
});
export type ProgramSummary = z.infer<typeof ProgramSummarySchema>;
export const ProgramSummary = {
  $entity: "ProgramSummary",
  $view: "v_program_summary",
  $path: "/program_summaries",
  id: { name: "id", label: "Id", view: "text", dbCol: "id" },
  title: { name: "title", label: "Title", view: "text", dbCol: "title" },
  authorName: {
    name: "authorName",
    label: "Author Name",
    view: "text",
    dbCol: "author_name",
  },
  lessonCount: {
    name: "lessonCount",
    label: "Lesson Count",
    view: "number",
    dbCol: "lesson_count",
  },
  completedRevenueCents: {
    name: "completedRevenueCents",
    label: "Completed Revenue Cents",
    view: "currency",
    dbCol: "completed_revenue_cents",
    currency: "USD",
    locale: "en-US",
  },
  hasCoverArt: {
    name: "hasCoverArt",
    label: "Has Cover Art",
    view: "checkbox",
    dbCol: "has_cover_art",
  },
} as const;
import type { FilterAllowlist } from "../../codegen/runtime/drizzle-fastify/filter-allowlist";

export const ProgramSummaryFilterAllowlist =
  {} as const satisfies FilterAllowlist;
import type { SortAllowlist } from "../../codegen/runtime/drizzle-fastify/filter-allowlist";

export const ProgramSummarySortAllowlist = {} as const satisfies SortAllowlist;
export type ProgramSummaryFilter = {
  limit?: number;
  offset?: number;
  sort?: string;
  or?: ProgramSummaryFilter[];
  and?: ProgramSummaryFilter[];
};