@verii/vnf-nodejs-wallet-sdk 1.0.0-pre.1752076816

package/dist/impl/data/repositories/VerifiedProfileRepositoryImpl.js

@@ -0,0 +1,70 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VCLVerifiedProfile_1 = __importDefault(require("../../../api/entities/VCLVerifiedProfile"));
+const Urls_1 = __importStar(require("./Urls"));
+const HttpMethod_1 = require("../infrastructure/network/HttpMethod");
+class VerifiedProfileRepositoryImpl {
+    constructor(networkService) {
+        this.networkService = networkService;
+    }
+    getVerifiedProfile(verifiedProfileDescriptor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const verifiedProfileResponse = yield this.networkService.sendRequest({
+                method: HttpMethod_1.HttpMethod.GET,
+                endpoint: Urls_1.default.VerifiedProfile.replace(Urls_1.Params.Did, verifiedProfileDescriptor.did),
+                body: null,
+                headers: {
+                    [Urls_1.HeaderKeys.XVnfProtocolVersion]: Urls_1.HeaderValues.XVnfProtocolVersion,
+                },
+            });
+            return new VCLVerifiedProfile_1.default(verifiedProfileResponse.payload);
+        });
+    }
+}
+exports.default = VerifiedProfileRepositoryImpl;
+//# sourceMappingURL=VerifiedProfileRepositoryImpl.js.map

package/dist/impl/data/repositories/VerifiedProfileRepositoryImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VerifiedProfileRepositoryImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/repositories/VerifiedProfileRepositoryImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,kGAA0E;AAI1E,+CAAgE;AAChE,qEAAkE;AAElE,MAAqB,6BAA6B;IAG9C,YAA6B,cAA8B;QAA9B,mBAAc,GAAd,cAAc,CAAgB;IAAG,CAAC;IAEzD,kBAAkB,CACpB,yBAAuD;;YAEvD,MAAM,uBAAuB,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC;gBAClE,MAAM,EAAE,uBAAU,CAAC,GAAG;gBACtB,QAAQ,EAAE,cAAI,CAAC,eAAe,CAAC,OAAO,CAClC,aAAM,CAAC,GAAG,EACV,yBAAyB,CAAC,GAAG,CAChC;gBACD,IAAI,EAAE,IAAI;gBACV,OAAO,EAAE;oBACL,CAAC,iBAAU,CAAC,mBAAmB,CAAC,EAC5B,mBAAY,CAAC,mBAAmB;iBACvC;aACJ,CAAC,CAAC;YACH,OAAO,IAAI,4BAAkB,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;QACnE,CAAC;KAAA;CACJ;AAtBD,gDAsBC"}

package/dist/impl/data/usecases/AuthTokenUseCaseImpl.d.ts

@@ -0,0 +1,9 @@
+import VCLAuthToken from '../../../api/entities/VCLAuthToken';
+import VCLAuthTokenDescriptor from '../../../api/entities/VCLAuthTokenDescriptor';
+import AuthTokenUseCase from '../../domain/usecases/AuthTokenUseCase';
+import AuthTokenRepository from '../../domain/repositories/AuthTokenRepository';
+export default class AuthTokenUseCaseImpl implements AuthTokenUseCase {
+    private readonly authTokenRepository;
+    constructor(authTokenRepository: AuthTokenRepository);
+    getAuthToken(authTokenDescriptor: VCLAuthTokenDescriptor): Promise<VCLAuthToken>;
+}

package/dist/impl/data/usecases/AuthTokenUseCaseImpl.js

@@ -0,0 +1,32 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VCLError_1 = __importDefault(require("../../../api/entities/error/VCLError"));
+class AuthTokenUseCaseImpl {
+    constructor(authTokenRepository) {
+        this.authTokenRepository = authTokenRepository;
+    }
+    getAuthToken(authTokenDescriptor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.authTokenRepository.getAuthToken(authTokenDescriptor);
+            }
+            catch (error) {
+                throw VCLError_1.default.fromError(error);
+            }
+        });
+    }
+}
+exports.default = AuthTokenUseCaseImpl;
+//# sourceMappingURL=AuthTokenUseCaseImpl.js.map

package/dist/impl/data/usecases/AuthTokenUseCaseImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthTokenUseCaseImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/usecases/AuthTokenUseCaseImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AASA,oFAA4D;AAG5D,MAAqB,oBAAoB;IACrC,YAA6B,mBAAwC;QAAxC,wBAAmB,GAAnB,mBAAmB,CAAqB;IAAG,CAAC;IAEnE,YAAY,CACd,mBAA2C;;YAE3C,IAAI,CAAC;gBACD,OAAO,MAAM,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAC9C,mBAAmB,CACtB,CAAC;YACN,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBAClB,MAAM,kBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;KAAA;CACJ;AAdD,uCAcC"}

package/dist/impl/data/usecases/CountriesModelUseCaseImpl.d.ts

@@ -0,0 +1,8 @@
+import VCLCountries from '../../../api/entities/VCLCountries';
+import CountriesRepository from '../../domain/repositories/CountriesRepository';
+import CountriesUseCase from '../../domain/usecases/CountriesModelUseCase';
+export default class CountriesUseCaseImpl implements CountriesUseCase {
+    private readonly countriesRepository;
+    constructor(countriesRepository: CountriesRepository);
+    getCountries(): Promise<VCLCountries>;
+}

package/dist/impl/data/usecases/CountriesModelUseCaseImpl.js

@@ -0,0 +1,32 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VCLError_1 = __importDefault(require("../../../api/entities/error/VCLError"));
+class CountriesUseCaseImpl {
+    constructor(countriesRepository) {
+        this.countriesRepository = countriesRepository;
+    }
+    getCountries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.countriesRepository.getCountries();
+            }
+            catch (error) {
+                throw VCLError_1.default.fromError(error);
+            }
+        });
+    }
+}
+exports.default = CountriesUseCaseImpl;
+//# sourceMappingURL=CountriesModelUseCaseImpl.js.map

package/dist/impl/data/usecases/CountriesModelUseCaseImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CountriesModelUseCaseImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/usecases/CountriesModelUseCaseImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAGA,oFAA4D;AAE5D,MAAqB,oBAAoB;IACrC,YAA6B,mBAAwC;QAAxC,wBAAmB,GAAnB,mBAAmB,CAAqB;IAAG,CAAC;IAEnE,YAAY;;YACd,IAAI,CAAC;gBACD,OAAO,MAAM,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC;YACzD,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBAClB,MAAM,kBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;KAAA;CACJ;AAVD,uCAUC"}

package/dist/impl/data/usecases/CredentialManifestUseCaseImpl.d.ts

@@ -0,0 +1,23 @@
+import VCLCredentialManifest from '../../../api/entities/VCLCredentialManifest';
+import VCLCredentialManifestDescriptor from '../../../api/entities/VCLCredentialManifestDescriptor';
+import VCLPublicJwk from '../../../api/entities/VCLPublicJwk';
+import CredentialManifestRepository from '../../domain/repositories/CredentialManifestRepository';
+import JwtServiceRepository from '../../domain/repositories/JwtServiceRepository';
+import CredentialManifestUseCase from '../../domain/usecases/CredentialManifestUseCase';
+import VCLVerifiedProfile from '../../../api/entities/VCLVerifiedProfile';
+import CredentialManifestByDeepLinkVerifier from '../../domain/verifiers/CredentialManifestByDeepLinkVerifier';
+import VCLDidDocument from '../../../api/entities/VCLDidDocument';
+import ResolveDidDocumentRepository from '../../domain/repositories/ResolveDidDocumentRepository';
+import VCLDeepLink from '../../../api/entities/VCLDeepLink';
+import { Nullish } from '../../../api/VCLTypes';
+export default class CredentialManifestUseCaseImpl implements CredentialManifestUseCase {
+    private readonly credentialManifestRepository;
+    private readonly resolveDidDocumentRepository;
+    private readonly jwtServiceRepository;
+    private readonly credentialManifestByDeepLinkVerifier;
+    constructor(credentialManifestRepository: CredentialManifestRepository, resolveDidDocumentRepository: ResolveDidDocumentRepository, jwtServiceRepository: JwtServiceRepository, credentialManifestByDeepLinkVerifier: CredentialManifestByDeepLinkVerifier);
+    getCredentialManifest(credentialManifestDescriptor: VCLCredentialManifestDescriptor, verifiedProfile: VCLVerifiedProfile): Promise<VCLCredentialManifest>;
+    verifyCredentialManifestJwt(publicJwk: VCLPublicJwk, credentialManifest: VCLCredentialManifest, didDocument: VCLDidDocument): Promise<VCLCredentialManifest>;
+    verifyCredentialManifestByDeepLink(credentialManifest: VCLCredentialManifest, didDocument: VCLDidDocument, deepLink?: Nullish<VCLDeepLink>): Promise<VCLCredentialManifest>;
+    onVerificationSuccess(isVerified: boolean, credentialManifest: VCLCredentialManifest): Promise<VCLCredentialManifest>;
+}

package/dist/impl/data/usecases/CredentialManifestUseCaseImpl.js

@@ -0,0 +1,71 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VCLCredentialManifest_1 = __importDefault(require("../../../api/entities/VCLCredentialManifest"));
+const VCLError_1 = __importDefault(require("../../../api/entities/error/VCLError"));
+const VCLJwt_1 = __importDefault(require("../../../api/entities/VCLJwt"));
+const VCLLog_1 = __importDefault(require("../../utils/VCLLog"));
+class CredentialManifestUseCaseImpl {
+    constructor(credentialManifestRepository, resolveDidDocumentRepository, jwtServiceRepository, credentialManifestByDeepLinkVerifier) {
+        this.credentialManifestRepository = credentialManifestRepository;
+        this.resolveDidDocumentRepository = resolveDidDocumentRepository;
+        this.jwtServiceRepository = jwtServiceRepository;
+        this.credentialManifestByDeepLinkVerifier = credentialManifestByDeepLinkVerifier;
+    }
+    getCredentialManifest(credentialManifestDescriptor, verifiedProfile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const jwtStr = yield this.credentialManifestRepository.getCredentialManifest(credentialManifestDescriptor);
+            if (jwtStr) {
+                const credentialManifest = new VCLCredentialManifest_1.default(VCLJwt_1.default.fromEncodedJwt(jwtStr), credentialManifestDescriptor.vendorOriginContext, verifiedProfile, credentialManifestDescriptor.deepLink, credentialManifestDescriptor.didJwk, credentialManifestDescriptor.remoteCryptoServicesToken);
+                const didDocument = yield this.resolveDidDocumentRepository.resolveDidDocument(credentialManifest.iss);
+                const { kid } = credentialManifest.jwt;
+                if (kid === null) {
+                    throw new VCLError_1.default(`Empty credentialManifest.jwt.kid in jwt: ${credentialManifest.jwt}`);
+                }
+                const publicJwk = didDocument.getPublicJwk(kid);
+                if (publicJwk === null) {
+                    throw new VCLError_1.default(`public jwk not found for kid: ${kid}`);
+                }
+                return this.verifyCredentialManifestJwt(publicJwk, credentialManifest, didDocument);
+            }
+            throw new VCLError_1.default('Empty jwtStr');
+        });
+    }
+    verifyCredentialManifestJwt(publicJwk, credentialManifest, didDocument) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.jwtServiceRepository.verifyJwt(credentialManifest.jwt, publicJwk, credentialManifest.remoteCryptoServicesToken);
+            return this.verifyCredentialManifestByDeepLink(credentialManifest, didDocument, credentialManifest.deepLink);
+        });
+    }
+    verifyCredentialManifestByDeepLink(credentialManifest, didDocument, deepLink) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (credentialManifest.deepLink === null) {
+                VCLLog_1.default.info('Deep link was not provided => nothing to verify');
+                return credentialManifest;
+            }
+            const isVerified = yield this.credentialManifestByDeepLinkVerifier.verifyCredentialManifest(credentialManifest, deepLink, didDocument);
+            return this.onVerificationSuccess(isVerified, credentialManifest);
+        });
+    }
+    onVerificationSuccess(isVerified, credentialManifest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isVerified) {
+                return credentialManifest;
+            }
+            throw new VCLError_1.default(`Failed to verify credentialManifest jwt:\n${credentialManifest.jwt}`);
+        });
+    }
+}
+exports.default = CredentialManifestUseCaseImpl;
+//# sourceMappingURL=CredentialManifestUseCaseImpl.js.map

package/dist/impl/data/usecases/CredentialManifestUseCaseImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredentialManifestUseCaseImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/usecases/CredentialManifestUseCaseImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,wGAAgF;AAEhF,oFAA4D;AAE5D,0EAAkD;AAMlD,gEAAwC;AAMxC,MAAqB,6BAA6B;IAG9C,YACqB,4BAA0D,EAC1D,4BAA0D,EAC1D,oBAA0C,EAC1C,oCAA0E;QAH1E,iCAA4B,GAA5B,4BAA4B,CAA8B;QAC1D,iCAA4B,GAA5B,4BAA4B,CAA8B;QAC1D,yBAAoB,GAApB,oBAAoB,CAAsB;QAC1C,yCAAoC,GAApC,oCAAoC,CAAsC;IAC5F,CAAC;IAEE,qBAAqB,CACvB,4BAA6D,EAC7D,eAAmC;;YAEnC,MAAM,MAAM,GACR,MAAM,IAAI,CAAC,4BAA4B,CAAC,qBAAqB,CACzD,4BAA4B,CAC/B,CAAC;YACN,IAAI,MAAM,EAAE,CAAC;gBACT,MAAM,kBAAkB,GAAG,IAAI,+BAAqB,CAChD,gBAAM,CAAC,cAAc,CAAC,MAAO,CAAC,EAC9B,4BAA4B,CAAC,mBAAmB,EAChD,eAAe,EACf,4BAA4B,CAAC,QAAQ,EACrC,4BAA4B,CAAC,MAAM,EACnC,4BAA4B,CAAC,yBAAyB,CACzD,CAAC;gBACF,MAAM,WAAW,GACb,MAAM,IAAI,CAAC,4BAA4B,CAAC,kBAAkB,CACtD,kBAAkB,CAAC,GAAG,CACzB,CAAC;gBACN,MAAM,EAAE,GAAG,EAAE,GAAG,kBAAkB,CAAC,GAAG,CAAC;gBACvC,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;oBACf,MAAM,IAAI,kBAAQ,CACd,4CAA4C,kBAAkB,CAAC,GAAG,EAAE,CACvE,CAAC;gBACN,CAAC;gBACD,MAAM,SAAS,GAAG,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;gBAChD,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;oBACrB,MAAM,IAAI,kBAAQ,CAAC,iCAAiC,GAAG,EAAE,CAAC,CAAC;gBAC/D,CAAC;gBACD,OAAO,IAAI,CAAC,2BAA2B,CACnC,SAAS,EACT,kBAAkB,EAClB,WAAW,CACd,CAAC;YACN,CAAC;YACD,MAAM,IAAI,kBAAQ,CAAC,cAAc,CAAC,CAAC;QACvC,CAAC;KAAA;IAEK,2BAA2B,CAC7B,SAAuB,EACvB,kBAAyC,EACzC,WAA2B;;YAE3B,MAAM,IAAI,CAAC,oBAAoB,CAAC,SAAS,CACrC,kBAAkB,CAAC,GAAG,EACtB,SAAS,EACT,kBAAkB,CAAC,yBAAyB,CAC/C,CAAC;YACF,OAAO,IAAI,CAAC,kCAAkC,CAC1C,kBAAkB,EAClB,WAAW,EACX,kBAAkB,CAAC,QAAQ,CAC9B,CAAC;QACN,CAAC;KAAA;IAEK,kCAAkC,CACpC,kBAAyC,EACzC,WAA2B,EAC3B,QAA+B;;YAE/B,IAAI,kBAAkB,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;gBACvC,gBAAM,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;gBAC/D,OAAO,kBAAkB,CAAC;YAC9B,CAAC;YACD,MAAM,UAAU,GACZ,MAAM,IAAI,CAAC,oCAAoC,CAAC,wBAAwB,CACpE,kBAAkB,EAClB,QAAS,EACT,WAAW,CACd,CAAC;YACN,OAAO,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC;QACtE,CAAC;KAAA;IAEK,qBAAqB,CACvB,UAAmB,EACnB,kBAAyC;;YAEzC,IAAI,UAAU,EAAE,CAAC;gBACb,OAAO,kBAAkB,CAAC;YAC9B,CAAC;YACD,MAAM,IAAI,kBAAQ,CACd,6CAA6C,kBAAkB,CAAC,GAAG,EAAE,CACxE,CAAC;QACN,CAAC;KAAA;CACJ;AAhGD,gDAgGC"}

package/dist/impl/data/usecases/CredentialTypeSchemasUseCaseImpl.d.ts

@@ -0,0 +1,10 @@
+import VCLCredentialTypeSchemas from '../../../api/entities/VCLCredentialTypeSchemas';
+import VCLCredentialTypes from '../../../api/entities/VCLCredentialTypes';
+import CredentialTypeSchemaRepository from '../../domain/repositories/CredentialTypeSchemaRepository';
+import CredentialTypeSchemasUseCase from '../../domain/usecases/CredentialTypeSchemasUseCase';
+export default class CredentialTypeSchemasUseCaseImpl implements CredentialTypeSchemasUseCase {
+    private readonly credentialTypeSchemaRepository;
+    private readonly credentialTypes;
+    constructor(credentialTypeSchemaRepository: CredentialTypeSchemaRepository, credentialTypes: VCLCredentialTypes);
+    getCredentialTypeSchemas(): Promise<VCLCredentialTypeSchemas>;
+}

package/dist/impl/data/usecases/CredentialTypeSchemasUseCaseImpl.js

@@ -0,0 +1,51 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VCLCredentialTypeSchemas_1 = __importDefault(require("../../../api/entities/VCLCredentialTypeSchemas"));
+const VCLError_1 = __importDefault(require("../../../api/entities/error/VCLError"));
+const VCLLog_1 = __importDefault(require("../../utils/VCLLog"));
+class CredentialTypeSchemasUseCaseImpl {
+    constructor(credentialTypeSchemaRepository, credentialTypes) {
+        this.credentialTypeSchemaRepository = credentialTypeSchemaRepository;
+        this.credentialTypes = credentialTypes;
+    }
+    getCredentialTypeSchemas() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const credentialTypeSchemasMap = {};
+                const schemaNamesArr = (_b = (_a = this.credentialTypes.all) === null || _a === void 0 ? void 0 : _a.filter((it) => {
+                    return it.schemaName != null;
+                }).map((it) => {
+                    return it.schemaName;
+                })) !== null && _b !== void 0 ? _b : [];
+                for (const schemaName of schemaNamesArr) {
+                    try {
+                        credentialTypeSchemasMap[schemaName] =
+                            yield this.credentialTypeSchemaRepository.getCredentialTypeSchema(schemaName);
+                    }
+                    catch (error) {
+                        VCLLog_1.default.error(error, `Error fetching schema for ${schemaName}`);
+                    }
+                }
+                return new VCLCredentialTypeSchemas_1.default(credentialTypeSchemasMap);
+            }
+            catch (error) {
+                throw VCLError_1.default.fromError(error);
+            }
+        });
+    }
+}
+exports.default = CredentialTypeSchemasUseCaseImpl;
+//# sourceMappingURL=CredentialTypeSchemasUseCaseImpl.js.map

package/dist/impl/data/usecases/CredentialTypeSchemasUseCaseImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredentialTypeSchemasUseCaseImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/usecases/CredentialTypeSchemasUseCaseImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAEA,8GAAsF;AAItF,oFAA4D;AAC5D,gEAAwC;AAExC,MAAqB,gCAAgC;IAGjD,YACqB,8BAA8D,EAC9D,eAAmC;QADnC,mCAA8B,GAA9B,8BAA8B,CAAgC;QAC9D,oBAAe,GAAf,eAAe,CAAoB;IACrD,CAAC;IAEE,wBAAwB;;;YAC1B,IAAI,CAAC;gBACD,MAAM,wBAAwB,GAE1B,EAAE,CAAC;gBAEP,MAAM,cAAc,GAChB,MAAA,MAAA,IAAI,CAAC,eAAe,CAAC,GAAG,0CAClB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE;oBACZ,OAAO,EAAE,CAAC,UAAU,IAAI,IAAI,CAAC;gBACjC,CAAC,EACA,GAAG,CAAS,CAAC,EAAqB,EAAE,EAAE;oBACnC,OAAO,EAAE,CAAC,UAAW,CAAC;gBAC1B,CAAC,CAAC,mCAAI,EAAE,CAAC;gBAEjB,KAAK,MAAM,UAAU,IAAI,cAAc,EAAE,CAAC;oBAEtC,IAAI,CAAC;wBACD,wBAAwB,CAAC,UAAU,CAAC;4BAEhC,MAAM,IAAI,CAAC,8BAA8B,CAAC,uBAAuB,CAC7D,UAAU,CACb,CAAC;oBACV,CAAC;oBAAC,OAAO,KAAU,EAAE,CAAC;wBAClB,gBAAM,CAAC,KAAK,CACR,KAAK,EACL,6BAA6B,UAAU,EAAE,CAC5C,CAAC;oBACN,CAAC;gBACL,CAAC;gBACD,OAAO,IAAI,kCAAwB,CAAC,wBAAwB,CAAC,CAAC;YAClE,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBAClB,MAAM,kBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;KAAA;CACJ;AA3CD,mDA2CC"}

package/dist/impl/data/usecases/CredentialTypesUIFormSchemaUseCaseImpl.d.ts

@@ -0,0 +1,10 @@
+import VCLCountries from '../../../api/entities/VCLCountries';
+import VCLCredentialTypesUIFormSchema from '../../../api/entities/VCLCredentialTypesUIFormSchema';
+import VCLCredentialTypesUIFormSchemaDescriptor from '../../../api/entities/VCLCredentialTypesUIFormSchemaDescriptor';
+import CredentialTypesUIFormSchemaRepository from '../../domain/repositories/CredentialTypesUIFormSchemaRepository';
+import CredentialTypesUIFormSchemaUseCase from '../../domain/usecases/CredentialTypesUIFormSchemaUseCase';
+export default class CredentialTypesUIFormSchemaUseCaseImpl implements CredentialTypesUIFormSchemaUseCase {
+    private readonly credentialTypesUIFormSchemaRepository;
+    constructor(credentialTypesUIFormSchemaRepository: CredentialTypesUIFormSchemaRepository);
+    getCredentialTypesUIFormSchema(credentialTypesUIFormSchemaDescriptor: VCLCredentialTypesUIFormSchemaDescriptor, countries: VCLCountries): Promise<VCLCredentialTypesUIFormSchema>;
+}

package/dist/impl/data/usecases/CredentialTypesUIFormSchemaUseCaseImpl.js

@@ -0,0 +1,32 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VCLError_1 = __importDefault(require("../../../api/entities/error/VCLError"));
+class CredentialTypesUIFormSchemaUseCaseImpl {
+    constructor(credentialTypesUIFormSchemaRepository) {
+        this.credentialTypesUIFormSchemaRepository = credentialTypesUIFormSchemaRepository;
+    }
+    getCredentialTypesUIFormSchema(credentialTypesUIFormSchemaDescriptor, countries) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.credentialTypesUIFormSchemaRepository.getCredentialTypesUIFormSchema(credentialTypesUIFormSchemaDescriptor, countries);
+            }
+            catch (error) {
+                throw VCLError_1.default.fromError(error);
+            }
+        });
+    }
+}
+exports.default = CredentialTypesUIFormSchemaUseCaseImpl;
+//# sourceMappingURL=CredentialTypesUIFormSchemaUseCaseImpl.js.map

package/dist/impl/data/usecases/CredentialTypesUIFormSchemaUseCaseImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredentialTypesUIFormSchemaUseCaseImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/usecases/CredentialTypesUIFormSchemaUseCaseImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAKA,oFAA4D;AAE5D,MAAqB,sCAAsC;IAGvD,YACqB,qCAA4E;QAA5E,0CAAqC,GAArC,qCAAqC,CAAuC;IAC9F,CAAC;IAEE,8BAA8B,CAChC,qCAA+E,EAC/E,SAAuB;;YAEvB,IAAI,CAAC;gBACD,OAAO,MAAM,IAAI,CAAC,qCAAqC,CAAC,8BAA8B,CAClF,qCAAqC,EACrC,SAAS,CACZ,CAAC;YACN,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBAClB,MAAM,kBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;KAAA;CACJ;AApBD,yDAoBC"}

package/dist/impl/data/usecases/CredentialTypesUseCaseImpl.d.ts

@@ -0,0 +1,8 @@
+import VCLCredentialTypes from '../../../api/entities/VCLCredentialTypes';
+import CredentialTypesRepository from '../../domain/repositories/CredentialTypesRepository';
+import { CredentialTypesUseCase } from '../../domain/usecases/CredentialTypesUseCase';
+export default class CredentialTypesUseCaseImpl implements CredentialTypesUseCase {
+    private readonly credentialTypes;
+    constructor(credentialTypes: CredentialTypesRepository);
+    getCredentialTypes(): Promise<VCLCredentialTypes>;
+}

package/dist/impl/data/usecases/CredentialTypesUseCaseImpl.js

@@ -0,0 +1,32 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VCLError_1 = __importDefault(require("../../../api/entities/error/VCLError"));
+class CredentialTypesUseCaseImpl {
+    constructor(credentialTypes) {
+        this.credentialTypes = credentialTypes;
+    }
+    getCredentialTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.credentialTypes.getCredentialTypes();
+            }
+            catch (error) {
+                throw VCLError_1.default.fromError(error);
+            }
+        });
+    }
+}
+exports.default = CredentialTypesUseCaseImpl;
+//# sourceMappingURL=CredentialTypesUseCaseImpl.js.map

package/dist/impl/data/usecases/CredentialTypesUseCaseImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredentialTypesUseCaseImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/usecases/CredentialTypesUseCaseImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAGA,oFAA4D;AAE5D,MAAqB,0BAA0B;IAG3C,YAA6B,eAA0C;QAA1C,oBAAe,GAAf,eAAe,CAA2B;IAAG,CAAC;IAErE,kBAAkB;;YACpB,IAAI,CAAC;gBACD,OAAO,MAAM,IAAI,CAAC,eAAe,CAAC,kBAAkB,EAAE,CAAC;YAC3D,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBAClB,MAAM,kBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;KAAA;CACJ;AAZD,6CAYC"}

package/dist/impl/data/usecases/ExchangeProgressUseCaseImpl.d.ts

@@ -0,0 +1,9 @@
+import VCLExchange from '../../../api/entities/VCLExchange';
+import VCLExchangeDescriptor from '../../../api/entities/VCLExchangeDescriptor';
+import ExchangeProgressRepository from '../../domain/repositories/ExchangeProgressRepository';
+import ExchangeProgressUseCase from '../../domain/usecases/ExchangeProgressUseCase';
+export default class ExchangeProgressUseCaseImpl implements ExchangeProgressUseCase {
+    private exchangeProgressRepository;
+    constructor(exchangeProgressRepository: ExchangeProgressRepository);
+    getExchangeProgress(exchangeDescriptor: VCLExchangeDescriptor): Promise<VCLExchange>;
+}

package/dist/impl/data/usecases/ExchangeProgressUseCaseImpl.js

@@ -0,0 +1,32 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VCLError_1 = __importDefault(require("../../../api/entities/error/VCLError"));
+class ExchangeProgressUseCaseImpl {
+    constructor(exchangeProgressRepository) {
+        this.exchangeProgressRepository = exchangeProgressRepository;
+    }
+    getExchangeProgress(exchangeDescriptor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.exchangeProgressRepository.getExchangeProgress(exchangeDescriptor);
+            }
+            catch (error) {
+                throw VCLError_1.default.fromError(error);
+            }
+        });
+    }
+}
+exports.default = ExchangeProgressUseCaseImpl;
+//# sourceMappingURL=ExchangeProgressUseCaseImpl.js.map

package/dist/impl/data/usecases/ExchangeProgressUseCaseImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExchangeProgressUseCaseImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/usecases/ExchangeProgressUseCaseImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAIA,oFAA4D;AAE5D,MAAqB,2BAA2B;IAG5C,YACY,0BAAsD;QAAtD,+BAA0B,GAA1B,0BAA0B,CAA4B;IAC/D,CAAC;IAEE,mBAAmB,CACrB,kBAAyC;;YAEzC,IAAI,CAAC;gBACD,OAAO,MAAM,IAAI,CAAC,0BAA0B,CAAC,mBAAmB,CAC5D,kBAAkB,CACrB,CAAC;YACN,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBAClB,MAAM,kBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;KAAA;CACJ;AAlBD,8CAkBC"}

package/dist/impl/data/usecases/FinalizeOffersUseCaseImpl.d.ts

@@ -0,0 +1,24 @@
+import VCLFinalizeOffersDescriptor from '../../../api/entities/VCLFinalizeOffersDescriptor';
+import VCLJwt from '../../../api/entities/VCLJwt';
+import VCLJwtVerifiableCredentials from '../../../api/entities/VCLJwtVerifiableCredentials';
+import VCLToken from '../../../api/entities/VCLToken';
+import FinalizeOffersRepository from '../../domain/repositories/FinalizeOffersRepository';
+import JwtServiceRepository from '../../domain/repositories/JwtServiceRepository';
+import FinalizeOffersUseCase from '../../domain/usecases/FinalizeOffersUseCase';
+import CredentialDidVerifier from '../../domain/verifiers/CredentialDidVerifier';
+import CredentialsByDeepLinkVerifier from '../../domain/verifiers/CredentialsByDeepLinkVerifier';
+import CredentialIssuerVerifier from '../../domain/verifiers/CredentialIssuerVerifier';
+import { Nullish } from '../../../api/VCLTypes';
+export default class FinalizeOffersUseCaseImpl implements FinalizeOffersUseCase {
+    private finalizeOffersRepository;
+    private jwtServiceRepository;
+    private credentialIssuerVerifier;
+    private credentialDidVerifier;
+    private credentialsByDeepLinkVerifier;
+    constructor(finalizeOffersRepository: FinalizeOffersRepository, jwtServiceRepository: JwtServiceRepository, credentialIssuerVerifier: CredentialIssuerVerifier, credentialDidVerifier: CredentialDidVerifier, credentialsByDeepLinkVerifier: CredentialsByDeepLinkVerifier);
+    finalizeOffers(finalizeOffersDescriptor: VCLFinalizeOffersDescriptor, sessionToken: VCLToken): Promise<VCLJwtVerifiableCredentials>;
+    finalizeOffersInvoke(finalizeOffersDescriptor: VCLFinalizeOffersDescriptor, sessionToken: VCLToken, proof?: Nullish<VCLJwt>): Promise<VCLJwtVerifiableCredentials>;
+    verifyCredentialsByDeepLink(jwtCredentials: VCLJwt[], finalizeOffersDescriptor: VCLFinalizeOffersDescriptor): Promise<boolean>;
+    verifyCredentialsByIssuer(jwtCredentials: VCLJwt[], finalizeOffersDescriptor: VCLFinalizeOffersDescriptor): Promise<boolean>;
+    verifyCredentialByDid(encodedJwtCredentialsList: VCLJwt[], finalizeOffersDescriptor: VCLFinalizeOffersDescriptor): Promise<VCLJwtVerifiableCredentials>;
+}

package/dist/impl/data/usecases/FinalizeOffersUseCaseImpl.js

@@ -0,0 +1,72 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const VCLError_1 = __importDefault(require("../../../api/entities/error/VCLError"));
+const VCLJwtDescriptor_1 = __importDefault(require("../../../api/entities/VCLJwtDescriptor"));
+class FinalizeOffersUseCaseImpl {
+    constructor(finalizeOffersRepository, jwtServiceRepository, credentialIssuerVerifier, credentialDidVerifier, credentialsByDeepLinkVerifier) {
+        this.finalizeOffersRepository = finalizeOffersRepository;
+        this.jwtServiceRepository = jwtServiceRepository;
+        this.credentialIssuerVerifier = credentialIssuerVerifier;
+        this.credentialDidVerifier = credentialDidVerifier;
+        this.credentialsByDeepLinkVerifier = credentialsByDeepLinkVerifier;
+    }
+    finalizeOffers(finalizeOffersDescriptor, sessionToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (finalizeOffersDescriptor.challenge) {
+                    const proof = yield this.jwtServiceRepository.generateSignedJwt(new VCLJwtDescriptor_1.default(null, (0, crypto_1.randomUUID)().toString(), finalizeOffersDescriptor.didJwk.did, finalizeOffersDescriptor.aud), finalizeOffersDescriptor.didJwk, finalizeOffersDescriptor.challenge, finalizeOffersDescriptor.remoteCryptoServicesToken);
+                    return yield this.finalizeOffersInvoke(finalizeOffersDescriptor, sessionToken, proof);
+                }
+                return yield this.finalizeOffersInvoke(finalizeOffersDescriptor, sessionToken);
+            }
+            catch (error) {
+                throw VCLError_1.default.fromError(error);
+            }
+        });
+    }
+    finalizeOffersInvoke(finalizeOffersDescriptor_1, sessionToken_1) {
+        return __awaiter(this, arguments, void 0, function* (finalizeOffersDescriptor, sessionToken, proof = null) {
+            const jwtCredentials = yield this.finalizeOffersRepository.finalizeOffers(finalizeOffersDescriptor, sessionToken, proof);
+            if (yield this.verifyCredentialsByDeepLink(jwtCredentials, finalizeOffersDescriptor)) {
+                if (yield this.verifyCredentialsByIssuer(jwtCredentials, finalizeOffersDescriptor)) {
+                    return this.verifyCredentialByDid(jwtCredentials, finalizeOffersDescriptor);
+                }
+            }
+            throw new VCLError_1.default('Credentials verification failed');
+        });
+    }
+    verifyCredentialsByDeepLink(jwtCredentials, finalizeOffersDescriptor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { deepLink } = finalizeOffersDescriptor.credentialManifest;
+            if (deepLink) {
+                return this.credentialsByDeepLinkVerifier.verifyCredentials(jwtCredentials, deepLink);
+            }
+            return true;
+        });
+    }
+    verifyCredentialsByIssuer(jwtCredentials, finalizeOffersDescriptor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.credentialIssuerVerifier.verifyCredentials(jwtCredentials, finalizeOffersDescriptor);
+        });
+    }
+    verifyCredentialByDid(encodedJwtCredentialsList, finalizeOffersDescriptor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.credentialDidVerifier.verifyCredentials(encodedJwtCredentialsList, finalizeOffersDescriptor);
+        });
+    }
+}
+exports.default = FinalizeOffersUseCaseImpl;
+//# sourceMappingURL=FinalizeOffersUseCaseImpl.js.map

package/dist/impl/data/usecases/FinalizeOffersUseCaseImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FinalizeOffersUseCaseImpl.js","sourceRoot":"","sources":["../../../../src/impl/data/usecases/FinalizeOffersUseCaseImpl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,mCAAoC;AAQpC,oFAA4D;AAI5D,8FAAsE;AAGtE,MAAqB,yBAAyB;IAG1C,YACY,wBAAkD,EAClD,oBAA0C,EAC1C,wBAAkD,EAClD,qBAA4C,EAC5C,6BAA4D;QAJ5D,6BAAwB,GAAxB,wBAAwB,CAA0B;QAClD,yBAAoB,GAApB,oBAAoB,CAAsB;QAC1C,6BAAwB,GAAxB,wBAAwB,CAA0B;QAClD,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,kCAA6B,GAA7B,6BAA6B,CAA+B;IACrE,CAAC;IAEE,cAAc,CAChB,wBAAqD,EACrD,YAAsB;;YAEtB,IAAI,CAAC;gBACD,IAAI,wBAAwB,CAAC,SAAS,EAAE,CAAC;oBACrC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAC3D,IAAI,0BAAgB,CAChB,IAAI,EACJ,IAAA,mBAAU,GAAE,CAAC,QAAQ,EAAE,EACvB,wBAAwB,CAAC,MAAM,CAAC,GAAG,EACnC,wBAAwB,CAAC,GAAG,CAC/B,EACD,wBAAwB,CAAC,MAAM,EAC/B,wBAAwB,CAAC,SAAS,EAClC,wBAAwB,CAAC,yBAAyB,CACrD,CAAC;oBACF,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAClC,wBAAwB,EACxB,YAAY,EACZ,KAAK,CACR,CAAC;gBACN,CAAC;gBACD,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAClC,wBAAwB,EACxB,YAAY,CACf,CAAC;YACN,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBAClB,MAAM,kBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;KAAA;IAEK,oBAAoB;6DACtB,wBAAqD,EACrD,YAAsB,EACtB,QAAyB,IAAI;YAE7B,MAAM,cAAc,GAChB,MAAM,IAAI,CAAC,wBAAwB,CAAC,cAAc,CAC9C,wBAAwB,EACxB,YAAY,EACZ,KAAK,CACR,CAAC;YACN,IACI,MAAM,IAAI,CAAC,2BAA2B,CAClC,cAAc,EACd,wBAAwB,CAC3B,EACH,CAAC;gBACC,IACI,MAAM,IAAI,CAAC,yBAAyB,CAChC,cAAc,EACd,wBAAwB,CAC3B,EACH,CAAC;oBACC,OAAO,IAAI,CAAC,qBAAqB,CAC7B,cAAc,EACd,wBAAwB,CAC3B,CAAC;gBACN,CAAC;YACL,CAAC;YACD,MAAM,IAAI,kBAAQ,CAAC,iCAAiC,CAAC,CAAC;QAC1D,CAAC;KAAA;IAEK,2BAA2B,CAC7B,cAAwB,EACxB,wBAAqD;;YAErD,MAAM,EAAE,QAAQ,EAAE,GAAG,wBAAwB,CAAC,kBAAkB,CAAC;YACjE,IAAI,QAAQ,EAAE,CAAC;gBACX,OAAO,IAAI,CAAC,6BAA6B,CAAC,iBAAiB,CACvD,cAAc,EACd,QAAQ,CACX,CAAC;YACN,CAAC;YAED,OAAO,IAAI,CAAC;QAChB,CAAC;KAAA;IAEK,yBAAyB,CAC3B,cAAwB,EACxB,wBAAqD;;YAErD,OAAO,IAAI,CAAC,wBAAwB,CAAC,iBAAiB,CAClD,cAAc,EACd,wBAAwB,CAC3B,CAAC;QACN,CAAC;KAAA;IAEK,qBAAqB,CACvB,yBAAmC,EACnC,wBAAqD;;YAErD,OAAO,IAAI,CAAC,qBAAqB,CAAC,iBAAiB,CAC/C,yBAAyB,EACzB,wBAAwB,CAC3B,CAAC;QACN,CAAC;KAAA;CACJ;AA7GD,4CA6GC"}

package/dist/impl/data/usecases/GenerateOffersUseCaseImpl.d.ts

@@ -0,0 +1,13 @@
+import VCLGenerateOffersDescriptor from '../../../api/entities/VCLGenerateOffersDescriptor';
+import VCLOffers from '../../../api/entities/VCLOffers';
+import VCLToken from '../../../api/entities/VCLToken';
+import GenerateOffersRepository from '../../domain/repositories/GenerateOffersRepository';
+import GenerateOffersUseCase from '../../domain/usecases/GenerateOffersUseCase';
+import OffersByDeepLinkVerifier from '../../domain/verifiers/OffersByDeepLinkVerifier';
+export default class GenerateOffersUseCaseImpl implements GenerateOffersUseCase {
+    private generateOffersRepository;
+    private offersByDeepLinkVerifier;
+    constructor(generateOffersRepository: GenerateOffersRepository, offersByDeepLinkVerifier: OffersByDeepLinkVerifier);
+    generateOffers(generateOffersDescriptor: VCLGenerateOffersDescriptor, sessionToken: VCLToken): Promise<VCLOffers>;
+    verifyOffersByDeepLink(offers: VCLOffers, generateOffersDescriptor: VCLGenerateOffersDescriptor): Promise<VCLOffers>;
+}