@sovrahq/waci 3.4.0

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateVcByInputDescriptor = exports.CredentialPresentationResponse = void 0;
+require("./handlers/common/step-2-oob-invitation.handler");
+require("./handlers/common/problem-report.handler");
+require("./handlers/issuance/step-3-propose-credential.handler");
+require("./handlers/issuance/step-4-offer-credential.handler");
+require("./handlers/issuance/step-5-request-credential.handler");
+require("./handlers/issuance/step-6-issue-credential.handler");
+require("./handlers/issuance/step-7-ack-message.handler");
+require("./handlers/presentation/step-3-propose-presentation.handler");
+require("./handlers/presentation/step-4-request-presentation.handler");
+require("./handlers/presentation/step-5-present-proof.handler");
+require("./handlers/presentation/step-6-ack-message.handler");
+__exportStar(require("./handlers/issuance/step-3-propose-credential.handler"), exports);
+var callbacks_1 = require("./callbacks");
+Object.defineProperty(exports, "CredentialPresentationResponse", { enumerable: true, get: function () { return callbacks_1.CredentialPresentationResponse; } });
+__exportStar(require("./services/waci-interpreter"), exports);
+__exportStar(require("./types/waci-message"), exports);
+__exportStar(require("./types"), exports);
+var index_1 = require("./utils/index");
+Object.defineProperty(exports, "validateVcByInputDescriptor", { enumerable: true, get: function () { return index_1.validateVcByInputDescriptor; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2DAAyD;AACzD,oDAAkD;AAClD,iEAA+D;AAC/D,+DAA6D;AAC7D,iEAA+D;AAC/D,+DAA6D;AAC7D,0DAAwD;AACxD,uEAAqE;AACrE,uEAAqE;AACrE,gEAA8D;AAC9D,8DAA4D;AAE5D,wFAAsE;AACtE,yCAA6E;AAApD,2HAAA,8BAA8B,OAAA;AACvD,8DAA4C;AAC5C,uDAAqC;AACrC,0CAAwB;AACxB,uCAA4D;AAAnD,oHAAA,2BAA2B,OAAA"}

package/dist/services/waci-interpreter.d.ts

@@ -0,0 +1,17 @@
+import { InputCallbacks } from '../callbacks';
+import { WACIMessage, GoalCode, Actor, CredentialManifest, CredentialFulfillment, WACIResponse, DIDCommVersion } from '../types';
+export declare class WACIInterpreter {
+    private readonly enabledActors;
+    private callbacks;
+    constructor();
+    setUpFor<T extends Actor>(params: InputCallbacks[T], actor: T): WACIInterpreter;
+    isWACIMessage(messageToCheck: any): messageToCheck is WACIMessage;
+    createOOBInvitation(senderDID: string, goalCode: GoalCode, body?: {}, version?: DIDCommVersion): Promise<WACIMessage>;
+    createOfferCredentialMessage(issuerDID: string, holderDID: string, manifest: CredentialManifest, fulfillment: CredentialFulfillment): Promise<WACIMessage>;
+    processMessage(messageThread: WACIMessage[]): Promise<WACIResponse | void>;
+    presentationProceed(messageThread: WACIMessage[], credentialsToPresent: any[], presentationProofTypes?: string[]): Promise<{
+        target: string;
+        message: WACIMessage;
+        responseType: import("../types").WACIMessageResponseType;
+    }>;
+}

package/dist/services/waci-interpreter.js

@@ -0,0 +1,222 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WACIInterpreter = void 0;
+var handlers_1 = require("../handlers");
+var types_1 = require("../types");
+var utils_1 = require("../utils");
+var constants_1 = require("../constants");
+var step_4_1_presentation_proceed_handler_1 = require("../handlers/presentation/step-4-1-presentation-proceed.handler");
+var step_4_1_offer_credential_proceed_handler_1 = require("../handlers/issuance/step-4-1-offer-credential-proceed.handler");
+var WACIInterpreter = /** @class */ (function () {
+    function WACIInterpreter() {
+        this.enabledActors = [];
+        this.callbacks = {};
+    }
+    WACIInterpreter.prototype.setUpFor = function (params, actor) {
+        this.enabledActors.push(actor);
+        this.callbacks[actor] = params;
+        return this;
+    };
+    WACIInterpreter.prototype.isWACIMessage = function (messageToCheck) {
+        try {
+            var allTypes = __spreadArray(__spreadArray([], (0, utils_1.getObjectValues)(types_1.WACIMessageType), true), (0, utils_1.getObjectValues)(types_1.WACIMessageTypeV1), true);
+            return allTypes.includes(messageToCheck.type);
+        }
+        catch (error) {
+            return false;
+        }
+    };
+    WACIInterpreter.prototype.createOOBInvitation = function (senderDID, goalCode, body, version) {
+        if (body === void 0) { body = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var type;
+            return __generator(this, function (_a) {
+                type = version === types_1.DIDCommVersion.V1
+                    ? (0, types_1.convertToVersion)(types_1.WACIMessageType.OutOfBandInvitation, types_1.DIDCommVersion.V1)
+                    : types_1.WACIMessageType.OutOfBandInvitation;
+                return [2 /*return*/, {
+                        type: type,
+                        id: (0, utils_1.createUUID)(),
+                        from: senderDID,
+                        body: __assign(__assign({}, body), { goal_code: goalCode, accept: constants_1.SUPPORTED_ALGORITHMS }),
+                    }];
+            });
+        });
+    };
+    WACIInterpreter.prototype.createOfferCredentialMessage = function (issuerDID, holderDID, manifest, fulfillment) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        type: types_1.WACIMessageType.OfferCredential,
+                        id: (0, utils_1.createUUID)(),
+                        from: issuerDID,
+                        to: [issuerDID],
+                        body: {},
+                        attachments: [manifest, fulfillment],
+                    }];
+            });
+        });
+    };
+    WACIInterpreter.prototype.processMessage = function (messageThread) {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var message, incomingVersion, normalizedType, _d, _e, _f, enabledActor, messageHandler, originalType, response, e_1_1;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        message = messageThread[messageThread.length - 1];
+                        incomingVersion = (0, types_1.detectDIDCommVersion)(message.type);
+                        normalizedType = (0, types_1.normalizeToV2)(message.type);
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 10, 11, 16]);
+                        _d = true, _e = __asyncValues(this.enabledActors);
+                        _g.label = 2;
+                    case 2: return [4 /*yield*/, _e.next()];
+                    case 3:
+                        if (!(_f = _g.sent(), _a = _f.done, !_a)) return [3 /*break*/, 9];
+                        _c = _f.value;
+                        _d = false;
+                        _g.label = 4;
+                    case 4:
+                        _g.trys.push([4, , 7, 8]);
+                        enabledActor = _c;
+                        messageHandler = handlers_1.handlers[enabledActor].get(normalizedType);
+                        if (!messageHandler) return [3 /*break*/, 6];
+                        originalType = message.type;
+                        message.type = normalizedType;
+                        return [4 /*yield*/, messageHandler.handle(messageThread, this.callbacks)];
+                    case 5:
+                        response = _g.sent();
+                        // Restore original type
+                        message.type = originalType;
+                        if (response) {
+                            // Convert response type back to v1 if the interlocutor speaks v1
+                            if (incomingVersion === types_1.DIDCommVersion.V1) {
+                                response.message.type = (0, types_1.convertToVersion)(response.message.type, types_1.DIDCommVersion.V1);
+                            }
+                            return [2 /*return*/, __assign(__assign({}, response), { target: response.message.to[0], message: response.message })];
+                        }
+                        return [2 /*return*/];
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        _d = true;
+                        return [7 /*endfinally*/];
+                    case 8: return [3 /*break*/, 2];
+                    case 9: return [3 /*break*/, 16];
+                    case 10:
+                        e_1_1 = _g.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 16];
+                    case 11:
+                        _g.trys.push([11, , 14, 15]);
+                        if (!(!_d && !_a && (_b = _e.return))) return [3 /*break*/, 13];
+                        return [4 /*yield*/, _b.call(_e)];
+                    case 12:
+                        _g.sent();
+                        _g.label = 13;
+                    case 13: return [3 /*break*/, 15];
+                    case 14:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 15: return [7 /*endfinally*/];
+                    case 16: throw Error("No handler found for message of type '".concat(message.type, "'"));
+                }
+            });
+        });
+    };
+    WACIInterpreter.prototype.presentationProceed = function (messageThread, credentialsToPresent, presentationProofTypes) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, lastType;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = null;
+                        lastType = (0, types_1.normalizeToV2)(messageThread[messageThread.length - 1].type);
+                        if (!(lastType == types_1.WACIMessageType.OfferCredential)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, step_4_1_offer_credential_proceed_handler_1.OfferCredentialProceed.handle(messageThread, credentialsToPresent, presentationProofTypes, this.callbacks)];
+                    case 1:
+                        response = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        if (!(lastType == types_1.WACIMessageType.RequestPresentation)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, step_4_1_presentation_proceed_handler_1.PresentationProceed.presentCredentials(messageThread, credentialsToPresent, this.callbacks)];
+                    case 3:
+                        response = _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        if (!response) {
+                            throw new Error("To call this process, the message thread must end with a message of type OfferCredential or RequestPresentation.");
+                        }
+                        return [2 /*return*/, __assign(__assign({}, response), { target: response.message.to[0], message: response.message })];
+                }
+            });
+        });
+    };
+    return WACIInterpreter;
+}());
+exports.WACIInterpreter = WACIInterpreter;
+//# sourceMappingURL=waci-interpreter.js.map

package/dist/services/waci-interpreter.js.map

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

package/dist/types/actor.d.ts

@@ -0,0 +1,5 @@
+export declare enum Actor {
+    Holder = "holder",
+    Issuer = "issuer",
+    Verifier = "verifier"
+}

package/dist/types/actor.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Actor = void 0;
+var Actor;
+(function (Actor) {
+    Actor["Holder"] = "holder";
+    Actor["Issuer"] = "issuer";
+    Actor["Verifier"] = "verifier";
+})(Actor = exports.Actor || (exports.Actor = {}));
+//# sourceMappingURL=actor.js.map

package/dist/types/actor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor.js","sourceRoot":"","sources":["../../src/types/actor.ts"],"names":[],"mappings":";;;AAAA,IAAY,KAIX;AAJD,WAAY,KAAK;IACf,0BAAiB,CAAA;IACjB,0BAAiB,CAAA;IACjB,8BAAqB,CAAA;AACvB,CAAC,EAJW,KAAK,GAAL,aAAK,KAAL,aAAK,QAIhB"}

package/dist/types/credential-application.d.ts

@@ -0,0 +1,36 @@
+import { ClaimFormat } from './credential-manifest';
+export type CredentialApplication = {
+    id: string;
+    media_type: 'application/json';
+    format: 'dif/credential-manifest/application@v1.0';
+    data: {
+        json: {
+            '@context': string[];
+            type: string[];
+            credential_application: {
+                id: string;
+                manifest_id: string;
+                format?: ClaimFormat;
+            };
+            presentation_submission: PresentationSubmission;
+            verifiableCredential: any[];
+            proof: {
+                type: string;
+                verificationMethod: string;
+                created: string;
+                proofPurpose: string;
+                challenge: string;
+                jws: string;
+            };
+        };
+    };
+};
+export type PresentationSubmission = {
+    id: string;
+    definition_id: string;
+    descriptor_map: {
+        id: string;
+        format: string;
+        path: string;
+    }[];
+};

package/dist/types/credential-application.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=credential-application.js.map

package/dist/types/credential-application.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-application.js","sourceRoot":"","sources":["../../src/types/credential-application.ts"],"names":[],"mappings":""}

package/dist/types/credential-manifest.d.ts

@@ -0,0 +1,173 @@
+import { PresentationSubmission } from './credential-application';
+export type CredentialManifest = {
+    id: string;
+    media_type: string;
+    format: 'dif/credential-manifest/manifest@v1.0';
+    data: {
+        json: {
+            options: {
+                challenge: string;
+                domain?: string;
+            };
+            credential_manifest: {
+                id: string;
+                version: string;
+                issuer: {
+                    id: string;
+                    name: string;
+                    styles?: CredentialManifestStyles;
+                };
+                format?: ClaimFormat;
+                output_descriptors: OutputDescriptor[];
+                presentation_definition?: PresentationDefinition;
+            };
+        };
+    };
+};
+export type CredentialFulfillment = {
+    id: string;
+    media_type: 'application/json';
+    format: 'dif/credential-manifest/fulfillment@v1.0';
+    data: {
+        json: {
+            '@context': string[];
+            type: string[];
+            credential_fulfillment: {
+                id: string;
+                manifest_id: string;
+                descriptor_map: {
+                    id: string;
+                    format: string;
+                    path: string;
+                }[];
+            };
+            verifiableCredential: any[];
+        };
+    };
+};
+export type CredentialRequest = {
+    id: string;
+    media_type: string;
+    format: 'dif/presentation-exchange/definitions@v1.0';
+    data: {
+        json: {
+            options: {
+                challenge: string;
+                domain?: string;
+            };
+            presentation_definition?: PresentationDefinition;
+        };
+    };
+};
+export type CredentialPresentation = {
+    id: string;
+    media_type: string;
+    format: 'dif/presentation-exchange/submission@v1.0';
+    data: {
+        json: {
+            '@context': string[];
+            type: string[];
+            holder: string;
+            verifiableCredential: any[];
+            presentation_submission: PresentationSubmission;
+            proof: {
+                type: string;
+                verificationMethod: string;
+                created: string;
+                proofPurpose: string;
+                challenge: string;
+                jws: string;
+            };
+        };
+    };
+};
+export type OutputDescriptor = {
+    id: string;
+    schema?: string;
+    display?: {
+        title?: DisplayMappingObject;
+        subtitle?: DisplayMappingObject;
+        description?: DisplayMappingObject;
+        properties?: (DisplayMappingObject & {
+            label?: string;
+        })[];
+    };
+    styles: CredentialManifestStyles;
+};
+export type DisplayMappingObject = {
+    path?: string[];
+    schema?: {
+        type?: string;
+    };
+    fallback?: string;
+} | {
+    text: string;
+};
+export type ClaimFormat = {
+    jwt?: {
+        alg: string[];
+    };
+    jwt_vc?: {
+        alg: string[];
+    };
+    jwt_vp?: {
+        alg: string[];
+    };
+    ldp_vc?: {
+        proof_type: string[];
+    };
+    ldp_vp?: {
+        proof_type: string[];
+    };
+    ldp?: {
+        proof_type: string[];
+    };
+};
+export type PresentationDefinitionFrame = {
+    '@context': string[];
+    type: string[];
+    credentialSubject: {
+        "@explicit": boolean;
+        type: string[];
+        [key: string]: {};
+    };
+};
+export type PresentationDefinition = {
+    id: string;
+    input_descriptors: InputDescriptor[];
+    frame?: PresentationDefinitionFrame;
+    name?: string;
+    purpose?: string;
+    format?: ClaimFormat;
+};
+export type InputDescriptor = {
+    id: string;
+    constraints: {
+        fields: {
+            path: string[];
+            id?: string;
+            purpose?: string;
+            filter?: {
+                type: string;
+                const?: any;
+            };
+        }[];
+        limit_disclosure?: 'required' | 'preferred';
+    };
+    name?: string;
+    purpose?: string;
+    format?: ClaimFormat;
+};
+export type CredentialManifestStyles = {
+    thumbnail?: ThumbnailImage;
+    hero?: ThumbnailImage;
+    background?: ColorDefinition;
+    text?: ColorDefinition;
+};
+export type ColorDefinition = {
+    color: string;
+};
+export type ThumbnailImage = {
+    uri: string;
+    alt: string;
+};

package/dist/types/credential-manifest.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=credential-manifest.js.map

package/dist/types/credential-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-manifest.js","sourceRoot":"","sources":["../../src/types/credential-manifest.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './actor';
+export * from './waci-message';
+export * from './credential-manifest';
+export * from './credential-application';

package/dist/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./actor"), exports);
+__exportStar(require("./waci-message"), exports);
+__exportStar(require("./credential-manifest"), exports);
+__exportStar(require("./credential-application"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,iDAA+B;AAC/B,wDAAsC;AACtC,2DAAyC"}

package/dist/types/problem-report.d.ts

@@ -0,0 +1,13 @@
+export interface ProblemReportBody {
+    code: string;
+    comment?: string;
+    args?: string[];
+    escalate_to?: string;
+}
+export declare class ProblemReportMessage {
+    code: string;
+    comment?: string;
+    args?: string[];
+    escalate_to?: string;
+    presentProofMessage(code: string, comment?: string, args?: string[], escalate_to?: string): ProblemReportBody;
+}

package/dist/types/problem-report.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProblemReportMessage = void 0;
+var ProblemReportMessage = /** @class */ (function () {
+    function ProblemReportMessage() {
+    }
+    ProblemReportMessage.prototype.presentProofMessage = function (code, comment, args, escalate_to) {
+        return {
+            code: code,
+            comment: comment,
+            args: args,
+            escalate_to: escalate_to
+        };
+    };
+    return ProblemReportMessage;
+}());
+exports.ProblemReportMessage = ProblemReportMessage;
+//# sourceMappingURL=problem-report.js.map

package/dist/types/problem-report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"problem-report.js","sourceRoot":"","sources":["../../src/types/problem-report.ts"],"names":[],"mappings":";;;AAUA;IAAA;IAkBA,CAAC;IAVG,kDAAmB,GAAnB,UAAoB,IAAY,EAAE,OAAe,EAAE,IAAe,EAAE,WAAoB;QACpF,OAAO;YACH,IAAI,EAAE,IAAI;YACV,OAAO,EAAE,OAAO;YAChB,IAAI,EAAE,IAAI;YACV,WAAW,EAAE,WAAW;SAC3B,CAAA;IACL,CAAC;IAGL,2BAAC;AAAD,CAAC,AAlBD,IAkBC;AAlBY,oDAAoB"}