@voyant-travel/inventory 0.1.0

package/dist/service-itinerary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-itinerary.d.ts","sourceRoot":"","sources":["../src/service-itinerary.ts"],"names":[],"mappings":"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"}

package/dist/service-itinerary.js

@@ -0,0 +1,419 @@
+import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
+import { productDayServices, productDays, productItineraries, productMedia, products, } from "./schema.js";
+async function recalculateProductCost(db, productId) {
+    const [result] = await db
+        .select({
+        totalCost: sql `coalesce(sum(${productDayServices.costAmountCents} * ${productDayServices.quantity}), 0)::int`,
+    })
+        .from(productDayServices)
+        .innerJoin(productDays, eq(productDayServices.dayId, productDays.id))
+        .innerJoin(productItineraries, eq(productDays.itineraryId, productItineraries.id))
+        .where(eq(productItineraries.productId, productId));
+    const costAmountCents = result?.totalCost ?? 0;
+    const [product] = await db
+        .select({ sellAmountCents: products.sellAmountCents })
+        .from(products)
+        .where(eq(products.id, productId))
+        .limit(1);
+    const sellAmountCents = product?.sellAmountCents ?? 0;
+    const marginPercent = sellAmountCents > 0
+        ? Math.round(((sellAmountCents - costAmountCents) / sellAmountCents) * 100)
+        : 0;
+    await db
+        .update(products)
+        .set({ costAmountCents, marginPercent, updatedAt: new Date() })
+        .where(eq(products.id, productId));
+    return { costAmountCents, marginPercent };
+}
+async function ensureProductExists(db, productId) {
+    const [product] = await db
+        .select({ id: products.id })
+        .from(products)
+        .where(eq(products.id, productId))
+        .limit(1);
+    return product ?? null;
+}
+async function getDefaultItinerary(db, productId) {
+    const [itinerary] = await db
+        .select({ id: productItineraries.id })
+        .from(productItineraries)
+        .where(and(eq(productItineraries.productId, productId), eq(productItineraries.isDefault, true)))
+        .orderBy(asc(productItineraries.sortOrder), asc(productItineraries.createdAt))
+        .limit(1);
+    return itinerary ?? null;
+}
+async function ensureDefaultItinerary(db, productId) {
+    const existing = await getDefaultItinerary(db, productId);
+    if (existing) {
+        return existing;
+    }
+    const [row] = await db
+        .insert(productItineraries)
+        .values({
+        productId,
+        name: "Main itinerary",
+        isDefault: true,
+        sortOrder: 0,
+    })
+        .returning({ id: productItineraries.id });
+    if (!row) {
+        throw new Error(`Failed to create default itinerary for product ${productId}`);
+    }
+    return row;
+}
+// Every product needs at least one bookable option for the operator pricing
+// grid to have something to attach inventory and prices to. Seed a single
+// "Standard" default option on creation so a brand-new product opens straight
+async function getItineraryById(db, itineraryId) {
+    const [itinerary] = await db
+        .select()
+        .from(productItineraries)
+        .where(eq(productItineraries.id, itineraryId))
+        .limit(1);
+    return itinerary ?? null;
+}
+async function getDayById(db, dayId) {
+    const [day] = await db
+        .select({
+        id: productDays.id,
+        itineraryId: productDays.itineraryId,
+        productId: productItineraries.productId,
+    })
+        .from(productDays)
+        .innerJoin(productItineraries, eq(productDays.itineraryId, productItineraries.id))
+        .where(eq(productDays.id, dayId))
+        .limit(1);
+    return day ?? null;
+}
+async function setDefaultItinerary(db, productId, itineraryId) {
+    await db
+        .update(productItineraries)
+        .set({
+        // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        isDefault: sql `${productItineraries.id} = ${itineraryId}`,
+        updatedAt: new Date(),
+    })
+        .where(eq(productItineraries.productId, productId));
+}
+async function promoteFallbackItinerary(db, productId) {
+    const [fallback] = await db
+        .select({ id: productItineraries.id })
+        .from(productItineraries)
+        .where(eq(productItineraries.productId, productId))
+        .orderBy(asc(productItineraries.sortOrder), asc(productItineraries.createdAt))
+        .limit(1);
+    if (!fallback) {
+        return null;
+    }
+    await setDefaultItinerary(db, productId, fallback.id);
+    return fallback;
+}
+export const itineraryProductsService = {
+    listItineraries(db, productId) {
+        return db
+            .select()
+            .from(productItineraries)
+            .where(eq(productItineraries.productId, productId))
+            .orderBy(desc(productItineraries.isDefault), asc(productItineraries.sortOrder));
+    },
+    getItineraryById(db, itineraryId) {
+        return getItineraryById(db, itineraryId);
+    },
+    async createItinerary(db, productId, data) {
+        const product = await ensureProductExists(db, productId);
+        if (!product) {
+            return null;
+        }
+        const [existingCount] = await db
+            .select({ count: sql `count(*)::int` })
+            .from(productItineraries)
+            .where(eq(productItineraries.productId, productId));
+        const shouldBeDefault = (existingCount?.count ?? 0) === 0 || data.isDefault;
+        const insertAsDefault = (existingCount?.count ?? 0) === 0;
+        const [row] = await db
+            .insert(productItineraries)
+            .values({
+            productId,
+            name: data.name,
+            isDefault: insertAsDefault,
+            sortOrder: data.sortOrder,
+        })
+            .returning();
+        if (!row) {
+            throw new Error(`Failed to create itinerary for product ${productId}`);
+        }
+        if (shouldBeDefault && !insertAsDefault) {
+            await setDefaultItinerary(db, productId, row.id);
+        }
+        return shouldBeDefault && !insertAsDefault ? ((await getItineraryById(db, row.id)) ?? row) : row;
+    },
+    async updateItinerary(db, itineraryId, data) {
+        const itinerary = await getItineraryById(db, itineraryId);
+        if (!itinerary) {
+            return null;
+        }
+        const { isDefault, ...rest } = data;
+        const [row] = await db
+            .update(productItineraries)
+            .set({
+            ...rest,
+            ...(isDefault === false ? { isDefault: false } : {}),
+            updatedAt: new Date(),
+        })
+            .where(eq(productItineraries.id, itineraryId))
+            .returning();
+        if (!row) {
+            return null;
+        }
+        if (isDefault === true) {
+            await setDefaultItinerary(db, itinerary.productId, itineraryId);
+            return (await getItineraryById(db, itineraryId));
+        }
+        if (isDefault === false && itinerary.isDefault) {
+            const [fallback] = await db
+                .select({ id: productItineraries.id })
+                .from(productItineraries)
+                .where(and(eq(productItineraries.productId, itinerary.productId), 
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `${productItineraries.id} <> ${itineraryId}`))
+                .orderBy(asc(productItineraries.sortOrder), asc(productItineraries.createdAt))
+                .limit(1);
+            if (fallback) {
+                await setDefaultItinerary(db, itinerary.productId, fallback.id);
+            }
+            else {
+                await setDefaultItinerary(db, itinerary.productId, itineraryId);
+            }
+            return (await getItineraryById(db, itineraryId));
+        }
+        return row;
+    },
+    async deleteItinerary(db, itineraryId) {
+        const itinerary = await getItineraryById(db, itineraryId);
+        if (!itinerary) {
+            return null;
+        }
+        const [row] = await db
+            .delete(productItineraries)
+            .where(eq(productItineraries.id, itineraryId))
+            .returning({ id: productItineraries.id });
+        if (!row) {
+            return null;
+        }
+        if (itinerary.isDefault) {
+            await promoteFallbackItinerary(db, itinerary.productId);
+        }
+        return row;
+    },
+    async duplicateItinerary(db, itineraryId, options) {
+        const source = await getItineraryById(db, itineraryId);
+        if (!source) {
+            return null;
+        }
+        const [countRow] = await db
+            .select({ count: sql `count(*)::int` })
+            .from(productItineraries)
+            .where(eq(productItineraries.productId, source.productId));
+        const name = options?.name?.trim() || `${source.name} (Copy)`;
+        const sortOrder = countRow?.count ?? 0;
+        const [created] = await db
+            .insert(productItineraries)
+            .values({
+            productId: source.productId,
+            name,
+            isDefault: false,
+            sortOrder,
+        })
+            .returning();
+        if (!created) {
+            throw new Error(`Failed to duplicate itinerary ${itineraryId}`);
+        }
+        const sourceDays = await db
+            .select()
+            .from(productDays)
+            .where(eq(productDays.itineraryId, source.id))
+            .orderBy(asc(productDays.dayNumber));
+        if (sourceDays.length === 0) {
+            return created;
+        }
+        const dayIdMap = new Map();
+        const insertedDays = await db
+            .insert(productDays)
+            .values(sourceDays.map((day) => ({
+            itineraryId: created.id,
+            dayNumber: day.dayNumber,
+            title: day.title,
+            description: day.description,
+            location: day.location,
+        })))
+            .returning({ id: productDays.id, dayNumber: productDays.dayNumber });
+        for (const sourceDay of sourceDays) {
+            const match = insertedDays.find((day) => day.dayNumber === sourceDay.dayNumber);
+            if (match) {
+                dayIdMap.set(sourceDay.id, match.id);
+            }
+        }
+        const sourceDayIds = sourceDays.map((day) => day.id);
+        const sourceServices = await db
+            .select()
+            .from(productDayServices)
+            .where(inArray(productDayServices.dayId, sourceDayIds))
+            .orderBy(asc(productDayServices.sortOrder));
+        if (sourceServices.length > 0) {
+            await db.insert(productDayServices).values(sourceServices
+                .map((service) => {
+                const newDayId = dayIdMap.get(service.dayId);
+                if (!newDayId)
+                    return null;
+                return {
+                    dayId: newDayId,
+                    supplierServiceId: service.supplierServiceId,
+                    serviceType: service.serviceType,
+                    name: service.name,
+                    description: service.description,
+                    countryCode: service.countryCode,
+                    costCurrency: service.costCurrency,
+                    costAmountCents: service.costAmountCents,
+                    quantity: service.quantity,
+                    sortOrder: service.sortOrder,
+                    notes: service.notes,
+                };
+            })
+                .filter((value) => value !== null));
+        }
+        const sourceDayMedia = await db
+            .select()
+            .from(productMedia)
+            .where(inArray(productMedia.dayId, sourceDayIds))
+            .orderBy(asc(productMedia.sortOrder));
+        if (sourceDayMedia.length > 0) {
+            await db.insert(productMedia).values(sourceDayMedia
+                .map((media) => {
+                const newDayId = media.dayId ? dayIdMap.get(media.dayId) : null;
+                if (!newDayId)
+                    return null;
+                return {
+                    productId: media.productId,
+                    dayId: newDayId,
+                    mediaType: media.mediaType,
+                    name: media.name,
+                    url: media.url,
+                    storageKey: media.storageKey,
+                    mimeType: media.mimeType,
+                    fileSize: media.fileSize,
+                    altText: media.altText,
+                    sortOrder: media.sortOrder,
+                    isCover: media.isCover,
+                    isBrochure: false,
+                    isBrochureCurrent: false,
+                    brochureVersion: null,
+                };
+            })
+                .filter((value) => value !== null));
+        }
+        return created;
+    },
+    async listDays(db, productId) {
+        const itinerary = await ensureDefaultItinerary(db, productId);
+        return itineraryProductsService.listItineraryDays(db, itinerary.id);
+    },
+    listItineraryDays(db, itineraryId) {
+        return db
+            .select()
+            .from(productDays)
+            .where(eq(productDays.itineraryId, itineraryId))
+            .orderBy(asc(productDays.dayNumber));
+    },
+    async getDayForProductMutation(db, dayId) {
+        const dayRef = await getDayById(db, dayId);
+        if (!dayRef) {
+            return null;
+        }
+        const [row] = await db.select().from(productDays).where(eq(productDays.id, dayId)).limit(1);
+        return row ? { ...row, productId: dayRef.productId } : null;
+    },
+    async createDay(db, productId, data) {
+        const itinerary = await ensureDefaultItinerary(db, productId);
+        return itineraryProductsService.createItineraryDay(db, productId, itinerary.id, data);
+    },
+    async createItineraryDay(db, productId, itineraryId, data) {
+        const itinerary = await getItineraryById(db, itineraryId);
+        if (!itinerary || itinerary.productId !== productId) {
+            return null;
+        }
+        const [row] = await db
+            .insert(productDays)
+            .values({ ...data, itineraryId })
+            .returning();
+        return row;
+    },
+    async updateDay(db, dayId, data) {
+        const [row] = await db
+            .update(productDays)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productDays.id, dayId))
+            .returning();
+        return row ?? null;
+    },
+    async deleteDay(db, dayId) {
+        const [row] = await db
+            .delete(productDays)
+            .where(eq(productDays.id, dayId))
+            .returning({ id: productDays.id });
+        return row ?? null;
+    },
+    listDayServices(db, dayId) {
+        return db
+            .select()
+            .from(productDayServices)
+            .where(eq(productDayServices.dayId, dayId))
+            .orderBy(asc(productDayServices.sortOrder));
+    },
+    async getDayServiceForProductMutation(db, serviceId) {
+        const [row] = await db
+            .select()
+            .from(productDayServices)
+            .where(eq(productDayServices.id, serviceId))
+            .limit(1);
+        if (!row) {
+            return null;
+        }
+        const dayRef = await getDayById(db, row.dayId);
+        return dayRef ? { ...row, productId: dayRef.productId } : null;
+    },
+    async createDayService(db, productId, dayId, data) {
+        const day = await getDayById(db, dayId);
+        if (!day || day.productId !== productId) {
+            return null;
+        }
+        const [row] = await db
+            .insert(productDayServices)
+            .values({ ...data, dayId })
+            .returning();
+        await recalculateProductCost(db, productId);
+        return row;
+    },
+    async updateDayService(db, productId, serviceId, data) {
+        const [row] = await db
+            .update(productDayServices)
+            .set(data)
+            .where(eq(productDayServices.id, serviceId))
+            .returning();
+        if (!row) {
+            return null;
+        }
+        await recalculateProductCost(db, productId);
+        return row;
+    },
+    async deleteDayService(db, productId, serviceId) {
+        const [row] = await db
+            .delete(productDayServices)
+            .where(eq(productDayServices.id, serviceId))
+            .returning({ id: productDayServices.id });
+        if (!row) {
+            return null;
+        }
+        await recalculateProductCost(db, productId);
+        return row;
+    },
+};

package/dist/service-media.d.ts

@@ -0,0 +1,272 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertProductMediaSchema, productMediaListQuerySchema, reorderProductMediaSchema, updateProductMediaSchema, upsertProductBrochureSchema } from "./validation.js";
+type ProductMediaListQuery = z.infer<typeof productMediaListQuerySchema>;
+type CreateProductMediaInput = z.infer<typeof insertProductMediaSchema>;
+type UpdateProductMediaInput = z.infer<typeof updateProductMediaSchema>;
+type UpsertProductBrochureInput = z.infer<typeof upsertProductBrochureSchema>;
+type ReorderProductMediaInput = z.infer<typeof reorderProductMediaSchema>;
+export declare const mediaProductsService: {
+    listMedia(db: PostgresJsDatabase, productId: string, query: ProductMediaListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            dayId: string | null;
+            mediaType: "image" | "video" | "document";
+            name: string;
+            url: string;
+            storageKey: string | null;
+            mimeType: string | null;
+            fileSize: number | null;
+            altText: string | null;
+            sortOrder: number;
+            isCover: boolean;
+            isBrochure: boolean;
+            isBrochureCurrent: boolean;
+            brochureVersion: number | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    listProductLevelMedia(db: PostgresJsDatabase, productId: string, query: ProductMediaListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            dayId: string | null;
+            mediaType: "image" | "video" | "document";
+            name: string;
+            url: string;
+            storageKey: string | null;
+            mimeType: string | null;
+            fileSize: number | null;
+            altText: string | null;
+            sortOrder: number;
+            isCover: boolean;
+            isBrochure: boolean;
+            isBrochureCurrent: boolean;
+            brochureVersion: number | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getMediaById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        productId: string;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        name: string;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        sortOrder: number;
+        isCover: boolean;
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        brochureVersion: number | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createMedia(db: PostgresJsDatabase, productId: string, data: CreateProductMediaInput): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string;
+        sortOrder: number;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        isCover: boolean;
+        brochureVersion: number | null;
+    } | null>;
+    updateMedia(db: PostgresJsDatabase, id: string, data: UpdateProductMediaInput): Promise<{
+        id: string;
+        productId: string;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        name: string;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        sortOrder: number;
+        isCover: boolean;
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        brochureVersion: number | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteMedia(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string;
+        sortOrder: number;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        isCover: boolean;
+        brochureVersion: number | null;
+    } | null>;
+    setCoverMedia(db: PostgresJsDatabase, productId: string, mediaId: string, dayId?: string | null): Promise<{
+        id: string;
+        productId: string;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        name: string;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        sortOrder: number;
+        isCover: boolean;
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        brochureVersion: number | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    reorderMedia(db: PostgresJsDatabase, data: ReorderProductMediaInput): Promise<{
+        id: string;
+    }[]>;
+    getBrochure(db: PostgresJsDatabase, productId: string): Promise<{
+        id: string;
+        productId: string;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        name: string;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        sortOrder: number;
+        isCover: boolean;
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        brochureVersion: number | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    listBrochures(db: PostgresJsDatabase, productId: string): Promise<{
+        id: string;
+        productId: string;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        name: string;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        sortOrder: number;
+        isCover: boolean;
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        brochureVersion: number | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    upsertBrochure(db: PostgresJsDatabase, productId: string, data: UpsertProductBrochureInput): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string;
+        sortOrder: number;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        isCover: boolean;
+        brochureVersion: number | null;
+    } | null>;
+    deleteBrochure(db: PostgresJsDatabase, productId: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string;
+        sortOrder: number;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        isCover: boolean;
+        brochureVersion: number | null;
+    } | null>;
+    setCurrentBrochure(db: PostgresJsDatabase, productId: string, brochureId: string): Promise<{
+        id: string;
+        productId: string;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        name: string;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        sortOrder: number;
+        isCover: boolean;
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        brochureVersion: number | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteBrochureVersion(db: PostgresJsDatabase, productId: string, brochureId: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string;
+        sortOrder: number;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        isCover: boolean;
+        brochureVersion: number | null;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-media.d.ts.map

package/dist/service-media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-media.d.ts","sourceRoot":"","sources":["../src/service-media.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EACV,wBAAwB,EACxB,2BAA2B,EAC3B,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,EAC5B,MAAM,iBAAiB,CAAA;AAExB,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AACxE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAC7E,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AA8BzE,eAAO,MAAM,oBAAoB;kBAKX,kBAAkB,aAAa,MAAM,SAAS,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;8BA6CjF,kBAAkB,aACX,MAAM,SACV,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;qBA0CP,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;oBAK/B,kBAAkB,aAAa,MAAM,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;;oBAuDpE,kBAAkB,MAAM,MAAM,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;;oBAmC7D,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;sBAO9C,kBAAkB,aACX,MAAM,WACR,MAAM,UACP,MAAM,GAAG,IAAI;;;;;;;;;;;;;;;;;;;qBAyBA,kBAAkB,QAAQ,wBAAwB;;;oBAgBnD,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;sBAuBnC,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;uBAqBvD,kBAAkB,aACX,MAAM,QACX,0BAA0B;;;;;;;;;;;;;;;;;;;uBA+BT,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;2BAoCjC,kBAAkB,aAAa,MAAM,cAAc,MAAM;;;;;;;;;;;;;;;;;;;8BAwCtD,kBAAkB,aAAa,MAAM,cAAc,MAAM;;;;;;;;;;;;;;;;;;;CAkD1F,CAAA"}