@magemetrics/core 0.5.3 → 0.6.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { Client } from 'openapi-fetch';
 import { DefaultChatTransport } from 'ai';
+import { GoTrueClient } from '@supabase/auth-js';
 import { GoTrueClientOptions } from '@supabase/auth-js';
 import { HttpChatTransportInitOptions } from 'ai';
 import type { InferUITool } from 'ai';
@@ -63,6 +64,54 @@ declare interface AsyncStorage_2 {
     removeItem(key: string): Promise<void>;
 }
 
+/**
+ * Authentication provider interface for MageMetrics client.
+ * Providers handle token management and header generation.
+ */
+export declare interface AuthProvider {
+    /**
+     * Initialize the auth provider and perform any necessary setup.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get authentication headers to include in API requests.
+     */
+    getHeaders(): Promise<Record<string, string>>;
+    /**
+     * Get the current authentication state.
+     */
+    getState(): AuthState;
+    /**
+     * Update the external JWT (if applicable).
+     */
+    updateExternalJwt(jwt: string): Promise<void>;
+    /**
+     * Logout and clear any stored tokens.
+     */
+    logout(): Promise<void>;
+    /**
+     * Get the Supabase client (if available).
+     * Used for backward compatibility with existing code.
+     */
+    getSupabaseClient(): GoTrueClient | null;
+    /**
+     * Add an event listener for auth events.
+     * @param type the type of the event
+     * @param listener the listener to add
+     * @param options options for the event listener
+     * @param options.signal an AbortSignal to remove the listener when aborted
+     */
+    addEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>, options?: {
+        signal?: AbortSignal;
+    }): void;
+    /**
+     * Remove an event listener.
+     * @param type the type of the event
+     * @param listener the listener to remove
+     */
+    removeEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>): void;
+}
+
 /**
  * Authentication states
  */
@@ -107,6 +156,13 @@ declare interface components {
             flow_data_id: number;
             created_at: string;
             bookmarked: boolean;
+            flow_data?: {
+                is_materialized: boolean | null;
+                last_materialized_at: string | null;
+                materialized_error_message: string | null;
+                /** @enum {string|null} */
+                materialized_status: "completed" | "running" | "failed" | null;
+            };
             configuration: {
                 /** @enum {string} */
                 type: "bar";
@@ -168,6 +224,13 @@ declare interface components {
             flow_data_id: number;
             created_at: string;
             bookmarked: boolean;
+            flow_data?: {
+                is_materialized: boolean | null;
+                last_materialized_at: string | null;
+                materialized_error_message: string | null;
+                /** @enum {string|null} */
+                materialized_status: "completed" | "running" | "failed" | null;
+            };
             configuration: {
                 /** @enum {string} */
                 type: "bar";
@@ -254,13 +317,104 @@ export declare type CreateFlowParam = {
 };
 
 declare type CustomDataParts = {
-    "quick-actions": z.infer<typeof QuickActionsSchema>;
-    signal: z.infer<typeof SignalWithReportIdSchema>;
+    "quick-actions": QuickActions;
+    signal: SignalWithReportId;
     "node-added": {
         node: NodeBase;
     };
 };
 
+/**
+ * Direct authentication provider that uses a Supabase JWT directly
+ * without going through the token exchange flow.
+ *
+ * This provider:
+ * - Does NOT create shadow users
+ * - Does NOT call the exchange endpoint
+ * - Simply returns the JWT in headers for backend validation
+ * - Preserves the original user's roles and permissions
+ *
+ * Use this for internal admin tools where you already have a valid
+ * Supabase JWT and want to bypass the external auth flow.
+ * @example
+ * ```typescript
+ * const authProvider = new DirectAuthProvider(internalUserJwt);
+ * const client = new MageMetricsClient(config, authProvider);
+ * ```
+ */
+export declare class DirectAuthProvider implements AuthProvider {
+    private state;
+    private jwt;
+    private events;
+    constructor(jwt: string);
+    initialize(): Promise<void>;
+    getHeaders(): Promise<Record<string, string>>;
+    getState(): AuthState;
+    updateExternalJwt(jwt: string): Promise<void>;
+    logout(): Promise<void>;
+    getSupabaseClient(): GoTrueClient | null;
+    addEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>, options?: {
+        signal?: AbortSignal;
+    }): void;
+    removeEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>): void;
+    private setState;
+}
+
+/**
+ * External authentication provider that handles the full token exchange flow.
+ *
+ * This provider:
+ * - Calls the exchange endpoint to create shadow users
+ * - Manages Supabase sessions
+ * - Handles token refresh
+ * - Supports auto-refresh and session management
+ *
+ * This is the default provider used for external customer integrations.
+ */
+export declare class ExternalAuthProvider implements AuthProvider {
+    private config;
+    private state;
+    private supabaseClient;
+    private noAuthApiClient;
+    private authApiResponse;
+    private processedJwt;
+    private userId;
+    private events;
+    constructor(config: ExternalAuthProviderConfig);
+    initialize(): Promise<void>;
+    getHeaders(): Promise<Record<string, string>>;
+    getState(): AuthState;
+    updateExternalJwt(jwt: string): Promise<void>;
+    logout(): Promise<void>;
+    getSupabaseClient(): GoTrueClient | null;
+    addEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>, options?: {
+        signal?: AbortSignal;
+    }): void;
+    removeEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>): void;
+    startAutoRefresh(): Promise<void> | undefined;
+    stopAutoRefresh(): Promise<void> | undefined;
+    private getApiInformation;
+    private initializeSupabaseClient;
+    private handleAuthentication;
+    private exchangeExternalToken;
+    private setState;
+    private encodeCheckKey;
+    private saveCheckKey;
+    private compareCheckKey;
+    private clearCheckKey;
+    private clearStorage;
+}
+
+export declare interface ExternalAuthProviderConfig {
+    apiUrl: string;
+    apiKey: string;
+    externalJwt?: string;
+    additionalHeaders?: Record<string, string>;
+    storage: AsyncStorage_2;
+    applicationName?: string;
+    authOptions?: Pick<GoTrueClientOptions, "fetch">;
+}
+
 declare type ExtractInsightResponse = z.infer<typeof ExtractInsightResponseSchema>;
 
 declare const ExtractInsightResponseSchema: z.ZodUnion<[z.ZodObject<{
@@ -291,6 +445,8 @@ export declare type GenerateInsightParam = {
 
 export declare const getPublicApiClient: (apiUrl: string, apiKey: string) => Client<NoAuthPaths>;
 
+declare const HEADER_SP_TOKEN: "sp-access-token";
+
 declare const inputSchema: z.ZodObject<{
     userRequest: z.ZodString;
     isNewAnalysisGoal: z.ZodBoolean;
@@ -351,18 +507,10 @@ declare type MageMetricsChatTransportOptions = Omit<HttpChatTransportInitOptions
  */
 export declare class MageMetricsClient {
     private config;
-    private authState;
-    private supabaseClient;
+    private authProvider;
     private internalApiClient;
-    private noAuthApiClient;
-    private authApiResponse;
     private authPromise;
-    private processedJwt;
-    private userId;
-    private storageAdapter;
-    private events;
-    private authOptions;
-    constructor(config: MageMetricsClientConfig, auth?: Pick<GoTrueClientOptions, "fetch">);
+    constructor(config: MageMetricsClientConfig, authProviderOrAuthOptions?: AuthProvider | Pick<GoTrueClientOptions, "fetch">);
     toJSON(): {
         config: string;
     };
@@ -390,7 +538,6 @@ export declare class MageMetricsClient {
     updateExternalJwt(jwt: string): Promise<void>;
     get state(): AuthState;
     getHeaders(): Promise<Record<string, string>>;
-    private clearStorage;
     logout(): Promise<void>;
     auth: {
         startAutoRefresh: () => Promise<void> | undefined;
@@ -405,6 +552,12 @@ export declare class MageMetricsClient {
             flow_data_id: number;
             created_at: string;
             bookmarked: boolean;
+            flow_data?: {
+                is_materialized: boolean | null;
+                last_materialized_at: string | null;
+                materialized_error_message: string | null;
+                materialized_status: "completed" | "running" | "failed" | null;
+            };
             configuration: {
                 type: "bar";
                 title: string;
@@ -460,6 +613,16 @@ export declare class MageMetricsClient {
                         null_count: number | null;
                         unique_count: number | null;
                         unique_percentage: number | null;
+                        min_value?: number | null;
+                        max_value?: number | null;
+                        avg_value?: number | null;
+                        median_value?: number | null;
+                        std_value?: number | null;
+                        min_date?: string | null;
+                        max_date?: string | null;
+                        min_length?: number | null;
+                        max_length?: number | null;
+                        avg_length?: number | null;
                     } & {
                         [key: string]: unknown;
                     };
@@ -470,6 +633,10 @@ export declare class MageMetricsClient {
             bookmarked: boolean;
             status: string | null;
             is_removed: boolean;
+            is_materialized: boolean | null;
+            last_materialized_at: string | null;
+            materialized_error_message: string | null;
+            materialized_status: "completed" | "running" | "failed" | null;
         }[]>;
         getFlow: (flowId: string) => Promise<{
             created_at: string;
@@ -553,27 +720,8 @@ export declare class MageMetricsClient {
             }[]>;
         }>;
     };
-    /**
-     * Perform the complete authentication flow
-     */
-    private performAuthFlow;
-    private getApiInformation;
-    private initializeSupabaseClient;
     client(): InternalApiClient;
-    /**
-     * Handle the authentication logic (check session or exchange token)
-     */
-    private handleAuthentication;
-    /**
-     * Exchange external JWT for Supabase tokens
-     */
-    private exchangeExternalToken;
     private createSupabaseHeaderMiddleware;
-    private setState;
-    private encodeCheckKey;
-    saveCheckKey(externalJwt: string, apiKey: string): Promise<void>;
-    compareCheckKey(externalJwt: string, apiKey: string): Promise<boolean>;
-    clearCheckKey(): Promise<void>;
 }
 
 /**
@@ -997,49 +1145,6 @@ declare interface operations {
             };
         };
     };
-    runEnd2EndFlow: {
-        parameters: {
-            query?: never;
-            header: {
-                "sp-access-token": string;
-            };
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": {
-                    userQuery: string;
-                    /** @default true */
-                    isNewAnalysisGoal?: boolean;
-                    /**
-                     * @default complex
-                     * @enum {string}
-                     */
-                    difficultyLevel?: "simple" | "moderate" | "complex";
-                };
-            };
-        };
-        responses: {
-            /** @description Run the end2end flow */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /** @enum {string} */
-                        status: "error";
-                        error: string;
-                    } | {
-                        /** @enum {string} */
-                        status: "success";
-                        flowId: string;
-                    };
-                };
-            };
-        };
-    };
     retrieveFlow: {
         parameters: {
             query?: never;
@@ -1168,6 +1273,16 @@ declare interface operations {
                                     null_count: number | null;
                                     unique_count: number | null;
                                     unique_percentage: number | null;
+                                    min_value?: number | null;
+                                    max_value?: number | null;
+                                    avg_value?: number | null;
+                                    median_value?: number | null;
+                                    std_value?: number | null;
+                                    min_date?: string | null;
+                                    max_date?: string | null;
+                                    min_length?: number | null;
+                                    max_length?: number | null;
+                                    avg_length?: number | null;
                                 } & {
                                     [key: string]: unknown;
                                 };
@@ -1178,6 +1293,11 @@ declare interface operations {
                         bookmarked: boolean;
                         status: string | null;
                         is_removed: boolean;
+                        is_materialized: boolean | null;
+                        last_materialized_at: string | null;
+                        materialized_error_message: string | null;
+                        /** @enum {string|null} */
+                        materialized_status: "completed" | "running" | "failed" | null;
                     }[];
                 };
             };
@@ -1813,6 +1933,16 @@ declare interface operations {
                                     null_count: number | null;
                                     unique_count: number | null;
                                     unique_percentage: number | null;
+                                    min_value?: number | null;
+                                    max_value?: number | null;
+                                    avg_value?: number | null;
+                                    median_value?: number | null;
+                                    std_value?: number | null;
+                                    min_date?: string | null;
+                                    max_date?: string | null;
+                                    min_length?: number | null;
+                                    max_length?: number | null;
+                                    avg_length?: number | null;
                                 } & {
                                     [key: string]: unknown;
                                 };
@@ -1823,6 +1953,11 @@ declare interface operations {
                         bookmarked: boolean;
                         status: string | null;
                         is_removed: boolean;
+                        is_materialized: boolean | null;
+                        last_materialized_at: string | null;
+                        materialized_error_message: string | null;
+                        /** @enum {string|null} */
+                        materialized_status: "completed" | "running" | "failed" | null;
                     };
                 };
             };
@@ -1905,6 +2040,102 @@ declare interface operations {
             };
         };
     };
+    refreshMaterializedViews: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description List of flow_data IDs to refresh */
+                    flow_data_ids: number[];
+                };
+            };
+        };
+        responses: {
+            /** @description Successfully triggered refresh for materialized views */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        status: "success";
+                        triggered_at: string;
+                    };
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getMaterializationStatus: {
+        parameters: {
+            query: {
+                /** @description Comma-separated list of flow_data IDs */
+                ids: string;
+            };
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Materialization status for the requested flow_data IDs */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: number;
+                        /** @enum {string|null} */
+                        materialized_status: "completed" | "running" | "failed" | null;
+                        last_materialized_at: string | null;
+                    }[];
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
     getPromptStarters: {
         parameters: {
             query?: {
@@ -2153,6 +2384,13 @@ declare interface operations {
                         flow_data_id: number;
                         created_at: string;
                         bookmarked: boolean;
+                        flow_data?: {
+                            is_materialized: boolean | null;
+                            last_materialized_at: string | null;
+                            materialized_error_message: string | null;
+                            /** @enum {string|null} */
+                            materialized_status: "completed" | "running" | "failed" | null;
+                        };
                         configuration: {
                             /** @enum {string} */
                             type: "bar";
@@ -2270,10 +2508,6 @@ declare interface operations {
                 };
                 content: {
                     "application/json": {
-                        /** @enum {string} */
-                        status: "error";
-                        error: string;
-                    } | {
                         /** @enum {string} */
                         status: "success";
                         flowId: string;
@@ -3242,6 +3476,209 @@ declare interface operations {
             };
         };
     };
+    getCompanySettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Company settings retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        name: string | null;
+                        website: string | null;
+                        context_profile: {
+                            company: {
+                                description: string;
+                                industries: string[];
+                                revenue_streams: string[];
+                                customers: {
+                                    label: string;
+                                    description: string;
+                                    typical_users: {
+                                        role: string;
+                                        typical_goals: string[];
+                                    }[];
+                                }[];
+                            };
+                            domain: {
+                                overview: string;
+                                concepts: {
+                                    name: string;
+                                    definition: string;
+                                    synonyms: string[];
+                                }[];
+                            };
+                            analytics: {
+                                examples_key_metrics: {
+                                    name: string;
+                                    why: string;
+                                }[];
+                            };
+                        } | null;
+                    };
+                };
+            };
+            /** @description Failed to retrieve company settings */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    updateCompanySettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    name: string;
+                    website: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Company settings updated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        name: string | null;
+                        website: string | null;
+                        context_profile: {
+                            company: {
+                                description: string;
+                                industries: string[];
+                                revenue_streams: string[];
+                                customers: {
+                                    label: string;
+                                    description: string;
+                                    typical_users: {
+                                        role: string;
+                                        typical_goals: string[];
+                                    }[];
+                                }[];
+                            };
+                            domain: {
+                                overview: string;
+                                concepts: {
+                                    name: string;
+                                    definition: string;
+                                    synonyms: string[];
+                                }[];
+                            };
+                            analytics: {
+                                examples_key_metrics: {
+                                    name: string;
+                                    why: string;
+                                }[];
+                            };
+                        } | null;
+                    };
+                };
+            };
+            /** @description Failed to update company settings */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    runCompanyResearchAgent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Company research agent executed successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        company: {
+                            description: string;
+                            industries: string[];
+                            revenue_streams: string[];
+                            customers: {
+                                label: string;
+                                description: string;
+                                typical_users: {
+                                    role: string;
+                                    typical_goals: string[];
+                                }[];
+                            }[];
+                        };
+                        domain: {
+                            overview: string;
+                            concepts: {
+                                name: string;
+                                definition: string;
+                                synonyms: string[];
+                            }[];
+                        };
+                        analytics: {
+                            examples_key_metrics: {
+                                name: string;
+                                why: string;
+                            }[];
+                        };
+                    };
+                };
+            };
+            /** @description Company name or website not configured */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Company research agent failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
 }
 
 declare type PatchParam<T, Config extends RemoveParamsConfig, P extends keyof Config> = Simplify<T extends {
@@ -3366,22 +3803,6 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/end2end": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        post: operations["runEnd2EndFlow"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/api/v1/flows/{flowId}": {
         parameters: {
             query?: never;
@@ -3606,6 +4027,38 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/flow_data/v1/materialized_views/refresh": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["refreshMaterializedViews"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/flow_data/materialization-status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getMaterializationStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/prompt-starters": {
         parameters: {
             query?: never;
@@ -3702,7 +4155,7 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/trigger-flow/": {
+    "/api/v1/trigger-flow": {
         parameters: {
             query?: never;
             header?: never;
@@ -3958,8 +4411,42 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/admin-console/company-settings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getCompanySettings"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch: operations["updateCompanySettings"];
+        trace?: never;
+    };
+    "/api/v1/admin-console/company-research-agent": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["runCompanyResearchAgent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 
+declare type QuickActions = z.infer<typeof QuickActionsSchema>;
+
 declare const QuickActionsSchema: z.ZodArray<z.ZodObject<{
     label: z.ZodString;
     explanation: z.ZodString;
@@ -4085,6 +4572,8 @@ declare type ReportDataFilters = {
     cursor?: number;
 };
 
+declare type SignalWithReportId = z.infer<typeof SignalWithReportIdSchema>;
+
 declare const SignalWithReportIdSchema: z.ZodObject<{
     rule: z.ZodString;
     metric: z.ZodString;
@@ -4102,9 +4591,9 @@ declare type TableFilters = Record<string, string | number>;
  */
 export declare const TOKEN_STORAGE_KEY = "mm-ai-sp-token";
 
-declare type ToRemove = Simplify<{
-    header: "sp-access-token";
-}>;
+declare type ToRemove = {
+    header: typeof HEADER_SP_TOKEN;
+};
 
 declare type UiTool = InferUITool<Tool<z.infer<typeof inputSchema>, z.infer<typeof redactedOutputSchema>>>;
 
@@ -4121,7 +4610,7 @@ declare type UiTool_6 = InferUITool<Tool<z.infer<typeof inputSchema_6>, z.infer<
 declare type UiTool_7 = InferUITool<Tool<z.infer<typeof inputSchema_7>, z.infer<typeof redactedOutputSchema_6>>>;
 
 declare const UpdateCanvasSchema: z.ZodObject<{
-    id: z.ZodString;
+    id: z.ZodUUID;
     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     nodes: z.ZodOptional<z.ZodArray<z.ZodAny>>;
     edges: z.ZodOptional<z.ZodArray<z.ZodAny>>;