@raytio/decrypt-helper 6.4.2 → 6.4.3

package/dist/pdf/components/Report.js

@@ -0,0 +1,91 @@
+import { randomBytes } from "node:crypto";
+import { isScoreResultValid } from "@raytio/core";
+import { JsxPdf } from "../../helpers/jsxPdf.js";
+import { $$ } from "../../locales/index.js";
+import { classes } from "../style.js";
+import { asset } from "../helpers/general.js";
+import { NULL_I_ID, SUBMISSION_DATA } from "../constants.js";
+import { transform } from "../helpers/transform.js";
+import { SCHEMA } from "../../constants.js";
+import { version } from "../../public-methods/version.js";
+import { VerifyBox } from "./VerifyBox.js";
+import { Table } from "./Table.js";
+import { TableTitle } from "./TableTitle.js";
+import { Subheader } from "./Subheader.js";
+import { POVerificationBadge } from "./POVerificationBadge.js";
+export const Report = ({ data, files, config, aId, clientUrl, envConfig, }) => {
+    // The PDF is read only; there's no reason why anyone would ever need to unlock it.
+    const randomToken = randomBytes(32).toString("base64");
+    const schemas = Object.values(data.profile_objects).sort(
+    // sort it so that the person schema comes first
+    (a, b) => {
+        var _a, _b;
+        return +(((_a = b[0]) === null || _a === void 0 ? void 0 : _a.$schemaName) === SCHEMA.PERSON) -
+            +(((_b = a[0]) === null || _b === void 0 ? void 0 : _b.$schemaName) === SCHEMA.PERSON);
+    });
+    const appName = envConfig.app_name;
+    const iId = data.id === NULL_I_ID ? "" : data.id;
+    return (JsxPdf.createElement("document", { defaultStyle: { font: "Lato", fontSize: 12 }, info: {
+            title: $$("Report.meta.title", { appName, iId }),
+            creator: appName,
+            producer: "Raytio", // don't whitelabel
+            subject: version,
+        }, 
+        // @ts-expect-error -- waiting on bpampuch/pdfmake#2453
+        lang: global.lang, ownerPassword: randomToken, permissions: {
+            printing: "highResolution",
+            copying: true, // allow copy/paste
+        }, pageSize: "A4", styles: classes, images: {
+            raytioLogo: envConfig.logo_url
+                ? asset("custom-logo.png")
+                : asset("logo.png"),
+        } },
+        JsxPdf.createElement("header", null, (currentPage) => currentPage !== 1 && (JsxPdf.createElement("stack", { color: "#333", fontSize: 10 },
+            JsxPdf.createElement("text", { margin: 16 },
+                JsxPdf.createElement("text", { bold: true },
+                    $$("Report.header", { appName }),
+                    " - "),
+                JsxPdf.createElement("text", null, iId))))),
+        JsxPdf.createElement("content", null,
+            JsxPdf.createElement("image", { src: "raytioLogo", width: 150, alignment: "center" }),
+            JsxPdf.createElement("text", { style: ["header", "marginBottom"], alignment: "center" }, $$("Report.header", { appName })),
+            JsxPdf.createElement("columns", { columnGap: 10 },
+                JsxPdf.createElement("column", { width: "auto" },
+                    JsxPdf.createElement("text", { style: ["subheader", "marginBottom"] },
+                        iId &&
+                            Object.entries(SUBMISSION_DATA)
+                                .map(([id, label]) => `${label}: ${transform(id, data[id], config)}`)
+                                .join("\n"),
+                        isScoreResultValid(data.score)
+                            ? [
+                                "",
+                                `${$$("constants.score")}: ${data.score.score}`,
+                                `${$$("constants.score-category")}: ${data.score.category}`,
+                            ].join("\n")
+                            : ""),
+                    JsxPdf.createElement(Subheader, { data: data, config: config })),
+                JsxPdf.createElement("column", { width: "*" },
+                    JsxPdf.createElement("text", null, " ")),
+                JsxPdf.createElement("column", { width: 150 },
+                    JsxPdf.createElement(VerifyBox, { aId: aId, iId: data.id, clientUrl: clientUrl }))),
+            schemas.map((POs) => {
+                // for each schema
+                return (JsxPdf.createElement("stack", { 
+                    // unbreakable is off because it crashes if its too big for one page
+                    // This is a 7-year-old issue in pdfmake (https://github.com/bpampuch/pdfmake/issues/207)
+                    unbreakable: false, style: "marginY" },
+                    JsxPdf.createElement(TableTitle, { POs: POs }),
+                    JsxPdf.createElement("columns", { columnGap: 15 },
+                        JsxPdf.createElement("column", { width: 80 },
+                            JsxPdf.createElement(POVerificationBadge, { width: 80, POs: POs })),
+                        JsxPdf.createElement("column", { width: "auto" },
+                            JsxPdf.createElement(Table, { POs: POs, files: files, config: config })))));
+            })),
+        JsxPdf.createElement("footer", null, (currentPage, pageCount, pageSize) => (JsxPdf.createElement("stack", { bold: true, color: "#333", fontSize: 10 },
+            JsxPdf.createElement("text", { margin: 16 },
+                JsxPdf.createElement("text", null,
+                    $$("Report.header", { appName }),
+                    " - "),
+                JsxPdf.createElement("text", { color: "#fb7171" }, $$("Report.footer-private"))),
+            JsxPdf.createElement("text", { absolutePosition: { x: pageSize.width - 50, y: 15 } }, $$("Report.pagecount", { currentPage, pageCount })))))));
+};

package/dist/pdf/components/Subheader.d.ts

@@ -0,0 +1 @@
+export declare const Subheader: () => JSX.Element;

package/dist/pdf/components/Subheader.js

@@ -0,0 +1,21 @@
+import { FieldVerification } from "@raytio/types";
+import { JsxPdf } from "../../helpers/jsxPdf.js";
+import { $$ } from "../../locales/index.js";
+import { FieldVerificationBadge } from "./FieldVerificationBadge.js";
+export const Subheader = () => {
+    return (JsxPdf.createElement(JsxPdf.Fragment, null,
+        JsxPdf.createElement("text", { bold: true, style: "marginBottom" }, "Key:"),
+        JsxPdf.createElement("table", { layout: "noBorders" },
+            JsxPdf.createElement("row", null,
+                JsxPdf.createElement("cell", null,
+                    JsxPdf.createElement(FieldVerificationBadge, { width: 10, status: FieldVerification.Verified })),
+                JsxPdf.createElement("cell", null, $$("FieldVerification.Verified"))),
+            JsxPdf.createElement("row", null,
+                JsxPdf.createElement("cell", null,
+                    JsxPdf.createElement(FieldVerificationBadge, { width: 10, status: FieldVerification.NotVerified })),
+                JsxPdf.createElement("cell", null, $$("FieldVerification.NotVerified"))),
+            JsxPdf.createElement("row", null,
+                JsxPdf.createElement("cell", null,
+                    JsxPdf.createElement(FieldVerificationBadge, { width: 10, status: FieldVerification.VerifiedFalse })),
+                JsxPdf.createElement("cell", null, $$("FieldVerification.VerifiedFalse"))))));
+};

package/dist/pdf/components/Table.d.ts

@@ -0,0 +1,8 @@
+import type { PdfConfig } from "../types.js";
+import { type FlatPO } from "../../helpers/index.js";
+import type { ProcessSubmissionOutput } from "../../public-methods/processSubmission.js";
+export declare const Table: ({ POs, files, config, }: {
+    POs: FlatPO[];
+    files: ProcessSubmissionOutput["files"];
+    config: PdfConfig;
+}) => JSX.Element;

package/dist/pdf/components/Table.js

@@ -0,0 +1,40 @@
+import { JsxPdf } from "../../helpers/jsxPdf.js";
+import { verifyColour } from "../helpers/general.js";
+import { assertSafeProperty, isFieldValueFile, isPOFile, } from "../../helpers/index.js";
+import { FieldVerificationBadge } from "./FieldVerificationBadge.js";
+import { Images } from "./Images.js";
+import { InnerTableRows } from "./InnerTableRows.js";
+export const Table = ({ POs, files, config, }) => {
+    /** every fieldName in these profile object */
+    const fieldNames = [
+        ...new Set(POs.flatMap((PO) => Object.keys(PO.$properties))),
+    ];
+    // some or all POs in this schema are files themselves. So render the file, assuming it's an image
+    const fileNIds = POs.filter(isPOFile).map((x) => x.$nId);
+    if (fileNIds.length)
+        return JsxPdf.createElement(Images, { nIds: fileNIds, files: files });
+    const imageFieldNames = fieldNames.filter((fieldName) => POs.map((PO) => { var _a; return (_a = PO.$properties[fieldName]) === null || _a === void 0 ? void 0 : _a.value; }).some(isFieldValueFile));
+    return (JsxPdf.createElement("table", { layout: "noBorders" }, fieldNames.map((fieldName) => {
+        var _a;
+        return (JsxPdf.createElement("row", null,
+            JsxPdf.createElement("cell", null,
+                JsxPdf.createElement("text", { color: "#12130e" }, ((_a = POs.find((PO) => PO.$properties[fieldName])) === null || _a === void 0 ? void 0 : _a.$properties[fieldName].title) || fieldName)),
+            POs.flatMap((PO) => {
+                assertSafeProperty(fieldName);
+                // if we're sharing multiple POs in this schema, and this field doesn't exist on this paticular PO,
+                // then just render some empty cells
+                if (!PO.$properties[fieldName]) {
+                    return [JsxPdf.createElement("cell", null, " "), JsxPdf.createElement("cell", null, " ")];
+                }
+                const { value, formatted_value, verification } = PO.$properties[fieldName];
+                const color = verifyColour(verification);
+                // jsx-pdf currently doesn't support fragments, will make a PR at some point
+                return [
+                    JsxPdf.createElement("cell", null,
+                        JsxPdf.createElement(FieldVerificationBadge, { width: 10, status: verification })),
+                    JsxPdf.createElement("cell", null,
+                        JsxPdf.createElement(InnerTableRows, { key: fieldName, value: formatted_value || value, files: files, config: config, color: color, imageFieldNames: imageFieldNames })),
+                ];
+            })));
+    })));
+};

package/dist/pdf/components/TableTitle.d.ts

@@ -0,0 +1,4 @@
+import { type FlatPO } from "../../helpers/index.js";
+export declare const TableTitle: ({ POs }: {
+    POs: FlatPO[];
+}) => JSX.Element;

package/dist/pdf/components/TableTitle.js

@@ -0,0 +1,10 @@
+import { JsxPdf } from "../../helpers/jsxPdf.js";
+import { isPOFile } from "../../helpers/index.js";
+export const TableTitle = ({ POs }) => {
+    var _a;
+    const schemaTitle = POs[0].$schemaTitle;
+    const maybeFileName = POs.some(isPOFile)
+        ? (_a = POs[0].$properties.title) === null || _a === void 0 ? void 0 : _a.value
+        : undefined;
+    return (JsxPdf.createElement("text", { bold: true, fontSize: 14, style: "marginBottom" }, maybeFileName || schemaTitle));
+};

package/dist/pdf/components/ValidationDisplay.d.ts

@@ -0,0 +1,4 @@
+import type { Validation } from "@raytio/types";
+export declare const ValidationDisplay: ({ value, }: {
+    value: Validation;
+}) => null | JSX.Element;

package/dist/pdf/components/ValidationDisplay.js

@@ -0,0 +1,22 @@
+import { JsxPdf } from "../../helpers/jsxPdf.js";
+import { $$ } from "../../locales/index.js";
+import { assertSafeProperty } from "../../helpers/index.js";
+import { pieChart } from "./pieChart.js";
+const SEVERITY_COLOURS = {
+    low: "#2e8bc0",
+    medium: "#ff9800",
+    high: "#fb7171",
+};
+export const ValidationDisplay = ({ value, }) => {
+    const colour = value.score > 0.5 ? "#c2d887" : "#fb7171";
+    return (JsxPdf.createElement(JsxPdf.Fragment, null,
+        JsxPdf.createElement("svg", { content: pieChart(colour, value.score * 100), width: 50 }),
+        $$("ValidationDisplay.text", { n: value.score * 10 }),
+        Object.values(value.breakdown)
+            .filter((x) => x.severity && x.reason)
+            .map((x) => {
+            const key = x.severity;
+            assertSafeProperty(key);
+            return JsxPdf.createElement("text", { color: SEVERITY_COLOURS[key] }, x.reason);
+        })));
+};

package/dist/pdf/components/VerifyBox.d.ts

@@ -0,0 +1,8 @@
+import type { AId, IId } from "@raytio/types";
+type Props = {
+    aId: AId;
+    iId: IId;
+    clientUrl: string;
+};
+export declare const VerifyBox: ({ aId, iId, clientUrl }: Props) => JSX.Element | null;
+export {};

package/dist/pdf/components/VerifyBox.js

@@ -0,0 +1,12 @@
+import { JsxPdf } from "../../helpers/jsxPdf.js";
+import { $$ } from "../../locales/index.js";
+import { NULL_I_ID } from "../constants.js";
+export const VerifyBox = ({ aId, iId, clientUrl }) => {
+    if (iId === NULL_I_ID)
+        return null;
+    const url = `${clientUrl}/apps/s/${aId}/i/${iId}`;
+    return (JsxPdf.createElement("stack", { alignment: "center" },
+        JsxPdf.createElement("text", { link: url }, $$("VerifyBox.text")),
+        JsxPdf.createElement("qr", { content: url, fit: 150 }),
+        JsxPdf.createElement("text", { color: "#1e90ff", fontSize: 9, link: url, alignment: "left" }, url)));
+};

package/dist/pdf/components/pieChart.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A semi-cirle pie chart
+ * (!) generates a SVG string, not a JSX component.
+ * @param percentage a number from 0 to 100
+ */
+export declare function pieChart(colour: string, percentage: number): string;

package/dist/pdf/components/pieChart.js

@@ -0,0 +1,23 @@
+/**
+ * A semi-cirle pie chart
+ * (!) generates a SVG string, not a JSX component.
+ * @param percentage a number from 0 to 100
+ */
+export function pieChart(colour, percentage) {
+    return `
+    <svg height="70" width="140" viewBox="0 -5 20 15">
+      <circle r="10" cx="10" cy="10" fill="bisque" />
+      <circle
+        r="5"
+        cx="10"
+        cy="10"
+        fill="white"
+        stroke="${colour}"
+        stroke-width="10"
+        stroke-dasharray="${(((percentage / 2) * 31.42) / 100).toFixed(2 // NOTE: css calc() doesn't work in PDFs
+    )} 31.42"
+        transform="rotate(-180) translate(-20, -20)"
+      />
+    </svg>
+`;
+}

package/dist/pdf/constants.d.ts

@@ -0,0 +1,3 @@
+import type { IId, Instance } from "@raytio/types";
+export declare const NULL_I_ID: IId;
+export declare const SUBMISSION_DATA: Partial<Record<keyof Instance, string>>;

package/dist/pdf/constants.js

@@ -0,0 +1,9 @@
+import { $$ } from "../locales/index.js";
+export const NULL_I_ID = "00000000-0000-0000-0000-000000000000";
+export const SUBMISSION_DATA = {
+    confirmation_code: $$("constants.confirmation_code"),
+    id: $$("constants.i_id"),
+    reference: $$("constants.reference"),
+    start_date: $$("constants.start_date"),
+    end_date: $$("constants.end_date"),
+};

package/dist/pdf/helpers/general.d.ts

@@ -0,0 +1,8 @@
+import { FieldVerification, POVerification } from "@raytio/types";
+export declare const asset: (name: string) => string;
+export declare const loadAsset: (name: string) => string;
+export declare const verifyColour: (x: FieldVerification | POVerification) => string;
+/**
+ * Produces a date with a long month
+ */
+export declare const formatDate: (d: Date, locale: string, timeZone: string) => string;

package/dist/pdf/helpers/general.js

@@ -0,0 +1,31 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { FieldVerification, POVerification } from "@raytio/types";
+import { getDirname } from "../../helpers/pathUtils.js";
+export const asset = (name) => {
+    if (/[^.A-Z_a-z-]/.test(name) || name.includes("..")) {
+        throw new Error("Invalid asset name");
+    }
+    return join(getDirname(), "./../../assets/", name);
+};
+export const loadAsset = (name) => readFileSync(asset(name), { encoding: "utf8" });
+export const verifyColour = (x) => {
+    if (x === FieldVerification.Verified)
+        return "#12130e";
+    if (x === FieldVerification.VerifiedFalse ||
+        x === POVerification.VerifiedFalse) {
+        return "#fb7171";
+    }
+    return "#000";
+};
+/**
+ * Produces a date with a long month
+ */
+export const formatDate = (d, locale, timeZone) => new Intl.DateTimeFormat(locale, {
+    day: "2-digit",
+    month: "long",
+    year: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    timeZone,
+}).format(d);

package/dist/pdf/helpers/transform.d.ts

@@ -0,0 +1,4 @@
+import type { PdfConfig } from "../types";
+export declare const IS_IMAGE: unique symbol;
+export declare const IS_ARRAY_OF_OBJECTS: unique symbol;
+export declare function transform(key: string, value: unknown, pdfConfig: PdfConfig, imageFieldNames?: string[]): string | typeof IS_IMAGE | typeof IS_ARRAY_OF_OBJECTS;

package/dist/pdf/helpers/transform.js

@@ -0,0 +1,35 @@
+import { repairDate } from "@raytio/core";
+import { $$ } from "../../locales/index.js";
+import { formatDate } from "./general.js";
+export const IS_IMAGE = Symbol.for("image");
+export const IS_ARRAY_OF_OBJECTS = Symbol.for("ArrayOfObjects");
+export function transform(key, value, pdfConfig, imageFieldNames) {
+    // value is possible to be false if type boolean
+    if (value === undefined) {
+        return $$("field.undefined");
+    }
+    if (typeof value === "boolean") {
+        return value ? $$("field.boolean.yes") : $$("field.boolean.no");
+    }
+    if (imageFieldNames === null || imageFieldNames === void 0 ? void 0 : imageFieldNames.includes(key)) {
+        return IS_IMAGE;
+    }
+    if (Array.isArray(value)) {
+        if (value.every((v) => typeof v === "object")) {
+            return IS_ARRAY_OF_OBJECTS;
+        }
+        return value.join(", ");
+    }
+    if (typeof value !== "string") {
+        return `${value}`;
+    }
+    switch (key) {
+        case "start_date":
+        case "end_date": {
+            return formatDate(repairDate(value), pdfConfig.DATE_FORMAT, pdfConfig.TIMEZONE);
+        }
+        default: {
+            return value;
+        }
+    }
+}

package/dist/pdf/style.d.ts

@@ -0,0 +1,10 @@
+import type { StyleDictionary } from "pdfmake/interfaces";
+export declare const classes: StyleDictionary;
+export declare const fonts: {
+    Lato: {
+        normal: string;
+        bold: string;
+        italics: string;
+        bolditalics: string;
+    };
+};

package/dist/pdf/style.js

@@ -0,0 +1,21 @@
+import { asset } from "./helpers/general.js";
+export const classes = {
+    header: {
+        fontSize: 18,
+    },
+    listing: {
+        fontSize: 10,
+        color: "#333",
+    },
+    // [l, t, r, b]
+    marginBottom: { margin: [0, 0, 0, 10] },
+    marginY: { margin: [0, 15, 0, 15] },
+};
+export const fonts = {
+    Lato: {
+        normal: asset("Lato-Light.ttf"),
+        bold: asset("Lato-Bold.ttf"),
+        italics: asset("Lato-LightItalic.ttf"),
+        bolditalics: asset("Lato-BoldItalic.ttf"),
+    },
+};

package/dist/public-methods/generatePDF.d.ts

@@ -0,0 +1,4 @@
+import type { TDocumentDefinitions } from "pdfmake/interfaces";
+import type { ProcessSubmissionOutput } from "./processSubmission.js";
+export declare function generatePdfJson(data: ProcessSubmissionOutput, DATE_FORMAT: string, TIMEZONE: string): TDocumentDefinitions;
+export declare const generatePDF: () => (data: ProcessSubmissionOutput) => Promise<ProcessSubmissionOutput>;

package/dist/public-methods/generatePDF.js

@@ -0,0 +1,54 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+import PdfPrinter from "pdfmake";
+import JsxPdfImport from "jsx-pdf";
+import { isValidLocale } from "../locales/index.js";
+import { Report } from "../pdf/components/Report.js";
+import { fonts } from "../pdf/style.js";
+import { getDirname } from "../helpers/pathUtils.js";
+const JsxPdf = (JsxPdfImport.default || JsxPdfImport);
+export function generatePdfJson(data, DATE_FORMAT, TIMEZONE) {
+    return JsxPdf.renderPdf(JsxPdf.createElement(Report, { data: data.json, files: data.files, aId: data.a_id, clientUrl: data.client_url, envConfig: data.envConfig, config: { DATE_FORMAT, TIMEZONE } }));
+}
+export const generatePDF = () => 
+// eslint-disable-next-line unicorn/consistent-function-scoping -- deliberately to future proof the SDK for options
+(data) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log("Generating PDF Report...");
+    const { DATE_FORMAT = "en-nz", TIMEZONE = "Pacific/Auckland", PDF_LANGUAGE: customLang, } = process.env;
+    if (data.envConfig.logo_url) {
+        // there is a white labelling URL, so fetch it and write it to disk, overriding the default logo
+        const arrayBuf = yield fetch(data.envConfig.logo_url).then((r) => r.arrayBuffer());
+        yield fs.writeFile(join(getDirname(), "../../assets/custom-logo.png"), Buffer.from(arrayBuf));
+    }
+    if (customLang) {
+        if (isValidLocale(customLang)) {
+            global.lang = customLang;
+        }
+        else {
+            console.warn(`The specified PDF_LANGUAGE is language is invalid (${customLang})`);
+        }
+    }
+    return new Promise((resolve) => {
+        const printer = new PdfPrinter(fonts);
+        const pdfDocument = printer.createPdfKitDocument(generatePdfJson(data, DATE_FORMAT, TIMEZONE));
+        const chunks = [];
+        pdfDocument.on("data", (chunk) => chunks.push(chunk));
+        pdfDocument.on("end", () => {
+            const final = Buffer.concat(chunks);
+            const dataUrl = `data:application/pdf;base64,${final.toString("base64")}`;
+            resolve(Object.assign(Object.assign({}, data), { files: Object.assign(Object.assign({}, data.files), { 
+                    // do not change name, will be a breaking change
+                    [data.json.id]: [dataUrl, "pdf"] }) }));
+        });
+        pdfDocument.end();
+    });
+});

package/dist/public-methods/getAndValidateConfig.d.ts

@@ -0,0 +1,8 @@
+import { type Config } from "../constants.js";
+/**
+ * This helper is designed for environments where the configuration
+ * options are in the environment variables, such as AWS lambda.
+ * It extracts the relevant ENV variables and throws an error if
+ * any are missing.
+ */
+export declare function getAndValidateConfig(): Config;

package/dist/public-methods/getAndValidateConfig.js

@@ -0,0 +1,16 @@
+import { ENV_VARIABLES } from "../constants.js";
+/**
+ * This helper is designed for environments where the configuration
+ * options are in the environment variables, such as AWS lambda.
+ * It extracts the relevant ENV variables and throws an error if
+ * any are missing.
+ */
+export function getAndValidateConfig() {
+    const CONFIG = ENV_VARIABLES.reduce((accumulator, name) => {
+        const value = process.env[name];
+        if (!value)
+            throw new Error(`${name} is not configured`);
+        return Object.assign(Object.assign({}, accumulator), { [name]: value });
+    }, {});
+    return CONFIG;
+}

package/dist/public-methods/processSubmission.d.ts

@@ -0,0 +1,49 @@
+import type { AId, IId, Instance, RealVer } from "@raytio/types";
+import { type Config, type InstanceDataToPassOn } from "../constants.js";
+import { type FlatPO } from "../helpers/index.js";
+import { type EnvConfig } from "../api/index.js";
+import type { ApplicationEncryptorLike } from "../types.js";
+type DecryptData = {
+    apiToken: string;
+    instance: Instance;
+    encryptedInstance: Instance;
+    applicationDecryptor: ApplicationEncryptorLike;
+    realVers?: RealVer[];
+};
+export interface ProcessSubmissionInput {
+    /** The a_id of the application */
+    applicationId: AId;
+    /** The i_id of this submission */
+    instanceId: IId;
+    /** whether to enable extra logging. Default = false */
+    verbose?: boolean;
+    /**
+     * the configuration options. You can extract these from the environment
+     * variables by using @see getAndValidateConfig
+     */
+    config: Config;
+    /** You can optionally supply Instance data and an API token - for Raytio internal use */
+    _supliedConfig?: DecryptData;
+}
+export interface ProcessSubmissionOutput {
+    /** details of the submission, included the decrypted profile objects */
+    json: InstanceDataToPassOn & {
+        profile_objects: {
+            [schemaName: string]: FlatPO[];
+        };
+    };
+    /** A string of a CSV file containing the same data as in `json` */
+    csv: string;
+    /** an object of files that were attached to the submission, such as images */
+    files: {
+        [nId: string]: [dataUrl: string, fileExtension: string];
+    };
+    /** the a_id is passed on */
+    a_id: AId;
+    /** passed down so that pdf generation has access to it */
+    client_url: string;
+    /** passed down so that pdf generation has access to it */
+    envConfig: EnvConfig;
+}
+export declare function processSubmission({ applicationId, instanceId, verbose, config, _supliedConfig, }: ProcessSubmissionInput): Promise<ProcessSubmissionOutput>;
+export {};