@webority/mobile-support 0.0.9

package/lib/module/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+export { createSupportClient, SupportApiError, toSupportApiError } from "./client.js";
+export { NewSupportTicket } from "./components/NewSupportTicket.js";
+export { SupportContact } from "./components/SupportContact.js";
+export { SupportTicketDetail } from "./components/SupportTicketDetail.js";
+export { SupportTicketList } from "./components/SupportTicketList.js";
+export { describeDevice } from "./device.js";
+export { SupportProvider, useCreateSupportTicket, useSupportClient, useSupportConfig, useSupportTicket, useSupportTickets } from "./SupportProvider.js";
+//# sourceMappingURL=index.js.map

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/photos.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import { compressImage } from '@webority/mobile-core/compressor';
+/** The one place `expo-image-picker` is named. */
+const picker = () => require('expo-image-picker');
+export class PhotoPermissionError extends Error {
+  constructor(source) {
+    super(source === 'camera' ? 'Allow camera access in Settings to take a photo.' : 'Allow photo access in Settings to attach a photo.');
+    this.name = 'PhotoPermissionError';
+    this.source = source;
+  }
+}
+
+// The fleet capture pass: quality 0.8, no editing, then bound to 1920 px.
+const CAPTURE_OPTIONS = {
+  mediaTypes: ['images'],
+  quality: 0.8,
+  allowsEditing: false
+};
+const MAX_SIDE = 1920;
+
+/**
+ * Lets the person pick or take photos and returns them ready to upload,
+ * compressed to fit the product's per-file limit. An empty list means they
+ * cancelled.
+ */
+export const pickPhotos = async (source, options) => {
+  if (options.maxCount <= 0) {
+    return [];
+  }
+  const m = picker();
+  const permission = source === 'camera' ? await m.requestCameraPermissionsAsync() : await m.requestMediaLibraryPermissionsAsync();
+  if (!permission.granted) {
+    throw new PhotoPermissionError(source);
+  }
+  const result = source === 'camera' ? await m.launchCameraAsync(CAPTURE_OPTIONS) : await m.launchImageLibraryAsync({
+    ...CAPTURE_OPTIONS,
+    allowsMultipleSelection: options.maxCount > 1,
+    selectionLimit: options.maxCount
+  });
+  if (result.canceled || !result.assets) {
+    return [];
+  }
+  const parts = [];
+  for (const asset of result.assets.slice(0, options.maxCount)) {
+    const compressed = await compressImage(asset.uri, {
+      maxSize: MAX_SIDE,
+      maxBytes: options.maxBytes,
+      fileSize: asset.fileSize ?? undefined,
+      name: asset.fileName ?? `photo-${Date.now()}-${parts.length + 1}`
+    });
+    parts.push({
+      uri: compressed.part.uri,
+      name: compressed.part.name,
+      type: compressed.part.type,
+      size: compressed.size ?? undefined
+    });
+  }
+  return parts;
+};
+//# sourceMappingURL=photos.js.map

package/lib/module/report/ReportIssueButton.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import { Button } from '@webority/mobile-ui';
+import { useState } from 'react';
+import { captureAndReport } from "./captureAndReport.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+/** A button that screenshots the current screen and hands a prefilled ticket draft to the app. */
+export const ReportIssueButton = ({
+  onReport,
+  onCaptureError,
+  screenName,
+  appVersion,
+  category,
+  subject,
+  title = 'Report an issue',
+  accessibilityLabel = 'Report an issue with this screen',
+  testID = 'support-report-issue',
+  ...buttonProps
+}) => {
+  const [capturing, setCapturing] = useState(false);
+  const press = async () => {
+    setCapturing(true);
+    try {
+      onReport(await captureAndReport({
+        screenName,
+        appVersion,
+        category,
+        subject
+      }));
+    } catch (error) {
+      onCaptureError?.(error);
+      onReport({
+        category,
+        subject,
+        pageUrl: screenName,
+        appVersion
+      });
+    } finally {
+      setCapturing(false);
+    }
+  };
+  return /*#__PURE__*/_jsx(Button, {
+    leftIcon: "message-question",
+    ...buttonProps,
+    title: title,
+    accessibilityLabel: accessibilityLabel,
+    testID: testID,
+    loading: capturing,
+    onPress: () => void press()
+  });
+};
+//# sourceMappingURL=ReportIssueButton.js.map

package/lib/module/report/captureAndReport.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import { describeDevice } from "../device.js";
+/** The one place `react-native-view-shot` is named, and only this subpath reaches it. */
+const viewShot = () => require('react-native-view-shot');
+/**
+ * Captures what is on screen right now and returns a draft for NewSupportTicket
+ * with the image under `screenshots`, plus the page, device and app version.
+ */
+export const captureAndReport = async options => {
+  const uri = await viewShot().captureScreen({
+    format: 'jpg',
+    quality: 0.8,
+    result: 'tmpfile'
+  });
+  return {
+    category: options.category,
+    subject: options.subject,
+    pageUrl: options.screenName,
+    userAgent: describeDevice(),
+    appVersion: options.appVersion,
+    screenshots: [{
+      uri,
+      name: `screenshot-${Date.now()}.jpg`,
+      type: 'image/jpeg'
+    }]
+  };
+};
+//# sourceMappingURL=captureAndReport.js.map

package/lib/module/report/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+/**
+ * Report an issue. A separate entry point because it names react-native-view-shot,
+ * an optional peer: Metro resolves every require reachable from an import, so
+ * keeping it off the main barrel lets an app skip the package when it does not
+ * use this button.
+ */
+
+export { captureAndReport } from "./captureAndReport.js";
+export { ReportIssueButton } from "./ReportIssueButton.js";
+//# sourceMappingURL=index.js.map

package/lib/module/share/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+/**
+ * Opens a support attachment through the system share sheet, by way of
+ * mobile-core's `/share`. A separate entry point because that reaches
+ * expo-sharing, an optional peer: Metro resolves every require reachable from an
+ * import, so keeping it off the main barrel lets an app skip the package when it
+ * does not open files.
+ */
+import { shareFile } from '@webority/mobile-core/share';
+export class SupportShareUnavailableError extends Error {
+  constructor() {
+    super('Opening files is not available on this device.');
+    this.name = 'SupportShareUnavailableError';
+  }
+}
+
+/**
+ * Hands a downloaded attachment to the OS share sheet, where the person can open
+ * it in a viewer or save it. Pass it to `SupportProvider` as `openFile`.
+ */
+export const shareSupportFile = async file => {
+  try {
+    await shareFile(file.uri, {
+      mimeType: file.contentType,
+      dialogTitle: file.name
+    });
+  } catch (error) {
+    // By name, not instanceof: a second copy of mobile-core would fail instanceof.
+    const e = error;
+    if (e?.name === 'ShareError' && e.code === 'unavailable') {
+      throw new SupportShareUnavailableError();
+    }
+    throw error;
+  }
+};
+//# sourceMappingURL=index.js.map

package/lib/module/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/module/validation.js

@@ -0,0 +1,38 @@
+"use strict";
+
+export const validateCategory = (category, config) => config.categories.includes(category) ? undefined : 'Choose one of the listed categories.';
+
+/** Limits come from GET /settings, so the product's own values are the only copy. */
+
+export const validateSubject = (subject, limits) => {
+  const trimmed = subject.trim();
+  if (!trimmed) {
+    return 'Add a short subject.';
+  }
+  return trimmed.length > limits.subjectMaxLength ? `Keep the subject under ${limits.subjectMaxLength} characters.` : undefined;
+};
+export const validateBody = (body, limits) => {
+  const trimmed = body.trim();
+  if (!trimmed) {
+    return 'Write a message.';
+  }
+  return trimmed.length > limits.bodyMaxLength ? `Keep the message under ${limits.bodyMaxLength} characters.` : undefined;
+};
+
+/** Checks every file on one message against the product's limits. The first problem wins. */
+export const validateFiles = (files, config) => {
+  if (files.length > config.maxAttachmentsPerMessage) {
+    return `Attach up to ${config.maxAttachmentsPerMessage} files to one message.`;
+  }
+  for (const file of files) {
+    if (config.allowedContentTypes.length > 0 && !config.allowedContentTypes.includes(file.type)) {
+      return `${file.name} can't be attached. Use an image, a PDF or a text file.`;
+    }
+    if (file.size !== undefined && file.size > config.maxAttachmentBytes) {
+      const mb = Math.floor(config.maxAttachmentBytes / (1024 * 1024));
+      return `${file.name} is too large. The limit is ${mb} MB per file.`;
+    }
+  }
+  return undefined;
+};
+//# sourceMappingURL=validation.js.map

package/lib/typescript/commonjs/SupportProvider.d.ts

@@ -0,0 +1,82 @@
+import type React from 'react';
+import { SupportApiError, type SupportClient } from './client';
+import type { NewSupportTicketInput, SupportAttachmentView, SupportContactInfo, SupportRatingInput, SupportReplyInput, SupportTicketCounts, SupportTicketDetail, SupportTicketStatus, SupportTicketSummary } from './types';
+/** A downloaded attachment, ready for the OS to open. */
+export interface SupportFileToOpen {
+    /** A `file://` URI in the app's cache. */
+    uri: string;
+    name: string;
+    contentType: string;
+}
+/** Hands a downloaded file to the OS. `shareSupportFile` from the `/share` entry is one. */
+export type SupportFileOpener = (file: SupportFileToOpen) => Promise<void>;
+type AttachmentOpener = (attachment: Pick<SupportAttachmentView, 'id' | 'fileName' | 'contentType'>) => Promise<void>;
+export interface SupportProviderProps {
+    client: SupportClient;
+    /**
+     * Opens a file that is not an image (a PDF, a text file). Leave it out and those
+     * attachments show their name and size only.
+     */
+    openFile?: SupportFileOpener;
+    children: React.ReactNode;
+}
+export declare const SupportProvider: React.FC<SupportProviderProps>;
+export declare const useSupportClient: () => SupportClient;
+/** @internal Used by the attachment thumbnails. */
+export declare const useAttachmentLoader: () => (attachment: Pick<SupportAttachmentView, "id" | "contentType">) => Promise<string>;
+/** @internal Used by the file rows; null when the app gave no `openFile`. */
+export declare const useAttachmentOpener: () => AttachmentOpener | null;
+export interface SupportConfigState {
+    config: SupportContactInfo | null;
+    loading: boolean;
+    error: SupportApiError | null;
+    reload: () => Promise<void>;
+}
+export declare const useSupportConfig: () => SupportConfigState;
+export interface SupportTicketsOptions {
+    /** Tickets per page. The server defaults to 20 and caps at 100. */
+    pageSize?: number;
+}
+export interface SupportTicketsState {
+    /** Every page loaded so far for the current status and search. */
+    tickets: SupportTicketSummary[];
+    /** All of the caller's tickets by status, whatever the filter. Null until first loaded. */
+    counts: SupportTicketCounts | null;
+    status: SupportTicketStatus | null;
+    search: string;
+    /** Null shows every status. Starts again from the first page. */
+    setStatus: (status: SupportTicketStatus | null) => void;
+    /** Matches the subject or the ticket number. Starts again from the first page. */
+    setSearch: (search: string) => void;
+    /** The first page for the current status and search is loading. */
+    loading: boolean;
+    refreshing: boolean;
+    loadingMore: boolean;
+    hasMore: boolean;
+    error: SupportApiError | null;
+    /** The last failed next page. The pages already loaded stay. */
+    loadMoreError: SupportApiError | null;
+    /** Reloads the counts and the first page. */
+    refresh: () => Promise<void>;
+    /** Loads the next page, when there is one and nothing else is loading. */
+    loadMore: () => Promise<void>;
+    createTicket: (input: NewSupportTicketInput) => Promise<SupportTicketDetail>;
+}
+export declare const useSupportTickets: (options?: SupportTicketsOptions) => SupportTicketsState;
+/** Raises a ticket and tells every mounted ticket list to refetch. */
+export declare const useCreateSupportTicket: () => ((input: NewSupportTicketInput) => Promise<SupportTicketDetail>);
+export interface SupportTicketState {
+    ticket: SupportTicketDetail | null;
+    loading: boolean;
+    error: SupportApiError | null;
+    /** The last reply, reopen or rating failure, for showing beside the action. */
+    actionError: SupportApiError | null;
+    busy: boolean;
+    reload: () => Promise<void>;
+    reply: (input: SupportReplyInput) => Promise<boolean>;
+    reopen: () => Promise<boolean>;
+    rate: (input: SupportRatingInput) => Promise<boolean>;
+}
+export declare const useSupportTicket: (id: string) => SupportTicketState;
+export {};
+//# sourceMappingURL=SupportProvider.d.ts.map

package/lib/typescript/commonjs/client.d.ts

@@ -0,0 +1,63 @@
+import type { NewSupportTicketInput, SupportAttachmentView, SupportContactInfo, SupportPage, SupportRatingInput, SupportReplyInput, SupportTicketCounts, SupportTicketDetail, SupportTicketQuery, SupportTicketSummary } from './types';
+/**
+ * The slice of an HTTP client the support client needs. The app's signed-in
+ * axios instance (mobile-core's `userClient`, or its own) satisfies it as is, so
+ * whatever it adds to a request (bearer token, tenant header, refresh on 401)
+ * applies to support calls too. Declared structurally so no axios type leaks into
+ * this package's declarations.
+ */
+export interface SupportHttpRequestConfig {
+    headers?: Record<string, string>;
+    timeout?: number;
+    responseType?: 'arraybuffer' | 'json';
+}
+export interface SupportHttpClient {
+    get<T = unknown>(url: string, config?: SupportHttpRequestConfig): Promise<{
+        data: T;
+    }>;
+    post<T = unknown>(url: string, body?: unknown, config?: SupportHttpRequestConfig): Promise<{
+        data: T;
+    }>;
+}
+export declare const OFFLINE_MESSAGE = "You are offline. Check your connection and try again.";
+export declare const GENERIC_MESSAGE = "Something went wrong. Try again in a moment.";
+/**
+ * A failed support call. `message` is written for the person and is shown as is;
+ * `code` is the backend's stable code, for branching only.
+ */
+export declare class SupportApiError extends Error {
+    readonly code: string;
+    readonly status: number | null;
+    constructor(code: string, message: string, status: number | null);
+}
+/** Turns whatever the HTTP client threw into a SupportApiError. */
+export declare const toSupportApiError: (error: unknown) => SupportApiError;
+export declare const encodeBase64: (buffer: ArrayBuffer) => string;
+export interface SupportClient {
+    readonly basePath: string;
+    getConfig(): Promise<SupportContactInfo>;
+    /** One page of the caller's tickets, most recently updated first. */
+    listTickets(query?: SupportTicketQuery): Promise<SupportPage<SupportTicketSummary>>;
+    /** The caller's tickets counted by status, for labelling the status filters. */
+    getTicketCounts(): Promise<SupportTicketCounts>;
+    getTicket(id: string): Promise<SupportTicketDetail>;
+    createTicket(input: NewSupportTicketInput): Promise<SupportTicketDetail>;
+    reply(id: string, input: SupportReplyInput): Promise<SupportTicketDetail>;
+    reopen(id: string): Promise<SupportTicketDetail>;
+    rate(id: string, input: SupportRatingInput): Promise<SupportTicketDetail>;
+    /** An attachment's raw bytes, fetched through the same authenticated client. */
+    getAttachmentBytes(id: string): Promise<ArrayBuffer>;
+    /**
+     * An attachment's bytes as a `data:` URI an `<Image>` can show. Fetched through
+     * the same authenticated client as every other call.
+     */
+    getAttachmentDataUri(attachment: Pick<SupportAttachmentView, 'id' | 'contentType'>): Promise<string>;
+    /**
+     * The person's yes to a support action an assistant prepared (raise a ticket, reply on
+     * one, reopen one). Only this call completes it. Resolves to the ticket it acted on; an
+     * expired or unknown token rejects with the code `action_expired`.
+     */
+    confirmAction(token: string): Promise<SupportTicketDetail>;
+}
+export declare const createSupportClient: (http: SupportHttpClient, basePath?: string) => SupportClient;
+//# sourceMappingURL=client.d.ts.map

package/lib/typescript/commonjs/clipboard.d.ts

@@ -0,0 +1,3 @@
+/** The one place `expo-clipboard` is named. */
+export declare const copyText: (text: string) => Promise<boolean>;
+//# sourceMappingURL=clipboard.d.ts.map

package/lib/typescript/commonjs/components/Attachments.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+import type { SupportAttachmentView } from '../types';
+/** A message's files: images as tappable thumbnails, anything else as a file row. */
+export declare const AttachmentList: React.FC<{
+    attachments: SupportAttachmentView[];
+    onOpenImage: (uri: string, name: string) => void;
+}>;
+/** Full-screen view of one image with pinch to zoom. */
+export declare const ImageViewer: React.FC<{
+    image: {
+        uri: string;
+        name: string;
+    } | null;
+    onClose: () => void;
+}>;
+//# sourceMappingURL=Attachments.d.ts.map

package/lib/typescript/commonjs/components/NewSupportTicket.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+import type { SupportTicketDetail, SupportTicketDraft } from '../types';
+export interface NewSupportTicketProps {
+    /** Called with the created ticket; navigate to its detail from here. */
+    onCreated: (ticket: SupportTicketDetail) => void;
+    onCancel?: () => void;
+    /** Prefill, typically from the report-an-issue button: screenshot, page and device. */
+    initialDraft?: SupportTicketDraft;
+    testID?: string;
+}
+export declare const NewSupportTicket: React.FC<NewSupportTicketProps>;
+//# sourceMappingURL=NewSupportTicket.d.ts.map

package/lib/typescript/commonjs/components/PhotoTray.d.ts

@@ -0,0 +1,17 @@
+import type React from 'react';
+import type { SupportFilePart } from '../types';
+export interface PhotoTrayProps {
+    photos: SupportFilePart[];
+    onChange: (photos: SupportFilePart[]) => void;
+    /** Photos this message may still take, after anything else attached to it. */
+    remaining: number;
+    maxBytes: number;
+    disabled?: boolean;
+    /** A heading above the tray. */
+    label?: string;
+    /** False shows the photos with remove buttons only, for a prefilled screenshot. */
+    allowAdd?: boolean;
+}
+/** Photos on a message: thumbnails with remove buttons, plus library and camera buttons. */
+export declare const PhotoTray: React.FC<PhotoTrayProps>;
+//# sourceMappingURL=PhotoTray.d.ts.map

package/lib/typescript/commonjs/components/SupportContact.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+export interface SupportContactProps {
+    testID?: string;
+}
+/** How to reach the support team: email with copy and compose, phone, and hours. */
+export declare const SupportContact: React.FC<SupportContactProps>;
+//# sourceMappingURL=SupportContact.d.ts.map

package/lib/typescript/commonjs/components/SupportTicketDetail.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+export interface SupportTicketDetailProps {
+    ticketId: string;
+    testID?: string;
+}
+export declare const SupportTicketDetail: React.FC<SupportTicketDetailProps>;
+//# sourceMappingURL=SupportTicketDetail.d.ts.map

package/lib/typescript/commonjs/components/SupportTicketList.d.ts

@@ -0,0 +1,28 @@
+import { type StatusBadgeTone } from '@webority/mobile-ui';
+import type React from 'react';
+import type { SupportTicketCounts, SupportTicketStatus, SupportTicketSummary } from '../types';
+export declare const STATUS_TONES: Record<SupportTicketStatus, StatusBadgeTone>;
+declare const ALL = "all";
+export interface StatusFilterOption {
+    value: SupportTicketStatus | typeof ALL;
+    label: string;
+    count: number;
+}
+/**
+ * All, then each status that has tickets. The selected status stays even at
+ * zero, so the chip the person is on never vanishes under them.
+ */
+export declare const statusFilterOptions: (counts: SupportTicketCounts, selected: SupportTicketStatus | null) => StatusFilterOption[];
+export interface SupportTicketListProps {
+    onOpenTicket: (ticket: SupportTicketSummary) => void;
+    /** Shows a New ticket button in the header and the empty state. */
+    onNewTicket?: () => void;
+    /** Content above the list, for example a SupportContact card. */
+    header?: React.ReactElement;
+    /** Tickets per page. Default 20. */
+    pageSize?: number;
+    testID?: string;
+}
+export declare const SupportTicketList: React.FC<SupportTicketListProps>;
+export {};
+//# sourceMappingURL=SupportTicketList.d.ts.map

package/lib/typescript/commonjs/device.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The device line a ticket carries as its user agent: platform, OS version and,
+ * when the app registered one with mobile-core's `setDeviceContext`, the model.
+ */
+export declare const describeDevice: () => string;
+//# sourceMappingURL=device.d.ts.map

package/lib/typescript/commonjs/files.d.ts

@@ -0,0 +1,10 @@
+import type { SupportAttachmentView } from './types';
+/** A server-supplied name reduced to one path segment, so it cannot leave the cache folder. */
+export declare const safeFileName: (name: string) => string;
+/**
+ * Writes an attachment to the app's cache and returns its `file://` URI. The id
+ * prefix keeps two tickets' `report.pdf` apart. Attachments never change once
+ * stored, so a file already on disk is reused rather than fetched again.
+ */
+export declare const saveAttachmentToCache: (attachment: Pick<SupportAttachmentView, "id" | "fileName">, loadBytes: () => Promise<ArrayBuffer>) => Promise<string>;
+//# sourceMappingURL=files.d.ts.map

package/lib/typescript/commonjs/format.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A timestamp in the device's own time zone. The backend sends UTC; mobile-core's
+ * formatter goes through Intl without pinning a zone, so the reader sees their
+ * own clock.
+ */
+export declare const formatWhen: (utc: string | null | undefined) => string;
+/** A byte count as a person reads it. */
+export declare const formatBytes: (bytes: number) => string;
+export declare const isImage: (contentType: string) => boolean;
+//# sourceMappingURL=format.d.ts.map

package/lib/typescript/commonjs/index.d.ts

@@ -0,0 +1,15 @@
+export type { SupportClient, SupportHttpClient, SupportHttpRequestConfig } from './client';
+export { createSupportClient, SupportApiError, toSupportApiError } from './client';
+export type { NewSupportTicketProps } from './components/NewSupportTicket';
+export { NewSupportTicket } from './components/NewSupportTicket';
+export type { SupportContactProps } from './components/SupportContact';
+export { SupportContact } from './components/SupportContact';
+export type { SupportTicketDetailProps } from './components/SupportTicketDetail';
+export { SupportTicketDetail } from './components/SupportTicketDetail';
+export type { SupportTicketListProps } from './components/SupportTicketList';
+export { SupportTicketList } from './components/SupportTicketList';
+export { describeDevice } from './device';
+export type { SupportConfigState, SupportFileOpener, SupportFileToOpen, SupportProviderProps, SupportTicketState, SupportTicketsOptions, SupportTicketsState } from './SupportProvider';
+export { SupportProvider, useCreateSupportTicket, useSupportClient, useSupportConfig, useSupportTicket, useSupportTickets } from './SupportProvider';
+export type { NewSupportTicketInput, SupportAttachmentKind, SupportAttachmentView, SupportContactInfo, SupportFilePart, SupportMessageAuthorKind, SupportMessageView, SupportPage, SupportRatingInput, SupportReplyInput, SupportSatisfaction, SupportTicketCounts, SupportTicketDetail as SupportTicketDetailView, SupportTicketDraft, SupportTicketPriority, SupportTicketQuery, SupportTicketStatus, SupportTicketSummary } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/typescript/commonjs/photos.d.ts

@@ -0,0 +1,16 @@
+import type { SupportFilePart } from './types';
+export type PhotoSource = 'library' | 'camera';
+export declare class PhotoPermissionError extends Error {
+    readonly source: PhotoSource;
+    constructor(source: PhotoSource);
+}
+/**
+ * Lets the person pick or take photos and returns them ready to upload,
+ * compressed to fit the product's per-file limit. An empty list means they
+ * cancelled.
+ */
+export declare const pickPhotos: (source: PhotoSource, options: {
+    maxCount: number;
+    maxBytes: number;
+}) => Promise<SupportFilePart[]>;
+//# sourceMappingURL=photos.d.ts.map

package/lib/typescript/commonjs/report/ReportIssueButton.d.ts

@@ -0,0 +1,14 @@
+import { type ButtonProps } from '@webority/mobile-ui';
+import type React from 'react';
+import type { SupportTicketDraft } from '../types';
+import { type CaptureAndReportOptions } from './captureAndReport';
+export interface ReportIssueButtonProps extends CaptureAndReportOptions, Omit<ButtonProps, 'onPress' | 'title' | 'children' | 'loading'> {
+    /** Open the new ticket screen with this draft, for example `navigation.navigate('NewTicket', { draft })`. */
+    onReport: (draft: SupportTicketDraft) => void;
+    /** Called when the screen could not be captured. The draft still opens, without a screenshot. */
+    onCaptureError?: (error: unknown) => void;
+    title?: string;
+}
+/** A button that screenshots the current screen and hands a prefilled ticket draft to the app. */
+export declare const ReportIssueButton: React.FC<ReportIssueButtonProps>;
+//# sourceMappingURL=ReportIssueButton.d.ts.map

package/lib/typescript/commonjs/report/captureAndReport.d.ts

@@ -0,0 +1,15 @@
+import type { SupportTicketDraft } from '../types';
+export interface CaptureAndReportOptions {
+    /** The current screen or route name. Sent as the ticket's page. */
+    screenName: string;
+    /** The app's user-visible version, for example from its compiled appsettings. */
+    appVersion?: string;
+    category?: string;
+    subject?: string;
+}
+/**
+ * Captures what is on screen right now and returns a draft for NewSupportTicket
+ * with the image under `screenshots`, plus the page, device and app version.
+ */
+export declare const captureAndReport: (options: CaptureAndReportOptions) => Promise<SupportTicketDraft>;
+//# sourceMappingURL=captureAndReport.d.ts.map

package/lib/typescript/commonjs/report/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Report an issue. A separate entry point because it names react-native-view-shot,
+ * an optional peer: Metro resolves every require reachable from an import, so
+ * keeping it off the main barrel lets an app skip the package when it does not
+ * use this button.
+ */
+export type { CaptureAndReportOptions } from './captureAndReport';
+export { captureAndReport } from './captureAndReport';
+export type { ReportIssueButtonProps } from './ReportIssueButton';
+export { ReportIssueButton } from './ReportIssueButton';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/share/index.d.ts

@@ -0,0 +1,10 @@
+import type { SupportFileOpener } from '../SupportProvider';
+export declare class SupportShareUnavailableError extends Error {
+    constructor();
+}
+/**
+ * Hands a downloaded attachment to the OS share sheet, where the person can open
+ * it in a viewer or save it. Pass it to `SupportProvider` as `openFile`.
+ */
+export declare const shareSupportFile: SupportFileOpener;
+//# sourceMappingURL=index.d.ts.map