@voyant-travel/quotes 0.119.2

package/dist/routes/quote-versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quote-versions.d.ts","sourceRoot":"","sources":["../../src/routes/quote-versions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAiBjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAsL3B,CAAA"}

package/dist/routes/quote-versions.js

@@ -0,0 +1,175 @@
+import { parseJsonBody, parseOptionalJsonBody, parseQuery } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { quotesService } from "../service/index.js";
+import { QuoteVersionConflictError } from "../service/quote-versions.js";
+import { acceptQuoteVersionSchema, applyTripSnapshotToQuoteVersionSchema, declineQuoteVersionSchema, expireQuoteVersionsSchema, insertQuoteVersionLineSchema, insertQuoteVersionSchema, quoteVersionListQuerySchema, sendQuoteVersionSchema, updateQuoteVersionLineSchema, updateQuoteVersionSchema, } from "../validation.js";
+export const quoteVersionRoutes = new Hono()
+    .get("/quote-versions", async (c) => {
+    const query = await parseQuery(c, quoteVersionListQuerySchema);
+    return c.json(await quotesService.listQuoteVersions(c.get("db"), query));
+})
+    .post("/quotes/:id/versions", async (c) => {
+    try {
+        const body = await parseJsonBody(c, insertQuoteVersionSchema.omit({ quoteId: true }));
+        return c.json({
+            data: await quotesService.createQuoteVersion(c.get("db"), {
+                ...body,
+                quoteId: c.req.param("id"),
+            }),
+        }, 201);
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .post("/quote-versions/expire", async (c) => {
+    return c.json({
+        data: await quotesService.expireQuoteVersions(c.get("db"), await parseOptionalJsonBody(c, expireQuoteVersionsSchema)),
+    });
+})
+    .get("/quote-versions/:id", async (c) => {
+    const row = await quotesService.getQuoteVersionById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Quote version not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/quote-versions/:id", async (c) => {
+    try {
+        const row = await quotesService.updateQuoteVersion(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateQuoteVersionSchema));
+        if (!row)
+            return c.json({ error: "Quote version not found" }, 404);
+        return c.json({ data: row });
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .delete("/quote-versions/:id", async (c) => {
+    try {
+        const row = await quotesService.deleteQuoteVersion(c.get("db"), c.req.param("id"));
+        if (!row)
+            return c.json({ error: "Quote version not found" }, 404);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .post("/quote-versions/:id/trip-snapshot", async (c) => {
+    try {
+        const row = await quotesService.applyTripSnapshotToQuoteVersion(c.get("db"), c.req.param("id"), await parseJsonBody(c, applyTripSnapshotToQuoteVersionSchema));
+        if (!row)
+            return c.json({ error: "Quote version not found" }, 404);
+        return c.json({ data: row });
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .post("/quote-versions/:id/send", async (c) => {
+    try {
+        const row = await quotesService.sendQuoteVersion(c.get("db"), c.req.param("id"), await parseOptionalJsonBody(c, sendQuoteVersionSchema));
+        if (!row)
+            return c.json({ error: "Quote version not found" }, 404);
+        return c.json({ data: row });
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .post("/quote-versions/:id/view", async (c) => {
+    const row = await quotesService.markQuoteVersionViewed(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Quote version not found" }, 404);
+    return c.json({ data: row });
+})
+    .post("/quote-versions/:id/accept", async (c) => {
+    try {
+        const row = await quotesService.acceptQuoteVersion(c.get("db"), c.req.param("id"), await parseOptionalJsonBody(c, acceptQuoteVersionSchema));
+        if (!row)
+            return c.json({ error: "Quote version not found" }, 404);
+        return c.json({ data: row });
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .post("/quote-versions/:id/decline", async (c) => {
+    try {
+        const row = await quotesService.declineQuoteVersion(c.get("db"), c.req.param("id"), await parseOptionalJsonBody(c, declineQuoteVersionSchema));
+        if (!row)
+            return c.json({ error: "Quote version not found" }, 404);
+        return c.json({ data: row });
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .get("/quote-versions/:id/lines", async (c) => {
+    return c.json({
+        data: await quotesService.listQuoteVersionLines(c.get("db"), c.req.param("id")),
+    });
+})
+    .post("/quote-versions/:id/lines", async (c) => {
+    try {
+        const row = await quotesService.createQuoteVersionLine(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertQuoteVersionLineSchema));
+        if (!row)
+            return c.json({ error: "Quote version not found" }, 404);
+        return c.json({ data: row }, 201);
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .patch("/quote-version-lines/:id", async (c) => {
+    try {
+        const row = await quotesService.updateQuoteVersionLine(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateQuoteVersionLineSchema));
+        if (!row)
+            return c.json({ error: "Quote version line not found" }, 404);
+        return c.json({ data: row });
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+})
+    .delete("/quote-version-lines/:id", async (c) => {
+    try {
+        const row = await quotesService.deleteQuoteVersionLine(c.get("db"), c.req.param("id"));
+        if (!row)
+            return c.json({ error: "Quote version line not found" }, 404);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        if (error instanceof QuoteVersionConflictError) {
+            return c.json({ error: error.message }, 409);
+        }
+        throw error;
+    }
+});

package/dist/routes/quotes.d.ts

@@ -0,0 +1,391 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export declare const quoteRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/quotes": {
+        $get: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    title: string;
+                    personId: string | null;
+                    organizationId: string | null;
+                    pipelineId: string;
+                    stageId: string;
+                    ownerId: string | null;
+                    status: "open" | "won" | "lost" | "archived";
+                    acceptedVersionId: string | null;
+                    valueAmountCents: number | null;
+                    valueCurrency: string | null;
+                    expectedCloseDate: string | null;
+                    source: string | null;
+                    sourceRef: string | null;
+                    lostReason: string | null;
+                    tags: string[];
+                    createdAt: string;
+                    updatedAt: string;
+                    stageChangedAt: string;
+                    closedAt: string | null;
+                }[];
+                total: number;
+                limit: number;
+                offset: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/quotes": {
+        $post: {
+            input: {};
+            output: {
+                data: {
+                    createdAt: string;
+                    updatedAt: string;
+                    id: string;
+                    title: string;
+                    pipelineId: string;
+                    personId: string | null;
+                    organizationId: string | null;
+                    stageId: string;
+                    ownerId: string | null;
+                    status: "open" | "won" | "lost" | "archived";
+                    acceptedVersionId: string | null;
+                    valueAmountCents: number | null;
+                    valueCurrency: string | null;
+                    expectedCloseDate: string | null;
+                    source: string | null;
+                    sourceRef: string | null;
+                    lostReason: string | null;
+                    tags: string[];
+                    stageChangedAt: string;
+                    closedAt: string | null;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/quotes/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    title: string;
+                    personId: string | null;
+                    organizationId: string | null;
+                    pipelineId: string;
+                    stageId: string;
+                    ownerId: string | null;
+                    status: "open" | "won" | "lost" | "archived";
+                    acceptedVersionId: string | null;
+                    valueAmountCents: number | null;
+                    valueCurrency: string | null;
+                    expectedCloseDate: string | null;
+                    source: string | null;
+                    sourceRef: string | null;
+                    lostReason: string | null;
+                    tags: string[];
+                    createdAt: string;
+                    updatedAt: string;
+                    stageChangedAt: string;
+                    closedAt: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/quotes/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    title: string;
+                    personId: string | null;
+                    organizationId: string | null;
+                    pipelineId: string;
+                    stageId: string;
+                    ownerId: string | null;
+                    status: "open" | "won" | "lost" | "archived";
+                    acceptedVersionId: string | null;
+                    valueAmountCents: number | null;
+                    valueCurrency: string | null;
+                    expectedCloseDate: string | null;
+                    source: string | null;
+                    sourceRef: string | null;
+                    lostReason: string | null;
+                    tags: string[];
+                    createdAt: string;
+                    updatedAt: string;
+                    stageChangedAt: string;
+                    closedAt: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/quotes/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/quotes/:id/participants": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    quoteId: string;
+                    personId: string;
+                    role: "traveler" | "booker" | "decision_maker" | "finance" | "other";
+                    isPrimary: boolean;
+                    createdAt: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/quotes/:id/participants": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    quoteId: string;
+                    createdAt: string;
+                    id: string;
+                    personId: string;
+                    role: "traveler" | "booker" | "decision_maker" | "finance" | "other";
+                    isPrimary: boolean;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/quote-participants/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/quotes/:id/products": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    quoteId: string;
+                    productId: string | null;
+                    supplierServiceId: string | null;
+                    nameSnapshot: string;
+                    description: string | null;
+                    quantity: number;
+                    unitPriceAmountCents: number | null;
+                    costAmountCents: number | null;
+                    currency: string | null;
+                    discountAmountCents: number | null;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/quotes/:id/products": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    quoteId: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    description: string | null;
+                    id: string;
+                    productId: string | null;
+                    supplierServiceId: string | null;
+                    nameSnapshot: string;
+                    quantity: number;
+                    unitPriceAmountCents: number | null;
+                    costAmountCents: number | null;
+                    currency: string | null;
+                    discountAmountCents: number | null;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/quote-products/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    quoteId: string;
+                    productId: string | null;
+                    supplierServiceId: string | null;
+                    nameSnapshot: string;
+                    description: string | null;
+                    quantity: number;
+                    unitPriceAmountCents: number | null;
+                    costAmountCents: number | null;
+                    currency: string | null;
+                    discountAmountCents: number | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/quote-products/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/quote-products/:id">;
+export {};
+//# sourceMappingURL=quotes.d.ts.map

package/dist/routes/quotes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quotes.d.ts","sourceRoot":"","sources":["../../src/routes/quotes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAajE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAuFpB,CAAA"}

package/dist/routes/quotes.js

@@ -0,0 +1,70 @@
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { quotesService } from "../service/index.js";
+import { insertQuoteParticipantSchema, insertQuoteProductSchema, insertQuoteSchema, quoteListQuerySchema, updateQuoteProductSchema, updateQuoteSchema, } from "../validation.js";
+export const quoteRoutes = new Hono()
+    .get("/quotes", async (c) => {
+    const query = await parseQuery(c, quoteListQuerySchema);
+    return c.json(await quotesService.listQuotes(c.get("db"), query));
+})
+    .post("/quotes", async (c) => {
+    return c.json({
+        data: await quotesService.createQuote(c.get("db"), await parseJsonBody(c, insertQuoteSchema)),
+    }, 201);
+})
+    .get("/quotes/:id", async (c) => {
+    const row = await quotesService.getQuoteById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Quote not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/quotes/:id", async (c) => {
+    const row = await quotesService.updateQuote(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateQuoteSchema));
+    if (!row)
+        return c.json({ error: "Quote not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/quotes/:id", async (c) => {
+    const row = await quotesService.deleteQuote(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Quote not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/quotes/:id/participants", async (c) => {
+    return c.json({
+        data: await quotesService.listQuoteParticipants(c.get("db"), c.req.param("id")),
+    });
+})
+    .post("/quotes/:id/participants", async (c) => {
+    return c.json({
+        data: await quotesService.createQuoteParticipant(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertQuoteParticipantSchema)),
+    }, 201);
+})
+    .delete("/quote-participants/:id", async (c) => {
+    const row = await quotesService.deleteQuoteParticipant(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Quote participant not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/quotes/:id/products", async (c) => {
+    return c.json({
+        data: await quotesService.listQuoteProducts(c.get("db"), c.req.param("id")),
+    });
+})
+    .post("/quotes/:id/products", async (c) => {
+    return c.json({
+        data: await quotesService.createQuoteProduct(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertQuoteProductSchema)),
+    }, 201);
+})
+    .patch("/quote-products/:id", async (c) => {
+    const row = await quotesService.updateQuoteProduct(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateQuoteProductSchema));
+    if (!row)
+        return c.json({ error: "Quote product not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/quote-products/:id", async (c) => {
+    const row = await quotesService.deleteQuoteProduct(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Quote product not found" }, 404);
+    return c.json({ success: true });
+});

package/dist/schema-relations.d.ts

@@ -0,0 +1,30 @@
+export declare const pipelinesRelations: import("drizzle-orm").Relations<"pipelines", {
+    stages: import("drizzle-orm").Many<"stages">;
+    quotes: import("drizzle-orm").Many<"quotes">;
+}>;
+export declare const stagesRelations: import("drizzle-orm").Relations<"stages", {
+    pipeline: import("drizzle-orm").One<"pipelines", true>;
+    quotes: import("drizzle-orm").Many<"quotes">;
+}>;
+export declare const quotesRelations: import("drizzle-orm").Relations<"quotes", {
+    pipeline: import("drizzle-orm").One<"pipelines", true>;
+    stage: import("drizzle-orm").One<"stages", true>;
+    participants: import("drizzle-orm").Many<"quote_participants">;
+    products: import("drizzle-orm").Many<"quote_products">;
+    versions: import("drizzle-orm").Many<"quote_versions">;
+}>;
+export declare const quoteParticipantsRelations: import("drizzle-orm").Relations<"quote_participants", {
+    quote: import("drizzle-orm").One<"quotes", true>;
+}>;
+export declare const quoteProductsRelations: import("drizzle-orm").Relations<"quote_products", {
+    quote: import("drizzle-orm").One<"quotes", true>;
+}>;
+export declare const quoteVersionsRelations: import("drizzle-orm").Relations<"quote_versions", {
+    quote: import("drizzle-orm").One<"quotes", true>;
+    supersedes: import("drizzle-orm").One<"quote_versions", false>;
+    lines: import("drizzle-orm").Many<"quote_version_lines">;
+}>;
+export declare const quoteVersionLinesRelations: import("drizzle-orm").Relations<"quote_version_lines", {
+    quoteVersion: import("drizzle-orm").One<"quote_versions", true>;
+}>;
+//# sourceMappingURL=schema-relations.d.ts.map

package/dist/schema-relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-relations.d.ts","sourceRoot":"","sources":["../src/schema-relations.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,kBAAkB;;;EAG5B,CAAA;AAEH,eAAO,MAAM,eAAe;;;EAGzB,CAAA;AAEH,eAAO,MAAM,eAAe;;;;;;EASzB,CAAA;AAEH,eAAO,MAAM,0BAA0B;;EAKpC,CAAA;AAEH,eAAO,MAAM,sBAAsB;;EAKhC,CAAA;AAEH,eAAO,MAAM,sBAAsB;;;;EAUhC,CAAA;AAEH,eAAO,MAAM,0BAA0B;;EAKpC,CAAA"}