@marketrix.ai/widget 4.0.108 → 4.0.110

package/dist/src/components/base/layoutProps.d.ts

@@ -67,11 +67,11 @@ export interface LayoutProps {
     minWidth?: '0';
     minHeight?: '0';
     border?: boolean | keyof typeof BORDER_SIDE;
-    rounded?: boolean | RadiusToken;
-    animate?: 'spin' | 'ping' | 'pulse' | 'fadeIn' | 'none';
-    hidden?: boolean;
+    rounded?: boolean | RadiusToken | undefined;
+    animate?: 'spin' | 'ping' | 'pulse' | 'fadeIn' | 'none' | undefined;
+    hidden?: boolean | undefined;
     as?: ElementType;
-    style?: CSSProperties;
+    style?: CSSProperties | undefined;
 }
 export declare function resolveLayoutStyle(props: LayoutProps): CSSProperties;
 export declare function stripLayoutProps<T extends LayoutProps>(props: T): Omit<T, keyof LayoutProps>;

package/dist/src/components/blocks/Notifications.d.ts

@@ -6,10 +6,10 @@ export interface NotificationProviderProps {
 }
 export declare const NotificationProvider: React.FC<NotificationProviderProps>;
 export interface WidgetNotificationsProps {
-    error?: string;
+    error?: string | undefined;
     onClearError: () => void;
-    onRetry?: () => void;
-    greeting?: string;
+    onRetry?: (() => void) | undefined;
+    greeting?: string | undefined;
     greetingBody?: string;
     onGreetingDismiss: () => void;
 }

package/dist/src/context/UIStateContext.d.ts

@@ -9,7 +9,7 @@ export interface UIState {
     isOpen: boolean;
     activeView: WidgetView;
     currentMode: InstructionType;
-    error?: string;
+    error?: string | undefined;
 }
 interface UIStateActions {
     setActiveView: (view: WidgetView) => void;

package/dist/src/hooks/useFocusTrap.d.ts

@@ -21,5 +21,5 @@
  */
 export declare function useFocusTrap(containerRef: React.RefObject<HTMLElement | null>, isActive: boolean, options?: {
     onEscape?: () => void;
-    focusTargetRef?: React.RefObject<HTMLElement | null>;
+    focusTargetRef?: React.RefObject<HTMLElement | null> | undefined;
 }): void;

package/dist/src/index.d.ts

@@ -22,7 +22,7 @@ declare global {
     interface Window {
         __mtx?: {
             state?: 'initializing' | 'active';
-        };
+        } | undefined;
     }
 }
 import React from 'react';

package/dist/src/sdk/contract.d.ts

@@ -169,7 +169,7 @@ export declare const widgetContract: {
         error: string;
     } | {
         type: "task/status";
-        status: "running" | "completed" | "failed" | "stopped" | "has_question";
+        status: "completed" | "failed" | "running" | "stopped" | "has_question";
         message?: string | undefined;
     } | {
         type: "tool/call";
@@ -197,7 +197,7 @@ export declare const widgetContract: {
         error: string;
     } | {
         type: "task/status";
-        status: "running" | "completed" | "failed" | "stopped" | "has_question";
+        status: "completed" | "failed" | "running" | "stopped" | "has_question";
         message?: string | undefined;
     } | {
         type: "tool/call";

package/dist/src/sdk/contracts/activityLogMetadata.d.ts

@@ -0,0 +1,217 @@
+/**
+ * `ActivityMetadataByType` — the strict, per-`ActivityLogType` shape of `activity_log.metadata`, the
+ * one write-time gate `models/columnSchemas.ts` registers against the column. Moved out of that file
+ * so `contracts/entities.ts` can import it to type `ActivityLogEntitySchema.metadata` precisely
+ * (a union of every branch) instead of the open `.passthrough()` it carried before — deriving from a
+ * registry that lived inside `models/columnSchemas.ts`, which itself imports from `entities.ts`,
+ * would have cycled.
+ *
+ * `slack_command`'s `status` imports `SlackCommandLogStatusSchema` from `./activityLogVocabulary` —
+ * the one home `tests/unit/contractEnumHomes.test.ts` requires for that value set — a dependency-free
+ * leaf, so this registry (and everything importing it through `entities.ts`) never pulls in
+ * `contracts/slack.ts`'s `@orpc/contract` import.
+ */
+import { z } from 'zod';
+export declare const ActivityMetadataByType: {
+    update_workspace: z.ZodObject<{
+        details: z.ZodString;
+    }, z.core.$strict>;
+    update_user: z.ZodUnion<readonly [z.ZodObject<{
+        target_user_id: z.ZodNumber;
+        target_user_email: z.ZodString;
+        reason: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        target_user_id: z.ZodNumber;
+        details: z.ZodString;
+    }, z.core.$strict>]>;
+    create_application: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            app: "app";
+            website: "website";
+        }>;
+    }, z.core.$strict>;
+    update_application: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            app: "app";
+            website: "website";
+        }>;
+    }, z.core.$strict>;
+    delete_application: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            app: "app";
+            website: "website";
+        }>;
+    }, z.core.$strict>;
+    create_widget: z.ZodObject<{
+        application_id: z.ZodNumber;
+        widget_type: z.ZodEnum<{
+            widget: "widget";
+        }>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    update_widget: z.ZodObject<{
+        application_id: z.ZodNumber;
+        widget_type: z.ZodEnum<{
+            widget: "widget";
+        }>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    delete_widget: z.ZodObject<{
+        application_id: z.ZodNumber;
+        widget_type: z.ZodEnum<{
+            widget: "widget";
+        }>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    create_knowledge: z.ZodObject<{
+        application_id: z.ZodNumber;
+        file_name: z.ZodString;
+        file_size: z.ZodNumber;
+        file_type: z.ZodString;
+        file_url: z.ZodString;
+        source_url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    update_knowledge: z.ZodObject<{
+        id: z.ZodNumber;
+        file_name: z.ZodString;
+        source_url: z.ZodString;
+        action: z.ZodLiteral<"refreshed">;
+    }, z.core.$strict>;
+    delete_knowledge: z.ZodObject<{
+        id: z.ZodNumber;
+        file_name: z.ZodString;
+        file_type: z.ZodString;
+    }, z.core.$strict>;
+    request_membership: z.ZodObject<{
+        target_user_email: z.ZodString;
+        reminder: z.ZodOptional<z.ZodLiteral<true>>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    invite_user: z.ZodObject<{
+        target_user_email: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    create_workspace: z.ZodObject<{
+        slug: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    trial_started: z.ZodObject<{
+        subscription_id: z.ZodString;
+        plan: z.ZodOptional<z.ZodString>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    trial_ending_soon: z.ZodObject<{
+        subscription_id: z.ZodString;
+        plan: z.ZodOptional<z.ZodString>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    trial_ended: z.ZodObject<{
+        subscription_id: z.ZodString;
+        plan: z.ZodOptional<z.ZodString>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    subscription_created: z.ZodObject<{
+        subscription_id: z.ZodString;
+        plan: z.ZodOptional<z.ZodString>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    subscription_canceled: z.ZodObject<{
+        subscription_id: z.ZodString;
+        plan: z.ZodOptional<z.ZodString>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    plan_changed: z.ZodObject<{
+        session_id: z.ZodString;
+        plan: z.ZodOptional<z.ZodString>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    payment_succeeded: z.ZodObject<{
+        invoice_id: z.ZodString;
+        plan: z.ZodOptional<z.ZodString>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    payment_failed: z.ZodObject<{
+        invoice_id: z.ZodString;
+        plan: z.ZodOptional<z.ZodString>;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    widget_question: z.ZodObject<{
+        application_id: z.ZodNumber;
+        chat_id: z.ZodString;
+        mode: z.ZodString;
+        question: z.ZodString;
+        timestamp: z.ZodString;
+        user_id: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    start_simulation: z.ZodObject<{
+        application_id: z.ZodNumber;
+        simulation_id: z.ZodNumber;
+    }, z.core.$strict>;
+    create_workflow: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    update_workflow: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    delete_workflow: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    toggle_workflow: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        id: z.ZodNumber;
+        name: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    slack_command: z.ZodObject<{
+        slack_user_id: z.ZodString;
+        slack_channel_id: z.ZodNullable<z.ZodString>;
+        raw_text: z.ZodString;
+        detected_intent: z.ZodString;
+        extracted_params: z.ZodObject<{
+            qaFlowId: z.ZodOptional<z.ZodNumber>;
+            appId: z.ZodOptional<z.ZodNumber>;
+            instructions: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodString>;
+            channel: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            workflowName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            received: "received";
+            classifying: "classifying";
+            dispatched: "dispatched";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        response_text: z.ZodNullable<z.ZodString>;
+        error_message: z.ZodNullable<z.ZodString>;
+        duration_ms: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    publish_survey: z.ZodObject<{
+        survey_id: z.ZodNumber;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    unpublish_survey: z.ZodObject<{
+        survey_id: z.ZodNumber;
+        details: z.ZodString;
+    }, z.core.$strict>;
+    delete_survey_response: z.ZodObject<{
+        survey_id: z.ZodNumber;
+        details: z.ZodString;
+    }, z.core.$strict>;
+};
+export type SlackCommandMetadata = z.infer<typeof ActivityMetadataByType.slack_command>;

package/dist/src/sdk/contracts/activityLogVocabulary.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The four closed vocabularies an activity-log row's shape is keyed on — `type` (what happened),
+ * the two enums that ride INSIDE some per-type metadata shapes (`ApplicationTypeSchema`,
+ * `WidgetTypeSchema`), and `SlackCommandLogStatusSchema` (the `slack_command` metadata's `status`,
+ * and `contracts/slack.ts`'s command-log entity status — one home per `tests/unit/contractEnumHomes.test.ts`).
+ * Split out of `contracts/entities.ts` into this dependency-free leaf — no `@orpc/contract` import —
+ * so `contracts/activityLogMetadata.ts`'s per-type registry can import them without cycling back
+ * through `entities.ts`, which needs the registry to type `ActivityLogEntitySchema.metadata`
+ * precisely instead of `.passthrough()`, and so an audience that never touches oRPC contract routes
+ * (the internal/monitor mirror) doesn't pull `@orpc/contract` in through the metadata registry.
+ * `entities.ts` re-exports the first three (unchanged); `SlackCommandLogStatusSchema` is new here and
+ * has no `entities.ts` re-export since nothing imported it from there before.
+ */
+import { z } from 'zod';
+export declare const ApplicationTypeSchema: z.ZodEnum<{
+    app: "app";
+    website: "website";
+}>;
+export type ApplicationType = z.infer<typeof ApplicationTypeSchema>;
+export declare const WidgetTypeSchema: z.ZodEnum<{
+    widget: "widget";
+}>;
+export type WidgetType = z.infer<typeof WidgetTypeSchema>;
+export declare const ActivityLogTypeSchema: z.ZodEnum<{
+    update_workspace: "update_workspace";
+    update_user: "update_user";
+    create_application: "create_application";
+    update_application: "update_application";
+    delete_application: "delete_application";
+    create_widget: "create_widget";
+    update_widget: "update_widget";
+    delete_widget: "delete_widget";
+    create_knowledge: "create_knowledge";
+    update_knowledge: "update_knowledge";
+    delete_knowledge: "delete_knowledge";
+    request_membership: "request_membership";
+    invite_user: "invite_user";
+    create_workspace: "create_workspace";
+    trial_started: "trial_started";
+    trial_ending_soon: "trial_ending_soon";
+    trial_ended: "trial_ended";
+    subscription_created: "subscription_created";
+    subscription_canceled: "subscription_canceled";
+    plan_changed: "plan_changed";
+    payment_succeeded: "payment_succeeded";
+    payment_failed: "payment_failed";
+    widget_question: "widget_question";
+    start_simulation: "start_simulation";
+    create_workflow: "create_workflow";
+    update_workflow: "update_workflow";
+    delete_workflow: "delete_workflow";
+    toggle_workflow: "toggle_workflow";
+    slack_command: "slack_command";
+    publish_survey: "publish_survey";
+    unpublish_survey: "unpublish_survey";
+    delete_survey_response: "delete_survey_response";
+}>;
+export type ActivityLogType = z.infer<typeof ActivityLogTypeSchema>;
+export declare const SlackCommandLogStatusSchema: z.ZodEnum<{
+    received: "received";
+    classifying: "classifying";
+    dispatched: "dispatched";
+    completed: "completed";
+    failed: "failed";
+}>;
+export type SlackCommandLogStatus = z.infer<typeof SlackCommandLogStatusSchema>;

package/dist/src/sdk/contracts/common.d.ts

@@ -60,6 +60,13 @@ export declare const ToolCallRecordSchema: z.ZodObject<{
     params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strict>;
+export declare const SessionStateSchema: z.ZodObject<{
+    cookies: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    local_storage: z.ZodArray<z.ZodObject<{
+        origin: z.ZodString;
+        items: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const SlackWebhookUrlSchema: z.ZodURL;
 export declare const GraphEdgeSchema: z.ZodObject<{
     start: z.ZodString;