@procivis/one-react-native-components 0.3.106 → 0.3.115

package/src/utils/hooks/core/proof-schemas.ts

@@ -1,8 +1,8 @@
 import {
-  CreateProofSchemaRequestDto,
-  GetProofSchemaListItemBindingDto,
-  ImportProofSchemaBindingDto,
-  ListProofSchemasFiltersBindingDto,
+  CreateProofSchemaRequest,
+  ImportProofSchema,
+  ProofSchemaListItem,
+  ProofSchemaListQuery,
 } from '@procivis/react-native-one-core';
 import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from 'react-query';
 
@@ -18,14 +18,14 @@ export const PROOF_SCHEMA_IMPORT_DETAIL_QUERY_KEY = 'proof-schema-import';
 export const PROOF_SCHEMA_DETAIL_QUERY_KEY = 'proof-schema-detail';
 export const PROOF_SCHEMA_SHARE_QUERY_KEY = 'proof-schema-share';
 
-export const useProofSchemas = (queryParams?: Partial<ListProofSchemasFiltersBindingDto>, keepPreviousData = true) => {
+export const useProofSchemas = (queryParams?: Partial<ProofSchemaListQuery>, keepPreviousData = true) => {
   const { core, organisationId } = useONECore();
 
   return useInfiniteQuery(
     [PROOF_SCHEMA_LIST_QUERY_KEY, ...getQueryKeyFromProofSchemaListQueryParams(queryParams)],
     ({ pageParam = 0 }) =>
       core
-        .getProofSchemas({
+        .listProofSchemas({
           organisationId,
           page: pageParam,
           pageSize: PAGE_SIZE,
@@ -39,10 +39,7 @@ export const useProofSchemas = (queryParams?: Partial<ListProofSchemasFiltersBin
   );
 };
 
-export const useProofSchemaDetail = (
-  proofSchemaId: GetProofSchemaListItemBindingDto['id'] | undefined,
-  active = true,
-) => {
+export const useProofSchemaDetail = (proofSchemaId: ProofSchemaListItem['id'] | undefined, active = true) => {
   const { core } = useONECore();
 
   return useQuery(
@@ -65,7 +62,7 @@ export const useProofSchemaImportDetail = (url: string) => {
         if (!response.ok) {
           throw response.originalError;
         }
-        return response.data as ImportProofSchemaBindingDto;
+        return response.data as ImportProofSchema;
       }),
     {
       keepPreviousData: true,
@@ -78,7 +75,7 @@ export const useProofSchemaAccept = () => {
   const { core, organisationId } = useONECore();
 
   return useMutation(
-    async ({ schema }: { schema: ImportProofSchemaBindingDto }) =>
+    async ({ schema }: { schema: ImportProofSchema }) =>
       core.importProofSchema({
         organisationId,
         schema,
@@ -97,7 +94,7 @@ export const useProofSchemaCreate = () => {
   const queryClient = useQueryClient();
   const { core } = useONECore();
 
-  return useMutation(async (proofSchema: CreateProofSchemaRequestDto) => core.createProofSchema(proofSchema), {
+  return useMutation(async (proofSchema: CreateProofSchemaRequest) => core.createProofSchema(proofSchema), {
     onSuccess: async () => {
       await queryClient.invalidateQueries(PROOF_SCHEMA_LIST_QUERY_KEY);
       await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
@@ -109,16 +106,13 @@ export const useProofSchemaDelete = () => {
   const queryClient = useQueryClient();
   const { core } = useONECore();
 
-  return useMutation(
-    async (proofSchemaId: GetProofSchemaListItemBindingDto['id']) => core.deleteProofSchema(proofSchemaId),
-    {
-      onSuccess: async (_, proofSchemaId) => {
-        await queryClient.invalidateQueries(PROOF_SCHEMA_LIST_QUERY_KEY);
-        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
-        await queryClient.removeQueries([PROOF_SCHEMA_DETAIL_QUERY_KEY, proofSchemaId]);
-      },
+  return useMutation(async (proofSchemaId: ProofSchemaListItem['id']) => core.deleteProofSchema(proofSchemaId), {
+    onSuccess: async (_, proofSchemaId) => {
+      await queryClient.invalidateQueries(PROOF_SCHEMA_LIST_QUERY_KEY);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      await queryClient.removeQueries([PROOF_SCHEMA_DETAIL_QUERY_KEY, proofSchemaId]);
     },
-  );
+  });
 };
 
 export const useShareProofSchema = (schemaId?: string) => {

package/src/utils/hooks/core/proofs.ts

@@ -1,17 +1,17 @@
 import {
-  Config,
-  CreateProofRequestBindingDto,
-  GetProofSchemaBindingDto,
-  HistoryActionBindingEnum,
-  HistoryEntityTypeBindingEnum,
-  HistoryErrorMetadataBindingDto,
-  IdentifierListQueryBindingDto,
+  CoreConfig,
+  CreateProofRequest,
+  HistoryAction,
+  HistoryEntityType,
+  HistoryErrorMetadata,
+  IdentifierListQuery,
   OneError,
-  PresentationSubmitCredentialRequestBindingDto,
-  ProofListQueryBindingDto,
-  ProofStateBindingEnum,
-  ProposeProofRequestBindingDto,
-  ShareProofRequestBindingDto,
+  PresentationSubmitCredentialRequest,
+  ProofListQuery,
+  ProofSchemaDetail,
+  ProofState,
+  ProposeProofRequest,
+  ShareProofRequest,
 } from '@procivis/react-native-one-core';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useMutation, useQuery, useQueryClient } from 'react-query';
@@ -51,18 +51,18 @@ export const useProofState = (proofId: string | undefined, isPolling: boolean) =
       }
 
       const state = await core.getProof(proofId).then((proof) => proof.state);
-      let metadata: HistoryErrorMetadataBindingDto | undefined;
-      if (state === ProofStateBindingEnum.ERROR) {
+      let metadata: HistoryErrorMetadata | undefined;
+      if (state === ProofState.ERROR) {
         metadata = await core
-          .getHistoryList({
+          .listHistory({
             organisationId,
             page: 0,
             pageSize: 1,
             entityIds: [proofId],
-            entityTypes: [HistoryEntityTypeBindingEnum.PROOF],
-            actions: [HistoryActionBindingEnum.ERRORED],
+            entityTypes: [HistoryEntityType.PROOF],
+            actions: [HistoryAction.ERRORED],
           })
-          .then((result) => result.values[0]?.metadata?.value as HistoryErrorMetadataBindingDto);
+          .then((result) => result.values[0]?.metadata?.value as HistoryErrorMetadata);
       }
       return { state, metadata };
     },
@@ -73,7 +73,7 @@ export const useProofState = (proofId: string | undefined, isPolling: boolean) =
   );
 };
 
-type ProofUrlHookParams = { proofId: string; request?: ShareProofRequestBindingDto };
+type ProofUrlHookParams = { proofId: string; request?: ShareProofRequest };
 
 export const useProofUrl = () => {
   const queryClient = useQueryClient();
@@ -101,7 +101,7 @@ export const useProofAccept = () => {
       interactionId,
       credentials,
     }: {
-      credentials: Record<string, PresentationSubmitCredentialRequestBindingDto[]>;
+      credentials: Record<string, PresentationSubmitCredentialRequest[]>;
       interactionId: string;
     }) => core.holderSubmitProof(interactionId, credentials),
     {
@@ -163,8 +163,7 @@ export const useProposeProof = () => {
   const { core, organisationId } = useONECore();
 
   return useMutation(
-    async (request: Omit<ProposeProofRequestBindingDto, 'organisationId'>) =>
-      core.proposeProof({ organisationId, ...request }),
+    async (request: Omit<ProposeProofRequest, 'organisationId'>) => core.proposeProof({ organisationId, ...request }),
     {
       onSuccess: async () => {
         await queryClient.invalidateQueries(PROOF_LIST_QUERY_KEY);
@@ -198,7 +197,7 @@ export const useProofDelete = () => {
   );
 };
 
-export const useProofs = (queryParams?: Partial<ProofListQueryBindingDto>) => {
+export const useProofs = (queryParams?: Partial<ProofListQuery>) => {
   const { core, organisationId } = useONECore();
 
   const queryKey = [PROOF_LIST_QUERY_KEY, ...getQueryKeyFromProofListQueryParams(queryParams)];
@@ -206,7 +205,7 @@ export const useProofs = (queryParams?: Partial<ProofListQueryBindingDto>) => {
   return useQuery(
     queryKey,
     ({ pageParam = 0 }) =>
-      core.getProofs({
+      core.listProofs({
         organisationId,
         page: pageParam,
         pageSize: PAGE_SIZE,
@@ -223,7 +222,7 @@ export const useProofCreate = () => {
 
   const { core } = useONECore();
 
-  return useMutation(async (data: CreateProofRequestBindingDto) => core.createProof(data), {
+  return useMutation(async (data: CreateProofRequest) => core.createProof(data), {
     onSuccess: async () => {
       await queryClient.invalidateQueries(PROOF_LIST_QUERY_KEY);
       await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
@@ -232,9 +231,9 @@ export const useProofCreate = () => {
 };
 
 const getIdentifierFilterForProofSchema = (
-  proofSchema: GetProofSchemaBindingDto,
-  config: Config,
-): Partial<IdentifierListQueryBindingDto> => {
+  proofSchema: ProofSchemaDetail,
+  config: CoreConfig,
+): Partial<IdentifierListQuery> => {
   const requestedFormats = proofSchema.proofInputSchemas.map((schema) => schema.credentialSchema.format);
   const requestedFormatsCapabilities = requestedFormats
     .map((format) => config.format[format]?.capabilities)
@@ -310,7 +309,7 @@ export const useProofForSchemaIdWithTransport = (
       return;
     }
 
-    if (proofState?.state !== ProofStateBindingEnum.CREATED && proofState?.state !== ProofStateBindingEnum.PENDING) {
+    if (proofState?.state !== ProofState.CREATED && proofState?.state !== ProofState.PENDING) {
       setProofId(undefined);
     } else {
       setDeleting(true);
@@ -357,7 +356,7 @@ export const useCleanupUnusedProofs = () => {
   const { data: proofs } = useProofs({
     page: 0,
     pageSize: 100,
-    proofStates: [ProofStateBindingEnum.CREATED, ProofStateBindingEnum.PENDING],
+    proofStates: [ProofState.CREATED, ProofState.PENDING],
   });
   const [cleaned, setCleaned] = useState(false);
 
@@ -382,7 +381,7 @@ export const useShareProof = (proofUrlProps: ProofUrlHookParams | undefined, ena
 
   // reset when proofId changes or the proof was retracted
   useEffect(() => {
-    if (!proofUrlProps?.proofId || proofState?.state === ProofStateBindingEnum.CREATED) {
+    if (!proofUrlProps?.proofId || proofState?.state === ProofState.CREATED) {
       setSharedProof(undefined);
     }
   }, [proofUrlProps?.proofId, proofState]);
@@ -418,7 +417,7 @@ export const useRetainProofCheck = (proofId?: string) => {
 
   const { core } = useONECore();
 
-  return useMutation(async () => core.runTask('RETAIN_PROOF_CHECK'), {
+  return useMutation(async () => core.runTask('RETAIN_PROOF_CHECK', undefined), {
     onSuccess: async () => {
       if (proofId) {
         await queryClient.removeQueries([PROOF_DETAIL_QUERY_KEY, proofId]);
@@ -449,12 +448,12 @@ export const useDeleteAllProofsData = (schemaId: string) => {
   return useMutation(
     async () =>
       core
-        .getProofs({
+        .listProofs({
           organisationId,
           page: 0,
           pageSize: 1000,
           proofSchemaIds: [schemaId],
-          proofStates: [ProofStateBindingEnum.ACCEPTED],
+          proofStates: [ProofState.ACCEPTED],
         })
         .then((result) => Promise.all(result.values.reverse().map((proof) => core.deleteProofClaims(proof.id)))),
     {

package/src/utils/hooks/core/trust-entity.ts

@@ -1,10 +1,10 @@
 import {
-  CreateRemoteTrustEntityRequestBindingDto,
-  GetTrustAnchorResponseBindingDto,
-  IdentifierTypeBindingEnum,
+  CreateRemoteTrustEntityRequest,
+  IdentifierType,
   ONECore,
   OneError,
-  UpdateRemoteTrustEntityFromDidRequestBindingDto,
+  TrustAnchorDetail,
+  UpdateRemoteTrustEntityRequest,
 } from '@procivis/react-native-one-core';
 import { useCallback } from 'react';
 import { useMutation, useQuery, useQueryClient } from 'react-query';
@@ -31,7 +31,7 @@ export const useCreateTrustAnchor = () => {
       if (trustAnchors.values.length > 0) {
         return;
       }
-      const response = await httpClient.get<GetTrustAnchorResponseBindingDto>(publisherReference);
+      const response = await httpClient.get<TrustAnchorDetail>(publisherReference);
       if (!response.ok || !response.data) {
         return;
       }
@@ -66,7 +66,7 @@ export const useTrustEntity = (identifierId: string | undefined) => {
               identifiers: [
                 {
                   certificateId:
-                    identifierDetail?.type === IdentifierTypeBindingEnum.CERTIFICATE
+                    identifierDetail?.type === IdentifierType.CERTIFICATE
                       ? identifierDetail.certificates?.[0]?.id
                       : undefined,
                   id: identifierId,
@@ -110,9 +110,7 @@ export const useCreateRemoteTrustEntity = () => {
   const { core } = useONECore();
 
   return useMutation(
-    async (
-      request: Omit<CreateRemoteTrustEntityRequestBindingDto, 'didId'> & { identifierId?: string; didId?: string },
-    ) => {
+    async (request: Omit<CreateRemoteTrustEntityRequest, 'didId'> & { identifierId?: string; didId?: string }) => {
       const { identifierId, didId } = request;
 
       let entityDidId = didId;
@@ -142,7 +140,7 @@ export const useUpdateRemoteTrustEntity = () => {
 
   return useMutation(
     async (
-      request: Omit<UpdateRemoteTrustEntityFromDidRequestBindingDto, 'didId'> & {
+      request: Omit<UpdateRemoteTrustEntityRequest, 'didId'> & {
         identifierId?: string;
         didId?: string;
       },

package/src/utils/hooks/core/trust-list.ts

@@ -0,0 +1,29 @@
+import { HolderWalletUnit } from '@procivis/react-native-one-core';
+import { useMutation } from 'react-query';
+
+import { reportException } from '../../reporting';
+import { useONECore } from './core-context';
+
+export const useTrustCollectionSync = () => {
+  const { core } = useONECore();
+
+  return useMutation(
+    async (params: { holderWalletUnitId?: HolderWalletUnit['id']; verifierInstanceId?: string }) =>
+      core.runTask('TRUST_COLLECTION_SYNC', JSON.stringify(params)),
+    {
+      onError: (err) => {
+        reportException(err, 'TRUST_COLLECTION_SYNC error');
+      },
+    },
+  );
+};
+
+export const useTrustListSubscriptionUpdate = () => {
+  const { core } = useONECore();
+
+  return useMutation(async () => core.runTask('TRUST_LIST_SUBSCRIPTION_UPDATE', undefined), {
+    onError: (err) => {
+      reportException(err, 'TRUST_LIST_SUBSCRIPTION_UPDATE error');
+    },
+  });
+};

package/src/utils/hooks/core/verifier-instance.ts

@@ -0,0 +1,54 @@
+import { RegisterVerifierInstanceRequest, UpdateVerifierInstanceRequest } from '@procivis/react-native-one-core';
+import { useMutation, useQuery, useQueryClient } from 'react-query';
+
+import { reportException } from '../../reporting';
+import { useONECore } from './core-context';
+
+export const VERIFIER_INSTANCE_TRUST_COLLECTIONS_QUERY_KEY = 'verifier-instance-trust-collections';
+
+export const useVerifierInstanceTrustCollections = (verifierInstanceId: string | undefined, active = true) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [VERIFIER_INSTANCE_TRUST_COLLECTIONS_QUERY_KEY, verifierInstanceId],
+    () => (verifierInstanceId ? core.getVerifierInstanceTrustCollections(verifierInstanceId) : undefined),
+    {
+      enabled: active && Boolean(verifierInstanceId),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useRegisterVerifierInstance = () => {
+  const queryClient = useQueryClient();
+  const { core, organisationId } = useONECore();
+
+  return useMutation(
+    async (request: Omit<RegisterVerifierInstanceRequest, 'organisationId'>) =>
+      core.registerVerifierInstance({
+        organisationId,
+        ...request,
+      }),
+
+    {
+      onSuccess: () => queryClient.invalidateQueries(VERIFIER_INSTANCE_TRUST_COLLECTIONS_QUERY_KEY),
+    },
+  );
+};
+
+export const useVerifierInstanceUpdate = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async ({ verifierInstanceId, update }: { verifierInstanceId: string; update: UpdateVerifierInstanceRequest }) =>
+      core.updateVerifierInstance(verifierInstanceId, update),
+    {
+      onError: async (err) => {
+        reportException(err, 'Update verifier instance failure');
+        await queryClient.invalidateQueries(VERIFIER_INSTANCE_TRUST_COLLECTIONS_QUERY_KEY);
+      },
+      onSuccess: () => queryClient.invalidateQueries(VERIFIER_INSTANCE_TRUST_COLLECTIONS_QUERY_KEY),
+    },
+  );
+};

package/src/utils/hooks/core/wallet-unit.ts

@@ -1,7 +1,8 @@
 import {
-  HolderWalletUnitResponseBindingDto,
-  WalletProviderBindingDto,
-  WalletUnitStatusBindingEnum,
+  HolderWalletUnit,
+  HolderWalletUnitUpdateRequest,
+  WalletProvider,
+  WalletUnitStatus,
 } from '@procivis/react-native-one-core';
 import { useEffect } from 'react';
 import { useMutation, useQuery, useQueryClient } from 'react-query';
@@ -10,11 +11,9 @@ import { reportException } from '../../reporting';
 import { useONECore } from './core-context';
 
 export const WALLET_UNIT_QUERY_KEY = 'wallet-unit';
+export const WALLET_UNIT_TRUST_COLLECTIONS_QUERY_KEY = 'wallet-unit-trust-collections';
 
-export const useWalletUnitDetail = (
-  walletUnitId: HolderWalletUnitResponseBindingDto['id'] | undefined,
-  active = true,
-) => {
+export const useWalletUnitDetail = (walletUnitId: HolderWalletUnit['id'] | undefined, active = true) => {
   const { core } = useONECore();
 
   return useQuery(
@@ -27,12 +26,25 @@ export const useWalletUnitDetail = (
   );
 };
 
+export const useWalletUnitTrustCollections = (walletUnitId: HolderWalletUnit['id'] | undefined, active = true) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [WALLET_UNIT_TRUST_COLLECTIONS_QUERY_KEY, walletUnitId],
+    () => (walletUnitId ? core.holderGetWalletUnitTrustCollections(walletUnitId) : undefined),
+    {
+      enabled: active && Boolean(walletUnitId),
+      keepPreviousData: true,
+    },
+  );
+};
+
 export const useRegisterWalletUnit = () => {
   const queryClient = useQueryClient();
   const { core, organisationId } = useONECore();
 
   return useMutation(
-    async (walletProvider: WalletProviderBindingDto) =>
+    async (walletProvider: WalletProvider) =>
       core.holderRegisterWalletUnit({
         keyType: 'ECDSA',
         organisationId,
@@ -40,7 +52,10 @@ export const useRegisterWalletUnit = () => {
       }),
 
     {
-      onSuccess: () => queryClient.invalidateQueries(WALLET_UNIT_QUERY_KEY),
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(WALLET_UNIT_QUERY_KEY);
+        await queryClient.invalidateQueries(WALLET_UNIT_TRUST_COLLECTIONS_QUERY_KEY);
+      },
     },
   );
 };
@@ -49,19 +64,37 @@ export const useWalletUnitStatus = () => {
   const queryClient = useQueryClient();
   const { core } = useONECore();
 
+  return useMutation(async (walletUnitId: HolderWalletUnit['id']) => core.holderWalletUnitStatus(walletUnitId), {
+    onError: async (err) => {
+      reportException(err, 'Refresh wallet unit failure');
+      await queryClient.invalidateQueries(WALLET_UNIT_QUERY_KEY);
+    },
+    onSuccess: () => queryClient.invalidateQueries(WALLET_UNIT_QUERY_KEY),
+  });
+};
+
+export const useWalletUnitUpdate = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
   return useMutation(
-    async (walletUnitId: HolderWalletUnitResponseBindingDto['id']) => core.holderWalletUnitStatus(walletUnitId),
+    async ({ walletUnitId, update }: { walletUnitId: HolderWalletUnit['id']; update: HolderWalletUnitUpdateRequest }) =>
+      core.holderWalletUnitUpdate(walletUnitId, update),
     {
       onError: async (err) => {
-        reportException(err, 'Refresh wallet unit failure');
+        reportException(err, 'Update wallet unit failure');
+        await queryClient.invalidateQueries(WALLET_UNIT_QUERY_KEY);
+        await queryClient.invalidateQueries(WALLET_UNIT_TRUST_COLLECTIONS_QUERY_KEY);
+      },
+      onSuccess: async () => {
         await queryClient.invalidateQueries(WALLET_UNIT_QUERY_KEY);
+        await queryClient.invalidateQueries(WALLET_UNIT_TRUST_COLLECTIONS_QUERY_KEY);
       },
-      onSuccess: () => queryClient.invalidateQueries(WALLET_UNIT_QUERY_KEY),
     },
   );
 };
 
-export const useWalletUnitCheck = (walletUnitId: HolderWalletUnitResponseBindingDto['id'] | undefined) => {
+export const useWalletUnitCheck = (walletUnitId: HolderWalletUnit['id'] | undefined) => {
   const { data: walletUnitDetail, isLoading } = useWalletUnitDetail(walletUnitId);
   const { mutateAsync: refreshWalletUnit, isLoading: isRefreshing, status: refreshStatus } = useWalletUnitStatus();
 
@@ -69,7 +102,7 @@ export const useWalletUnitCheck = (walletUnitId: HolderWalletUnitResponseBinding
     if (isLoading || refreshStatus !== 'idle') {
       return;
     }
-    if (walletUnitId && walletUnitDetail?.status === WalletUnitStatusBindingEnum.ACTIVE) {
+    if (walletUnitId && walletUnitDetail?.status === WalletUnitStatus.ACTIVE) {
       void refreshWalletUnit(walletUnitId);
     }
   }, [isLoading, refreshStatus, walletUnitDetail, refreshWalletUnit, walletUnitId]);

package/src/utils/hooks/revocation/credential-status.ts

@@ -1,4 +1,4 @@
-import { CredentialStateBindingEnum } from '@procivis/react-native-one-core';
+import { CredentialState } from '@procivis/react-native-one-core';
 import { useIsFocused } from '@react-navigation/native';
 import { useCallback, useRef } from 'react';
 
@@ -18,7 +18,7 @@ export const useCredentialStatusCheck = (credentialIds?: string[], forceRefresh
   const { mutateAsync: check } = useCredentialRevocationCheck(forceRefresh);
   const { data: credentials } = useCredentials({
     ids: credentialIds,
-    states: [CredentialStateBindingEnum.ACCEPTED, CredentialStateBindingEnum.SUSPENDED],
+    states: [CredentialState.ACCEPTED, CredentialState.SUSPENDED],
   });
 
   const checkCredentialsStatus = useCallback(async () => {

package/src/utils/parsers/credential-images.tsx

@@ -1,8 +1,4 @@
-import {
-  ClaimBindingDto,
-  CredentialSchemaCodeTypeBindingDto,
-  CredentialSchemaLayoutPropertiesBindingDto,
-} from '@procivis/react-native-one-core';
+import { Claim, CredentialSchemaCodeType, CredentialSchemaLayoutProperties } from '@procivis/react-native-one-core';
 import React from 'react';
 import { StyleSheet } from 'react-native';
 
@@ -21,8 +17,8 @@ const styles = StyleSheet.create({
 });
 
 export const getCarouselImagesFromClaims = (
-  claims: ClaimBindingDto[],
-  layoutProperties?: CredentialSchemaLayoutPropertiesBindingDto,
+  claims: Claim[],
+  layoutProperties?: CredentialSchemaLayoutProperties,
   testID?: string,
 ): CarouselImage[] => {
   const result: CarouselImage[] = [];
@@ -62,17 +58,17 @@ export const getCarouselImagesFromClaims = (
       return result;
     }
 
-    if (code.type === CredentialSchemaCodeTypeBindingDto.QR_CODE) {
+    if (code.type === CredentialSchemaCodeType.QR_CODE) {
       result.push({
         element: <QrCode content={claimValue} testID={concatTestID(testID, CarouselImageType.QrCode)} />,
         type: CarouselImageType.QrCode,
       });
-    } else if (code.type === CredentialSchemaCodeTypeBindingDto.BARCODE && isASCII(claimValue)) {
+    } else if (code.type === CredentialSchemaCodeType.BARCODE && isASCII(claimValue)) {
       result.push({
         element: <Barcode content={claimValue} testID={concatTestID(testID, CarouselImageType.Barcode)} />,
         type: CarouselImageType.Barcode,
       });
-    } else if (code.type === CredentialSchemaCodeTypeBindingDto.MRZ) {
+    } else if (code.type === CredentialSchemaCodeType.MRZ) {
       result.push({
         element: <Mrz content={claimValue} testID={concatTestID(testID, CarouselImageType.MRZ)} />,
         type: CarouselImageType.MRZ,