@withpotter/lib 0.13.0-next.101

package/dist/api/types/inquiries.d.ts

@@ -0,0 +1,266 @@
+import { type InquiryStatus, type InquiryType } from './campaigns';
+/**
+ * Inquiries — as the API sends it.
+ *
+ * One slice of what was a 4,164-line `types.ts`. The sections were already
+ * here as comment fences; they are files now, so a type is found by the
+ * endpoint it belongs to rather than by scrolling.
+ */
+export type InquiryPriority = 'low' | 'normal' | 'high' | 'urgent';
+export type InquirySource = 'website' | 'google' | 'facebook' | 'instagram' | 'whatsapp' | 'referral' | 'walk_in' | 'phone' | 'email' | 'other';
+/**
+ * Everything the form asked that the record has no column for.
+ *
+ * The shape is open on purpose. A storefront contact form is built per
+ * template, so `guestCount`, `propertyId` and `monthlyBill` are three
+ * businesses' worth of keys that this file cannot know and must not gate.
+ * `toAnswers` in `lib/form-answers.ts` renders whatever arrives.
+ *
+ * The named members are the ones the API writes itself and the dashboard
+ * treats specially: attribution is shown as where a lead came from, not as an
+ * answer the person typed, and `conversion` is a record rather than a reply.
+ */
+export interface InquiryMetadata {
+    utm?: {
+        source?: string;
+        medium?: string;
+        campaign?: string;
+        content?: string;
+        term?: string;
+    };
+    referrerUrl?: string;
+    userAgent?: string;
+    ipAddress?: string;
+    customFields?: Record<string, unknown>;
+    quote?: Record<string, unknown>;
+    consultation?: Record<string, unknown>;
+    followUps?: Array<{
+        date: string;
+        method: 'email' | 'phone' | 'sms' | 'meeting';
+        notes: string;
+        by: string;
+    }>;
+    attachments?: Array<{
+        name: string;
+        url: string;
+        type: string;
+        size: number;
+    }>;
+    conversion?: {
+        convertedAt: string;
+        convertedTo: 'booking' | 'order' | 'member' | 'invoice';
+        referenceId: string;
+        value?: number;
+    };
+    [key: string]: unknown;
+}
+export interface Inquiry {
+    id: string;
+    inquiryNumber: string;
+    type: InquiryType;
+    status: InquiryStatus;
+    priority: InquiryPriority;
+    source?: InquirySource;
+    memberId?: string | null;
+    email: string;
+    name: string;
+    phone?: string;
+    company?: string;
+    subject?: string;
+    message: string;
+    assignedTo?: string | null;
+    assignedAt?: string | null;
+    response?: string;
+    respondedAt?: string;
+    followUpDate?: string | null;
+    followUpComplete?: boolean;
+    createdAt: string;
+    /**
+     * The qualifying answers.
+     *
+     * The API has stored and returned these since the module was written —
+     * `InquiryMapper.toResponse` sends `metadata` — and this interface did not
+     * declare it, so every field a caterer, an estate agent or a school asked for
+     * was typed out of existence one property short of the screen. A wedding for
+     * 300 on 12 December rendered as a name and a paragraph.
+     */
+    metadata?: InquiryMetadata;
+    tags?: string[];
+    internalNote?: string | null;
+    quotedAmount?: number | null;
+    quoteExpiresAt?: string | null;
+    quoteAccepted?: boolean;
+    convertedAt?: string | null;
+}
+export interface InquiryListResponse {
+    /** The API envelopes rows as `items`, not `data`. */
+    items: Inquiry[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+export interface InquiryDashboardCounts {
+    new?: number;
+    unassigned?: number;
+    overdueFollowUp?: number;
+    total?: number;
+    [key: string]: number | undefined;
+}
+/**
+ * What `GET /inquiries/stats` returns, exactly.
+ *
+ * `byStatus`, `byType` and `bySource` are dense — the API seeds every enum key
+ * to 0 before counting — so a caller can read a zero rather than guess at an
+ * absent key.
+ *
+ * `conversionRate` counts records whose status a human set to `converted`. It
+ * is a count of ticked boxes, not of money: see `metadata.conversion` for the
+ * record that ties a won lead to what it became.
+ */
+export interface InquiryStats {
+    total: number;
+    byStatus: Record<InquiryStatus, number>;
+    byType: Record<InquiryType, number>;
+    bySource: Record<InquirySource, number>;
+    conversionRate: number;
+    avgResponseTimeHours: number | null;
+    /**
+     * What the won leads were worth, and which door they came through.
+     *
+     * `bySource` answers "which door do leads come through". That is not the
+     * question a merchant spends against — a source can send fifty enquiries and
+     * win nothing. These come from `metadata.conversion.value`, which is the
+     * invoice total when an enquiry became a bill, so it is the money actually
+     * charged rather than a figure typed into a quote box weeks earlier.
+     *
+     * Zero means nobody has recorded a win, not that the leads were worthless.
+     */
+    wonValue: number;
+    valueBySource: Record<InquirySource, number>;
+}
+export interface InquiriesQuery {
+    type?: InquiryType;
+    status?: InquiryStatus;
+    priority?: InquiryPriority;
+    assignedTo?: string;
+    unassigned?: boolean;
+    hasFollowUp?: boolean;
+    overdueFollowUp?: boolean;
+    search?: string;
+    page?: number;
+    limit?: number;
+}
+export type InquiryListQuery = InquiriesQuery;
+export type UpdateInquiryInput = Partial<Pick<Inquiry, 'status' | 'priority' | 'assignedTo' | 'internalNote' | 'followUpDate' | 'tags'>>;
+export type GalleryItemType = 'image' | 'video';
+export type GalleryItemStatus = 'active' | 'hidden' | 'archived';
+export interface GalleryItem {
+    id: string;
+    title?: string;
+    description?: string;
+    altText?: string;
+    type: GalleryItemType;
+    url: string;
+    thumbnailUrl?: string;
+    width?: number;
+    height?: number;
+    category?: string;
+    tags?: string[];
+    status: GalleryItemStatus;
+    sortOrder: number;
+    featured: boolean;
+    beforeImageUrl?: string;
+    isBeforeAfter: boolean;
+    createdAt: string;
+}
+export interface GalleryListResponse {
+    items: GalleryItem[];
+    total?: number;
+    page?: number;
+    limit?: number;
+    totalPages?: number;
+}
+/**
+ * What the bio page has been recording since the module shipped. The API has
+ * served this summary the whole time and nothing read it, so the merchant had
+ * no way to know whether the link they pasted in their profile did anything.
+ */
+export interface BioAnalytics {
+    totalViews: number;
+    totalClicks: number;
+    totalFormSubmits: number;
+    /** Clicks keyed by the bio item's id. */
+    clicksByItem: Record<string, number>;
+}
+export interface GalleryQuery {
+    category?: string;
+    type?: GalleryItemType;
+    status?: GalleryItemStatus;
+    featured?: boolean;
+    search?: string;
+    page?: number;
+    limit?: number;
+}
+/** The rails a commitment can arrive on. Mirrors CommerceSource on the API. */
+export type CommitmentSource = 'order' | 'booking' | 'invoice';
+export type CommitmentPaymentState = 'paid' | 'partially_paid' | 'unpaid';
+/**
+ * One thing a customer committed to buy, whatever rail it came in on.
+ *
+ * `status` stays the rail's own — an order is `confirmed`, a booking is
+ * `cancelled`, an invoice is `overdue` — because the rails genuinely do not
+ * share a lifecycle and flattening them would invent states nobody operates.
+ * `paymentState` is the one thing that IS common, so it is normalised.
+ */
+export interface Commitment {
+    id: string;
+    source: CommitmentSource;
+    reference: string;
+    customerName: string | null;
+    customerEmail: string | null;
+    memberId: string | null;
+    amount: number;
+    currency: string;
+    status: string;
+    paymentState: CommitmentPaymentState;
+    /**
+     * What was sold, as behaviour names. `source` is the RAIL; this is the thing.
+     * Empty where nothing identifies the row — an invoice typed by hand with no
+     * content behind any line.
+     */
+    behaviors: string[];
+    createdAt: string;
+}
+export interface CommitmentsResponse {
+    commitments: Commitment[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+    countsBySource: Record<CommitmentSource, number>;
+}
+/**
+ * What a peeked invite tells us before anyone accepts it.
+ *
+ * `status` distinguishes the failures that `valid` alone flattened: expired
+ * needs a new invite, accepted needs a sign-in, unknown means the token
+ * resolves to nothing and the api deliberately returns no other field.
+ *
+ * Every field past `status` is optional because the api and the dashboard
+ * deploy separately, and the org-invite endpoint still returns the older
+ * three-field shape. Readers must degrade rather than assume.
+ */
+export interface PeekInviteResponse {
+    valid: boolean;
+    status?: 'valid' | 'expired' | 'accepted' | 'unknown';
+    email?: string;
+    role?: string;
+    roleName?: string;
+    businessName?: string;
+    /** The business's own mark, when it has set one. */
+    businessLogo?: string;
+    invitedByName?: string;
+    permissions?: Record<string, boolean>;
+    hasAccount?: boolean;
+}

package/dist/api/types/inquiries.js

@@ -0,0 +1 @@
+//# sourceMappingURL=inquiries.js.map

package/dist/api/types/inquiries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/api/types/locations.d.ts

@@ -0,0 +1,208 @@
+import { type ResourceItem } from './bookings';
+import { type LocationBookingPolicy, type WeeklyHours } from './catalog';
+/**
+ * BUSINESS LOCATIONS ("/business-locations") — as the API sends it.
+ *
+ * One slice of what was a 4,164-line `types.ts`. The sections were already
+ * here as comment fences; they are files now, so a type is found by the
+ * endpoint it belongs to rather than by scrolling.
+ */
+/** One location's holding of a product, or of one of its variants. */
+export interface LocationStock {
+    locationId: string;
+    locationName: string;
+    /**
+     * Null on a product that holds stock as a whole. Non-null means this row is
+     * one variant at one location, and the product holds stock per variant.
+     */
+    variantId?: string | null;
+    variantName?: string | null;
+    quantity: number;
+    reserved: number;
+    /** quantity minus what pending orders already hold. Only this can be moved. */
+    available: number;
+}
+export interface UpdateBusinessLocationData {
+    name?: string;
+    address?: string | null;
+    city?: string | null;
+    state?: string | null;
+    country?: string | null;
+    phoneNumber?: string | null;
+    isDefault?: boolean;
+    sortOrder?: number;
+    email?: string | null;
+    timezone?: string | null;
+    /** null puts the branch back on the business's hours. */
+    hours?: WeeklyHours | null;
+    /** null puts the branch back on the business's booking policy. */
+    bookingPolicy?: LocationBookingPolicy | null;
+    latitude?: number | null;
+    longitude?: number | null;
+    showOnStorefront?: boolean;
+    isPickupPoint?: boolean;
+    pickupInstructions?: string | null;
+    handoverMinutes?: number | null;
+}
+/** A collection point, as the storefront sees it. */
+export interface PickupPoint {
+    locationId: string;
+    name: string;
+    address: string | null;
+    city: string | null;
+    state: string | null;
+    country: string | null;
+    phoneNumber: string | null;
+    instructions: string | null;
+    handoverMinutes: number | null;
+}
+export interface CalculatedShippingOption {
+    rateId: string;
+    rateName: string;
+    zoneName: string;
+    price: number;
+    isFreeShipping: boolean;
+    estimatedDays: string | null;
+    originLocationId?: string | null;
+}
+/**
+ * Everything a checkout needs to ask "how would you like this?". Three lists,
+ * because collection, the merchant's own rider and a courier are three
+ * different decisions.
+ */
+export interface FulfilmentOptions {
+    pickup: PickupPoint[];
+    delivery: CalculatedShippingOption[];
+    shipping: CalculatedShippingOption[];
+    requiresFulfilment: boolean;
+    /** Why delivery and shipping are both empty, when they are. */
+    unservedReason?: 'no_zone' | 'no_eligible_rate' | null;
+}
+export interface PageSectionResponse {
+    id: string;
+    pageId: string;
+    tenantId: string;
+    blockType: string;
+    position: number;
+    status: 'draft' | 'published';
+    data: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PageResponse {
+    id: string;
+    tenantId: string;
+    slug: string;
+    title: string;
+    status: 'draft' | 'published';
+    publishedAt: string | null;
+    seo: {
+        title?: string;
+        description?: string;
+        ogImage?: string;
+    };
+    isSystem: boolean;
+    sections?: PageSectionResponse[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TemplateEntitlement {
+    templateId: string;
+    purchasedAt: string | null;
+}
+export interface InitiateTemplatePurchaseResult {
+    purchaseId: string;
+    templateId: string;
+    amount: number;
+    currency: string;
+    paymentUrl: string;
+    reference: string;
+}
+export interface TemplateSummary {
+    id: string;
+    name: string;
+    description?: string;
+    category?: string;
+    previewImage?: string | null;
+    sortOrder?: number;
+    isActive?: boolean;
+}
+export interface CalendarConnectionItem {
+    id: string;
+    tenantId: string;
+    name: string;
+    provider: 'google' | 'outlook' | 'apple' | 'ical' | 'other';
+    externalCalendarId: string | null;
+    status: 'connected' | 'disconnected' | 'error' | 'syncing' | 'pending';
+    lastErrorMessage: string | null;
+    lastSyncAt: string | null;
+    syncedEventsCount: number;
+    teamMemberId: string | null;
+    blockExternalEvents: boolean;
+    showExternalEvents: boolean;
+    eventColor: string | null;
+    syncDirection: 'one_way_import' | 'one_way_export' | 'two_way';
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CalendarEventItem {
+    id: string;
+    type: 'booking' | 'block' | 'synced';
+    title: string;
+    start: string;
+    end: string;
+    color?: string;
+    status?: string;
+    resourceId?: string;
+    /** What was booked, when the booking hangs off a catalogue item. */
+    contentId?: string;
+    bookingNumber?: string;
+    customerName?: string;
+    customerEmail?: string;
+    customerPhone?: string;
+    customerNote?: string;
+    serviceName?: string;
+    /** The per-booking video room, when the booking happens on the internet. */
+    meetingLink?: string;
+    description?: string;
+    calendarName?: string;
+    isAllDay?: boolean;
+    blockReason?: string;
+}
+/**
+ * One thing a service needs, resolved for a particular slot.
+ *
+ * `GET /bookings/eligible-resources` answers with one of these per requirement.
+ * `requiresCustomerChoice` is the whole point: the assignment engine has always
+ * been able to say "somebody has to pick", and until now nothing asked it.
+ *
+ * Vertical-agnostic — `categoryLabel` is the merchant's own noun, so the same
+ * shape covers which stylist, which doctor, which court, which bay, which
+ * tutor and which room.
+ */
+export interface BookingResourceRequirement {
+    requirementId: string;
+    categoryId: string;
+    categoryLabel: string;
+    strategy: 'auto-first' | 'auto-best' | 'customer-chooses' | 'round-robin' | 'pool' | 'sole-provider';
+    requiresCustomerChoice: boolean;
+    /** Already decided, for the strategies that decide by themselves. */
+    resource?: ResourceItem | null;
+    /** Populated only when a choice is required. */
+    eligibleResources?: ResourceItem[];
+}
+export interface BlockTimePayload {
+    resourceId: string;
+    date: string;
+    /**
+     * Inclusive last day. Absent means the one day.
+     *
+     * A block is stored per calendar day, so closing an apartment for a week is
+     * genuinely seven rows — but it is one request, and one failure, rather than
+     * seven of each.
+     */
+    endDate?: string;
+    startTime: string;
+    endTime: string;
+    reason?: string;
+}

package/dist/api/types/locations.js

@@ -0,0 +1 @@
+//# sourceMappingURL=locations.js.map

package/dist/api/types/locations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}