@procivis/react-native-one-core 1.26730.0

package/android/src/main/java/ch/procivis/one/core/SerializeSpecific.kt

@@ -0,0 +1,121 @@
+package ch.procivis.one.core
+
+import ch.procivis.one.core.Serialize.convertToRN
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+object SerializeSpecific {
+    object Obj {
+        private val CustomConversionTypes =
+            arrayOf(
+                HistoryMetadataBinding::class.java,
+                ClaimBindingDto::class.java,
+                ProofRequestClaimBindingDto::class.java,
+            )
+
+        fun isCustomConversionType(input: Any?): Boolean {
+            for (customType in CustomConversionTypes) {
+                if (customType.isInstance(input)) {
+                    return true
+                }
+            }
+            return false
+        }
+
+        fun convertCustom(input: Any): ReadableMap {
+            if (input is HistoryMetadataBinding) {
+                return historyMetadata(input)
+            }
+            if (input is ClaimBindingDto) {
+                return claim(input)
+            }
+            if (input is ProofRequestClaimBindingDto) {
+                return proofClaim(input)
+            }
+            throw IllegalArgumentException("Invalid map conversion: $input")
+        }
+
+        private fun historyMetadata(metadata: HistoryMetadataBinding): ReadableMap {
+            when (metadata) {
+                is HistoryMetadataBinding.UnexportableEntities ->
+                    return convertToRN(metadata.value) as ReadableMap
+            }
+        }
+
+        private fun claim(c: ClaimBindingDto): ReadableMap {
+            val result = Arguments.createMap()
+            result.putString("id", c.id)
+            result.putString("key", c.key)
+            result.putString("dataType", c.dataType)
+            result.putBoolean("array", c.array)
+
+            when (val value = c.value) {
+                is ClaimValueBindingDto.Boolean -> result.putBoolean("value", value.value)
+                is ClaimValueBindingDto.Float -> result.putDouble("value", value.value)
+                is ClaimValueBindingDto.Integer -> result.putInt("value", value.value.toInt())
+                is ClaimValueBindingDto.String -> result.putString("value", value.value)
+                is ClaimValueBindingDto.Nested ->
+                    result.putArray("value", convertToRN(value.value) as ReadableArray)
+            }
+
+            return result
+        }
+
+        private fun proofClaim(c: ProofRequestClaimBindingDto): ReadableMap {
+            val result = Arguments.createMap()
+            result.putMap("schema", convertToRN(c.schema) as ReadableMap)
+
+            c.value?.let {
+                when (val value = it) {
+                    is ProofRequestClaimValueBindingDto.Value ->
+                        result.putString("value", value.value)
+
+                    is ProofRequestClaimValueBindingDto.Claims ->
+                        result.putArray("value", convertToRN(value.value) as ReadableArray)
+                }
+            }
+
+            return result
+        }
+    }
+
+    object Str {
+        private val CustomConversionTypes =
+            arrayOf(
+                CredentialSchemaTypeBindingEnum::class.java,
+            )
+
+        fun isCustomConversionType(input: Any?): Boolean {
+            for (customType in CustomConversionTypes) {
+                if (customType.isInstance(input)) {
+                    return true
+                }
+            }
+            return false
+        }
+
+        fun convertCustom(input: Any): String {
+            if (input is CredentialSchemaTypeBindingEnum) {
+                return credentialSchemaType(input)
+            }
+            throw IllegalArgumentException("Invalid string conversion: $input")
+        }
+
+        private fun credentialSchemaType(type: CredentialSchemaTypeBindingEnum): String {
+            return when (type) {
+                is CredentialSchemaTypeBindingEnum.ProcivisOneSchema2024 ->
+                    "PROCIVIS_ONE_SCHEMA2024"
+
+                is CredentialSchemaTypeBindingEnum.FallbackSchema2024 ->
+                    "FALLBACK_SCHEMA2024"
+
+                is CredentialSchemaTypeBindingEnum.Mdoc ->
+                    "MDOC"
+
+                is CredentialSchemaTypeBindingEnum.Other ->
+                    type.value
+            }
+        }
+    }
+}

package/android/src/main/java/ch/procivis/one/core/Util.kt

@@ -0,0 +1,23 @@
+package ch.procivis.one.core
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+
+object Util {
+    // error handling
+    fun asyncCall(promise: Promise, function: () -> Any?) {
+        try {
+            promise.resolve(function())
+        } catch (error: Throwable) {
+            promise.reject(
+                error.javaClass.simpleName.replaceFirst(Regex("Exception$"), "Error"),
+                error.message,
+                error
+            )
+        }
+    }
+}
+
+fun ReadableMap.getUInt(name: String): UInt? {
+    return if (this.hasKey(name) && !this.isNull(name)) this.getInt(name).toUInt() else null
+}

package/bin/postinstall

@@ -0,0 +1,12 @@
+const fs = require('fs');
+const childProcess = require('child_process');
+
+if (fs.existsSync('node_modules/husky')) {
+  try {
+    childProcess.execSync('yarn husky install', {
+      stdio: 'inherit',
+    });
+  } catch (error) {
+    process.exit(error.status);
+  }
+}

package/core-sdk.json

@@ -0,0 +1,16 @@
+{
+  "android": {
+    "debug": {
+      "url": "https://onetfstatestorage.blob.core.windows.net/core-sdk/android/26730/onecore-debug.aar",
+      "sha1": "5064f7c4f6ac8ef0e5105796b581868ec6cf8014"
+    },
+    "release": {
+      "url": "https://onetfstatestorage.blob.core.windows.net/core-sdk/android/26730/onecore-release.aar",
+      "sha1": "8fa14a6be6465f2161f32ac8bcbf703fbc48303a"
+    }
+  },
+  "ios": {
+    "url": "https://onetfstatestorage.blob.core.windows.net/core-sdk/ios/26730/deploy.zip",
+    "sha1": "d613c5848050444af33cdcf6b02ba9c6dce654c5"
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { ONECore } from "./src/core";
+export * from "./src/core";
+export * from "./src/error";
+/**
+ * Initialize ONE Core for Holder
+ * @note Beware that only one instance can be initialized at a time, repeated calls will fail
+ * @returns ONE Core instance
+ */
+export declare function initializeHolderCore(): Promise<ONECore>;
+/**
+ * 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 declare function initializeVerifierCore(): Promise<ONECore>;

package/dist/index.js

@@ -0,0 +1,59 @@
+import { NativeModules } from "react-native";
+import { OneError, OneErrorCode } from "./src/error";
+export * from "./src/core";
+export * from "./src/error";
+const ONE = NativeModules.ProcivisOneCoreModule;
+// Config entities are exposed as serialized JSON, here conversion to structs
+const originalGetConfig = ONE.getConfig;
+ONE.getConfig = () => originalGetConfig().then((config) => objectMap(config, (entities) => objectMap(entities, (json) => JSON.parse(json))));
+/**
+ * Initialize ONE Core for Holder
+ * @note Beware that only one instance can be initialized at a time, repeated calls will fail
+ * @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")();
+    return wrapObj(ONE);
+}
+// UTILS
+// returns a new object with the values at each key mapped using fn(value)
+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) {
+    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
+                throw new OneError({
+                    code,
+                    cause,
+                    message: cause?.message,
+                });
+            }
+            else {
+                throw cause;
+            }
+        };
+        // set name on the err handler to display the original function name in callstack
+        Object.defineProperty(errHandler, "name", { value: name });
+        // convert undefined parameters to null for proper parameter matching in native code
+        return fn(...args.map((x) => (x === undefined ? null : x))).catch(errHandler);
+    };
+}
+function wrapObj(obj) {
+    return Object.entries(obj).reduce((aggr, [key, fn]) => ({
+        ...aggr,
+        [key]: typeof fn === "function" ? wrapFn(fn, key) : fn,
+    }), {});
+}

package/dist/src/backup.d.ts

@@ -0,0 +1,22 @@
+import { CredentialDetail } from "./credential";
+import { DidListItem } from "./did";
+import { HistoryListItem } from "./history";
+import { KeyListItem } from "./key";
+export interface UnexportableEntities {
+    credentials: CredentialDetail[];
+    keys: KeyListItem[];
+    dids: DidListItem[];
+    totalCredentials: number;
+    totalKeys: number;
+    totalDids: number;
+}
+export interface BackupCreate {
+    historyId: HistoryListItem["id"];
+    file: string;
+    unexportable: UnexportableEntities;
+}
+export interface ImportBackupMetadata {
+    dbVersion: string;
+    dbHash: string;
+    createdAt: string;
+}

package/dist/src/backup.js

@@ -0,0 +1 @@
+export {};

package/dist/src/config.d.ts

@@ -0,0 +1,100 @@
+export declare enum KeyStorageSecurityEnum {
+    HARDWARE = "HARDWARE",
+    SOFTWARE = "SOFTWARE"
+}
+export interface KeyStorageCapabilities {
+    algorithms: string[];
+    security: KeyStorageSecurityEnum[];
+}
+export interface DidCapabilities {
+    operations: string[];
+}
+export declare enum FormatFeatureEnum {
+    SelectiveDisclosure = "SELECTIVE_DISCLOSURE",
+    SupportsCredentialDesign = "SUPPORTS_CREDENTIAL_DESIGN",
+    RequiresSchemaId = "REQUIRES_SCHEMA_ID"
+}
+export declare enum FormatSelectiveDisclosureEnum {
+    AnyLevel = "ANY_LEVEL",
+    SecondLevel = "SECOND_LEVEL"
+}
+export interface FormatCapabilities {
+    features: FormatFeatureEnum[];
+    selectiveDisclosure: FormatSelectiveDisclosureEnum[];
+    issuanceDidMethods: string[];
+    issuanceExchangeProtocols: string[];
+    proofExchangeProtocols: string[];
+    revocationMethods: string[];
+    signingKeyAlgorithms: string[];
+    verificationKeyAlgorithms: string[];
+    datatypes: Array<DataTypeEnum | string>;
+    allowedSchemaIds: string[];
+    forbiddenClaimNames: string[];
+}
+export interface ConfigEntity<Capabilities> {
+    disabled?: boolean;
+    capabilities?: Capabilities;
+    display: string;
+    order: number;
+}
+export type ConfigEntities<Capabilities = undefined, Params = {
+    type: string;
+}> = Record<string, ConfigEntity<Capabilities> & Params>;
+export declare enum DataTypeEnum {
+    String = "STRING",
+    Number = "NUMBER",
+    Date = "DATE",
+    File = "FILE",
+    Boolean = "BOOLEAN",
+    Object = "OBJECT"
+}
+type DataTypeError = string | Record<string, string>;
+export interface StringDataTypeParams {
+    autocomplete: boolean;
+    error?: DataTypeError;
+    pattern: string;
+    placeholder: string;
+}
+export interface NumberDataTypeParams {
+    error?: DataTypeError;
+    max?: number;
+    min?: number;
+}
+export interface DateDataTypeParams {
+    error?: DataTypeError;
+    max?: string;
+    min?: string;
+}
+export interface FileDataTypeParams {
+    accept?: string[];
+    fileSize?: number;
+    showAs: "IMAGE" | "VIDEO" | "FILE";
+}
+export type DataTypeParams = {
+    type: DataTypeEnum.String;
+    params?: StringDataTypeParams;
+} | {
+    type: DataTypeEnum.Number;
+    params?: NumberDataTypeParams;
+} | {
+    type: DataTypeEnum.Date;
+    params?: DateDataTypeParams;
+} | {
+    type: DataTypeEnum.File;
+    params?: FileDataTypeParams;
+} | {
+    type: DataTypeEnum.Object;
+    params?: undefined;
+};
+export interface Config {
+    format: ConfigEntities<FormatCapabilities>;
+    exchange: ConfigEntities;
+    transport: ConfigEntities;
+    revocation: ConfigEntities;
+    did: ConfigEntities<DidCapabilities>;
+    datatype: ConfigEntities<undefined, DataTypeParams>;
+    keyAlgorithm: ConfigEntities;
+    keyStorage: ConfigEntities<KeyStorageCapabilities>;
+    cacheEntities: ConfigEntities;
+}
+export {};

package/dist/src/config.js

@@ -0,0 +1,25 @@
+export var KeyStorageSecurityEnum;
+(function (KeyStorageSecurityEnum) {
+    KeyStorageSecurityEnum["HARDWARE"] = "HARDWARE";
+    KeyStorageSecurityEnum["SOFTWARE"] = "SOFTWARE";
+})(KeyStorageSecurityEnum || (KeyStorageSecurityEnum = {}));
+export var FormatFeatureEnum;
+(function (FormatFeatureEnum) {
+    FormatFeatureEnum["SelectiveDisclosure"] = "SELECTIVE_DISCLOSURE";
+    FormatFeatureEnum["SupportsCredentialDesign"] = "SUPPORTS_CREDENTIAL_DESIGN";
+    FormatFeatureEnum["RequiresSchemaId"] = "REQUIRES_SCHEMA_ID";
+})(FormatFeatureEnum || (FormatFeatureEnum = {}));
+export var FormatSelectiveDisclosureEnum;
+(function (FormatSelectiveDisclosureEnum) {
+    FormatSelectiveDisclosureEnum["AnyLevel"] = "ANY_LEVEL";
+    FormatSelectiveDisclosureEnum["SecondLevel"] = "SECOND_LEVEL";
+})(FormatSelectiveDisclosureEnum || (FormatSelectiveDisclosureEnum = {}));
+export var DataTypeEnum;
+(function (DataTypeEnum) {
+    DataTypeEnum["String"] = "STRING";
+    DataTypeEnum["Number"] = "NUMBER";
+    DataTypeEnum["Date"] = "DATE";
+    DataTypeEnum["File"] = "FILE";
+    DataTypeEnum["Boolean"] = "BOOLEAN";
+    DataTypeEnum["Object"] = "OBJECT";
+})(DataTypeEnum || (DataTypeEnum = {}));

package/dist/src/core.d.ts

@@ -0,0 +1,109 @@
+import { BackupCreate, ImportBackupMetadata, UnexportableEntities } from "./backup";
+import { Config } from "./config";
+import { CredentialDetail, CredentialListItem, CredentialListQuery, CredentialRevocationCheckResponse, InvitationResultCredentialIssuance } from "./credential";
+import { CredentialSchema, CredentialSchemaDetail, CredentialSchemaListQuery, ImportCredentialSchemaRequest, ShareCredentialSchemaResponse } from "./credentialSchema";
+import { DidListItem, DidListQuery, DidRequest } from "./did";
+import { HistoryListItem, HistoryListQuery } from "./history";
+import { KeyRequest } from "./key";
+import { ItemList } from "./list";
+import { CreateProofRequest, InvitationResultProofRequest, PresentationDefinition, PresentationDefinitionRequestedCredential, PresentationSubmitCredentialRequest, ProofDetail, ProofListItem, ProofListQuery, ProposeProofResponse, ShareProofResponse } from "./proof";
+import { CreateProofSchemaRequest, ImportProofSchemaRequest, ProofSchema, ProofSchemaListItem, ProofSchemaListQuery, ShareProofSchemaResponse } from "./proofSchema";
+import { CreateTrustAnchorRequest, TrustAnchor, TrustAnchorListItem, TrustAnchorListQuery } from "./trust";
+export * from "./backup";
+export * from "./config";
+export * from "./credential";
+export * from "./credentialSchema";
+export * from "./did";
+export * from "./history";
+export * from "./key";
+export * from "./list";
+export * from "./proof";
+export * from "./proofSchema";
+export * from "./trust";
+export interface Version {
+    target: string;
+    buildTime: string;
+    branch: string;
+    tag: string;
+    commit: string;
+    rustVersion: string;
+    pipelineId: string;
+}
+export type InvitationResult = InvitationResultCredentialIssuance | InvitationResultProofRequest;
+export interface ResolveJsonLdContextResponse {
+    context: string;
+}
+export interface ONECore {
+    getVersion(): Promise<Version>;
+    getConfig(): Promise<Config>;
+    createOrganisation(uuid: string | undefined): Promise<string>;
+    generateKey(keyRequest: KeyRequest): Promise<string>;
+    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>;
+    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>;
+    deleteProofClaims(proofId: ProofDetail["id"]): Promise<void>;
+    getCredential(credentialId: CredentialListItem["id"]): Promise<CredentialDetail>;
+    deleteCredential(credentialId: CredentialListItem["id"]): Promise<void>;
+    importCredentialSchema(request: ImportCredentialSchemaRequest): Promise<CredentialSchema["id"]>;
+    getCredentialSchema(credentialSchemaId: CredentialSchema["id"]): Promise<CredentialSchemaDetail>;
+    getCredentialSchemas(query: CredentialSchemaListQuery): Promise<ItemList<CredentialSchema>>;
+    deleteCredentialSchema(credentialSchemaId: CredentialSchema["id"]): Promise<void>;
+    createProof(request: CreateProofRequest): Promise<ProofDetail["id"]>;
+    shareProof(proofId: ProofDetail["id"]): Promise<ShareProofResponse>;
+    shareProofSchema(proofSchemaId: ProofSchema["id"]): Promise<ShareProofSchemaResponse>;
+    shareCredentialSchema(credentialSchemaId: CredentialSchema["id"]): Promise<ShareCredentialSchemaResponse>;
+    getProof(proofId: ProofDetail["id"]): Promise<ProofDetail>;
+    getProofs(query: ProofListQuery): Promise<ItemList<ProofListItem>>;
+    retractProof(proofId: ProofDetail["id"]): Promise<ProofDetail["id"]>;
+    proposeProof(exchange: string, organisationId: string): Promise<ProposeProofResponse>;
+    createProofSchema(request: CreateProofSchemaRequest): Promise<ProofSchema["id"]>;
+    getProofSchemas(query: ProofSchemaListQuery): Promise<ItemList<ProofSchemaListItem>>;
+    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[]>;
+    createTrustAnchor(request: CreateTrustAnchorRequest): Promise<TrustAnchor["id"]>;
+    getTrustAnchor(trustAnchorId: TrustAnchor["id"]): Promise<TrustAnchor>;
+    getTrustAnchors(query: TrustAnchorListQuery): Promise<ItemList<TrustAnchorListItem>>;
+    getHistory(query: HistoryListQuery): Promise<ItemList<HistoryListItem>>;
+    getHistoryEntry(historyId: HistoryListItem["id"]): Promise<HistoryListItem>;
+    createBackup(password: string, outputPath: string): Promise<BackupCreate>;
+    backupInfo(): Promise<UnexportableEntities>;
+    /**
+     * Start import procedure
+     *
+     * This call will open the provided backup file, other subsequent function calls like {@link getCredentials} will return data from the imported package
+     * After this successful call, either {@link finalizeImport} (to persist the changes) or {@link rollbackImport} (to revert to old data) must be called
+     * @param {string} password User password matching selected during creation of the backup file
+     * @param {string} inputPath Path to the stored backup file
+     */
+    unpackBackup(password: string, inputPath: string): Promise<ImportBackupMetadata>;
+    /**
+     * Persist unpacked backup
+     *
+     * This call will delete/overwrite the previously stored entries
+     */
+    finalizeImport(): Promise<void>;
+    /**
+     * Close unpacked backup
+     *
+     * This call will restore the old entries prior calling {@link unpackBackup}
+     */
+    rollbackImport(): Promise<void>;
+    resolveJsonldContext(url: string): Promise<ResolveJsonLdContextResponse>;
+    /**
+     * Uninitialize the core instance
+     *
+     * Any following calls on this instance will fail.
+     * A new core instance has to be initialized after.
+     * @param {boolean} deleteData If true, also delete all data from the DB, otherwise data will be persisted for the next core instance
+     */
+    uninitialize(deleteData: boolean): Promise<void>;
+}

package/dist/src/core.js

@@ -0,0 +1,11 @@
+export * from "./backup";
+export * from "./config";
+export * from "./credential";
+export * from "./credentialSchema";
+export * from "./did";
+export * from "./history";
+export * from "./key";
+export * from "./list";
+export * from "./proof";
+export * from "./proofSchema";
+export * from "./trust";

package/dist/src/credential.d.ts

@@ -0,0 +1,115 @@
+import { DataTypeEnum } from "./config";
+import { CredentialSchema } from "./credentialSchema";
+import { ListQuery, SortDirection } from "./list";
+export declare enum CredentialStateEnum {
+    CREATED = "CREATED",
+    PENDING = "PENDING",
+    OFFERED = "OFFERED",
+    ACCEPTED = "ACCEPTED",
+    REJECTED = "REJECTED",
+    REVOKED = "REVOKED",
+    SUSPENDED = "SUSPENDED",
+    ERROR = "ERROR"
+}
+export type ClaimValue = {
+    dataType: DataTypeEnum.String | DataTypeEnum.Date | DataTypeEnum.File;
+    value: string;
+    array: false;
+} | {
+    dataType: DataTypeEnum.Number;
+    value: number;
+    array: false;
+} | {
+    dataType: DataTypeEnum.Boolean;
+    value: boolean;
+    array: false;
+} | {
+    dataType: DataTypeEnum.Object;
+    value: Claim[];
+    array: false;
+} | {
+    dataType: string;
+    value: string | number | boolean;
+    array: false;
+} | {
+    dataType: string;
+    value: Claim[];
+    array: true;
+};
+export type Claim = ClaimValue & {
+    id: string;
+    key: string;
+};
+export interface CredentialListItem {
+    id: string;
+    createdDate: string;
+    issuanceDate: string;
+    lastModified: string;
+    revocationDate?: string;
+    issuerDid?: string;
+    state: CredentialStateEnum;
+    schema: CredentialSchema;
+    role: CredentialRoleEnum;
+    suspendEndDate?: string;
+}
+export interface CredentialDetail extends CredentialListItem {
+    claims: Claim[];
+    redirectUri?: string;
+    lvvcIssuanceDate?: string;
+    mdocMsoValidity?: MdocMsoValidity;
+}
+export interface MdocMsoValidity {
+    expiration: string;
+    nextUpdate: string;
+    lastUpdate: string;
+}
+export declare enum CredentialRoleEnum {
+    HOLDER = "HOLDER",
+    ISSUER = "ISSUER",
+    VERIFIER = "VERIFIER"
+}
+export declare enum CredentialListQueryExactColumnEnum {
+    NAME = "NAME"
+}
+export declare enum SortableCredentialColumnEnum {
+    CREATED_DATE = "CREATED_DATE",
+    SCHEMA_NAME = "SCHEMA_NAME",
+    ISSUER_DID = "ISSUER_DID",
+    STATE = "STATE"
+}
+export declare enum CredentialListIncludeEntityType {
+    LAYOUT_PROPERTIES = "LAYOUT_PROPERTIES",
+    CREDENTIAL = "CREDENTIAL"
+}
+export declare enum CredentialListSearchType {
+    CLAIM_NAME = "CLAIM_NAME",
+    CLAIM_VALUE = "CLAIM_VALUE",
+    CREDENTIAL_SCHEMA_NAME = "CREDENTIAL_SCHEMA_NAME"
+}
+export type CredentialListQuery = ListQuery & {
+    sort?: SortableCredentialColumnEnum;
+    sortDirection?: SortDirection;
+    exact?: CredentialListQueryExactColumnEnum[];
+    role?: CredentialRoleEnum;
+    ids?: Array<CredentialListItem["id"]>;
+    status?: CredentialStateEnum[];
+    include?: CredentialListIncludeEntityType[];
+} & ({
+    name?: string;
+    searchType?: never;
+    searchText?: never;
+} | {
+    searchText?: string;
+    searchType?: CredentialListSearchType[];
+    name?: never;
+});
+export interface CredentialRevocationCheckResponse {
+    credentialId: string;
+    status: CredentialStateEnum;
+    success: boolean;
+    reason?: string;
+}
+export interface InvitationResultCredentialIssuance {
+    interactionId: string;
+    credentialIds: Array<CredentialListItem["id"]>;
+}