@adoptai/genui-components 0.1.32

package/dist/schemas/reconciliation-view.d.ts

@@ -0,0 +1,156 @@
+import { z } from "zod";
+export declare const reconciliationViewSchema: z.ZodObject<{
+    type: z.ZodLiteral<"reconciliation-view">;
+    title: z.ZodOptional<z.ZodString>;
+    currency: z.ZodDefault<z.ZodString>;
+    sourceA: z.ZodObject<{
+        label: z.ZodString;
+    }, z.core.$strip>;
+    sourceB: z.ZodObject<{
+        label: z.ZodString;
+    }, z.core.$strip>;
+    matched: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        description: z.ZodString;
+        amountA: z.ZodNumber;
+        amountB: z.ZodNumber;
+        reference: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    unmatchedA: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        description: z.ZodString;
+        amount: z.ZodNumber;
+        reference: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    unmatchedB: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        description: z.ZodString;
+        amount: z.ZodNumber;
+        reference: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    summary: z.ZodOptional<z.ZodObject<{
+        balanceA: z.ZodNumber;
+        balanceB: z.ZodNumber;
+        difference: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const reconciliationViewTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            currency: {
+                type: string;
+            };
+            sourceA: {
+                type: string;
+                properties: {
+                    label: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+            sourceB: {
+                type: string;
+                properties: {
+                    label: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+            matched: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        date: {
+                            type: string;
+                        };
+                        description: {
+                            type: string;
+                        };
+                        amountA: {
+                            type: string;
+                        };
+                        amountB: {
+                            type: string;
+                        };
+                        reference: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            unmatchedA: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        date: {
+                            type: string;
+                        };
+                        description: {
+                            type: string;
+                        };
+                        amount: {
+                            type: string;
+                        };
+                        reference: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            unmatchedB: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        date: {
+                            type: string;
+                        };
+                        description: {
+                            type: string;
+                        };
+                        amount: {
+                            type: string;
+                        };
+                        reference: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            summary: {
+                type: string;
+                properties: {
+                    balanceA: {
+                        type: string;
+                    };
+                    balanceB: {
+                        type: string;
+                    };
+                    difference: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=reconciliation-view.d.ts.map

package/dist/schemas/reconciliation-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciliation-view.d.ts","sourceRoot":"","sources":["../../src/schemas/reconciliation-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CnC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwElC,CAAC"}

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

@@ -0,0 +1,90 @@
+import { z } from "zod";
+export declare const scatterChartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"scatter-chart">;
+    title: z.ZodOptional<z.ZodString>;
+    xLabel: z.ZodOptional<z.ZodString>;
+    yLabel: z.ZodOptional<z.ZodString>;
+    xUnit: z.ZodOptional<z.ZodString>;
+    yUnit: z.ZodOptional<z.ZodString>;
+    series: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        points: z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodOptional<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const scatterChartTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            xLabel: {
+                type: string;
+            };
+            yLabel: {
+                type: string;
+            };
+            xUnit: {
+                type: string;
+                description: string;
+            };
+            yUnit: {
+                type: string;
+                description: string;
+            };
+            series: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        color: {
+                            type: string;
+                            description: string;
+                        };
+                        points: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    x: {
+                                        type: string;
+                                    };
+                                    y: {
+                                        type: string;
+                                    };
+                                    z: {
+                                        type: string;
+                                        description: string;
+                                    };
+                                    label: {
+                                        type: string;
+                                        description: string;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=scatter-chart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scatter-chart.d.ts","sourceRoot":"","sources":["../../src/schemas/scatter-chart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBA2B7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwC5B,CAAC"}

package/dist/schemas/screener-table.d.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export declare const screenerTableSchema: z.ZodObject<{
+    type: z.ZodLiteral<"screener-table">;
+    title: z.ZodOptional<z.ZodString>;
+    columns: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        align: z.ZodDefault<z.ZodEnum<{
+            start: "start";
+            center: "center";
+            end: "end";
+        }>>;
+        meterKey: z.ZodDefault<z.ZodBoolean>;
+        meterMax: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    activeFilters: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const screenerTableTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            columns: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        key: {
+                            type: string;
+                        };
+                        label: {
+                            type: string;
+                        };
+                        align: {
+                            type: string;
+                            enum: string[];
+                        };
+                        meterKey: {
+                            type: string;
+                        };
+                        meterMax: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            rows: {
+                type: string;
+                items: {
+                    type: string;
+                    additionalProperties: boolean;
+                };
+            };
+            activeFilters: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=screener-table.d.ts.map

package/dist/schemas/screener-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screener-table.d.ts","sourceRoot":"","sources":["../../src/schemas/screener-table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAmB9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B7B,CAAC"}

package/dist/schemas/search-results.d.ts

@@ -0,0 +1,87 @@
+import { z } from "zod";
+export declare const searchResultsSchema: z.ZodObject<{
+    type: z.ZodLiteral<"search-results">;
+    title: z.ZodOptional<z.ZodString>;
+    query: z.ZodString;
+    totalResults: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        source: z.ZodString;
+        sourceType: z.ZodOptional<z.ZodEnum<{
+            other: "other";
+            "tech-memo": "tech-memo";
+            questionnaire: "questionnaire";
+            contract: "contract";
+            workpaper: "workpaper";
+            regulation: "regulation";
+        }>>;
+        relevance: z.ZodNumber;
+        snippet: z.ZodString;
+        highlights: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        location: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const searchResultsTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            query: {
+                type: string;
+            };
+            totalResults: {
+                type: string;
+            };
+            results: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        title: {
+                            type: string;
+                        };
+                        source: {
+                            type: string;
+                        };
+                        sourceType: {
+                            type: string;
+                            enum: string[];
+                        };
+                        relevance: {
+                            type: string;
+                            minimum: number;
+                            maximum: number;
+                        };
+                        snippet: {
+                            type: string;
+                        };
+                        highlights: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                        location: {
+                            type: string;
+                        };
+                        url: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=search-results.d.ts.map

package/dist/schemas/search-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-results.d.ts","sourceRoot":"","sources":["../../src/schemas/search-results.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;iBAe9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC7B,CAAC"}

package/dist/schemas/sparkline-table.d.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export declare const sparklineTableSchema: z.ZodObject<{
+    type: z.ZodLiteral<"sparkline-table">;
+    title: z.ZodOptional<z.ZodString>;
+    sparklineLabel: z.ZodDefault<z.ZodString>;
+    columns: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        align: z.ZodDefault<z.ZodEnum<{
+            start: "start";
+            center: "center";
+            end: "end";
+        }>>;
+    }, z.core.$strip>>;
+    rows: z.ZodArray<z.ZodObject<{
+        sparkline: z.ZodArray<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>>;
+}, z.core.$strip>;
+export declare const sparklineTableTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            sparklineLabel: {
+                type: string;
+            };
+            columns: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        key: {
+                            type: string;
+                        };
+                        label: {
+                            type: string;
+                        };
+                        align: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            rows: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        sparkline: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=sparkline-table.d.ts.map

package/dist/schemas/sparkline-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkline-table.d.ts","sourceRoot":"","sources":["../../src/schemas/sparkline-table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;iBAe/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B9B,CAAC"}

package/dist/schemas/stacked-breakdown.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export declare const stackedBreakdownSchema: z.ZodObject<{
+    type: z.ZodLiteral<"stacked-breakdown">;
+    title: z.ZodOptional<z.ZodString>;
+    currency: z.ZodDefault<z.ZodString>;
+    periods: z.ZodArray<z.ZodString>;
+    categories: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        values: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    totals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const stackedBreakdownTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            currency: {
+                type: string;
+            };
+            periods: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            categories: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        color: {
+                            type: string;
+                        };
+                        values: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            totals: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=stacked-breakdown.d.ts.map

package/dist/schemas/stacked-breakdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stacked-breakdown.d.ts","sourceRoot":"","sources":["../../src/schemas/stacked-breakdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;iBAgBjC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BhC,CAAC"}

package/dist/schemas/stat-grid.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export declare const statGridSchema: z.ZodObject<{
+    type: z.ZodLiteral<"stat-grid">;
+    stats: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        change: z.ZodOptional<z.ZodString>;
+        changeType: z.ZodOptional<z.ZodEnum<{
+            neutral: "neutral";
+            positive: "positive";
+            negative: "negative";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const statGridTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            stats: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        label: {
+                            type: string;
+                        };
+                        value: {
+                            type: string;
+                        };
+                        change: {
+                            type: string;
+                        };
+                        changeType: {
+                            type: string;
+                            enum: string[];
+                        };
+                        description: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=stat-grid.d.ts.map

package/dist/schemas/stat-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stat-grid.d.ts","sourceRoot":"","sources":["../../src/schemas/stat-grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;iBAczB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BxB,CAAC"}