@procivis/react-native-one-core 1.26999.0 → 1.33398.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { NativeModules } from "react-native";
-import { OneError, OneErrorCode } from "./src/error";
+import { OneError } from "./src/error";
 export * from "./src/core";
 export * from "./src/error";
 const ONE = NativeModules.ProcivisOneCoreModule;
@@ -7,21 +7,13 @@ const ONE = NativeModules.ProcivisOneCoreModule;
 const originalGetConfig = ONE.getConfig;
 ONE.getConfig = () => originalGetConfig().then((config) => objectMap(config, (entities) => objectMap(entities, (json) => JSON.parse(json))));
 /**
- * Initialize ONE Core for Holder
+ * Initialize ONE Core
  * @note Beware that only one instance can be initialized at a time, repeated calls will fail
+ * @param config one-core configuration
  * @returns ONE Core instance
  */
-export async function initializeHolderCore() {
-    await wrapFn(ONE.initializeHolder, "initializeHolderCore")();
-    return wrapObj(ONE);
-}
-/**
- * Initialize ONE Core for Verifier
- * @note Beware that only one instance can be initialized at a time, repeated calls will fail
- * @returns ONE Core instance
- */
-export async function initializeVerifierCore() {
-    await wrapFn(ONE.initializeVerifier, "initializeVerifierCore")();
+export async function initializeCore(config = {}) {
+    await wrapFn(ONE.initialize, "initializeCore")(JSON.stringify(config));
     return wrapObj(ONE);
 }
 // UTILS
@@ -29,24 +21,32 @@ export async function initializeVerifierCore() {
 const objectMap = (obj, fn) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v)]));
 // Function call arguments/Error transformation
 // for devs: Beware to not declare function parameters as optional, otherwise automatic conversion to null will not be performed
-function wrapFn(fn, name) {
+function wrapFn(fn, operation) {
     return (...args) => {
-        const errHandler = (cause) => {
-            const code = (cause ?? {}).code;
-            if (Object.values(OneErrorCode).includes(code)) {
-                // throw a specific error to be able to handle it easily
+        const errHandler = (e) => {
+            if (e instanceof Error && "code" in e) {
+                const userInfo = "userInfo" in e && typeof e.userInfo === "object"
+                    ? e.userInfo
+                    : undefined;
+                const cause = userInfo && "cause" in userInfo && typeof userInfo.cause === "string"
+                    ? userInfo.cause
+                    : undefined;
                 throw new OneError({
-                    code,
+                    operation,
+                    code: e.code,
+                    message: e.message,
                     cause,
-                    message: cause?.message,
+                    originalError: e,
                 });
+                // iOS additional fields: "nativeStackIOS"
+                // android additional fields: "nativeStackAndroid"
             }
             else {
-                throw cause;
+                throw e;
             }
         };
         // set name on the err handler to display the original function name in callstack
-        Object.defineProperty(errHandler, "name", { value: name });
+        Object.defineProperty(errHandler, "name", { value: operation });
         // convert undefined parameters to null for proper parameter matching in native code
         return fn(...args.map((x) => (x === undefined ? null : x))).catch(errHandler);
     };

package/dist/src/cache.d.ts

@@ -0,0 +1,12 @@
+export declare enum CacheType {
+    DID_DOCUMENT = "DID_DOCUMENT",
+    JSON_LD_CONTEXT = "JSON_LD_CONTEXT",
+    STATUS_LIST_CREDENTIAL = "STATUS_LIST_CREDENTIAL",
+    VCT_METADATA = "VCT_METADATA",
+    JSON_SCHEMA = "JSON_SCHEMA",
+    TRUST_LIST = "TRUST_LIST"
+}
+export declare enum BypassCache {
+    DID_DOCUMENT = "DID_DOCUMENT",
+    STATUS_LIST_CREDENTIAL = "STATUS_LIST_CREDENTIAL"
+}

package/dist/src/cache.js

@@ -0,0 +1,14 @@
+export var CacheType;
+(function (CacheType) {
+    CacheType["DID_DOCUMENT"] = "DID_DOCUMENT";
+    CacheType["JSON_LD_CONTEXT"] = "JSON_LD_CONTEXT";
+    CacheType["STATUS_LIST_CREDENTIAL"] = "STATUS_LIST_CREDENTIAL";
+    CacheType["VCT_METADATA"] = "VCT_METADATA";
+    CacheType["JSON_SCHEMA"] = "JSON_SCHEMA";
+    CacheType["TRUST_LIST"] = "TRUST_LIST";
+})(CacheType || (CacheType = {}));
+export var BypassCache;
+(function (BypassCache) {
+    BypassCache["DID_DOCUMENT"] = "DID_DOCUMENT";
+    BypassCache["STATUS_LIST_CREDENTIAL"] = "STATUS_LIST_CREDENTIAL";
+})(BypassCache || (BypassCache = {}));

package/dist/src/config.d.ts

@@ -1,13 +1,29 @@
+export declare enum KeyAlgorithmFeatureEnum {
+    GENERATE_CSR = "GENERATE_CSR"
+}
+export interface KeyAlgorithmCapabilities {
+    features: KeyAlgorithmFeatureEnum[];
+}
 export declare enum KeyStorageSecurityEnum {
     HARDWARE = "HARDWARE",
     SOFTWARE = "SOFTWARE"
 }
+export declare enum KeyStorageFeatureEnum {
+    EXPORTABLE = "EXPORTABLE"
+}
 export interface KeyStorageCapabilities {
     algorithms: string[];
+    features: KeyStorageFeatureEnum[];
     security: KeyStorageSecurityEnum[];
 }
+export declare enum DidOperationEnum {
+    RESOLVE = "RESOLVE",
+    CREATE = "CREATE",
+    DEACTIVATE = "DEACTIVATE"
+}
 export interface DidCapabilities {
-    operations: string[];
+    operations: DidOperationEnum[];
+    keyAlgorithms: string[];
 }
 export declare enum FormatFeatureEnum {
     SelectiveDisclosure = "SELECTIVE_DISCLOSURE",
@@ -27,13 +43,21 @@ export interface FormatCapabilities {
     revocationMethods: string[];
     signingKeyAlgorithms: string[];
     verificationKeyAlgorithms: string[];
+    verificationKeyStorages: string[];
     datatypes: Array<DataTypeEnum | string>;
     allowedSchemaIds: string[];
     forbiddenClaimNames: string[];
 }
+export declare enum RevocationOperationEnum {
+    REVOKE = "REVOKE",
+    SUSPEND = "SUSPEND"
+}
+export interface RevocationCapabilities {
+    operations: RevocationOperationEnum[];
+}
 export interface ConfigEntity<Capabilities> {
     disabled?: boolean;
-    capabilities?: Capabilities;
+    capabilities: Capabilities;
     display: string;
     order: number;
 }
@@ -90,11 +114,12 @@ export interface Config {
     format: ConfigEntities<FormatCapabilities>;
     exchange: ConfigEntities;
     transport: ConfigEntities;
-    revocation: ConfigEntities;
+    revocation: ConfigEntities<RevocationCapabilities>;
     did: ConfigEntities<DidCapabilities>;
     datatype: ConfigEntities<undefined, DataTypeParams>;
-    keyAlgorithm: ConfigEntities;
+    keyAlgorithm: ConfigEntities<KeyAlgorithmCapabilities>;
     keyStorage: ConfigEntities<KeyStorageCapabilities>;
+    trustManagement: ConfigEntities;
     cacheEntities: ConfigEntities;
 }
 export {};

package/dist/src/config.js

@@ -1,8 +1,22 @@
+export var KeyAlgorithmFeatureEnum;
+(function (KeyAlgorithmFeatureEnum) {
+    KeyAlgorithmFeatureEnum["GENERATE_CSR"] = "GENERATE_CSR";
+})(KeyAlgorithmFeatureEnum || (KeyAlgorithmFeatureEnum = {}));
 export var KeyStorageSecurityEnum;
 (function (KeyStorageSecurityEnum) {
     KeyStorageSecurityEnum["HARDWARE"] = "HARDWARE";
     KeyStorageSecurityEnum["SOFTWARE"] = "SOFTWARE";
 })(KeyStorageSecurityEnum || (KeyStorageSecurityEnum = {}));
+export var KeyStorageFeatureEnum;
+(function (KeyStorageFeatureEnum) {
+    KeyStorageFeatureEnum["EXPORTABLE"] = "EXPORTABLE";
+})(KeyStorageFeatureEnum || (KeyStorageFeatureEnum = {}));
+export var DidOperationEnum;
+(function (DidOperationEnum) {
+    DidOperationEnum["RESOLVE"] = "RESOLVE";
+    DidOperationEnum["CREATE"] = "CREATE";
+    DidOperationEnum["DEACTIVATE"] = "DEACTIVATE";
+})(DidOperationEnum || (DidOperationEnum = {}));
 export var FormatFeatureEnum;
 (function (FormatFeatureEnum) {
     FormatFeatureEnum["SelectiveDisclosure"] = "SELECTIVE_DISCLOSURE";
@@ -14,6 +28,11 @@ export var FormatSelectiveDisclosureEnum;
     FormatSelectiveDisclosureEnum["AnyLevel"] = "ANY_LEVEL";
     FormatSelectiveDisclosureEnum["SecondLevel"] = "SECOND_LEVEL";
 })(FormatSelectiveDisclosureEnum || (FormatSelectiveDisclosureEnum = {}));
+export var RevocationOperationEnum;
+(function (RevocationOperationEnum) {
+    RevocationOperationEnum["REVOKE"] = "REVOKE";
+    RevocationOperationEnum["SUSPEND"] = "SUSPEND";
+})(RevocationOperationEnum || (RevocationOperationEnum = {}));
 export var DataTypeEnum;
 (function (DataTypeEnum) {
     DataTypeEnum["String"] = "STRING";

package/dist/src/core.d.ts

@@ -4,12 +4,14 @@ import { CredentialDetail, CredentialListItem, CredentialListQuery, CredentialRe
 import { CredentialSchema, CredentialSchemaDetail, CredentialSchemaListQuery, ImportCredentialSchemaRequest, ShareCredentialSchemaResponse } from "./credentialSchema";
 import { DidListItem, DidListQuery, DidRequest } from "./did";
 import { HistoryListItem, HistoryListQuery } from "./history";
-import { KeyRequest } from "./key";
+import { KeyCheckCertificateRequestBindingDto, KeyListItem, KeyRequest } from "./key";
 import { ItemList } from "./list";
-import { CreateProofRequest, InvitationResultProofRequest, PresentationDefinition, PresentationDefinitionRequestedCredential, PresentationSubmitCredentialRequest, ProofDetail, ProofListItem, ProofListQuery, ProposeProofResponse, ShareProofResponse } from "./proof";
+import { CreateProofRequest, InvitationResultProofRequest, PresentationDefinition, PresentationDefinitionRequestedCredential, PresentationSubmitCredentialRequest, ProofDetail, ProofListItem, ProofListQuery, ProposeProofResponse, ShareProofRequest, ShareProofResponse } from "./proof";
 import { CreateProofSchemaRequest, ImportProofSchemaRequest, ProofSchema, ProofSchemaListItem, ProofSchemaListQuery, ShareProofSchemaResponse } from "./proofSchema";
-import { CreateTrustAnchorRequest, TrustAnchor, TrustAnchorListItem, TrustAnchorListQuery } from "./trust";
+import { CreateRemoteTrustEntityRequest, CreateTrustAnchorRequest, CreateTrustEntityRequest, TrustAnchor, TrustAnchorListItem, TrustAnchorListQuery, TrustEntity, TrustEntityListItem, TrustEntityListQuery, UpdateRemoteTrustEntityRequest } from "./trust";
+import { BypassCache, CacheType } from "./cache";
 export * from "./backup";
+export * from "./cache";
 export * from "./config";
 export * from "./credential";
 export * from "./credentialSchema";
@@ -41,13 +43,14 @@ export interface ONECore {
     createDid(didRequest: DidRequest): Promise<string>;
     getDids(query: DidListQuery): Promise<ItemList<DidListItem>>;
     handleInvitation(url: string, organisationId: string, transport: string[] | undefined): Promise<InvitationResult>;
-    holderAcceptCredential(interactionId: InvitationResultCredentialIssuance["interactionId"], didId: string, keyId: string | undefined): Promise<void>;
+    holderAcceptCredential(interactionId: InvitationResultCredentialIssuance["interactionId"], didId: string, keyId: string | undefined, txCode: string | undefined): Promise<void>;
     holderRejectCredential(interactionId: InvitationResultCredentialIssuance["interactionId"]): Promise<void>;
     getPresentationDefinition(proofId: ProofDetail["id"]): Promise<PresentationDefinition>;
     holderRejectProof(interactionId: InvitationResultProofRequest["interactionId"]): Promise<void>;
     holderSubmitProof(interactionId: InvitationResultProofRequest["interactionId"], credentials: Record<PresentationDefinitionRequestedCredential["id"], PresentationSubmitCredentialRequest>, didId: string, keyId: string | undefined): Promise<void>;
     getCredentials(query: CredentialListQuery): Promise<ItemList<CredentialListItem>>;
     runTask(task: string): Promise<string>;
+    checkCertificate(keyId: KeyListItem["id"], certificate: KeyCheckCertificateRequestBindingDto): Promise<void>;
     deleteProofClaims(proofId: ProofDetail["id"]): Promise<void>;
     getCredential(credentialId: CredentialListItem["id"]): Promise<CredentialDetail>;
     deleteCredential(credentialId: CredentialListItem["id"]): Promise<void>;
@@ -56,7 +59,7 @@ export interface ONECore {
     getCredentialSchemas(query: CredentialSchemaListQuery): Promise<ItemList<CredentialSchema>>;
     deleteCredentialSchema(credentialSchemaId: CredentialSchema["id"]): Promise<void>;
     createProof(request: CreateProofRequest): Promise<ProofDetail["id"]>;
-    shareProof(proofId: ProofDetail["id"]): Promise<ShareProofResponse>;
+    shareProof(proofId: ProofDetail["id"], request: ShareProofRequest): Promise<ShareProofResponse>;
     shareProofSchema(proofSchemaId: ProofSchema["id"]): Promise<ShareProofSchemaResponse>;
     shareCredentialSchema(credentialSchemaId: CredentialSchema["id"]): Promise<ShareCredentialSchemaResponse>;
     getProof(proofId: ProofDetail["id"]): Promise<ProofDetail>;
@@ -68,14 +71,23 @@ export interface ONECore {
     getProofSchema(proofSchemaId: ProofSchema["id"]): Promise<ProofSchema>;
     deleteProofSchema(proofSchemaId: ProofSchema["id"]): Promise<void>;
     importProofSchema(request: ImportProofSchemaRequest): Promise<ProofSchema["id"]>;
-    checkRevocation(credentialIds: Array<CredentialListItem["id"]>): Promise<CredentialRevocationCheckResponse[]>;
+    checkRevocation(credentialIds: Array<CredentialListItem["id"]>, bypassCache: BypassCache[] | undefined): Promise<CredentialRevocationCheckResponse[]>;
     createTrustAnchor(request: CreateTrustAnchorRequest): Promise<TrustAnchor["id"]>;
+    deleteTrustAnchor(trustAnchorId: TrustAnchor["id"]): Promise<void>;
     getTrustAnchor(trustAnchorId: TrustAnchor["id"]): Promise<TrustAnchor>;
     getTrustAnchors(query: TrustAnchorListQuery): Promise<ItemList<TrustAnchorListItem>>;
+    createTrustEntity(request: CreateTrustEntityRequest): Promise<TrustEntity["id"]>;
+    getTrustEntity(trustEntityId: TrustEntity["id"]): Promise<TrustEntity>;
+    getTrustEntities(query: TrustEntityListQuery): Promise<ItemList<TrustEntityListItem>>;
+    getTrustEntityByDid(didId: DidListItem["id"]): Promise<TrustEntity>;
+    createRemoteTrustEntity(request: CreateRemoteTrustEntityRequest): Promise<TrustEntity["id"]>;
+    getRemoteTrustEntity(didId: DidListItem["id"]): Promise<TrustEntity>;
+    updateRemoteTrustEntity(request: UpdateRemoteTrustEntityRequest): Promise<void>;
     getHistory(query: HistoryListQuery): Promise<ItemList<HistoryListItem>>;
     getHistoryEntry(historyId: HistoryListItem["id"]): Promise<HistoryListItem>;
     createBackup(password: string, outputPath: string): Promise<BackupCreate>;
     backupInfo(): Promise<UnexportableEntities>;
+    deleteCache(types: CacheType[] | undefined): Promise<void>;
     /**
      * Start import procedure
      *

package/dist/src/core.js

@@ -1,4 +1,5 @@
 export * from "./backup";
+export * from "./cache";
 export * from "./config";
 export * from "./credential";
 export * from "./credentialSchema";

package/dist/src/credential.d.ts

@@ -1,6 +1,7 @@
 import { DataTypeEnum } from "./config";
 import { CredentialSchema } from "./credentialSchema";
 import { ListQuery, SortDirection } from "./list";
+import { DidListItem } from "./did";
 export declare enum CredentialStateEnum {
     CREATED = "CREATED",
     PENDING = "PENDING",
@@ -52,11 +53,13 @@ export interface CredentialListItem {
     role: CredentialRoleEnum;
     suspendEndDate?: string;
 }
-export interface CredentialDetail extends CredentialListItem {
+export interface CredentialDetail extends Omit<CredentialListItem, "issuerDid"> {
     claims: Claim[];
     redirectUri?: string;
     lvvcIssuanceDate?: string;
     mdocMsoValidity?: MdocMsoValidity;
+    issuerDid?: DidListItem;
+    holderDid?: DidListItem;
 }
 export interface MdocMsoValidity {
     expiration: string;
@@ -112,4 +115,14 @@ export interface CredentialRevocationCheckResponse {
 export interface InvitationResultCredentialIssuance {
     interactionId: string;
     credentialIds: Array<CredentialListItem["id"]>;
+    txCode?: OpenID4VCITxCode;
+}
+export interface OpenID4VCITxCode {
+    inputMode?: OpenID4VCITxCodeInputMode;
+    length?: number;
+    description?: string;
+}
+export declare enum OpenID4VCITxCodeInputMode {
+    NUMERIC = "NUMERIC",
+    TEXT = "TEXT"
 }

package/dist/src/credential.js

@@ -37,3 +37,8 @@ export var CredentialListSearchType;
     CredentialListSearchType["CLAIM_VALUE"] = "CLAIM_VALUE";
     CredentialListSearchType["CREDENTIAL_SCHEMA_NAME"] = "CREDENTIAL_SCHEMA_NAME";
 })(CredentialListSearchType || (CredentialListSearchType = {}));
+export var OpenID4VCITxCodeInputMode;
+(function (OpenID4VCITxCodeInputMode) {
+    OpenID4VCITxCodeInputMode["NUMERIC"] = "NUMERIC";
+    OpenID4VCITxCodeInputMode["TEXT"] = "TEXT";
+})(OpenID4VCITxCodeInputMode || (OpenID4VCITxCodeInputMode = {}));

package/dist/src/did.d.ts

@@ -1,3 +1,4 @@
+import { KeyListItem } from "./key";
 import { ListQuery, SortDirection } from "./list";
 export declare enum DidTypeEnum {
     LOCAL = "LOCAL",
@@ -11,11 +12,11 @@ export interface DidRequest {
     params: Record<string, string>;
 }
 export interface DidRequestKeys {
-    authentication: string[];
-    assertionMethod: string[];
-    keyAgreement: string[];
-    capabilityInvocation: string[];
-    capabilityDelegation: string[];
+    authentication: Array<KeyListItem["id"]>;
+    assertionMethod: Array<KeyListItem["id"]>;
+    keyAgreement: Array<KeyListItem["id"]>;
+    capabilityInvocation: Array<KeyListItem["id"]>;
+    capabilityDelegation: Array<KeyListItem["id"]>;
 }
 export interface DidListItem {
     id: string;
@@ -56,4 +57,7 @@ export interface DidListQuery extends ListQuery {
     exact?: ExactDidFilterColumnEnum[];
     keyAlgorithms?: string[];
     keyRoles?: KeyRoleEnum[];
+    keyStorages?: string[];
+    keyIds?: Array<KeyListItem["id"]>;
+    didMethods?: string[];
 }

package/dist/src/error.d.ts

@@ -1,23 +1,16 @@
-export declare enum OneErrorCode {
-    AlreadyExists = "AlreadyExists",
-    NotFound = "NotFound",
-    NotSupported = "NotSupported",
-    ValidationError = "ValidationError",
-    ConfigValidationError = "ConfigValidationError",
-    Uninitialized = "Uninitialized",
-    DbErr = "DbErr",
-    IOError = "IOError",
-    Unknown = "Unknown"
-}
 /**
- * Specific errors being throw from the {@link ONECore} functions
+ * Specific errors being thrown from the {@link ONECore} functions
  */
 export declare class OneError extends Error {
-    readonly code: OneErrorCode;
-    readonly cause: unknown;
+    readonly operation: string;
+    readonly code: string;
+    readonly cause?: string;
+    readonly originalError: Error;
     constructor(params: {
-        code: OneErrorCode;
-        cause: unknown;
-        message?: string;
+        operation: string;
+        code: string;
+        message: string;
+        cause?: string;
+        originalError: Error;
     });
 }

package/dist/src/error.js

@@ -1,25 +1,16 @@
-export var OneErrorCode;
-(function (OneErrorCode) {
-    // BindingError
-    OneErrorCode["AlreadyExists"] = "AlreadyExists";
-    OneErrorCode["NotFound"] = "NotFound";
-    OneErrorCode["NotSupported"] = "NotSupported";
-    OneErrorCode["ValidationError"] = "ValidationError";
-    OneErrorCode["ConfigValidationError"] = "ConfigValidationError";
-    OneErrorCode["Uninitialized"] = "Uninitialized";
-    OneErrorCode["DbErr"] = "DbErr";
-    OneErrorCode["IOError"] = "IOError";
-    OneErrorCode["Unknown"] = "Unknown";
-})(OneErrorCode || (OneErrorCode = {}));
 /**
- * Specific errors being throw from the {@link ONECore} functions
+ * Specific errors being thrown from the {@link ONECore} functions
  */
 export class OneError extends Error {
+    operation;
     code;
     cause;
+    originalError;
     constructor(params) {
         super(params.message);
+        this.operation = params.operation;
         this.code = params.code;
         this.cause = params.cause;
+        this.originalError = params.originalError;
     }
 }

package/dist/src/history.d.ts

@@ -7,7 +7,6 @@ export declare enum HistoryActionEnum {
     DELETED = "DELETED",
     ISSUED = "ISSUED",
     OFFERED = "OFFERED",
-    REACTIVATED = "REACTIVATED",
     REJECTED = "REJECTED",
     REQUESTED = "REQUESTED",
     REVOKED = "REVOKED",

package/dist/src/history.js

@@ -6,7 +6,6 @@ export var HistoryActionEnum;
     HistoryActionEnum["DELETED"] = "DELETED";
     HistoryActionEnum["ISSUED"] = "ISSUED";
     HistoryActionEnum["OFFERED"] = "OFFERED";
-    HistoryActionEnum["REACTIVATED"] = "REACTIVATED";
     HistoryActionEnum["REJECTED"] = "REJECTED";
     HistoryActionEnum["REQUESTED"] = "REQUESTED";
     HistoryActionEnum["REVOKED"] = "REVOKED";

package/dist/src/key.d.ts

@@ -15,3 +15,6 @@ export interface KeyListItem {
     keyType: string;
     storageType: string;
 }
+export interface KeyCheckCertificateRequestBindingDto {
+    certificate: string;
+}

package/dist/src/proof.d.ts

@@ -2,6 +2,7 @@ import { CredentialDetail, CredentialListItem } from "./credential";
 import { CredentialSchema } from "./credentialSchema";
 import { ListQuery, SortDirection } from "./list";
 import { ProofInputClaimSchema, ProofSchemaListItem } from "./proofSchema";
+import { DidListItem } from "./did";
 export declare enum ProofStateEnum {
     CREATED = "CREATED",
     PENDING = "PENDING",
@@ -27,7 +28,8 @@ export interface ProofDetail {
     proofInputs: ProofInput[];
     state: ProofStateEnum;
     proofSchema?: ProofSchemaListItem;
-    verifierDid?: string;
+    verifierDid?: DidListItem;
+    holderDid?: DidListItem;
     exchange: string;
     redirectUri?: string;
     retainUntilDate?: string;
@@ -135,3 +137,13 @@ export interface InvitationResultProofRequest {
     interactionId: string;
     proofId: ProofDetail["id"];
 }
+export interface ShareProofRequest {
+    params?: ShareProofRequestParams;
+}
+export interface ShareProofRequestParams {
+    clientIdSchema?: ShareProofRequestClientIdSchemaType;
+}
+export declare enum ShareProofRequestClientIdSchemaType {
+    REDIRECT_URI = "REDIRECT_URI",
+    VERIFIER_ATTESTATION = "VERIFIER_ATTESTATION"
+}

package/dist/src/proof.js

@@ -28,3 +28,8 @@ export var ExactProofFilterColumnEnum;
 (function (ExactProofFilterColumnEnum) {
     ExactProofFilterColumnEnum["NAME"] = "NAME";
 })(ExactProofFilterColumnEnum || (ExactProofFilterColumnEnum = {}));
+export var ShareProofRequestClientIdSchemaType;
+(function (ShareProofRequestClientIdSchemaType) {
+    ShareProofRequestClientIdSchemaType["REDIRECT_URI"] = "REDIRECT_URI";
+    ShareProofRequestClientIdSchemaType["VERIFIER_ATTESTATION"] = "VERIFIER_ATTESTATION";
+})(ShareProofRequestClientIdSchemaType || (ShareProofRequestClientIdSchemaType = {}));

package/dist/src/proofSchema.d.ts

@@ -2,6 +2,7 @@ import { CredentialSchema, CredentialSchemaLayoutProperties, CredentialSchemaTyp
 import { ListQuery, SortDirection } from "./list";
 export interface ProofInputClaimSchema {
     id: string;
+    requested: boolean;
     required: boolean;
     key: string;
     dataType: string;
@@ -69,6 +70,7 @@ export interface ImportProofSchemaInputSchema {
 }
 export interface ImportProofSchemaClaimSchema {
     id: string;
+    requested: boolean;
     required: boolean;
     key: string;
     dataType: string;

package/dist/src/trust.d.ts

@@ -1,26 +1,23 @@
 import { ListQuery, SortDirection } from "./list";
-export declare enum TrustAnchorRoleEnum {
-    PUBLISHER = "PUBLISHER",
-    CLIENT = "CLIENT"
-}
-export interface CreateTrustAnchorRequest {
+import { DidListItem } from "./did";
+export type CreateTrustAnchorRequest = {
     name: string;
     type: string;
-    publisherReference?: string;
-    role: TrustAnchorRoleEnum;
-    priority?: number;
-    organisationId: string;
-}
+} & ({
+    isPublisher: true;
+    publisherReference?: never;
+} | {
+    isPublisher?: false;
+    publisherReference: string;
+});
 export interface TrustAnchor {
     id: string;
     createdDate: string;
     lastModified: string;
     name: string;
     type: string;
-    publisherReference?: string;
-    role: TrustAnchorRoleEnum;
-    priority?: number;
-    organisationId: string;
+    isPublisher: boolean;
+    publisherReference: string;
 }
 export interface TrustAnchorListItem extends TrustAnchor {
     entities: number;
@@ -28,19 +25,88 @@ export interface TrustAnchorListItem extends TrustAnchor {
 export declare enum SortableTrustAnchorColumnEnum {
     NAME = "NAME",
     CREATED_DATE = "CREATED_DATE",
-    TYPE = "TYPE",
-    ROLE = "ROLE",
-    PRIORITY = "PRIORITY"
+    TYPE = "TYPE"
 }
 export declare enum ExactTrustAnchorFilterColumnEnum {
     NAME = "NAME",
     TYPE = "TYPE"
 }
-export interface TrustAnchorListQuery extends ListQuery {
+export interface TrustAnchorListQuery extends Omit<ListQuery, "organisationId"> {
     sort?: SortableTrustAnchorColumnEnum;
     sortDirection?: SortDirection;
     name?: string;
     exact?: ExactTrustAnchorFilterColumnEnum[];
     type?: string;
-    role?: TrustAnchorRoleEnum;
+    isPublisher?: boolean;
+}
+export interface TrustEntityListItem {
+    id: string;
+    createdDate: string;
+    lastModified: string;
+    name: string;
+    logo?: string;
+    website?: string;
+    termsUrl?: string;
+    privacyUrl?: string;
+    role: TrustEntityRoleEnum;
+    state: TrustEntityStateEnum;
+    did: DidListItem;
+    trustAnchor: TrustAnchor;
+}
+export interface TrustEntity extends TrustEntityListItem {
+    organisationId: string;
+}
+export declare enum TrustEntityRoleEnum {
+    ISSUER = "ISSUER",
+    VERIFIER = "VERIFIER",
+    BOTH = "BOTH"
+}
+export declare enum TrustEntityStateEnum {
+    ACTIVE = "ACTIVE",
+    REMOVED = "REMOVED",
+    WITHDRAWN = "WITHDRAWN",
+    REMOVED_AND_WITHDRAWN = "REMOVED_AND_WITHDRAWN"
+}
+export interface CreateTrustEntityRequest {
+    name: string;
+    logo?: string;
+    website?: string;
+    termsUrl?: string;
+    privacyUrl?: string;
+    role: TrustEntityRoleEnum;
+    trustAnchorId: TrustAnchor["id"];
+    didId: DidListItem["id"];
+}
+export interface TrustEntityListQuery {
+    sort?: SortableTrustEntityColumnEnum;
+    sortDirection?: SortDirection;
+    name?: string;
+    exact?: ExactTrustEntityFilterColumnEnum[];
+    type?: string;
+    isPublisher?: boolean;
+}
+export declare enum SortableTrustEntityColumnEnum {
+    NAME = "NAME",
+    ROLE = "ROLE"
+}
+export declare enum ExactTrustEntityFilterColumnEnum {
+    NAME = "NAME"
+}
+export interface CreateRemoteTrustEntityRequest extends Omit<CreateTrustEntityRequest, "trustAnchorId"> {
+    trustAnchorId?: TrustAnchor["id"];
+}
+export interface UpdateRemoteTrustEntityRequest {
+    didId: DidListItem["id"];
+    action?: TrustEntityUpdateActionEnum;
+    name?: string;
+    logo?: string | null;
+    website?: string | null;
+    termsUrl?: string | null;
+    privacyUrl?: string | null;
+    role?: TrustEntityRoleEnum;
+}
+export declare enum TrustEntityUpdateActionEnum {
+    ACTIVATE = "ACTIVATE",
+    WITHDRAW = "WITHDRAW",
+    REMOVE = "REMOVE"
 }