@webority/mobile-support 0.0.9

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

@@ -0,0 +1,152 @@
+/**
+ * Wire shapes of the Webority Support HTTP contract. Field names are the camelCase
+ * of the backend's view records and enums travel as their member names, so these
+ * mirror `Webority.Support/SupportViews.cs` and `SupportEnums.cs` exactly.
+ */
+export type SupportTicketStatus = 'Open' | 'InProgress' | 'Resolved' | 'Closed';
+export type SupportTicketPriority = 'Low' | 'Normal' | 'High' | 'Urgent';
+export type SupportMessageAuthorKind = 'Customer' | 'Agent' | 'System';
+export type SupportAttachmentKind = 'Screenshot' | 'File';
+export type SupportSatisfaction = 'Satisfied' | 'Unsatisfied';
+export interface SupportContactInfo {
+    productName: string;
+    supportEmail: string;
+    supportName: string;
+    supportPhone: string | null;
+    supportHours: string | null;
+    categories: string[];
+    maxAttachmentBytes: number;
+    maxAttachmentsPerMessage: number;
+    allowedContentTypes: string[];
+    subjectMaxLength: number;
+    bodyMaxLength: number;
+    satisfactionCommentMaxLength: number;
+}
+export interface SupportTicketSummary {
+    id: string;
+    number: string;
+    category: string;
+    subject: string;
+    status: SupportTicketStatus;
+    statusLabel: string;
+    messageCount: number;
+    awaitingCustomer: boolean;
+    createdDateTimeUtc: string;
+    updatedDateTimeUtc: string;
+}
+/** The fleet pagination shape `GET {base}/tickets` returns. */
+export interface SupportPage<T> {
+    items: T[];
+    page: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+}
+/** `GET {base}/tickets`. Empty or missing fields are left off the request. */
+export interface SupportTicketQuery {
+    status?: SupportTicketStatus;
+    /** Matches the subject or the ticket number. */
+    search?: string;
+    /** 1-based. The server defaults to 1. */
+    page?: number;
+    /** The server defaults to 20 and caps at 100. */
+    pageSize?: number;
+}
+/** `GET {base}/tickets/counts`: the caller's tickets by status. */
+export interface SupportTicketCounts {
+    open: number;
+    inProgress: number;
+    resolved: number;
+    closed: number;
+    total: number;
+}
+export interface SupportAttachmentView {
+    id: string;
+    fileName: string;
+    contentType: string;
+    sizeBytes: number;
+    kind: SupportAttachmentKind;
+}
+export interface SupportMessageView {
+    id: string;
+    authorKind: SupportMessageAuthorKind;
+    authorName: string | null;
+    body: string;
+    isInternal: boolean;
+    createdDateTimeUtc: string;
+    attachments: SupportAttachmentView[];
+}
+export interface SupportTicketDetail {
+    id: string;
+    number: string;
+    /** Null on the customer view: internal ids never leave the platform. */
+    accountId: number | null;
+    /** Null on the customer view. */
+    realm: string | null;
+    category: string;
+    subject: string;
+    status: SupportTicketStatus;
+    statusLabel: string;
+    priority: SupportTicketPriority | null;
+    reporterName: string;
+    reporterEmail: string;
+    assignedAgentUserId: number | null;
+    assignedAgentName: string | null;
+    dueDateTimeUtc: string | null;
+    isOverdue: boolean;
+    pageUrl: string | null;
+    userAgent: string | null;
+    appVersion: string | null;
+    satisfaction: SupportSatisfaction | null;
+    satisfactionComment: string | null;
+    canReopen: boolean;
+    canRate: boolean;
+    createdDateTimeUtc: string;
+    updatedDateTimeUtc: string;
+    resolvedDateTimeUtc: string | null;
+    closedDateTimeUtc: string | null;
+    messages: SupportMessageView[];
+    /** Opaque. Changes whenever the ticket changes. */
+    version: string;
+}
+/** A local file as React Native's FormData takes it. */
+export interface SupportFilePart {
+    uri: string;
+    name: string;
+    type: string;
+    /** Bytes, when the picker knew it. Used for the size check only; never sent. */
+    size?: number;
+}
+export interface NewSupportTicketInput {
+    category: string;
+    subject: string;
+    body: string;
+    pageUrl?: string;
+    userAgent?: string;
+    appVersion?: string;
+    files?: SupportFilePart[];
+    screenshots?: SupportFilePart[];
+}
+export interface SupportReplyInput {
+    body: string;
+    files?: SupportFilePart[];
+    screenshots?: SupportFilePart[];
+}
+export interface SupportRatingInput {
+    satisfaction: SupportSatisfaction;
+    comment?: string;
+}
+/**
+ * What the report-an-issue flow hands to the new ticket screen: the captured
+ * screenshot and where it was taken.
+ */
+export interface SupportTicketDraft {
+    category?: string;
+    subject?: string;
+    body?: string;
+    pageUrl?: string;
+    userAgent?: string;
+    appVersion?: string;
+    screenshots?: SupportFilePart[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { SupportContactInfo, SupportFilePart } from './types';
+export declare const validateCategory: (category: string, config: SupportContactInfo) => string | undefined;
+/** Limits come from GET /settings, so the product's own values are the only copy. */
+type Limits = Pick<SupportContactInfo, 'subjectMaxLength' | 'bodyMaxLength'>;
+export declare const validateSubject: (subject: string, limits: Limits) => string | undefined;
+export declare const validateBody: (body: string, limits: Limits) => string | undefined;
+/** Checks every file on one message against the product's limits. The first problem wins. */
+export declare const validateFiles: (files: SupportFilePart[], config: SupportContactInfo) => string | undefined;
+export {};
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1,82 @@
+import type React from 'react';
+import { SupportApiError, type SupportClient } from './client.js';
+import type { NewSupportTicketInput, SupportAttachmentView, SupportContactInfo, SupportRatingInput, SupportReplyInput, SupportTicketCounts, SupportTicketDetail, SupportTicketStatus, SupportTicketSummary } from './types.js';
+/** 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/module/client.d.ts

@@ -0,0 +1,63 @@
+import type { NewSupportTicketInput, SupportAttachmentView, SupportContactInfo, SupportPage, SupportRatingInput, SupportReplyInput, SupportTicketCounts, SupportTicketDetail, SupportTicketQuery, SupportTicketSummary } from './types.js';
+/**
+ * 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/module/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/module/components/Attachments.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+import type { SupportAttachmentView } from '../types.js';
+/** 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/module/components/NewSupportTicket.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+import type { SupportTicketDetail, SupportTicketDraft } from '../types.js';
+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/module/components/PhotoTray.d.ts

@@ -0,0 +1,17 @@
+import type React from 'react';
+import type { SupportFilePart } from '../types.js';
+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/module/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/module/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/module/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.js';
+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/module/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/module/files.d.ts

@@ -0,0 +1,10 @@
+import type { SupportAttachmentView } from './types.js';
+/** 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/module/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/module/index.d.ts

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

package/lib/typescript/module/package.json

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

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

@@ -0,0 +1,16 @@
+import type { SupportFilePart } from './types.js';
+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/module/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.js';
+import { type CaptureAndReportOptions } from './captureAndReport.js';
+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/module/report/captureAndReport.d.ts

@@ -0,0 +1,15 @@
+import type { SupportTicketDraft } from '../types.js';
+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/module/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.js';
+export { captureAndReport } from './captureAndReport.js';
+export type { ReportIssueButtonProps } from './ReportIssueButton.js';
+export { ReportIssueButton } from './ReportIssueButton.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { SupportFileOpener } from '../SupportProvider.js';
+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