@adland/data 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,229 +1,646 @@
 import { z } from 'zod';
 
 /**
- * Link ad schema - basic link
- */
-declare const linkAdSchema: z.ZodObject<{
-    type: z.ZodLiteral<"link">;
-    data: z.ZodObject<{
-        url: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * Cast ad schema - link to a Farcaster cast
- */
-declare const castAdSchema: z.ZodObject<{
-    type: z.ZodLiteral<"cast">;
-    data: z.ZodObject<{
-        hash: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * MiniApp ad schema - link to a Farcaster mini app
- */
-declare const miniappAdSchema: z.ZodObject<{
-    type: z.ZodLiteral<"miniapp">;
-    data: z.ZodObject<{
-        url: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * Union schema for all ad types
- */
-declare const adDataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"link">;
-    data: z.ZodObject<{
-        url: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"cast">;
-    data: z.ZodObject<{
-        hash: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
+ * Cast Ad Definition
+ * Represents a Farcaster cast ad with validation and verification
+ */
+declare const castAd: AdDefinition<z.ZodObject<{
+    hash: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"miniapp">;
-    data: z.ZodObject<{
-        url: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>], "type">;
-/**
- * All ad schemas as an object
- */
-declare const adSchemas: {
-    readonly link: z.ZodObject<{
-        type: z.ZodLiteral<"link">;
-        data: z.ZodObject<{
-            url: z.ZodNonOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    readonly cast: z.ZodObject<{
-        type: z.ZodLiteral<"cast">;
-        data: z.ZodObject<{
-            hash: z.ZodNonOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    readonly miniapp: z.ZodObject<{
-        type: z.ZodLiteral<"miniapp">;
-        data: z.ZodObject<{
-            url: z.ZodNonOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
+    username: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>> & {
+    process: (input: {
+        hash: string;
+    }) => Promise<{
+        data: {
+            hash: string;
+        };
+        metadata: {
+            username?: string | undefined;
+            text?: string | undefined;
+            timestamp?: number | undefined;
+        } | undefined;
+    }>;
+    safeProcess: (input: {
+        hash: string;
+    }) => Promise<{
+        success: boolean;
+        data?: {
+            hash: string;
+        } | undefined;
+        metadata?: {
+            username?: string | undefined;
+            text?: string | undefined;
+            timestamp?: number | undefined;
+        } | undefined;
+        error?: z.ZodError | string;
+    }>;
 };
 /**
- * Get schema for a specific ad type
- */
-declare function getAdSchema(type: keyof typeof adSchemas): z.ZodObject<{
-    type: z.ZodLiteral<"link">;
-    data: z.ZodObject<{
-        url: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip> | z.ZodObject<{
-    type: z.ZodLiteral<"cast">;
-    data: z.ZodObject<{
-        hash: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip> | z.ZodObject<{
-    type: z.ZodLiteral<"miniapp">;
-    data: z.ZodObject<{
-        url: z.ZodNonOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * Get all ad schemas
- */
-declare function getAllAdSchemas(): {
-    readonly link: z.ZodObject<{
-        type: z.ZodLiteral<"link">;
-        data: z.ZodObject<{
-            url: z.ZodNonOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    readonly cast: z.ZodObject<{
-        type: z.ZodLiteral<"cast">;
-        data: z.ZodObject<{
-            hash: z.ZodNonOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    readonly miniapp: z.ZodObject<{
-        type: z.ZodLiteral<"miniapp">;
-        data: z.ZodObject<{
-            url: z.ZodNonOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
+ * Type inference for CastAd data
+ */
+type CastAdData = z.infer<typeof castAd.data>;
+/**
+ * Type inference for CastAd metadata
+ */
+type CastAdMetadata = z.infer<NonNullable<typeof castAd.metadata>>;
+
+/**
+ * Link Ad Definition
+ * Represents a basic link ad with validation and verification
+ */
+declare const linkAd: AdDefinition<z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> & {
+    process: (input: {
+        url: string;
+    }) => Promise<{
+        data: {
+            url: string;
+        };
+        metadata: {
+            title?: string | undefined;
+            description?: string | undefined;
+            image?: string | undefined;
+        } | undefined;
+    }>;
+    safeProcess: (input: {
+        url: string;
+    }) => Promise<{
+        success: boolean;
+        data?: {
+            url: string;
+        } | undefined;
+        metadata?: {
+            title?: string | undefined;
+            description?: string | undefined;
+            image?: string | undefined;
+        } | undefined;
+        error?: z.ZodError | string;
+    }>;
 };
 /**
- * Validate ad data
+ * Type inference for LinkAd data
  */
-declare function validateAdData(data: unknown): {
-    success: boolean;
-    data?: z.infer<typeof adDataSchema>;
-    error?: z.ZodError;
+type LinkAdData = z.infer<typeof linkAd.data>;
+/**
+ * Type inference for LinkAd metadata
+ */
+type LinkAdMetadata = z.infer<NonNullable<typeof linkAd.metadata>>;
+
+/**
+ * MiniApp Ad Definition
+ * Represents a Farcaster mini app ad with validation and verification
+ */
+declare const miniappAd: AdDefinition<z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    icon: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> & {
+    process: (input: {
+        url: string;
+    }) => Promise<{
+        data: {
+            url: string;
+        };
+        metadata: {
+            icon?: string | undefined;
+            title?: string | undefined;
+        } | undefined;
+    }>;
+    safeProcess: (input: {
+        url: string;
+    }) => Promise<{
+        success: boolean;
+        data?: {
+            url: string;
+        } | undefined;
+        metadata?: {
+            icon?: string | undefined;
+            title?: string | undefined;
+        } | undefined;
+        error?: z.ZodError | string;
+    }>;
 };
+/**
+ * Type inference for MiniAppAd data
+ */
+type MiniAppAdData = z.infer<typeof miniappAd.data>;
+/**
+ * Type inference for MiniAppAd metadata
+ */
+type MiniAppAdMetadata = z.infer<NonNullable<typeof miniappAd.metadata>>;
 
 /**
- * Base class for data models with schema validation and verification
+ * Ad Definition type
+ * Represents a data contract + behavior for an ad type
  */
-declare abstract class DataModel<S extends z.ZodTypeAny> {
-    readonly schema: S;
-    constructor(schema: S);
+type AdDefinition<TData extends z.ZodTypeAny, TMetadata extends z.ZodTypeAny | undefined = undefined> = {
     /**
-     * Validate input against Zod schema
+     * The literal type string for this ad (e.g., "cast", "link")
      */
-    validate(input: unknown): Promise<z.infer<S>>;
+    type: string;
     /**
-     * Custom async checks (override in subclasses)
-     * Throw an error if verification fails
+     * The Zod schema for the ad's data field
      */
-    verify(_data: z.infer<S>): Promise<void>;
+    data: TData;
     /**
-     * Full pipeline: validate → verify
+     * Optional Zod schema for the ad's metadata field
      */
-    prepare(input: unknown): Promise<z.infer<S>>;
+    metadata?: TMetadata;
     /**
-     * Safe validation that returns result instead of throwing
+     * Optional verification function that runs after parsing
+     * Receives already-validated data
      */
-    safeValidate(input: unknown): Promise<{
-        success: boolean;
-        data?: z.infer<S>;
-        error?: z.ZodError;
+    verify?: (data: z.infer<TData>) => Promise<void>;
+    /**
+     * Optional metadata enrichment function
+     * Only available if metadata schema is defined
+     */
+    getMetadata?: (data: z.infer<TData>) => Promise<TMetadata extends z.ZodTypeAny ? z.infer<TMetadata> : never>;
+};
+/**
+ * Typed helper to define an ad
+ * Locks type inference and prevents widening
+ * Adds a `process` method for convenience
+ * @param def - Ad definition object
+ * @returns The same definition with proper types and a process method
+ */
+declare function defineAd<const TData extends z.ZodTypeAny, const TMetadata extends z.ZodTypeAny | undefined>(def: AdDefinition<TData, TMetadata>): AdDefinition<TData, TMetadata> & {
+    /**
+     * Process this ad through the full pipeline: parse → verify → getMetadata
+     * @param input - Raw input data to process
+     * @returns Processed data and optional metadata
+     */
+    process: (input: z.infer<TData>) => Promise<{
+        data: z.infer<TData>;
+        metadata: TMetadata extends z.ZodTypeAny ? TMetadata extends undefined ? undefined : z.infer<TMetadata> | undefined : undefined;
     }>;
     /**
-     * Safe prepare that returns result instead of throwing
+     * Safe version of process that returns a result object
+     * @param input - Raw input data to process
+     * @returns Result object with success flag and data or error
      */
-    safePrepare(input: unknown): Promise<{
+    safeProcess: (input: z.infer<TData>) => Promise<{
         success: boolean;
-        data?: z.infer<S>;
-        error?: string | z.ZodError;
+        data?: z.infer<TData>;
+        metadata?: TMetadata extends z.ZodTypeAny ? TMetadata extends undefined ? undefined : z.infer<TMetadata> | undefined : undefined;
+        error?: z.ZodError | string;
     }>;
-}
-
-declare const adTypes: readonly ["link", "cast", "miniapp"];
-/**
- * Base ad type
- */
-type AdType = (typeof adTypes)[number];
-/**
- * Link ad type - basic link
- */
-type LinkAd = z.infer<typeof linkAdSchema>;
-/**
- * Cast ad type - link to a Farcaster cast
- */
-type CastAd = z.infer<typeof castAdSchema>;
+};
 /**
- * MiniApp ad type - link to a Farcaster mini app
+ * Process an ad through the full pipeline: parse → verify → getMetadata
+ * @param ad - Ad definition
+ * @param input - Raw input data to process
+ * @returns Processed data and optional metadata
  */
-type MiniAppAd = z.infer<typeof miniappAdSchema>;
+declare function processAd<TData extends z.ZodTypeAny, TMetadata extends z.ZodTypeAny | undefined>(ad: AdDefinition<TData, TMetadata>, input: z.infer<TData>): Promise<{
+    data: z.infer<TData>;
+    metadata: TMetadata extends z.ZodTypeAny ? TMetadata extends undefined ? undefined : z.infer<TMetadata> | undefined : undefined;
+}>;
 /**
- * Union type of all ad types
+ * Safe version of processAd that returns a result object
+ * @param ad - Ad definition
+ * @param input - Raw input data to process
+ * @returns Result object with success flag and data or error
  */
-type AdData = z.infer<typeof adDataSchema>;
+declare function safeProcessAd<TData extends z.ZodTypeAny, TMetadata extends z.ZodTypeAny | undefined>(ad: AdDefinition<TData, TMetadata>, input: unknown): Promise<{
+    success: boolean;
+    data?: z.infer<TData>;
+    metadata?: TMetadata extends z.ZodTypeAny ? TMetadata extends undefined ? undefined : z.infer<TMetadata> | undefined : undefined;
+    error?: z.ZodError | string;
+}>;
 
 /**
- * Base ad model class
+ * Registry of all ad definitions
+ * Each entry is an AdDefinition object
  */
-declare abstract class AdModel<T extends LinkAd | CastAd | MiniAppAd> extends DataModel<z.ZodType<T, any, any>> {
-    abstract readonly type: T["type"];
-}
-
+declare const ads: {
+    readonly link: AdDefinition<z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            url: string;
+        }) => Promise<{
+            data: {
+                url: string;
+            };
+            metadata: {
+                title?: string | undefined;
+                description?: string | undefined;
+                image?: string | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            url: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                url: string;
+            } | undefined;
+            metadata?: {
+                title?: string | undefined;
+                description?: string | undefined;
+                image?: string | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
+    readonly cast: AdDefinition<z.ZodObject<{
+        hash: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        username: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            hash: string;
+        }) => Promise<{
+            data: {
+                hash: string;
+            };
+            metadata: {
+                username?: string | undefined;
+                text?: string | undefined;
+                timestamp?: number | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            hash: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                hash: string;
+            } | undefined;
+            metadata?: {
+                username?: string | undefined;
+                text?: string | undefined;
+                timestamp?: number | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
+    readonly miniapp: AdDefinition<z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        icon: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            url: string;
+        }) => Promise<{
+            data: {
+                url: string;
+            };
+            metadata: {
+                icon?: string | undefined;
+                title?: string | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            url: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                url: string;
+            } | undefined;
+            metadata?: {
+                icon?: string | undefined;
+                title?: string | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
+};
+declare const adTypes: readonly ["link", "cast", "miniapp"];
 /**
- * Link Ad Model
+ * Type for ad definition keys
  */
-declare class LinkAdModel extends AdModel<LinkAd> {
-    readonly type: "link";
-    constructor();
-    verify(data: LinkAd): Promise<void>;
-}
-
+type AdType = keyof typeof ads;
 /**
- * Cast Ad Model
+ * Get ad definition by type
  */
-declare class CastAdModel extends AdModel<CastAd> {
-    readonly type: "cast";
-    constructor();
-    verify(data: CastAd): Promise<void>;
-}
-
+declare function getAd(type: AdType): (AdDefinition<z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> & {
+    process: (input: {
+        url: string;
+    }) => Promise<{
+        data: {
+            url: string;
+        };
+        metadata: {
+            title?: string | undefined;
+            description?: string | undefined;
+            image?: string | undefined;
+        } | undefined;
+    }>;
+    safeProcess: (input: {
+        url: string;
+    }) => Promise<{
+        success: boolean;
+        data?: {
+            url: string;
+        } | undefined;
+        metadata?: {
+            title?: string | undefined;
+            description?: string | undefined;
+            image?: string | undefined;
+        } | undefined;
+        error?: z.ZodError | string;
+    }>;
+}) | (AdDefinition<z.ZodObject<{
+    hash: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    username: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>> & {
+    process: (input: {
+        hash: string;
+    }) => Promise<{
+        data: {
+            hash: string;
+        };
+        metadata: {
+            username?: string | undefined;
+            text?: string | undefined;
+            timestamp?: number | undefined;
+        } | undefined;
+    }>;
+    safeProcess: (input: {
+        hash: string;
+    }) => Promise<{
+        success: boolean;
+        data?: {
+            hash: string;
+        } | undefined;
+        metadata?: {
+            username?: string | undefined;
+            text?: string | undefined;
+            timestamp?: number | undefined;
+        } | undefined;
+        error?: z.ZodError | string;
+    }>;
+}) | (AdDefinition<z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    icon: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> & {
+    process: (input: {
+        url: string;
+    }) => Promise<{
+        data: {
+            url: string;
+        };
+        metadata: {
+            icon?: string | undefined;
+            title?: string | undefined;
+        } | undefined;
+    }>;
+    safeProcess: (input: {
+        url: string;
+    }) => Promise<{
+        success: boolean;
+        data?: {
+            url: string;
+        } | undefined;
+        metadata?: {
+            icon?: string | undefined;
+            title?: string | undefined;
+        } | undefined;
+        error?: z.ZodError | string;
+    }>;
+});
 /**
- * MiniApp Ad Model
+ * Validate ad data against any ad definition
  */
-declare class MiniAppAdModel extends AdModel<MiniAppAd> {
-    readonly type: "miniapp";
-    constructor();
-    verify(data: MiniAppAd): Promise<void>;
-}
+declare function validateAdData(data: any): {
+    success: boolean;
+    data?: {
+        type: AdType;
+        data: unknown;
+    };
+    error?: z.ZodError | string;
+};
 
-/**
- * Registry of all ad models
- */
+declare const adDefinitions: {
+    readonly link: AdDefinition<z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            url: string;
+        }) => Promise<{
+            data: {
+                url: string;
+            };
+            metadata: {
+                title?: string | undefined;
+                description?: string | undefined;
+                image?: string | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            url: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                url: string;
+            } | undefined;
+            metadata?: {
+                title?: string | undefined;
+                description?: string | undefined;
+                image?: string | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
+    readonly cast: AdDefinition<z.ZodObject<{
+        hash: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        username: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            hash: string;
+        }) => Promise<{
+            data: {
+                hash: string;
+            };
+            metadata: {
+                username?: string | undefined;
+                text?: string | undefined;
+                timestamp?: number | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            hash: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                hash: string;
+            } | undefined;
+            metadata?: {
+                username?: string | undefined;
+                text?: string | undefined;
+                timestamp?: number | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
+    readonly miniapp: AdDefinition<z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        icon: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            url: string;
+        }) => Promise<{
+            data: {
+                url: string;
+            };
+            metadata: {
+                icon?: string | undefined;
+                title?: string | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            url: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                url: string;
+            } | undefined;
+            metadata?: {
+                icon?: string | undefined;
+                title?: string | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
+};
 declare const adModels: {
-    readonly link: LinkAdModel;
-    readonly cast: CastAdModel;
-    readonly miniapp: MiniAppAdModel;
+    readonly link: AdDefinition<z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            url: string;
+        }) => Promise<{
+            data: {
+                url: string;
+            };
+            metadata: {
+                title?: string | undefined;
+                description?: string | undefined;
+                image?: string | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            url: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                url: string;
+            } | undefined;
+            metadata?: {
+                title?: string | undefined;
+                description?: string | undefined;
+                image?: string | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
+    readonly cast: AdDefinition<z.ZodObject<{
+        hash: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        username: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            hash: string;
+        }) => Promise<{
+            data: {
+                hash: string;
+            };
+            metadata: {
+                username?: string | undefined;
+                text?: string | undefined;
+                timestamp?: number | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            hash: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                hash: string;
+            } | undefined;
+            metadata?: {
+                username?: string | undefined;
+                text?: string | undefined;
+                timestamp?: number | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
+    readonly miniapp: AdDefinition<z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        icon: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> & {
+        process: (input: {
+            url: string;
+        }) => Promise<{
+            data: {
+                url: string;
+            };
+            metadata: {
+                icon?: string | undefined;
+                title?: string | undefined;
+            } | undefined;
+        }>;
+        safeProcess: (input: {
+            url: string;
+        }) => Promise<{
+            success: boolean;
+            data?: {
+                url: string;
+            } | undefined;
+            metadata?: {
+                icon?: string | undefined;
+                title?: string | undefined;
+            } | undefined;
+            error?: z.ZodError | string;
+        }>;
+    };
 };
-/**
- * Get ad model for a specific type
- */
-declare function getAdModel<T extends "link" | "cast" | "miniapp">(type: T): T extends "link" ? LinkAdModel : T extends "cast" ? CastAdModel : T extends "miniapp" ? MiniAppAdModel : never;
 
-export { type AdData, AdModel, type AdType, type CastAd, CastAdModel, DataModel, type LinkAd, LinkAdModel, type MiniAppAd, MiniAppAdModel, adDataSchema, adModels, adSchemas, adTypes, castAdSchema, getAdModel, getAdSchema, getAllAdSchemas, linkAdSchema, miniappAdSchema, validateAdData };
+export { type AdDefinition, type AdType, type CastAdData, type CastAdMetadata, type LinkAdData, type LinkAdMetadata, type MiniAppAdData, type MiniAppAdMetadata, adDefinitions, adModels, adTypes, ads, castAd, defineAd, getAd, linkAd, miniappAd, processAd, safeProcessAd, validateAdData };