@idelio/contracts 0.1.0-beta.0

package/dist/brands.js

@@ -0,0 +1,364 @@
+import { z } from "zod";
+import { brandStyles, creativeDirectionSchema } from "./creative-direction.js";
+export const brandStatuses = ["draft", "generating", "ready", "failed"];
+export const teamTiers = ["flash", "studio", "elite"];
+export const assetKinds = [
+    "logo",
+    "logo_alternative",
+    "logo_wordmark",
+    "color_palette",
+    "font_pairing",
+    "logo_mono",
+    "logo_reversed",
+    "favicon",
+    "brand_guide",
+    "profile_avatar",
+    "social_x",
+    "social_linkedin",
+    "social_linkedin_personal",
+    "social_facebook",
+    "social_youtube",
+    "social_post",
+    "social_story",
+    "app_icon",
+    "og_image",
+    "email_signature",
+    "hero_image",
+    "play_feature_graphic",
+    "business_card",
+    "letterhead",
+    "mockup",
+    "custom_image",
+];
+export const requiredAssetKinds = [
+    "logo",
+    "logo_alternative",
+    "logo_wordmark",
+    "color_palette",
+    "font_pairing",
+];
+export function isRequiredAssetKind(kind) {
+    return requiredAssetKinds.includes(kind);
+}
+export const defaultLockedAssetKinds = requiredAssetKinds;
+export function isDefaultLockedAssetKind(kind) {
+    return defaultLockedAssetKinds.includes(kind);
+}
+export const templatedAssetKinds = ["hero_image"];
+export const flashUnavailableAssetKinds = ["mockup", ...templatedAssetKinds];
+export const expandableAssetKinds = assetKinds.filter((kind) => kind !== "logo");
+export const regenerableAssetKinds = [
+    "color_palette",
+    "font_pairing",
+    "logo_wordmark",
+    "business_card",
+    "letterhead",
+    "mockup",
+    "og_image",
+    "email_signature",
+    "hero_image",
+    "play_feature_graphic",
+    "social_x",
+    "social_linkedin",
+    "social_linkedin_personal",
+    "social_facebook",
+    "social_youtube",
+    "social_post",
+    "social_story",
+];
+export const suggestableAssetKinds = [
+    "logo_alternative",
+    "logo_wordmark",
+    "logo_mono",
+    "logo_reversed",
+    "favicon",
+    "brand_guide",
+    "profile_avatar",
+    "social_x",
+    "social_linkedin",
+    "social_linkedin_personal",
+    "social_facebook",
+    "social_youtube",
+    "social_post",
+    "social_story",
+    "app_icon",
+    "og_image",
+    "email_signature",
+    "hero_image",
+    "play_feature_graphic",
+    "business_card",
+    "letterhead",
+    "mockup",
+];
+export const suggestionItemKinds = [...suggestableAssetKinds, "custom_image"];
+export function nextSuggestableKinds(owned, count = 3) {
+    const ownedSet = new Set(owned);
+    return suggestableAssetKinds.filter((kind) => !ownedSet.has(kind)).slice(0, count);
+}
+export const composedAssetKinds = [
+    "favicon",
+    "app_icon",
+    "business_card",
+    "letterhead",
+    "og_image",
+    "email_signature",
+    "play_feature_graphic",
+    "profile_avatar",
+    "social_x",
+    "social_linkedin",
+    "social_linkedin_personal",
+    "social_facebook",
+    "social_youtube",
+    "social_post",
+    "social_story",
+];
+export function isComposedAssetKind(kind) {
+    return composedAssetKinds.includes(kind);
+}
+export const markRequiringAssetKinds = [
+    "logo_alternative",
+    "logo_mono",
+    "logo_reversed",
+    "brand_guide",
+    ...composedAssetKinds,
+];
+export function isMarkRequiringAssetKind(kind) {
+    return markRequiringAssetKinds.includes(kind);
+}
+export const generationLocksSchema = z.object({
+    colors: z.boolean().default(false),
+    typography: z.boolean().default(false),
+    icon: z.boolean().default(false),
+});
+export const createBrandRequestSchema = z
+    .object({
+    prompt: z.string().min(8).optional(),
+    template_id: z.string().optional(),
+    name: z.string().min(1).max(80).optional(),
+    tagline: z.string().min(1).max(60).optional(),
+    assets: z.array(z.enum(assetKinds)).optional(),
+    team: z.enum(teamTiers).default("studio"),
+    customize: z
+        .object({
+        palette: z.record(z.string(), z.string()).optional(),
+        typography: z.record(z.string(), z.string()).optional(),
+        logo_direction: z.string().optional(),
+    })
+        .optional(),
+    creative_direction: creativeDirectionSchema.optional(),
+    auto_select_logo: z.boolean().optional(),
+})
+    .refine((v) => v.prompt !== undefined || v.template_id !== undefined, {
+    message: "either prompt or template_id is required",
+})
+    .superRefine((v, ctx) => {
+    if (v.assets === undefined || v.assets.length === 0)
+        return;
+    const missing = requiredAssetKinds.filter((kind) => !v.assets?.includes(kind));
+    if (missing.length > 0) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["assets"],
+            params: { code: "required_assets_missing" },
+            message: `Every new brand includes ${requiredAssetKinds.join(", ")}; missing: ${missing.join(", ")}`,
+        });
+    }
+});
+const generationLocksPatchSchema = z.object({
+    colors: z.boolean().optional(),
+    typography: z.boolean().optional(),
+    icon: z.boolean().optional(),
+});
+export const updateBrandRequestSchema = z.object({
+    name: z.string().min(1).optional(),
+    slug: z.string().min(1).optional(),
+    locks: generationLocksPatchSchema.optional(),
+});
+export const brandPreviewSchema = z.object({
+    palette: z.array(z.string()),
+    cover: z.string().nullable(),
+    asset_count: z.number().int().nonnegative(),
+    logo_url: z.string().nullable(),
+    gradient_stops: z.array(z.string()),
+});
+export const brandSchema = z.object({
+    id: z.string(),
+    workspace_id: z.string(),
+    name: z.string(),
+    slug: z.string(),
+    status: z.enum(brandStatuses),
+    current_version_id: z.string().nullable(),
+    locks: generationLocksSchema,
+    preview: brandPreviewSchema.optional(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+});
+export const customImageFormats = [
+    "square_1_1",
+    "portrait_4_5",
+    "story_9_16",
+    "landscape_16_9",
+    "wide_21_9",
+    "photo_3_2",
+    "poster_2_3",
+    "standard_4_3",
+    "auto",
+    "instagram_post",
+    "story",
+    "linkedin_post",
+    "ad_banner",
+    "custom",
+];
+export const OFFERED_CUSTOM_IMAGE_FORMATS = [
+    "square_1_1",
+    "portrait_4_5",
+    "story_9_16",
+    "landscape_16_9",
+    "wide_21_9",
+    "photo_3_2",
+    "poster_2_3",
+    "standard_4_3",
+    "auto",
+];
+export const MODEL_ASPECT_RATIOS = [
+    "auto",
+    "21:9",
+    "16:9",
+    "3:2",
+    "4:3",
+    "5:4",
+    "1:1",
+    "4:5",
+    "3:4",
+    "2:3",
+    "9:16",
+];
+export const CUSTOM_IMAGE_ASPECT_RATIOS = {
+    square_1_1: "1:1",
+    portrait_4_5: "4:5",
+    story_9_16: "9:16",
+    landscape_16_9: "16:9",
+    wide_21_9: "21:9",
+    photo_3_2: "3:2",
+    poster_2_3: "2:3",
+    standard_4_3: "4:3",
+    auto: "auto",
+    instagram_post: "1:1",
+    story: "9:16",
+    linkedin_post: "5:4",
+    ad_banner: "16:9",
+    custom: "1:1",
+};
+export const customSuggestionSchema = z.object({
+    name: z
+        .string()
+        .trim()
+        .min(1)
+        .max(60)
+        .regex(/^[^\u0000-\u001f\u007f]+$/u, "must not contain control characters"),
+    prompt: z.string().trim().min(1).max(500),
+    format: z.enum(OFFERED_CUSTOM_IMAGE_FORMATS),
+});
+export const brandSuggestionItemSchema = z.object({
+    kind: z.enum(suggestionItemKinds),
+    tag: z.string(),
+    title: z.string(),
+    desc: z.string(),
+    state: z.enum(["idle", "generating", "ready"]),
+    asset_id: z.string().nullable(),
+    custom: customSuggestionSchema.nullable().default(null),
+});
+export const brandSuggestionsResponseSchema = z.object({
+    items: z.array(brandSuggestionItemSchema),
+});
+export const workspaceSuggestionItemSchema = brandSuggestionItemSchema.extend({
+    job_id: z.string().nullable(),
+    brand: z.object({
+        id: z.string(),
+        name: z.string(),
+        preview: brandPreviewSchema.optional(),
+    }),
+});
+export const workspaceSuggestionsResponseSchema = z.object({
+    items: z.array(workspaceSuggestionItemSchema),
+});
+export const surpriseBriefResponseSchema = z.object({
+    name: z.string(),
+    tagline: z.string(),
+    description: z.string(),
+    styles: z.array(z.enum(brandStyles)),
+});
+export const nameStyles = ["compound", "abstract", "evocative", "playful"];
+export const nameIdeasRequestSchema = z.object({
+    style: z.enum(nameStyles),
+    keyword: z.string().max(80).optional(),
+    description: z.string().max(500).optional(),
+});
+export const nameIdeaSchema = z.object({
+    name: z.string(),
+    hint: z.string(),
+});
+export const nameIdeasResponseSchema = z.object({
+    items: z.array(nameIdeaSchema).min(1),
+});
+export const expandBrandRequestSchema = z.object({
+    assets: z.array(z.enum(assetKinds)).min(1),
+    team: z.enum(teamTiers).optional(),
+    custom_image_prompt: z.string().min(1).max(500).optional(),
+    custom_image_format: z.enum(customImageFormats).optional(),
+    custom_image_name: z
+        .string()
+        .trim()
+        .min(1)
+        .max(60)
+        .regex(/^[^\u0000-\u001f\u007f]+$/u, "must not contain control characters")
+        .optional(),
+});
+export const brandRefineRequestSchema = z.object({
+    message: z.string().min(1).max(500),
+});
+export const brandDnaSchema = z.object({
+    brief: z
+        .object({
+        industry: z.string(),
+        audience: z.string(),
+        tone: z.string(),
+        keywords: z.array(z.string()),
+        constraints: z.array(z.string()),
+    })
+        .partial(),
+    strategy: z
+        .object({
+        positioning: z.string(),
+        archetype: z.string(),
+        values: z.array(z.string()),
+        name: z.string(),
+        tagline: z.string(),
+        name_rationale: z.string(),
+    })
+        .partial(),
+    visual_system: z
+        .object({
+        palette: z
+            .object({ tokens: z.array(z.object({ name: z.string(), hex: z.string() })) })
+            .partial(),
+        typography: z
+            .object({
+            heading_font: z.string(),
+            body_font: z.string(),
+            mono_font: z.string().nullable(),
+        })
+            .partial(),
+    })
+        .partial()
+        .optional(),
+});
+export const brandVersionSummarySchema = z.object({
+    id: z.string(),
+    version_no: z.number().int(),
+    message: z.string().nullable(),
+    created_by: z.string(),
+    qa_score: z.number().int().nullable(),
+    created_at: z.string().datetime(),
+    is_current: z.boolean(),
+});

package/dist/catalog.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const aiTeamSchema: z.ZodObject<{
+    tier: z.ZodEnum<{
+        flash: "flash";
+        studio: "studio";
+        elite: "elite";
+    }>;
+    name: z.ZodString;
+    multiplier: z.ZodNumber;
+    tagline: z.ZodString;
+    variants: z.ZodNumber;
+    agents_label: z.ZodString;
+    speed: z.ZodString;
+    qa: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const templateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodString;
+    prompt: z.ZodString;
+    accent: z.ZodString;
+}, z.core.$strip>;
+export type AiTeam = z.infer<typeof aiTeamSchema>;
+export type Template = z.infer<typeof templateSchema>;
+export declare const AI_TEAMS: AiTeam[];

package/dist/catalog.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { teamTiers } from "./brands.js";
+import { CREDIT_MULTIPLIERS } from "./pricing.js";
+export const aiTeamSchema = z.object({
+    tier: z.enum(teamTiers),
+    name: z.string(),
+    multiplier: z.number(),
+    tagline: z.string(),
+    variants: z.number().int(),
+    agents_label: z.string(),
+    speed: z.string(),
+    qa: z.boolean(),
+});
+export const templateSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    category: z.string(),
+    description: z.string(),
+    prompt: z.string(),
+    accent: z.string(),
+});
+export const AI_TEAMS = [
+    {
+        tier: "flash",
+        name: "Flash",
+        multiplier: CREDIT_MULTIPLIERS.flash,
+        tagline: "Fast drafts from a lean team. One variant per asset.",
+        variants: 1,
+        agents_label: "3 agents",
+        speed: "Fastest",
+        qa: false,
+    },
+    {
+        tier: "studio",
+        name: "Studio",
+        multiplier: CREDIT_MULTIPLIERS.studio,
+        tagline: "The balanced default. Opus strategy and 2-3 variants.",
+        variants: 3,
+        agents_label: "5 agents",
+        speed: "Balanced",
+        qa: false,
+    },
+    {
+        tier: "elite",
+        name: "Elite",
+        multiplier: CREDIT_MULTIPLIERS.elite,
+        tagline: "Extra variants plus a Brand Guardian QA pass.",
+        variants: 6,
+        agents_label: "6 agents",
+        speed: "Most thorough",
+        qa: true,
+    },
+];

package/dist/consent.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+export declare const CONSENT_TYPES: readonly ["cookie_consent", "privacy_choice", "terms_acceptance", "purchase_disclosure"];
+export type ConsentType = (typeof CONSENT_TYPES)[number];
+export declare const TERMS_CHECKBOX_TEXT = "I agree to the Terms of Service.";
+export declare const ACCEPTED_VERSIONS: {
+    readonly terms: "1.0";
+    readonly aup: "1.0";
+};
+export declare function isCanonicalTermsAcceptance(input: {
+    checkbox_text: string;
+    accepted_versions: Record<string, string>;
+}): boolean;
+export declare const consentRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    client_id: z.ZodString;
+    type: z.ZodLiteral<"cookie_consent">;
+    region: z.ZodString;
+    categories: z.ZodArray<z.ZodString>;
+    banner_version: z.ZodNumber;
+    gpc: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    client_id: z.ZodString;
+    type: z.ZodLiteral<"privacy_choice">;
+    region: z.ZodString;
+    choices: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    gpc: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    client_id: z.ZodString;
+    type: z.ZodLiteral<"terms_acceptance">;
+    checkbox_text: z.ZodString;
+    accepted_versions: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    client_id: z.ZodString;
+    type: z.ZodLiteral<"purchase_disclosure">;
+    idempotency_key: z.ZodString;
+    price_id: z.ZodString;
+    kind: z.ZodEnum<{
+        plan: "plan";
+        topup: "topup";
+    }>;
+    plan: z.ZodOptional<z.ZodEnum<{
+        studio: "studio";
+        pro: "pro";
+        agency: "agency";
+    }>>;
+    credits: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<300>, z.ZodLiteral<1000>]>>;
+    amount: z.ZodString;
+    currency: z.ZodString;
+    billing_period: z.ZodEnum<{
+        month: "month";
+        one_time: "one_time";
+    }>;
+    renewal_text: z.ZodOptional<z.ZodString>;
+    disclosure_version: z.ZodNumber;
+}, z.core.$strip>], "type">;
+export type ConsentRequest = z.infer<typeof consentRequestSchema>;
+export declare const consentResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    recorded_at: z.ZodString;
+}, z.core.$strip>;
+export type ConsentResponse = z.infer<typeof consentResponseSchema>;

package/dist/consent.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export const CONSENT_TYPES = [
+    "cookie_consent",
+    "privacy_choice",
+    "terms_acceptance",
+    "purchase_disclosure",
+];
+const base = { client_id: z.string().min(1).max(128) };
+const MAX_RECORD_KEYS = 32;
+const withKeyCap = (schema) => schema.refine((value) => Object.keys(value).length <= MAX_RECORD_KEYS, { message: `Too many keys (max ${MAX_RECORD_KEYS}).` });
+const cookieConsent = z.object({
+    type: z.literal("cookie_consent"),
+    region: z.string().min(1).max(16),
+    categories: z.array(z.string().min(1).max(64)).max(16),
+    banner_version: z.number().int().nonnegative(),
+    gpc: z.boolean(),
+    ...base,
+});
+const privacyChoice = z.object({
+    type: z.literal("privacy_choice"),
+    region: z.string().min(1).max(16),
+    choices: withKeyCap(z.record(z.string().min(1).max(64), z.boolean())),
+    gpc: z.boolean(),
+    ...base,
+});
+const termsAcceptance = z.object({
+    type: z.literal("terms_acceptance"),
+    checkbox_text: z.string().min(1).max(512),
+    accepted_versions: withKeyCap(z.record(z.string().min(1).max(64), z.string().max(32))),
+    ...base,
+});
+export const TERMS_CHECKBOX_TEXT = "I agree to the Terms of Service.";
+export const ACCEPTED_VERSIONS = { terms: "1.0", aup: "1.0" };
+export function isCanonicalTermsAcceptance(input) {
+    if (input.checkbox_text !== TERMS_CHECKBOX_TEXT)
+        return false;
+    const expected = Object.entries(ACCEPTED_VERSIONS);
+    if (Object.keys(input.accepted_versions).length !== expected.length)
+        return false;
+    return expected.every(([document, version]) => input.accepted_versions[document] === version);
+}
+const purchaseDisclosure = z.object({
+    type: z.literal("purchase_disclosure"),
+    idempotency_key: z.string().min(1).max(128),
+    price_id: z.string().min(1).max(255),
+    kind: z.enum(["plan", "topup"]),
+    plan: z.enum(["pro", "studio", "agency"]).optional(),
+    credits: z.union([z.literal(100), z.literal(300), z.literal(1000)]).optional(),
+    amount: z.string().min(1).max(32),
+    currency: z.string().min(1).max(8),
+    billing_period: z.enum(["month", "one_time"]),
+    renewal_text: z.string().min(1).max(512).optional(),
+    disclosure_version: z.number().int().nonnegative(),
+    ...base,
+});
+export const consentRequestSchema = z.discriminatedUnion("type", [
+    cookieConsent,
+    privacyChoice,
+    termsAcceptance,
+    purchaseDisclosure,
+]);
+export const consentResponseSchema = z.object({
+    id: z.string(),
+    recorded_at: z.string().datetime(),
+});