@adoptai/genui-components 0.1.65 → 0.1.66

package/dist/schemas/cash-flow-statement.d.ts

@@ -0,0 +1,165 @@
+import { z } from "zod";
+export declare const cashFlowStatementSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cash-flow-statement">;
+    title: z.ZodOptional<z.ZodString>;
+    currency: z.ZodDefault<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        companyName: z.ZodOptional<z.ZodString>;
+        preparedBy: z.ZodOptional<z.ZodString>;
+        reviewedBy: z.ZodOptional<z.ZodString>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<{
+            draft: "draft";
+            approved: "approved";
+            "pending-review": "pending-review";
+            filed: "filed";
+        }>>;
+        date: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    periodLabel: z.ZodOptional<z.ZodString>;
+    priorPeriodLabel: z.ZodOptional<z.ZodString>;
+    activities: z.ZodArray<z.ZodObject<{
+        activityType: z.ZodEnum<{
+            operating: "operating";
+            investing: "investing";
+            financing: "financing";
+        }>;
+        lineItems: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            amount: z.ZodNumber;
+            priorAmount: z.ZodOptional<z.ZodNumber>;
+            indent: z.ZodDefault<z.ZodNumber>;
+            isSubtotal: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        netCash: z.ZodNumber;
+        priorNetCash: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    netChange: z.ZodNumber;
+    priorNetChange: z.ZodOptional<z.ZodNumber>;
+    beginningCash: z.ZodNumber;
+    endingCash: z.ZodNumber;
+    priorBeginningCash: z.ZodOptional<z.ZodNumber>;
+    priorEndingCash: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const cashFlowStatementTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            currency: {
+                type: string;
+                description: string;
+            };
+            metadata: {
+                type: string;
+                properties: {
+                    companyName: {
+                        type: string;
+                    };
+                    preparedBy: {
+                        type: string;
+                    };
+                    reviewedBy: {
+                        type: string;
+                    };
+                    approvedBy: {
+                        type: string;
+                    };
+                    status: {
+                        type: string;
+                        enum: string[];
+                    };
+                    date: {
+                        type: string;
+                    };
+                };
+            };
+            periodLabel: {
+                type: string;
+                description: string;
+            };
+            priorPeriodLabel: {
+                type: string;
+                description: string;
+            };
+            activities: {
+                type: string;
+                minItems: number;
+                maxItems: number;
+                items: {
+                    type: string;
+                    properties: {
+                        activityType: {
+                            type: string;
+                            enum: string[];
+                        };
+                        lineItems: {
+                            type: string;
+                            minItems: number;
+                            maxItems: number;
+                            items: {
+                                type: string;
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                    amount: {
+                                        type: string;
+                                    };
+                                    priorAmount: {
+                                        type: string;
+                                    };
+                                    indent: {
+                                        type: string;
+                                        minimum: number;
+                                        maximum: number;
+                                        description: string;
+                                    };
+                                    isSubtotal: {
+                                        type: string;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                        netCash: {
+                            type: string;
+                        };
+                        priorNetCash: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            netChange: {
+                type: string;
+            };
+            priorNetChange: {
+                type: string;
+            };
+            beginningCash: {
+                type: string;
+            };
+            endingCash: {
+                type: string;
+            };
+            priorBeginningCash: {
+                type: string;
+            };
+            priorEndingCash: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=cash-flow-statement.d.ts.map

package/dist/schemas/cash-flow-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cash-flow-statement.d.ts","sourceRoot":"","sources":["../../src/schemas/cash-flow-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0ClC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EjC,CAAC"}

package/dist/schemas/chart-of-accounts.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+export declare const chartOfAccountsSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chart-of-accounts">;
+    title: z.ZodOptional<z.ZodString>;
+    currency: z.ZodDefault<z.ZodString>;
+    showBalances: z.ZodDefault<z.ZodBoolean>;
+    accounts: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        name: z.ZodString;
+        accountType: z.ZodEnum<{
+            equity: "equity";
+            revenue: "revenue";
+            asset: "asset";
+            liability: "liability";
+            expense: "expense";
+        }>;
+        subType: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            inactive: "inactive";
+        }>>;
+        indent: z.ZodDefault<z.ZodNumber>;
+        isHeader: z.ZodDefault<z.ZodBoolean>;
+        balance: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const chartOfAccountsTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            currency: {
+                type: string;
+                description: string;
+            };
+            showBalances: {
+                type: string;
+                description: string;
+            };
+            accounts: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        code: {
+                            type: string;
+                            description: string;
+                        };
+                        name: {
+                            type: string;
+                            description: string;
+                        };
+                        accountType: {
+                            type: string;
+                            enum: string[];
+                        };
+                        subType: {
+                            type: string;
+                            description: string;
+                        };
+                        status: {
+                            type: string;
+                            enum: string[];
+                        };
+                        indent: {
+                            type: string;
+                            description: string;
+                        };
+                        isHeader: {
+                            type: string;
+                            description: string;
+                        };
+                        balance: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=chart-of-accounts.d.ts.map

package/dist/schemas/chart-of-accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-of-accounts.d.ts","sourceRoot":"","sources":["../../src/schemas/chart-of-accounts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBAoBhC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC/B,CAAC"}

package/dist/schemas/cited-answer.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export declare const citedAnswerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cited-answer">;
+    title: z.ZodOptional<z.ZodString>;
+    answer: z.ZodString;
+    citations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        source: z.ZodString;
+        sourceType: z.ZodOptional<z.ZodString>;
+        snippet: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    followUps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const citedAnswerTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            answer: {
+                type: string;
+                description: string;
+            };
+            citations: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        id: {
+                            type: string;
+                        };
+                        label: {
+                            type: string;
+                        };
+                        source: {
+                            type: string;
+                        };
+                        sourceType: {
+                            type: string;
+                        };
+                        snippet: {
+                            type: string;
+                        };
+                        url: {
+                            type: string;
+                        };
+                        confidence: {
+                            type: string;
+                            minimum: number;
+                            maximum: number;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            followUps: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=cited-answer.d.ts.map

package/dist/schemas/cited-answer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cited-answer.d.ts","sourceRoot":"","sources":["../../src/schemas/cited-answer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;iBAc5B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B3B,CAAC"}

package/dist/schemas/coercePayload.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tolerate the most common LLM marshalling error: an array/object field
+ * arriving as a JSON-encoded *string* (e.g. `columns: "[{...}]"`) when the
+ * component schema expects a real array/object.
+ *
+ * Schema-guided + shallow: only top-level fields the component's tool
+ * `input_schema` types as `array`/`object` are parsed, and only when the
+ * string parses to the matching type. A legitimately string-valued field
+ * (e.g. a title that happens to start with "[") is left untouched.
+ *
+ * Mirrors the backend `_coerce_json_strings` in adoptai-workflows so the FE
+ * renders correctly even though the streamed tool_use payload carries the raw
+ * (stringified) LLM output. Returns the input unchanged when nothing coerces.
+ */
+export declare function coercePayload<T>(data: T): T;
+//# sourceMappingURL=coercePayload.d.ts.map

package/dist/schemas/coercePayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coercePayload.d.ts","sourceRoot":"","sources":["../../src/schemas/coercePayload.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAoC3C"}

package/dist/schemas/combo-chart.d.ts

@@ -0,0 +1,111 @@
+import { z } from "zod";
+export declare const comboChartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"combo-chart">;
+    title: z.ZodOptional<z.ZodString>;
+    xKey: z.ZodString;
+    leftUnit: z.ZodOptional<z.ZodString>;
+    rightUnit: z.ZodOptional<z.ZodString>;
+    bars: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        dataKey: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        axis: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+    }, z.core.$strip>>>;
+    lines: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        dataKey: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        axis: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+    }, z.core.$strip>>>;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strip>;
+export declare const comboChartTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            xKey: {
+                type: string;
+                description: string;
+            };
+            leftUnit: {
+                type: string;
+                description: string;
+            };
+            rightUnit: {
+                type: string;
+                description: string;
+            };
+            bars: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        dataKey: {
+                            type: string;
+                        };
+                        color: {
+                            type: string;
+                        };
+                        axis: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            lines: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        dataKey: {
+                            type: string;
+                        };
+                        color: {
+                            type: string;
+                        };
+                        axis: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            data: {
+                type: string;
+                items: {
+                    type: string;
+                    additionalProperties: boolean;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=combo-chart.d.ts.map

package/dist/schemas/combo-chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combo-chart.d.ts","sourceRoot":"","sources":["../../src/schemas/combo-chart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBzB,CAAC;AAEL,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8C1B,CAAC"}

package/dist/schemas/comparative-bar-chart.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const comparativeBarChartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"comparative-bar-chart">;
+    title: z.ZodOptional<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        grouped: "grouped";
+        stacked: "stacked";
+    }>>;
+    orientation: z.ZodDefault<z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>>;
+    xKey: z.ZodString;
+    series: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        dataKey: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    unit: z.ZodDefault<z.ZodString>;
+    showValues: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const comparativeBarChartTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            mode: {
+                type: string;
+                enum: string[];
+            };
+            orientation: {
+                type: string;
+                enum: string[];
+            };
+            xKey: {
+                type: string;
+                description: string;
+            };
+            series: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        dataKey: {
+                            type: string;
+                        };
+                        color: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            data: {
+                type: string;
+                items: {
+                    type: string;
+                    additionalProperties: boolean;
+                };
+            };
+            unit: {
+                type: string;
+            };
+            showValues: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=comparative-bar-chart.d.ts.map

package/dist/schemas/comparative-bar-chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparative-bar-chart.d.ts","sourceRoot":"","sources":["../../src/schemas/comparative-bar-chart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;iBAmBpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BnC,CAAC"}

package/dist/schemas/compliance-checklist.d.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+export declare const complianceChecklistSchema: z.ZodObject<{
+    type: z.ZodLiteral<"compliance-checklist">;
+    title: z.ZodOptional<z.ZodString>;
+    sections: z.ZodArray<z.ZodObject<{
+        sectionTitle: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                "in-progress": "in-progress";
+                "not-started": "not-started";
+                overdue: "overdue";
+                blocked: "blocked";
+                na: "na";
+            }>;
+            dueDate: z.ZodOptional<z.ZodString>;
+            assignee: z.ZodOptional<z.ZodString>;
+            notes: z.ZodOptional<z.ZodString>;
+            priority: z.ZodDefault<z.ZodEnum<{
+                critical: "critical";
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const complianceChecklistTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            sections: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        sectionTitle: {
+                            type: string;
+                        };
+                        items: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    id: {
+                                        type: string;
+                                    };
+                                    description: {
+                                        type: string;
+                                    };
+                                    status: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    dueDate: {
+                                        type: string;
+                                    };
+                                    assignee: {
+                                        type: string;
+                                    };
+                                    notes: {
+                                        type: string;
+                                    };
+                                    priority: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=compliance-checklist.d.ts.map

package/dist/schemas/compliance-checklist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compliance-checklist.d.ts","sourceRoot":"","sources":["../../src/schemas/compliance-checklist.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCnC,CAAC"}