gdc-sdk-front-ts 0.5.1 → 0.6.0

package/README.md

@@ -22,11 +22,14 @@ If you are integrating this package for the first time, open these in order:
    Real frontend/native setup, imports, `new ClientSDK(...)`,
    `initializeCommunicationIdentity(...)`, provider discovery, and
    `initializeSession(...)`.
-2. [gdc-sdk-core-ts/docs/SDK_FLOWS_101.md](https://github.com/Global-DataCare/gdc-sdk-core-ts/blob/main/docs/SDK_FLOWS_101.md)
+2. [docs/DATASPACE_DISCOVERY_FRONTEND_TODO.md](./docs/DATASPACE_DISCOVERY_FRONTEND_TODO.md)
+   Frontend discovery guide for BFF-first provider/operator discovery, UI card
+   mapping, and copy/paste backend DTO consumption.
+3. [gdc-sdk-core-ts/docs/SDK_FLOWS_101.md](https://github.com/Global-DataCare/gdc-sdk-core-ts/blob/main/docs/SDK_FLOWS_101.md)
    Shared business-flow map by actor family.
-3. [gdc-common-utils-ts/src/examples/frontend-session.ts](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/src/examples/frontend-session.ts)
+4. [gdc-common-utils-ts/src/examples/frontend-session.ts](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/src/examples/frontend-session.ts)
    Shared profile/session payload source of truth.
-4. [gdc-common-utils-ts/docs/LIFECYCLE_101.md](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/docs/LIFECYCLE_101.md)
+5. [gdc-common-utils-ts/docs/LIFECYCLE_101.md](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/docs/LIFECYCLE_101.md)
    Canonical lifecycle semantics and reusable placeholders for UI and portal flows.
 
 If you need the shortest path:
@@ -55,6 +58,42 @@ Open these tests when you want to see exact frontend calls and exact inputs:
   Profile registry and persistence behavior.
 - [tests/session-descriptor.test.mjs](tests/session-descriptor.test.mjs)
   Session descriptor shaping for UI/runtime code.
+- [tests/dataspace-discovery-client.test.mjs](tests/dataspace-discovery-client.test.mjs)
+  BFF-first dataspace discovery mapping, capability filtering, and DTO-to-card
+  behavior.
+
+## Frontend Discovery Quick Map
+
+Frontend apps should not crawl host catalogs directly by default.
+
+Preferred model:
+
+- backend/BFF resolves host discovery from `/.well-known/dspace-version`
+- backend/BFF derives `/dsp/catalog/dcat.json`
+- frontend consumes normalized DTOs and maps them into cards
+
+Primary references:
+
+- [docs/DATASPACE_DISCOVERY_FRONTEND_TODO.md](./docs/DATASPACE_DISCOVERY_FRONTEND_TODO.md)
+- [tests/dataspace-discovery-client.test.mjs](tests/dataspace-discovery-client.test.mjs)
+
+Copy/paste starting point:
+
+```ts
+import { HttpDataspaceDiscoveryClient } from 'gdc-sdk-front-ts';
+import { ServiceCapabilityToken } from 'gdc-common-utils-ts/constants';
+
+const discoveryClient = new HttpDataspaceDiscoveryClient({
+  endpointUrl: '/api/dataspace-discovery/providers',
+});
+
+const result = await discoveryClient.listPublishedProviders({
+  sector: 'animal-care',
+  jurisdiction: 'ES',
+  coverageScope: 'EU',
+  providerCapability: ServiceCapabilityToken.IndexProvider,
+});
+```
 
 ## Actor Split And UI Scope
 

package/dist/discovery/DataspaceDiscoveryClient.d.ts

@@ -0,0 +1,54 @@
+import { type AppInfo } from 'gdc-sdk-core-ts';
+import type { ListPublishedProvidersInput, ListPublishedProvidersResult } from './types.js';
+type DiscoveryFetchResponse = Readonly<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+}>;
+export type DiscoveryFetch = (input: string, init?: Readonly<{
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}>) => Promise<DiscoveryFetchResponse>;
+export type HttpDataspaceDiscoveryClientOptions = Readonly<{
+    endpointUrl?: string;
+    fetcher?: DiscoveryFetch;
+    requestHeaders?: Record<string, string>;
+    appInfo?: AppInfo;
+}>;
+/**
+ * Frontend-facing discovery client.
+ *
+ * Default integration model:
+ * - browser/native app calls a portal or app backend
+ * - backend resolves dataspace discovery and returns normalized DTOs
+ *
+ * Optional direct-public-catalog mode can be layered later behind an adapter,
+ * but must not be treated as the default portal integration path.
+ */
+export interface DataspaceDiscoveryClient {
+    /**
+     * Lists publicly published provider offerings for a given sector and provider
+     * capability.
+     */
+    listPublishedProviders(input: ListPublishedProvidersInput): Promise<ListPublishedProvidersResult>;
+}
+/**
+ * Concrete frontend discovery client that calls a backend/BFF endpoint and
+ * maps normalized provider/operator DTOs into UI cards.
+ *
+ * Default integration model:
+ * - browser/native app calls a portal or app backend
+ * - backend resolves dataspace discovery and returns normalized DTO matches
+ *
+ * Optional direct-public-catalog mode can be layered later behind a separate
+ * adapter, but must not replace the BFF-first default contract.
+ */
+export declare class HttpDataspaceDiscoveryClient implements DataspaceDiscoveryClient {
+    private readonly endpointUrl;
+    private readonly fetcher;
+    private readonly requestHeaders;
+    constructor(options?: HttpDataspaceDiscoveryClientOptions);
+    listPublishedProviders(input: ListPublishedProvidersInput): Promise<ListPublishedProvidersResult>;
+}
+export {};

package/dist/discovery/DataspaceDiscoveryClient.js

@@ -0,0 +1,85 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { buildAppHeaders, resolveAppInfo } from 'gdc-sdk-core-ts';
+import { filterPublishedProviderCardsByCapability, mapHostingOperatorMatchToCard, mapPublishedProviderMatchToCard, } from './mappers.js';
+function defaultFetch(input, init) {
+    return fetch(input, init);
+}
+function normalizeResponseDto(body) {
+    if (!body || typeof body !== 'object') {
+        throw new Error('Invalid dataspace discovery response payload.');
+    }
+    const candidate = body;
+    return {
+        providers: Array.isArray(candidate.providers) ? candidate.providers : [],
+        hostingOperators: Array.isArray(candidate.hostingOperators) ? candidate.hostingOperators : undefined,
+    };
+}
+function dedupeHostingOperatorCards(cards) {
+    const seen = new Set();
+    const deduped = [];
+    for (const card of cards) {
+        const did = String(card.did || '').trim();
+        if (!did || seen.has(did))
+            continue;
+        seen.add(did);
+        deduped.push(card);
+    }
+    return deduped;
+}
+/**
+ * Concrete frontend discovery client that calls a backend/BFF endpoint and
+ * maps normalized provider/operator DTOs into UI cards.
+ *
+ * Default integration model:
+ * - browser/native app calls a portal or app backend
+ * - backend resolves dataspace discovery and returns normalized DTO matches
+ *
+ * Optional direct-public-catalog mode can be layered later behind a separate
+ * adapter, but must not replace the BFF-first default contract.
+ */
+export class HttpDataspaceDiscoveryClient {
+    constructor(options = {}) {
+        this.endpointUrl = String(options.endpointUrl || '/api/dataspace-discovery/providers').trim();
+        this.fetcher = options.fetcher || defaultFetch;
+        const appHeaders = options.appInfo
+            ? buildAppHeaders(resolveAppInfo(options.appInfo))
+            : {};
+        this.requestHeaders = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            ...appHeaders,
+            ...(options.requestHeaders || {}),
+        };
+    }
+    async listPublishedProviders(input) {
+        const response = await this.fetcher(this.endpointUrl, {
+            method: 'POST',
+            headers: this.requestHeaders,
+            body: JSON.stringify({
+                sector: input.sector,
+                providerCapability: input.providerCapability,
+                jurisdiction: input.jurisdiction,
+                coverageScope: input.coverageScope,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to list dataspace discovery providers (${response.status}).`);
+        }
+        const body = normalizeResponseDto(await response.json());
+        const providers = filterPublishedProviderCardsByCapability(body.providers.map((match) => mapPublishedProviderMatchToCard(match)), input.providerCapability);
+        const hostingOperators = body.hostingOperators
+            ? dedupeHostingOperatorCards(body.hostingOperators.map((match) => mapHostingOperatorMatchToCard(match)))
+            : dedupeHostingOperatorCards(body.providers
+                .filter((match) => match.hostingOperator)
+                .map((match) => mapHostingOperatorMatchToCard({
+                operatorDid: match.hostingOperatorDid || match.hostingOperator?.subjectId || '',
+                record: match.hostingOperator,
+                title: match.hostingOperatorTitle,
+                catalogUrl: match.record.catalogUrl,
+            })));
+        return {
+            providers,
+            hostingOperators: hostingOperators.length ? hostingOperators : undefined,
+        };
+    }
+}

package/dist/discovery/HttpDataspaceDiscoveryClient.d.ts

@@ -0,0 +1,34 @@
+import type { DataspaceDiscoveryClient } from './DataspaceDiscoveryClient.js';
+import type { ListPublishedProvidersInput, ListPublishedProvidersResult } from './types.js';
+type DiscoveryFetchResponse = Readonly<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+}>;
+export type FrontendDiscoveryFetch = (input: string, init?: Readonly<{
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}>) => Promise<DiscoveryFetchResponse>;
+export type HttpDataspaceDiscoveryClientOptions = Readonly<{
+    baseUrl: string;
+    fetcher?: FrontendDiscoveryFetch;
+    endpointPath?: string;
+    headers?: Record<string, string>;
+}>;
+/**
+ * HTTP/BFF-first frontend discovery client.
+ */
+export declare class HttpDataspaceDiscoveryClient implements DataspaceDiscoveryClient {
+    private readonly baseUrl;
+    private readonly fetcher;
+    private readonly endpointPath;
+    private readonly headers;
+    constructor(options: HttpDataspaceDiscoveryClientOptions);
+    /**
+     * Calls the configured backend/BFF endpoint and maps normalized discovery
+     * DTOs into UI-facing cards.
+     */
+    listPublishedProviders(input: ListPublishedProvidersInput): Promise<ListPublishedProvidersResult>;
+}
+export {};

package/dist/discovery/HttpDataspaceDiscoveryClient.js

@@ -0,0 +1,47 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { mapHostingOperatorRecordToCard, mapPublishedProviderRecordToCard } from './mappers.js';
+function defaultFetch(input, init) {
+    return fetch(input, init);
+}
+/**
+ * HTTP/BFF-first frontend discovery client.
+ */
+export class HttpDataspaceDiscoveryClient {
+    constructor(options) {
+        this.baseUrl = new URL(options.baseUrl.endsWith('/') ? options.baseUrl : `${options.baseUrl}/`);
+        this.fetcher = options.fetcher || defaultFetch;
+        this.endpointPath = options.endpointPath || '/api/dataspace-discovery/providers';
+        this.headers = { ...(options.headers || {}) };
+    }
+    /**
+     * Calls the configured backend/BFF endpoint and maps normalized discovery
+     * DTOs into UI-facing cards.
+     */
+    async listPublishedProviders(input) {
+        const response = await this.fetcher(new URL(this.endpointPath.replace(/^\//, ''), this.baseUrl).href, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...this.headers,
+            },
+            body: JSON.stringify(input),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to load dataspace discovery results (${response.status}).`);
+        }
+        const body = await response.json();
+        const providers = Array.isArray(body.providers)
+            ? body.providers.map((record) => mapPublishedProviderRecordToCard(record))
+            : [];
+        const hostingOperators = Array.isArray(body.hostingOperators)
+            ? body.hostingOperators.map((entry) => mapHostingOperatorRecordToCard(entry.record, {
+                catalogUrl: entry.catalogUrl,
+                title: entry.title,
+            }))
+            : [];
+        return {
+            providers,
+            ...(hostingOperators.length ? { hostingOperators } : {}),
+        };
+    }
+}

package/dist/discovery/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DataspaceDiscoveryClient.js';
+export * from './types.js';
+export * from './mappers.js';

package/dist/discovery/index.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+export * from './DataspaceDiscoveryClient.js';
+export * from './types.js';
+export * from './mappers.js';

package/dist/discovery/mappers.d.ts

@@ -0,0 +1,29 @@
+import type { HostingOperatorSemanticRecord, PublishedProviderCatalogRecord } from 'gdc-common-utils-ts';
+import type { HostingOperatorCard, HostingOperatorMatchDto, PublishedProviderCard, PublishedProviderMatchDto } from './types.js';
+/**
+ * Maps a normalized hosting-operator semantic record to a compact UI card.
+ */
+export declare function mapHostingOperatorRecordToCard(record: HostingOperatorSemanticRecord, input?: {
+    catalogUrl?: string;
+    title?: string;
+}): HostingOperatorCard;
+/**
+ * Maps a published-provider catalog entry to a compact UI card.
+ */
+export declare function mapPublishedProviderRecordToCard(record: PublishedProviderCatalogRecord, input?: {
+    title?: string;
+}): PublishedProviderCard;
+/**
+ * Maps a normalized backend/BFF hosting-operator match DTO to a compact UI
+ * card.
+ */
+export declare function mapHostingOperatorMatchToCard(match: HostingOperatorMatchDto): HostingOperatorCard;
+/**
+ * Maps a normalized backend/BFF published-provider match DTO to a compact UI
+ * card.
+ */
+export declare function mapPublishedProviderMatchToCard(match: PublishedProviderMatchDto): PublishedProviderCard;
+/**
+ * Filters provider cards by the requested capability at the presentation layer.
+ */
+export declare function filterPublishedProviderCardsByCapability(cards: readonly PublishedProviderCard[], capability: string): PublishedProviderCard[];

package/dist/discovery/mappers.js

@@ -0,0 +1,60 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+function titleFromDid(did) {
+    const normalized = String(did || '').trim();
+    if (!normalized)
+        return 'Unknown';
+    const suffix = normalized.split(':').pop() || normalized;
+    return suffix.replace(/[-_]+/g, ' ');
+}
+/**
+ * Maps a normalized hosting-operator semantic record to a compact UI card.
+ */
+export function mapHostingOperatorRecordToCard(record, input = {}) {
+    return {
+        did: record.subjectId || '',
+        title: input.title || titleFromDid(record.subjectId || ''),
+        sectors: record.categories,
+        coverageLabel: record.areaServed.join(', ') || record.coverageScope,
+        catalogUrl: input.catalogUrl,
+    };
+}
+/**
+ * Maps a published-provider catalog entry to a compact UI card.
+ */
+export function mapPublishedProviderRecordToCard(record, input = {}) {
+    return {
+        did: record.providerDid,
+        title: input.title || titleFromDid(record.providerDid),
+        sector: record.category,
+        capability: record.serviceType,
+        coverageLabel: record.areaServed,
+        endpointUrl: record.endpointUrl,
+        catalogUrl: record.catalogUrl,
+    };
+}
+/**
+ * Maps a normalized backend/BFF hosting-operator match DTO to a compact UI
+ * card.
+ */
+export function mapHostingOperatorMatchToCard(match) {
+    return mapHostingOperatorRecordToCard(match.record, {
+        catalogUrl: match.catalogUrl,
+        title: match.title,
+    });
+}
+/**
+ * Maps a normalized backend/BFF published-provider match DTO to a compact UI
+ * card.
+ */
+export function mapPublishedProviderMatchToCard(match) {
+    return mapPublishedProviderRecordToCard(match.record, {
+        title: match.title,
+    });
+}
+/**
+ * Filters provider cards by the requested capability at the presentation layer.
+ */
+export function filterPublishedProviderCardsByCapability(cards, capability) {
+    const normalized = String(capability || '').trim();
+    return cards.filter((card) => card.capability === normalized);
+}

package/dist/discovery/types.d.ts

@@ -0,0 +1,83 @@
+import type { DataspaceDiscoveryFilter } from 'gdc-common-utils-ts';
+import type { HostingOperatorSemanticRecord, PublishedProviderCatalogRecord, TenantServiceSemanticRecord } from 'gdc-common-utils-ts';
+/**
+ * Input used by frontend discovery clients to request published providers from
+ * a backend/BFF or, optionally, a public-catalog adapter.
+ *
+ * Default integration:
+ * - browser/native app calls its backend
+ * - backend resolves host DSP discovery and returns normalized DTOs
+ */
+export type ListPublishedProvidersInput = Omit<DataspaceDiscoveryFilter, 'capability' | 'requiredCapabilities'> & Readonly<{
+    providerCapability: string;
+}>;
+/**
+ * Normalized hosting-operator match DTO returned by a backend/BFF discovery
+ * endpoint.
+ *
+ * `catalogUrl` is optional because the frontend should not need to know
+ * whether the backend started from `/.well-known/dspace-version` and derived
+ * the DSP artifact or received a pre-normalized DTO from another layer.
+ */
+export type HostingOperatorMatchDto = Readonly<{
+    operatorDid: string;
+    record: HostingOperatorSemanticRecord;
+    matchedCapabilities?: readonly string[];
+    catalogUrl?: string;
+    title?: string;
+}>;
+/**
+ * Normalized published-provider match DTO returned by a backend/BFF discovery
+ * endpoint.
+ *
+ * `record.discoveryUrl` is the participant-scoped `/.well-known/dspace-version`
+ * entrypoint when the backend chooses to expose it.
+ *
+ * `record.catalogUrl` is the derived `/dsp/catalog/dcat.json` artifact.
+ */
+export type PublishedProviderMatchDto = Readonly<{
+    providerDid: string;
+    record: PublishedProviderCatalogRecord;
+    hostingOperator?: HostingOperatorSemanticRecord;
+    hostingOperatorDid?: string;
+    tenantSemanticRecord?: TenantServiceSemanticRecord;
+    title?: string;
+    hostingOperatorTitle?: string;
+}>;
+/**
+ * Compact UI-oriented hosting-operator summary.
+ */
+export type HostingOperatorCard = Readonly<{
+    did: string;
+    title: string;
+    sectors: string[];
+    coverageLabel?: string;
+    catalogUrl?: string;
+}>;
+/**
+ * Compact UI-oriented provider summary.
+ */
+export type PublishedProviderCard = Readonly<{
+    did: string;
+    title: string;
+    sector: string;
+    capability: string;
+    coverageLabel?: string;
+    endpointUrl?: string;
+    catalogUrl?: string;
+}>;
+/**
+ * Frontend-facing result shape for published provider discovery.
+ */
+export type ListPublishedProvidersResult = Readonly<{
+    providers: PublishedProviderCard[];
+    hostingOperators?: HostingOperatorCard[];
+}>;
+/**
+ * Backend/BFF discovery payload consumed by the frontend HTTP discovery
+ * client before mapping into UI cards.
+ */
+export type ListPublishedProvidersResponseDto = Readonly<{
+    providers: readonly PublishedProviderMatchDto[];
+    hostingOperators?: readonly HostingOperatorMatchDto[];
+}>;

package/dist/discovery/types.js

@@ -0,0 +1,2 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+export {};

package/dist/index.d.ts

@@ -10,3 +10,4 @@ export * from './VerifierService.js';
 export * from './ProfileManager.js';
 export * from './ProfileRegistry.js';
 export * from './ClientSDK.js';
+export * from './discovery/index.js';

package/dist/index.js

@@ -11,3 +11,4 @@ export * from './VerifierService.js';
 export * from './ProfileManager.js';
 export * from './ProfileRegistry.js';
 export * from './ClientSDK.js';
+export * from './discovery/index.js';

package/dist/services.d.ts

@@ -1,12 +1,4 @@
-/**
- * @fileoverview Frontend-only service facades.
- *
- * @architecture 101
- * Keep this layer free from GW routing/crypto concerns. Product apps should call
- * their portal/BFF here and map responses into shared DTOs.
- */
 import type { DeviceAppType, DeviceUserClass } from 'gdc-common-utils-ts/constants';
-import type { FrontRelatedProfileSearchResult } from './types.js';
 export declare class CommonAuthService {
     activateDevice(_licenseCode: string, _providerDid: string, _idToken: string): Promise<{
         thid: string;
@@ -168,13 +160,6 @@ export declare class IndividualService {
     }): Promise<{
         thid: string;
     }>;
-    /**
-     * Placeholder frontend-facing related-profile query surface.
-     *
-     * Product integrations are expected to call a portal/BFF endpoint such as
-     * `GET /api/personal/related-profiles` and map the response to this shared DTO.
-     */
-    listRelatedProfiles(actorIdentifier: string): Promise<FrontRelatedProfileSearchResult>;
 }
 export declare class PhysicianService {
 }

package/dist/services.js

@@ -1,12 +1,4 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-/**
- * @fileoverview Frontend-only service facades.
- *
- * @architecture 101
- * Keep this layer free from GW routing/crypto concerns. Product apps should call
- * their portal/BFF here and map responses into shared DTOs.
- */
-import { RELATED_PROFILE_SEARCH_PARAM_ACTOR_IDENTIFIER } from 'gdc-sdk-core-ts';
 function requireNonEmptyText(value, fieldName) {
     const normalized = String(value ?? '').trim();
     if (!normalized) {
@@ -79,21 +71,6 @@ export class IndividualService {
     async getLatestIps(_subject, _providerDid, _requiredScope, _idToken, _date) {
         return { thid: `thid-${Date.now()}` };
     }
-    /**
-     * Placeholder frontend-facing related-profile query surface.
-     *
-     * Product integrations are expected to call a portal/BFF endpoint such as
-     * `GET /api/personal/related-profiles` and map the response to this shared DTO.
-     */
-    async listRelatedProfiles(actorIdentifier) {
-        requireNonEmptyText(actorIdentifier, `listRelatedProfiles ${RELATED_PROFILE_SEARCH_PARAM_ACTOR_IDENTIFIER}`);
-        const data = [];
-        return {
-            actorIdentifier,
-            total: data.length,
-            data,
-        };
-    }
 }
 export class PhysicianService {
 }

package/dist/types.d.ts

@@ -1,10 +1,4 @@
-/**
- * @fileoverview Frontend SDK shared type aliases.
- *
- * @architecture 101
- * Re-export runtime-neutral contracts instead of duplicating DTO definitions.
- */
-import type { IApiConfig, INetwork, BundleSearchQuery, CommunicationInput, DateRange, RelatedProfileSearchInput, RelatedProfileSearchResult, RelatedProfileRole, RelatedProfileStatus, RelatedProfileSummary } from 'gdc-sdk-core-ts';
+import type { IApiConfig, INetwork, BundleSearchQuery, CommunicationInput, DateRange } from 'gdc-sdk-core-ts';
 export type { AppInfo, ResolvedAppInfo, InitializeSessionParams, Profile, ProfileRegistryEntry, VaultQueryCondition, VaultQuery, IVaultRepository, IApiConfig, INetwork, IVerifier } from 'gdc-sdk-core-ts';
 export type SdkConfig = {
     crypto?: unknown;
@@ -15,8 +9,3 @@ export type SdkConfig = {
 export type FrontDateRange = DateRange;
 export type FrontBundleSearchQuery = BundleSearchQuery;
 export type FrontCommunicationInput = CommunicationInput;
-export type FrontRelatedProfileStatus = RelatedProfileStatus;
-export type FrontRelatedProfileRole = RelatedProfileRole;
-export type FrontRelatedProfileSearchInput = RelatedProfileSearchInput;
-export type FrontRelatedProfileSummary = RelatedProfileSummary;
-export type FrontRelatedProfileSearchResult = RelatedProfileSearchResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-front-ts",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Next-generation frontend runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -17,8 +17,8 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.28.4",
-    "gdc-common-utils-ts": "^1.10.0",
-    "gdc-sdk-core-ts": "^0.5.1"
+    "gdc-common-utils-ts": "^1.13.0",
+    "gdc-sdk-core-ts": "^0.6.0"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",