@voyantjs/octo 0.2.0 → 0.3.1

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

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

package/dist/service-bookings.js

@@ -0,0 +1,219 @@
+import { bookingsService } from "@voyantjs/bookings";
+import { bookingAllocations, bookingFulfillments, bookingItemParticipants, bookingItems, bookingParticipants, bookingRedemptionEvents, bookingSupplierStatuses, bookings, } from "@voyantjs/bookings/schema";
+import { offers, orders } from "@voyantjs/transactions/schema";
+import { asc, eq, inArray } from "drizzle-orm";
+import { mapBookingArtifact, mapBookingStatus, pickBookingContact, toIsoString, } from "./service-shared.js";
+import { bookingTransactionDetailsRef } from "./transactions-ref.js";
+export async function getProjectedBookingById(db, id) {
+    const [booking] = await db.select().from(bookings).where(eq(bookings.id, id)).limit(1);
+    if (!booking)
+        return null;
+    const [participants, items, allocations, fulfillments, redemptions, supplierStatuses, transactionLink,] = await Promise.all([
+        db
+            .select()
+            .from(bookingParticipants)
+            .where(eq(bookingParticipants.bookingId, booking.id))
+            .orderBy(asc(bookingParticipants.createdAt)),
+        db
+            .select()
+            .from(bookingItems)
+            .where(eq(bookingItems.bookingId, booking.id))
+            .orderBy(asc(bookingItems.createdAt)),
+        db
+            .select()
+            .from(bookingAllocations)
+            .where(eq(bookingAllocations.bookingId, booking.id))
+            .orderBy(asc(bookingAllocations.createdAt)),
+        db
+            .select()
+            .from(bookingFulfillments)
+            .where(eq(bookingFulfillments.bookingId, booking.id))
+            .orderBy(asc(bookingFulfillments.createdAt)),
+        db
+            .select()
+            .from(bookingRedemptionEvents)
+            .where(eq(bookingRedemptionEvents.bookingId, booking.id))
+            .orderBy(asc(bookingRedemptionEvents.redeemedAt), asc(bookingRedemptionEvents.createdAt)),
+        db
+            .select()
+            .from(bookingSupplierStatuses)
+            .where(eq(bookingSupplierStatuses.bookingId, booking.id))
+            .orderBy(asc(bookingSupplierStatuses.createdAt)),
+        db
+            .select()
+            .from(bookingTransactionDetailsRef)
+            .where(eq(bookingTransactionDetailsRef.bookingId, booking.id))
+            .limit(1)
+            .then((rows) => rows[0] ?? null),
+    ]);
+    const itemParticipants = items.length > 0
+        ? await db
+            .select()
+            .from(bookingItemParticipants)
+            .where(inArray(bookingItemParticipants.bookingItemId, items.map((item) => item.id)))
+            .orderBy(asc(bookingItemParticipants.createdAt))
+        : [];
+    const activeAllocation = allocations.find((allocation) => allocation.status === "confirmed") ??
+        allocations.find((allocation) => allocation.status === "held") ??
+        allocations[0];
+    const [offer, order] = await Promise.all([
+        transactionLink?.offerId
+            ? db
+                .select({ id: offers.id, offerNumber: offers.offerNumber })
+                .from(offers)
+                .where(eq(offers.id, transactionLink.offerId))
+                .limit(1)
+                .then((rows) => rows[0] ?? null)
+            : Promise.resolve(null),
+        transactionLink?.orderId
+            ? db
+                .select({ id: orders.id, orderNumber: orders.orderNumber })
+                .from(orders)
+                .where(eq(orders.id, transactionLink.orderId))
+                .limit(1)
+                .then((rows) => rows[0] ?? null)
+            : Promise.resolve(null),
+    ]);
+    return {
+        id: booking.id,
+        bookingNumber: booking.bookingNumber,
+        status: mapBookingStatus(booking.status),
+        availabilityId: activeAllocation?.availabilitySlotId ?? null,
+        contact: pickBookingContact(participants),
+        unitItems: items.map((item) => {
+            const itemAllocation = allocations.find((allocation) => allocation.bookingItemId === item.id) ?? null;
+            return {
+                bookingItemId: item.id,
+                title: item.title,
+                itemType: item.itemType,
+                status: item.status,
+                quantity: item.quantity,
+                productId: item.productId,
+                optionId: item.optionId,
+                unitId: item.optionUnitId,
+                pricingCategoryId: item.pricingCategoryId,
+                availabilityId: itemAllocation?.availabilitySlotId ?? null,
+                participantIds: itemParticipants
+                    .filter((link) => link.bookingItemId === item.id)
+                    .map((link) => link.participantId),
+            };
+        }),
+        fulfillments: fulfillments.map((fulfillment) => ({
+            id: fulfillment.id,
+            bookingItemId: fulfillment.bookingItemId,
+            participantId: fulfillment.participantId,
+            type: fulfillment.fulfillmentType,
+            deliveryChannel: fulfillment.deliveryChannel,
+            status: fulfillment.status,
+            artifactUrl: fulfillment.artifactUrl,
+            payload: fulfillment.payload ?? null,
+            issuedAt: toIsoString(fulfillment.issuedAt),
+            revokedAt: toIsoString(fulfillment.revokedAt),
+        })),
+        artifacts: fulfillments.map(mapBookingArtifact),
+        redemptions: redemptions.map((event) => ({
+            id: event.id,
+            bookingItemId: event.bookingItemId,
+            participantId: event.participantId,
+            redeemedAt: event.redeemedAt.toISOString(),
+            redeemedBy: event.redeemedBy,
+            location: event.location,
+            method: event.method,
+            metadata: event.metadata ?? null,
+        })),
+        references: {
+            resellerReference: booking.externalBookingRef,
+            offerId: offer?.id ?? transactionLink?.offerId ?? null,
+            offerNumber: offer?.offerNumber ?? null,
+            orderId: order?.id ?? transactionLink?.orderId ?? null,
+            orderNumber: order?.orderNumber ?? null,
+            supplierReferences: supplierStatuses.map((status) => ({
+                id: status.id,
+                supplierServiceId: status.supplierServiceId,
+                serviceName: status.serviceName,
+                status: status.status,
+                supplierReference: status.supplierReference,
+                confirmedAt: toIsoString(status.confirmedAt),
+            })),
+        },
+        holdExpiresAt: toIsoString(booking.holdExpiresAt),
+        confirmedAt: toIsoString(booking.confirmedAt),
+        cancelledAt: toIsoString(booking.cancelledAt),
+        expiredAt: toIsoString(booking.expiredAt),
+        utcRedeemedAt: toIsoString(booking.redeemedAt),
+        extensions: {
+            sourceType: booking.sourceType,
+            externalBookingRef: booking.externalBookingRef,
+            communicationLanguage: booking.communicationLanguage,
+            personId: booking.personId,
+            organizationId: booking.organizationId,
+            sellCurrency: booking.sellCurrency,
+            baseCurrency: booking.baseCurrency,
+        },
+    };
+}
+export async function listProjectedBookings(db, query) {
+    const result = await bookingsService.listBookings(db, query);
+    const data = await Promise.all(result.data.map(async (booking) => getProjectedBookingById(db, booking.id)));
+    return {
+        data: data.filter((row) => Boolean(row)),
+        total: result.total,
+        limit: result.limit,
+        offset: result.offset,
+    };
+}
+async function projectBookingMutationResult(db, result) {
+    if (!("booking" in result) || !result.booking) {
+        return result;
+    }
+    const projected = await getProjectedBookingById(db, result.booking.id);
+    return { status: "ok", booking: projected };
+}
+export async function reserveProjectedBooking(db, data, userId) {
+    return projectBookingMutationResult(db, await bookingsService.reserveBooking(db, data, userId));
+}
+export async function confirmProjectedBooking(db, id, data, userId) {
+    return projectBookingMutationResult(db, await bookingsService.confirmBooking(db, id, data, userId));
+}
+export async function extendProjectedBookingHold(db, id, data, userId) {
+    return projectBookingMutationResult(db, await bookingsService.extendBookingHold(db, id, data, userId));
+}
+export async function expireProjectedBooking(db, id, data, userId) {
+    return projectBookingMutationResult(db, await bookingsService.expireBooking(db, id, data, userId));
+}
+export async function cancelProjectedBooking(db, id, data, userId) {
+    return projectBookingMutationResult(db, await bookingsService.cancelBooking(db, id, data, userId));
+}
+export async function listProjectedRedemptions(db, bookingId) {
+    const events = await bookingsService.listRedemptionEvents(db, bookingId);
+    return events.map((event) => ({
+        id: event.id,
+        bookingItemId: event.bookingItemId,
+        participantId: event.participantId,
+        redeemedAt: event.redeemedAt.toISOString(),
+        redeemedBy: event.redeemedBy,
+        location: event.location,
+        method: event.method,
+        metadata: event.metadata ?? null,
+    }));
+}
+export async function recordProjectedRedemption(db, bookingId, data, userId) {
+    const event = await bookingsService.recordRedemption(db, bookingId, data, userId);
+    if (!event) {
+        return null;
+    }
+    const booking = await getProjectedBookingById(db, bookingId);
+    return {
+        event: {
+            id: event.id,
+            bookingItemId: event.bookingItemId,
+            participantId: event.participantId,
+            redeemedAt: event.redeemedAt.toISOString(),
+            redeemedBy: event.redeemedBy,
+            location: event.location,
+            method: event.method,
+            metadata: event.metadata ?? null,
+        },
+        booking,
+    };
+}

package/dist/service-products.d.ts

@@ -0,0 +1,28 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type OctoAvailabilityCalendarQuery, type OctoAvailabilityListQuery, type OctoProductListQuery } from "./service-shared.js";
+import type { OctoAvailabilityStatus, OctoProjectedProduct } from "./types.js";
+export declare function getProjectedProductById(db: PostgresJsDatabase, id: string): Promise<OctoProjectedProduct | null>;
+export declare function getProjectedAvailabilityById(db: PostgresJsDatabase, id: string): Promise<import("./types.js").OctoProjectedAvailability | null>;
+export declare function listProjectedAvailability(db: PostgresJsDatabase, query: OctoAvailabilityListQuery): Promise<{
+    data: import("./types.js").OctoProjectedAvailability[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function getProjectedAvailabilityCalendar(db: PostgresJsDatabase, productId: string, query: OctoAvailabilityCalendarQuery): Promise<{
+    data: {
+        localDate: string;
+        status: OctoAvailabilityStatus;
+        vacancies: number | null;
+        capacity: number | null;
+        availabilityIds: string[];
+    }[];
+    total: number;
+}>;
+export declare function listProjectedProducts(db: PostgresJsDatabase, query: OctoProductListQuery): Promise<{
+    data: OctoProjectedProduct[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+//# sourceMappingURL=service-products.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-products.d.ts","sourceRoot":"","sources":["../src/service-products.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAKL,KAAK,6BAA6B,EAClC,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EAE1B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAE9E,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAoFtC;AAED,wBAAsB,4BAA4B,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,kEAepF;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,yBAAyB;;;;;GA0CjC;AAED,wBAAsB,gCAAgC,CACpD,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,6BAA6B;;mBAcrB,MAAM;gBACT,sBAAsB;mBACnB,MAAM,GAAG,IAAI;kBACd,MAAM,GAAG,IAAI;yBACN,MAAM,EAAE;;;GAuC9B;AAED,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,oBAAoB;;;;;GAY9F"}

package/dist/service-products.js

@@ -0,0 +1,189 @@
+import { availabilitySlots, availabilityStartTimes } from "@voyantjs/availability/schema";
+import { productsService } from "@voyantjs/products";
+import { optionUnits, productCapabilities, productDeliveryFormats, productFaqs, productFeatures, productLocations, productOptions, products, } from "@voyantjs/products/schema";
+import { and, asc, eq, gte, inArray, lte, sql } from "drizzle-orm";
+import { buildProductContent, buildProjectedAvailability, inferOctoAvailabilityType, mapUnit, pickOptionStartTimes, } from "./service-shared.js";
+export async function getProjectedProductById(db, id) {
+    const [product] = await db.select().from(products).where(eq(products.id, id)).limit(1);
+    if (!product)
+        return null;
+    const [options, startTimes, capabilities, deliveryFormats, features, faqs, locations] = await Promise.all([
+        db
+            .select()
+            .from(productOptions)
+            .where(eq(productOptions.productId, product.id))
+            .orderBy(asc(productOptions.sortOrder), asc(productOptions.createdAt)),
+        db
+            .select()
+            .from(availabilityStartTimes)
+            .where(eq(availabilityStartTimes.productId, product.id))
+            .orderBy(asc(availabilityStartTimes.sortOrder), asc(availabilityStartTimes.createdAt)),
+        db
+            .select()
+            .from(productCapabilities)
+            .where(eq(productCapabilities.productId, product.id))
+            .orderBy(asc(productCapabilities.createdAt)),
+        db
+            .select()
+            .from(productDeliveryFormats)
+            .where(eq(productDeliveryFormats.productId, product.id))
+            .orderBy(asc(productDeliveryFormats.createdAt)),
+        db
+            .select()
+            .from(productFeatures)
+            .where(eq(productFeatures.productId, product.id))
+            .orderBy(asc(productFeatures.sortOrder), asc(productFeatures.createdAt)),
+        db
+            .select()
+            .from(productFaqs)
+            .where(eq(productFaqs.productId, product.id))
+            .orderBy(asc(productFaqs.sortOrder), asc(productFaqs.createdAt)),
+        db
+            .select()
+            .from(productLocations)
+            .where(eq(productLocations.productId, product.id))
+            .orderBy(asc(productLocations.sortOrder), asc(productLocations.createdAt)),
+    ]);
+    const optionIds = options.map((option) => option.id);
+    const units = optionIds.length > 0
+        ? await db
+            .select()
+            .from(optionUnits)
+            .where(inArray(optionUnits.optionId, optionIds))
+            .orderBy(asc(optionUnits.sortOrder), asc(optionUnits.createdAt))
+        : [];
+    return {
+        id: product.id,
+        name: product.name,
+        description: product.description,
+        timeZone: product.timezone,
+        availabilityType: inferOctoAvailabilityType(product.bookingMode),
+        allowFreesale: product.capacityMode === "free_sale",
+        instantConfirmation: capabilities.some((capability) => capability.capability === "instant_confirmation" && capability.enabled),
+        options: options.map((option) => ({
+            id: option.id,
+            name: option.name,
+            code: option.code,
+            default: option.isDefault,
+            availabilityLocalStartTimes: pickOptionStartTimes(option, startTimes),
+            units: units.filter((unit) => unit.optionId === option.id).map(mapUnit),
+        })),
+        content: buildProductContent({ features, faqs, locations }),
+        extensions: {
+            status: product.status,
+            visibility: product.visibility,
+            activated: product.activated,
+            facilityId: product.facilityId ?? null,
+            bookingMode: product.bookingMode,
+            capabilityCodes: capabilities
+                .filter((capability) => capability.enabled)
+                .map((capability) => capability.capability),
+            deliveryFormats: deliveryFormats.map((format) => format.format),
+        },
+    };
+}
+export async function getProjectedAvailabilityById(db, id) {
+    const [row] = await db
+        .select()
+        .from(availabilitySlots)
+        .where(eq(availabilitySlots.id, id))
+        .limit(1);
+    if (!row)
+        return null;
+    const [product] = await db
+        .select({ capacityMode: products.capacityMode, timezone: products.timezone })
+        .from(products)
+        .where(eq(products.id, row.productId))
+        .limit(1);
+    return buildProjectedAvailability(row, product);
+}
+export async function listProjectedAvailability(db, query) {
+    const conditions = [];
+    if (query.productId)
+        conditions.push(eq(availabilitySlots.productId, query.productId));
+    if (query.optionId)
+        conditions.push(eq(availabilitySlots.optionId, query.optionId));
+    if (query.localDateStart)
+        conditions.push(gte(availabilitySlots.dateLocal, query.localDateStart));
+    if (query.localDateEnd)
+        conditions.push(lte(availabilitySlots.dateLocal, query.localDateEnd));
+    const where = conditions.length > 0 ? and(...conditions) : undefined;
+    const [rows, countResult] = await Promise.all([
+        db
+            .select()
+            .from(availabilitySlots)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(availabilitySlots.startsAt)),
+        db.select({ count: sql `count(*)::int` }).from(availabilitySlots).where(where),
+    ]);
+    const productIds = [...new Set(rows.map((row) => row.productId))];
+    const productRows = productIds.length > 0
+        ? await db
+            .select({
+            id: products.id,
+            capacityMode: products.capacityMode,
+            timezone: products.timezone,
+        })
+            .from(products)
+            .where(inArray(products.id, productIds))
+        : [];
+    const productsById = new Map(productRows.map((product) => [product.id, product]));
+    return {
+        data: rows.map((row) => buildProjectedAvailability(row, productsById.get(row.productId))),
+        total: countResult[0]?.count ?? 0,
+        limit: query.limit,
+        offset: query.offset,
+    };
+}
+export async function getProjectedAvailabilityCalendar(db, productId, query) {
+    const result = await listProjectedAvailability(db, {
+        productId,
+        optionId: query.optionId,
+        localDateStart: query.localDateStart,
+        localDateEnd: query.localDateEnd,
+        limit: 200,
+        offset: 0,
+    });
+    const days = new Map();
+    const rank = {
+        FREESALE: 5,
+        AVAILABLE: 4,
+        LIMITED: 3,
+        SOLD_OUT: 2,
+        CLOSED: 1,
+    };
+    for (const availability of result.data) {
+        const localDate = availability.localDateTimeStart.slice(0, 10);
+        const existing = days.get(localDate);
+        const nextStatus = !existing || rank[availability.status] > rank[existing.status]
+            ? availability.status
+            : existing.status;
+        days.set(localDate, {
+            localDate,
+            status: nextStatus,
+            vacancies: existing?.vacancies === null || availability.vacancies === null
+                ? null
+                : Math.max(existing?.vacancies ?? 0, availability.vacancies),
+            capacity: existing?.capacity === null || availability.capacity === null
+                ? null
+                : Math.max(existing?.capacity ?? 0, availability.capacity),
+            availabilityIds: [...(existing?.availabilityIds ?? []), availability.id],
+        });
+    }
+    return {
+        data: [...days.values()].sort((left, right) => left.localDate.localeCompare(right.localDate)),
+        total: days.size,
+    };
+}
+export async function listProjectedProducts(db, query) {
+    const result = await productsService.listProducts(db, query);
+    const data = await Promise.all(result.data.map(async (product) => getProjectedProductById(db, product.id)));
+    return {
+        data: data.filter((row) => Boolean(row)),
+        total: result.total,
+        limit: result.limit,
+        offset: result.offset,
+    };
+}

package/dist/service-shared.d.ts

@@ -0,0 +1,64 @@
+import type { availabilitySlots, availabilityStartTimes } from "@voyantjs/availability/schema";
+import type { bookingFulfillments, bookings } from "@voyantjs/bookings/schema";
+import type { optionUnits, productFaqs, productFeatures, productLocations, productOptions, products } from "@voyantjs/products/schema";
+import type { z } from "zod";
+import type { OctoAvailabilityStatus, OctoAvailabilityType, OctoBookingStatus, OctoProjectedAvailability, OctoProjectedProductContent, OctoProjectedUnit, OctoUnitType } from "./types.js";
+import type { octoAvailabilityCalendarQuerySchema, octoAvailabilityListQuerySchema, octoBookingListQuerySchema, octoProductListQuerySchema } from "./validation.js";
+export type ProductRow = typeof products.$inferSelect;
+export type OptionRow = typeof productOptions.$inferSelect;
+export type UnitRow = typeof optionUnits.$inferSelect;
+export type SlotRow = typeof availabilitySlots.$inferSelect;
+export type BookingRow = typeof bookings.$inferSelect;
+export type OctoAvailabilityListQuery = z.infer<typeof octoAvailabilityListQuerySchema>;
+export type OctoAvailabilityCalendarQuery = z.infer<typeof octoAvailabilityCalendarQuerySchema>;
+export type OctoProductListQuery = z.infer<typeof octoProductListQuerySchema>;
+export type OctoBookingListQuery = z.infer<typeof octoBookingListQuerySchema>;
+export declare function toIsoString(value: Date | null | undefined): string | null;
+export declare function formatLocalDateTime(value: Date, timeZone: string): string;
+export declare function inferOctoAvailabilityType(bookingMode: ProductRow["bookingMode"]): OctoAvailabilityType;
+export declare function inferOctoUnitType(unit: Pick<UnitRow, "name" | "code" | "unitType">): OctoUnitType;
+export declare function deriveOctoAvailabilityStatus(slot: Pick<SlotRow, "status" | "unlimited" | "initialPax" | "remainingPax">, capacityMode: ProductRow["capacityMode"] | null | undefined): OctoAvailabilityStatus;
+export declare function mapBookingStatus(status: BookingRow["status"]): OctoBookingStatus;
+export declare function mapUnit(unit: UnitRow): OctoProjectedUnit;
+export declare function buildProductContent({ features, faqs, locations, }: {
+    features: Array<typeof productFeatures.$inferSelect>;
+    faqs: Array<typeof productFaqs.$inferSelect>;
+    locations: Array<typeof productLocations.$inferSelect>;
+}): OctoProjectedProductContent;
+export declare function pickOptionStartTimes(option: OptionRow, startTimes: Array<typeof availabilityStartTimes.$inferSelect>): string[];
+export declare function pickBookingContact(participants: Array<{
+    participantType: string | null;
+    isPrimary: boolean | null;
+    id: string;
+    firstName: string | null;
+    lastName: string | null;
+    email: string | null;
+    phone: string | null;
+    preferredLanguage: string | null;
+}>): {
+    participantId: string;
+    firstName: string | null;
+    lastName: string | null;
+    email: string | null;
+    phone: string | null;
+    language: string | null;
+} | null;
+export declare function pickPayloadString(payload: Record<string, unknown> | null | undefined, keys: string[]): string | null;
+export declare function mapBookingArtifact(fulfillment: typeof bookingFulfillments.$inferSelect): {
+    fulfillmentId: string;
+    bookingItemId: string | null;
+    participantId: string | null;
+    type: "other" | "voucher" | "ticket" | "pdf" | "qr_code" | "barcode" | "mobile";
+    deliveryChannel: "other" | "download" | "email" | "api" | "wallet";
+    status: "pending" | "issued" | "reissued" | "revoked" | "failed";
+    artifactUrl: string | null;
+    downloadUrl: string | null;
+    pdfUrl: string | null;
+    qrCode: string | null;
+    barcode: string | null;
+    voucherCode: string | null;
+    issuedAt: string | null;
+    revokedAt: string | null;
+};
+export declare function buildProjectedAvailability(slot: SlotRow, product: Pick<ProductRow, "capacityMode" | "timezone"> | null | undefined): OctoProjectedAvailability;
+//# sourceMappingURL=service-shared.d.ts.map

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

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