@adoptai/genui-components 0.1.65 → 0.1.67

package/dist/schemas/integrations-list.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+export declare const integrationsListSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations-list">;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    integrations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            connected: "connected";
+            not_connected: "not_connected";
+        }>;
+        capability: z.ZodOptional<z.ZodString>;
+        connectUrl: z.ZodOptional<z.ZodString>;
+        iconUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const integrationsListTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            description: {
+                type: string;
+            };
+            integrations: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        status: {
+                            type: string;
+                            enum: string[];
+                        };
+                        capability: {
+                            type: string;
+                        };
+                        connectUrl: {
+                            type: string;
+                        };
+                        iconUrl: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=integrations-list.d.ts.map

package/dist/schemas/integrations-list.d.ts.map

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

package/dist/schemas/invoice-detail.d.ts

@@ -0,0 +1,157 @@
+import { z } from "zod";
+export declare const invoiceDetailSchema: z.ZodObject<{
+    type: z.ZodLiteral<"invoice-detail">;
+    invoiceNumber: z.ZodString;
+    status: z.ZodEnum<{
+        void: "void";
+        draft: "draft";
+        overdue: "overdue";
+        partial: "partial";
+        sent: "sent";
+        paid: "paid";
+    }>;
+    issueDate: z.ZodString;
+    dueDate: z.ZodString;
+    currency: z.ZodDefault<z.ZodString>;
+    client: z.ZodObject<{
+        name: z.ZodString;
+        address: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    lineItems: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        quantity: z.ZodNumber;
+        unitPrice: z.ZodNumber;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>;
+    subtotal: z.ZodNumber;
+    taxLabel: z.ZodOptional<z.ZodString>;
+    taxAmount: z.ZodDefault<z.ZodNumber>;
+    discount: z.ZodDefault<z.ZodNumber>;
+    total: z.ZodNumber;
+    amountPaid: z.ZodDefault<z.ZodNumber>;
+    amountDue: z.ZodNumber;
+    payments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        method: z.ZodString;
+        amount: z.ZodNumber;
+        reference: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    notes: z.ZodOptional<z.ZodString>;
+    terms: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const invoiceDetailTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            invoiceNumber: {
+                type: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+            };
+            issueDate: {
+                type: string;
+            };
+            dueDate: {
+                type: string;
+            };
+            currency: {
+                type: string;
+            };
+            client: {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    address: {
+                        type: string;
+                    };
+                    email: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+            lineItems: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        description: {
+                            type: string;
+                        };
+                        quantity: {
+                            type: string;
+                        };
+                        unitPrice: {
+                            type: string;
+                        };
+                        amount: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            subtotal: {
+                type: string;
+            };
+            taxLabel: {
+                type: string;
+            };
+            taxAmount: {
+                type: string;
+            };
+            discount: {
+                type: string;
+            };
+            total: {
+                type: string;
+            };
+            amountPaid: {
+                type: string;
+            };
+            amountDue: {
+                type: string;
+            };
+            payments: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        date: {
+                            type: string;
+                        };
+                        method: {
+                            type: string;
+                        };
+                        amount: {
+                            type: string;
+                        };
+                        reference: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            notes: {
+                type: string;
+            };
+            terms: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=invoice-detail.d.ts.map

package/dist/schemas/invoice-detail.d.ts.map

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

package/dist/schemas/job-tracker.d.ts

@@ -0,0 +1,114 @@
+import { z } from "zod";
+export declare const jobTrackerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"job-tracker">;
+    title: z.ZodOptional<z.ZodString>;
+    jobId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        queued: "queued";
+        running: "running";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+            running: "running";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        duration: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    result: z.ZodOptional<z.ZodObject<{
+        summary: z.ZodString;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const jobTrackerTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            jobId: {
+                type: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+            };
+            progress: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+            startedAt: {
+                type: string;
+            };
+            completedAt: {
+                type: string;
+            };
+            steps: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        label: {
+                            type: string;
+                        };
+                        status: {
+                            type: string;
+                            enum: string[];
+                        };
+                        duration: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            result: {
+                type: string;
+                properties: {
+                    summary: {
+                        type: string;
+                    };
+                    data: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+            error: {
+                type: string;
+                properties: {
+                    message: {
+                        type: string;
+                    };
+                    code: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=job-tracker.d.ts.map

package/dist/schemas/job-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-tracker.d.ts","sourceRoot":"","sources":["../../src/schemas/job-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB3B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C1B,CAAC"}

package/dist/schemas/journal-entry.d.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+export declare const journalEntrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"journal-entry">;
+    title: z.ZodOptional<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        entryId: z.ZodString;
+        date: z.ZodString;
+        memo: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<{
+            draft: "draft";
+            posted: "posted";
+            reversed: "reversed";
+            "pending-approval": "pending-approval";
+        }>>;
+        lines: z.ZodArray<z.ZodObject<{
+            account: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            debit: z.ZodDefault<z.ZodNumber>;
+            credit: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    currency: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const journalEntryTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            entries: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        entryId: {
+                            type: string;
+                        };
+                        date: {
+                            type: string;
+                            description: string;
+                        };
+                        memo: {
+                            type: string;
+                        };
+                        status: {
+                            type: string;
+                            enum: string[];
+                        };
+                        lines: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    account: {
+                                        type: string;
+                                    };
+                                    description: {
+                                        type: string;
+                                    };
+                                    debit: {
+                                        type: string;
+                                        minimum: number;
+                                    };
+                                    credit: {
+                                        type: string;
+                                        minimum: number;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            currency: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=journal-entry.d.ts.map

package/dist/schemas/journal-entry.d.ts.map

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

package/dist/schemas/key-value-list.d.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+export declare const keyValueListSchema: z.ZodObject<{
+    type: z.ZodLiteral<"key-value-list">;
+    title: z.ZodOptional<z.ZodString>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+            type: z.ZodDefault<z.ZodEnum<{
+                boolean: "boolean";
+                date: "date";
+                code: "code";
+                url: "url";
+                currency: "currency";
+                text: "text";
+            }>>;
+            copyable: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+        type: z.ZodDefault<z.ZodEnum<{
+            boolean: "boolean";
+            date: "date";
+            code: "code";
+            url: "url";
+            currency: "currency";
+            text: "text";
+        }>>;
+        copyable: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const keyValueListTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            groups: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        label: {
+                            type: string;
+                        };
+                        items: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    key: {
+                                        type: string;
+                                    };
+                                    value: {
+                                        type: string;
+                                    };
+                                    type: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    copyable: {
+                                        type: string;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            items: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        key: {
+                            type: string;
+                        };
+                        value: {
+                            type: string;
+                        };
+                        type: {
+                            type: string;
+                            enum: string[];
+                        };
+                        copyable: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=key-value-list.d.ts.map

package/dist/schemas/key-value-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-value-list.d.ts","sourceRoot":"","sources":["../../src/schemas/key-value-list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+C5B,CAAC"}

package/dist/schemas/legal-test-result.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export declare const legalTestResultSchema: z.ZodObject<{
+    type: z.ZodLiteral<"legal-test-result">;
+    title: z.ZodOptional<z.ZodString>;
+    citation: z.ZodOptional<z.ZodString>;
+    overallResult: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        inconclusive: "inconclusive";
+        partial: "partial";
+    }>;
+    overallNarrative: z.ZodOptional<z.ZodString>;
+    parts: z.ZodArray<z.ZodObject<{
+        partLabel: z.ZodString;
+        result: z.ZodEnum<{
+            na: "na";
+            pass: "pass";
+            fail: "fail";
+            inconclusive: "inconclusive";
+        }>;
+        narrative: z.ZodString;
+        subRequirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            result: z.ZodEnum<{
+                na: "na";
+                pass: "pass";
+                fail: "fail";
+                inconclusive: "inconclusive";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+            threshold: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            scenario: z.ZodString;
+            qualifies: z.ZodBoolean;
+            explanation: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const legalTestResultTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            title: {
+                type: string;
+            };
+            citation: {
+                type: string;
+            };
+            overallResult: {
+                type: string;
+                enum: string[];
+            };
+            overallNarrative: {
+                type: string;
+            };
+            parts: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        partLabel: {
+                            type: string;
+                        };
+                        result: {
+                            type: string;
+                            enum: string[];
+                        };
+                        narrative: {
+                            type: string;
+                        };
+                        subRequirements: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    label: {
+                                        type: string;
+                                    };
+                                    result: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    detail: {
+                                        type: string;
+                                    };
+                                    threshold: {
+                                        type: string;
+                                    };
+                                    evidence: {
+                                        type: string;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                        examples: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    scenario: {
+                                        type: string;
+                                    };
+                                    qualifies: {
+                                        type: string;
+                                    };
+                                    explanation: {
+                                        type: string;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=legal-test-result.d.ts.map

package/dist/schemas/legal-test-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legal-test-result.d.ts","sourceRoot":"","sources":["../../src/schemas/legal-test-result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsChC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8D/B,CAAC"}