gdc-common-utils-ts 2.0.4 → 2.0.5

package/dist/constants/verifiable-credentials.d.ts

@@ -30,5 +30,11 @@ export declare const ActivationCredentialTypes: Readonly<{
     LegalRepresentativeCredential: "LegalRepresentativeCredential";
     PersonCredential: "PersonCredential";
 }>;
+/**
+ * Canonical credential subtype names used by professional/member access flows.
+ */
+export declare const ProfessionalCredentialTypes: Readonly<{
+    EmployeeCredential: "EmployeeCredential";
+}>;
 export declare const ORGANIZATION_ACTIVATION_VC_TYPES: readonly ("OrganizationCredential" | "LegalOrganizationCredential")[];
 export declare const REPRESENTATIVE_ACTIVATION_VC_TYPES: readonly ("LegalRepresentativeCredential" | "PersonCredential")[];

package/dist/constants/verifiable-credentials.js

@@ -32,6 +32,12 @@ export const ActivationCredentialTypes = Object.freeze({
     LegalRepresentativeCredential: 'LegalRepresentativeCredential',
     PersonCredential: 'PersonCredential',
 });
+/**
+ * Canonical credential subtype names used by professional/member access flows.
+ */
+export const ProfessionalCredentialTypes = Object.freeze({
+    EmployeeCredential: 'EmployeeCredential',
+});
 export const ORGANIZATION_ACTIVATION_VC_TYPES = Object.freeze([
     ActivationCredentialTypes.OrganizationCredential,
     ActivationCredentialTypes.LegalOrganizationCredential,

package/dist/examples/employee.d.ts

@@ -39,3 +39,18 @@ export declare const EXAMPLE_EMPLOYEE_DIRECTORY_RECORDS: readonly [Readonly<{
     status: "active" | "inactive" | "purged";
 }>];
 export declare function buildExampleEmployeeClaims(record: ExampleEmployeeRecord): Readonly<Record<string, string>>;
+/**
+ * Canonical employee search/list response body reused by runtime and doc tests.
+ *
+ * This keeps one stable GW-style envelope for high-level tutorials that want
+ * to show employee directory flows without reauthoring `meta.claims` by hand.
+ */
+export declare const EXAMPLE_EMPLOYEE_SEARCH_RESPONSE_BODY: Readonly<{
+    readonly data: {
+        id: string;
+        meta: {
+            status: "active" | "inactive" | "purged";
+            claims: Readonly<Record<string, string>>;
+        };
+    }[];
+}>;

package/dist/examples/employee.js

@@ -37,3 +37,18 @@ export function buildExampleEmployeeClaims(record) {
         [ClaimsPersonSchemaorg.hasOccupationalRoleValue]: record.role,
     });
 }
+/**
+ * Canonical employee search/list response body reused by runtime and doc tests.
+ *
+ * This keeps one stable GW-style envelope for high-level tutorials that want
+ * to show employee directory flows without reauthoring `meta.claims` by hand.
+ */
+export const EXAMPLE_EMPLOYEE_SEARCH_RESPONSE_BODY = Object.freeze({
+    data: EXAMPLE_EMPLOYEE_DIRECTORY_RECORDS.map((record) => ({
+        id: record.identifier,
+        meta: {
+            status: record.status,
+            claims: buildExampleEmployeeClaims(record),
+        },
+    })),
+});

package/dist/examples/individual-controller.d.ts

@@ -98,3 +98,28 @@ export declare const EXAMPLE_DIGITAL_TWIN_COMPOSITION_INPUT: {
 };
 export declare const EXAMPLE_CLINICAL_BUNDLE_SEARCH_INPUT: ExampleClinicalBundleSearchInput;
 export declare const EXAMPLE_LATEST_IPS_SEARCH_INPUT: ExampleLatestIpsSearchInput;
+export declare const EXAMPLE_FAMILY_ORGANIZATION_SEARCH_INPUT: {
+    readonly controllerPhone: "+34600000001";
+    readonly usualname: "Ana";
+    readonly birthDate: "2010-05-20";
+};
+export declare const EXAMPLE_FAMILY_ORGANIZATION_SEARCH_RESPONSE_BODY: {
+    readonly body: {
+        readonly data: readonly [{
+            readonly type: "Family-search-result-v1.0";
+            readonly meta: {
+                readonly claims: {
+                    readonly 'org.schema.FamilyRegistration.status': "already_exists";
+                    readonly 'org.schema.Offer.identifier': "offer-uuid-001";
+                    readonly 'org.schema.Organization.identifier.value': "org-uuid-001";
+                    readonly 'org.schema.Organization.alternateName': "Ana";
+                    readonly 'org.schema.Organization.owner.telephone': "+34600000001";
+                    readonly 'org.schema.Organization.foundingDate': "2010-05-20";
+                };
+            };
+            readonly resource: {
+                readonly id: "org-uuid-001";
+            };
+        }];
+    };
+};

package/dist/examples/individual-controller.js

@@ -69,3 +69,26 @@ export const EXAMPLE_CLINICAL_BUNDLE_SEARCH_INPUT = {
 export const EXAMPLE_LATEST_IPS_SEARCH_INPUT = {
     subject: EXAMPLE_SUBJECT_DID,
 };
+export const EXAMPLE_FAMILY_ORGANIZATION_SEARCH_INPUT = {
+    controllerPhone: '+34600000001',
+    usualname: 'Ana',
+    birthDate: '2010-05-20',
+};
+export const EXAMPLE_FAMILY_ORGANIZATION_SEARCH_RESPONSE_BODY = {
+    body: {
+        data: [{
+                type: 'Family-search-result-v1.0',
+                meta: {
+                    claims: {
+                        'org.schema.FamilyRegistration.status': 'already_exists',
+                        'org.schema.Offer.identifier': 'offer-uuid-001',
+                        'org.schema.Organization.identifier.value': 'org-uuid-001',
+                        'org.schema.Organization.alternateName': EXAMPLE_FAMILY_ORGANIZATION_SEARCH_INPUT.usualname,
+                        'org.schema.Organization.owner.telephone': EXAMPLE_FAMILY_ORGANIZATION_SEARCH_INPUT.controllerPhone,
+                        'org.schema.Organization.foundingDate': EXAMPLE_FAMILY_ORGANIZATION_SEARCH_INPUT.birthDate,
+                    },
+                },
+                resource: { id: 'org-uuid-001' },
+            }],
+    },
+};

package/dist/examples/legal-organization-verification-transaction.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 import { ClaimsOrganizationSchemaorg, ClaimsPersonSchemaorg, ClaimsServiceSchemaorg, } from '../constants/schemaorg.js';
+import { serializeServiceCapabilityTokens, ServiceCapability, } from '../constants/service-capabilities.js';
 import { buildLegalOrganizationVerificationTransactionBundle, } from '../utils/legal-organization-verification-transaction.js';
 import { EXAMPLE_CONTROLLER_BINDING, EXAMPLE_EMAIL_CONTROLLER_ORG, EXAMPLE_JURISDICTION, EXAMPLE_ORGANIZATION_LEGAL_NAME, EXAMPLE_LEGAL_ORGANIZATION_TAX_ID, EXAMPLE_SECTOR, EXAMPLE_SIGNED_TERMS_PDF_URL, EXAMPLE_TENANT_SERVICE_DID, } from './shared.js';
 /**
@@ -11,6 +12,11 @@ import { EXAMPLE_CONTROLLER_BINDING, EXAMPLE_EMAIL_CONTROLLER_ORG, EXAMPLE_JURIS
  *   that wraps an ICA `_verify`
  * - the example keeps the controller business binding separate from any
  *   technical DIDComm communication key
+ *
+ * Contract note:
+ * - the same request must already declare the requested tenant service
+ *   capabilities because GW uses them to prepare the pending Offer that the
+ *   client will later confirm via `Order/_batch`
  */
 const exampleControllerBinding = {
     did: EXAMPLE_CONTROLLER_BINDING.did,
@@ -36,6 +42,10 @@ export const EXAMPLE_LEGAL_ORGANIZATION_VERIFICATION_TRANSACTION_BUNDLE = buildL
         [ClaimsServiceSchemaorg.category]: EXAMPLE_SECTOR,
         [ClaimsServiceSchemaorg.identifier]: EXAMPLE_TENANT_SERVICE_DID,
         [ClaimsServiceSchemaorg.url]: `https://operator.example.net/acme/cds-${String(EXAMPLE_JURISDICTION).toLowerCase()}/v1/${EXAMPLE_SECTOR}`,
+        [ClaimsServiceSchemaorg.serviceType]: serializeServiceCapabilityTokens([
+            ServiceCapability.IndexProvider,
+            ServiceCapability.DigitalTwinReader,
+        ]),
     },
     controller: exampleControllerBinding,
     organization: {

package/dist/examples/shared.d.ts

@@ -91,6 +91,13 @@ export declare const EXAMPLE_TENANT_ROUTE_CONTEXT: {
 export declare const EXAMPLE_HOST_ROUTE_CONTEXT: {
     readonly hostCoverageScope: "EU";
     readonly jurisdiction: "ES";
+    /**
+     * Host route segment used in `/host/cds-{hostCoverageScope}/v1/{hostNetwork}/...`.
+     *
+     * This is intentionally not the tenant business sector.
+     */
+    readonly hostNetwork: "test";
+    /** @deprecated Use `hostNetwork`. */
     readonly sector: "test";
 };
 export declare const EXAMPLE_CONTROLLER_DID: "did:web:people.acme.org:controllers:primary";

package/dist/examples/shared.js

@@ -106,7 +106,14 @@ export const EXAMPLE_TENANT_ROUTE_CONTEXT = {
 export const EXAMPLE_HOST_ROUTE_CONTEXT = {
     hostCoverageScope: EXAMPLE_HOST_COVERAGE_SCOPE,
     jurisdiction: EXAMPLE_JURISDICTION,
-    sector: HostNetworkTypes.Test,
+    /**
+     * Host route segment used in `/host/cds-{hostCoverageScope}/v1/{hostNetwork}/...`.
+     *
+     * This is intentionally not the tenant business sector.
+     */
+    hostNetwork: EXAMPLE_NETWORK_TYPE,
+    /** @deprecated Use `hostNetwork`. */
+    sector: EXAMPLE_NETWORK_TYPE,
 };
 export const EXAMPLE_CONTROLLER_DID = 'did:web:people.acme.org:controllers:primary';
 export const EXAMPLE_CONTROLLER_EMAIL = EXAMPLE_EMAIL_CONTROLLER_ORG;

package/dist/utils/bundle-reader.d.ts

@@ -84,3 +84,5 @@ export declare class BundleReader {
     private buildSeverityBucket;
     private resolveEntryIdentifier;
 }
+export declare function unwrapBundleLikeResponseBody(input: unknown): Record<string, unknown>;
+export declare function readFirstBundleResourceFromResponseBody(input: unknown): Record<string, unknown> | undefined;

package/dist/utils/bundle-reader.js

@@ -221,3 +221,17 @@ export class BundleReader {
 function normalizeOptionalString(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
+export function unwrapBundleLikeResponseBody(input) {
+    const body = input && typeof input === 'object' ? input : {};
+    const nested = body.body && typeof body.body === 'object' ? body.body : undefined;
+    const candidate = nested && (Array.isArray(nested.data) || Array.isArray(nested.entry))
+        ? nested
+        : body;
+    return candidate && typeof candidate === 'object' ? candidate : {};
+}
+export function readFirstBundleResourceFromResponseBody(input) {
+    const reader = new BundleReader(unwrapBundleLikeResponseBody(input));
+    const first = reader.getEntries()[0];
+    const resource = first?.resource;
+    return resource && typeof resource === 'object' ? resource : undefined;
+}

package/dist/utils/clinical-bundle-summary.d.ts

@@ -0,0 +1,20 @@
+import type { ClinicalResourceBundleLike } from './clinical-resource-view.js';
+export type ClinicalBundleTypeSummary = Readonly<{
+    resourceType: string;
+    count: number;
+}>;
+export type ClinicalBundleSummary = Readonly<{
+    totalEntries: number;
+    resourceTypes: ClinicalBundleTypeSummary[];
+    xhtmlEntries: number;
+    notedEntries: number;
+}>;
+/**
+ * Builds one high-level summary from a FHIR/IPS bundle already normalized to
+ * the common clinical-resource view contract.
+ *
+ * Intended for BFF/frontend/call-center code that needs to announce simple
+ * menu facts such as "how many medications are present" without hand-reading
+ * bundle entries.
+ */
+export declare function summarizeClinicalBundle(bundle: ClinicalResourceBundleLike): ClinicalBundleSummary;

package/dist/utils/clinical-bundle-summary.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { toClinicalResourceExpandedViews } from './clinical-resource-view.js';
+/**
+ * Builds one high-level summary from a FHIR/IPS bundle already normalized to
+ * the common clinical-resource view contract.
+ *
+ * Intended for BFF/frontend/call-center code that needs to announce simple
+ * menu facts such as "how many medications are present" without hand-reading
+ * bundle entries.
+ */
+export function summarizeClinicalBundle(bundle) {
+    const views = toClinicalResourceExpandedViews(bundle);
+    const counts = new Map();
+    let xhtmlEntries = 0;
+    let notedEntries = 0;
+    views.forEach((view) => {
+        const resourceType = String(view.common.resourceType || 'Unknown').trim() || 'Unknown';
+        counts.set(resourceType, (counts.get(resourceType) || 0) + 1);
+        if (String(view.xhtml || '').trim()) {
+            xhtmlEntries += 1;
+        }
+        if (Array.isArray(view.notes) && view.notes.length > 0) {
+            notedEntries += 1;
+        }
+    });
+    return {
+        totalEntries: views.length,
+        resourceTypes: [...counts.entries()]
+            .map(([resourceType, count]) => ({ resourceType, count }))
+            .sort((left, right) => left.resourceType.localeCompare(right.resourceType)),
+        xhtmlEntries,
+        notedEntries,
+    };
+}

package/dist/utils/didcomm-submit-policy.d.ts

@@ -1,10 +1,27 @@
-export type CommunicationMode = 'plain' | 'strict' | 'auto-detect';
+export declare const DIDCOMM_COMMUNICATION_MODES: Readonly<{
+    readonly Plain: "plain";
+    readonly Strict: "strict";
+    readonly AutoDetect: "auto-detect";
+}>;
+export type CommunicationMode = typeof DIDCOMM_COMMUNICATION_MODES[keyof typeof DIDCOMM_COMMUNICATION_MODES];
+export declare const DIDCOMM_SUBMIT_KINDS: Readonly<{
+    readonly Plain: "plain";
+    readonly Encrypted: "encrypted";
+}>;
+export type DidcommSubmitKind = typeof DIDCOMM_SUBMIT_KINDS[keyof typeof DIDCOMM_SUBMIT_KINDS];
 export type DidcommSubmissionCapabilities = {
     hasRecipientEncryptionJwk: boolean;
 };
+export declare const DIDCOMM_SUBMISSION_REASONS: Readonly<{
+    readonly PlainMode: "plain-mode";
+    readonly StrictMode: "strict-mode";
+    readonly AutoDetectEncrypted: "auto-detect-encrypted";
+    readonly AutoDetectPlain: "auto-detect-plain";
+}>;
+export type DidcommSubmissionReason = typeof DIDCOMM_SUBMISSION_REASONS[keyof typeof DIDCOMM_SUBMISSION_REASONS];
 export type DidcommSubmissionPlan = {
     mode: CommunicationMode;
-    submitKind: 'plain' | 'encrypted';
-    reason: 'plain-mode' | 'strict-mode' | 'auto-detect-encrypted' | 'auto-detect-plain';
+    submitKind: DidcommSubmitKind;
+    reason: DidcommSubmissionReason;
 };
 export declare function resolveDidcommSubmissionPlan(mode: CommunicationMode, capabilities: DidcommSubmissionCapabilities): DidcommSubmissionPlan;

package/dist/utils/didcomm-submit-policy.js

@@ -1,15 +1,46 @@
+export const DIDCOMM_COMMUNICATION_MODES = Object.freeze({
+    Plain: 'plain',
+    Strict: 'strict',
+    AutoDetect: 'auto-detect',
+});
+export const DIDCOMM_SUBMIT_KINDS = Object.freeze({
+    Plain: 'plain',
+    Encrypted: 'encrypted',
+});
+export const DIDCOMM_SUBMISSION_REASONS = Object.freeze({
+    PlainMode: 'plain-mode',
+    StrictMode: 'strict-mode',
+    AutoDetectEncrypted: 'auto-detect-encrypted',
+    AutoDetectPlain: 'auto-detect-plain',
+});
 export function resolveDidcommSubmissionPlan(mode, capabilities) {
-    if (mode === 'plain') {
-        return { mode, submitKind: 'plain', reason: 'plain-mode' };
+    if (mode === DIDCOMM_COMMUNICATION_MODES.Plain) {
+        return {
+            mode,
+            submitKind: DIDCOMM_SUBMIT_KINDS.Plain,
+            reason: DIDCOMM_SUBMISSION_REASONS.PlainMode,
+        };
     }
-    if (mode === 'strict') {
+    if (mode === DIDCOMM_COMMUNICATION_MODES.Strict) {
         if (!capabilities.hasRecipientEncryptionJwk) {
             throw new Error('strict mode requires recipient encryption JWK.');
         }
-        return { mode, submitKind: 'encrypted', reason: 'strict-mode' };
+        return {
+            mode,
+            submitKind: DIDCOMM_SUBMIT_KINDS.Encrypted,
+            reason: DIDCOMM_SUBMISSION_REASONS.StrictMode,
+        };
     }
     if (capabilities.hasRecipientEncryptionJwk) {
-        return { mode, submitKind: 'encrypted', reason: 'auto-detect-encrypted' };
+        return {
+            mode,
+            submitKind: DIDCOMM_SUBMIT_KINDS.Encrypted,
+            reason: DIDCOMM_SUBMISSION_REASONS.AutoDetectEncrypted,
+        };
     }
-    return { mode, submitKind: 'plain', reason: 'auto-detect-plain' };
+    return {
+        mode,
+        submitKind: DIDCOMM_SUBMIT_KINDS.Plain,
+        reason: DIDCOMM_SUBMISSION_REASONS.AutoDetectPlain,
+    };
 }

package/dist/utils/didcomm-submit.d.ts

@@ -1,4 +1,11 @@
-import { CommunicationMode } from './didcomm-submit-policy';
+import { CommunicationMode, type DidcommSubmitKind } from './didcomm-submit-policy';
+export declare const DIDCOMM_PLAINTEXT_JSON_MEDIA_TYPE: "application/didcomm-plaintext+json";
+export declare const DIDCOMM_ENCRYPTED_JSON_MEDIA_TYPE: "application/didcomm-encrypted+json";
+export declare const DIDCOMM_DEFAULT_ACCEPT_HEADER: "application/json, application/didcomm-plaintext+json, */*";
+export declare const DIDCOMM_CONTENT_TYPE_BY_SUBMIT_KIND: Readonly<{
+    readonly plain: "application/didcomm-plaintext+json";
+    readonly encrypted: "application/didcomm-encrypted+json";
+}>;
 export type DidcommFetchInit = {
     method: 'POST';
     headers: Record<string, string>;
@@ -28,8 +35,8 @@ export type DidcommSubmitResult = {
     status: number;
     location?: string;
     body: unknown;
-    submitKind: 'plain' | 'encrypted';
-    contentType: 'application/didcomm-plaintext+json' | 'application/didcomm-encrypted+json';
+    submitKind: DidcommSubmitKind;
+    contentType: typeof DIDCOMM_PLAINTEXT_JSON_MEDIA_TYPE | typeof DIDCOMM_ENCRYPTED_JSON_MEDIA_TYPE;
 };
 /**
  * Submits a DIDComm payload using either plaintext or encrypted transport,

package/dist/utils/didcomm-submit.js

@@ -1,4 +1,11 @@
-import { resolveDidcommSubmissionPlan } from './didcomm-submit-policy.js';
+import { DIDCOMM_SUBMIT_KINDS, resolveDidcommSubmissionPlan, } from './didcomm-submit-policy.js';
+export const DIDCOMM_PLAINTEXT_JSON_MEDIA_TYPE = 'application/didcomm-plaintext+json';
+export const DIDCOMM_ENCRYPTED_JSON_MEDIA_TYPE = 'application/didcomm-encrypted+json';
+export const DIDCOMM_DEFAULT_ACCEPT_HEADER = `application/json, ${DIDCOMM_PLAINTEXT_JSON_MEDIA_TYPE}, */*`;
+export const DIDCOMM_CONTENT_TYPE_BY_SUBMIT_KIND = Object.freeze({
+    [DIDCOMM_SUBMIT_KINDS.Plain]: DIDCOMM_PLAINTEXT_JSON_MEDIA_TYPE,
+    [DIDCOMM_SUBMIT_KINDS.Encrypted]: DIDCOMM_ENCRYPTED_JSON_MEDIA_TYPE,
+});
 function getHeaderValue(headers, name) {
     if (!headers || typeof headers.get !== 'function') {
         return undefined;
@@ -40,12 +47,12 @@ export async function submitDidcomm(input) {
     });
     const headers = {
         ...(input.defaultHeaders ?? {}),
-        Accept: 'application/json, application/didcomm-plaintext+json, */*',
+        Accept: DIDCOMM_DEFAULT_ACCEPT_HEADER,
     };
     let body;
     let contentType;
-    if (plan.submitKind === 'plain') {
-        contentType = 'application/didcomm-plaintext+json';
+    if (plan.submitKind === DIDCOMM_SUBMIT_KINDS.Plain) {
+        contentType = DIDCOMM_CONTENT_TYPE_BY_SUBMIT_KIND[DIDCOMM_SUBMIT_KINDS.Plain];
         body = JSON.stringify(input.payload);
     }
     else {
@@ -60,7 +67,7 @@ export async function submitDidcomm(input) {
         }
         const compactJws = await input.signCompactJws(input.payload);
         body = await input.encryptCompactJwe(compactJws, input.recipientEncryptionJwk);
-        contentType = 'application/didcomm-encrypted+json';
+        contentType = DIDCOMM_CONTENT_TYPE_BY_SUBMIT_KIND[DIDCOMM_SUBMIT_KINDS.Encrypted];
     }
     headers['Content-Type'] = contentType;
     if (input.bearerToken) {

package/dist/utils/family-organization-summary.d.ts

@@ -0,0 +1,24 @@
+export type FamilyRegistrationStatus = 'new_created' | 'resume_required' | 'already_exists' | 'not_found';
+export type FamilyOrganizationSubjectInfo = Readonly<{
+    identifierType?: string;
+    identifierValue?: string;
+    alternateName?: string;
+    birthDate?: string;
+    ownerTelephone?: string;
+}>;
+export type FamilyOrganizationSummary = Readonly<{
+    status: FamilyRegistrationStatus;
+    offerId?: string;
+    organizationId?: string;
+    subjectInfo?: FamilyOrganizationSubjectInfo;
+    missingFields?: string[];
+    updatedAt?: string;
+}>;
+/**
+ * Reads the first family-organization summary returned by current GW-style
+ * search or batch responses.
+ *
+ * Returns `null` when the response does not contain one usable summary or when
+ * the registration status is explicitly `not_found`.
+ */
+export declare function readFamilyOrganizationSummaryFromResponseBody(body: unknown): FamilyOrganizationSummary | null;

package/dist/utils/family-organization-summary.js

@@ -0,0 +1,59 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+function normalizeText(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized || undefined;
+}
+function normalizeStringList(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value.map((item) => normalizeText(item)).filter(Boolean);
+    return items.length ? items : undefined;
+}
+/**
+ * Reads the first family-organization summary returned by current GW-style
+ * search or batch responses.
+ *
+ * Returns `null` when the response does not contain one usable summary or when
+ * the registration status is explicitly `not_found`.
+ */
+export function readFamilyOrganizationSummaryFromResponseBody(body) {
+    const root = asRecord(body);
+    const bodyNode = asRecord(root.body);
+    const rawEntries = Array.isArray(bodyNode.data)
+        ? bodyNode.data
+        : (Array.isArray(root.data) ? root.data : []);
+    const firstEntry = rawEntries[0];
+    if (!firstEntry || typeof firstEntry !== 'object') {
+        return null;
+    }
+    const entry = asRecord(firstEntry);
+    const entryMeta = asRecord(entry.meta);
+    const entryResource = asRecord(entry.resource);
+    const entryResourceMeta = asRecord(entryResource.meta);
+    const claims = {
+        ...asRecord(entryMeta.claims),
+        ...asRecord(entryResourceMeta.claims),
+    };
+    const status = normalizeText(claims['org.schema.FamilyRegistration.status'] ?? claims.status);
+    if (!status || status === 'not_found') {
+        return null;
+    }
+    return {
+        status,
+        offerId: normalizeText(claims['org.schema.Offer.identifier']),
+        organizationId: normalizeText(claims['org.schema.Organization.identifier.value'] ?? entryResource.id),
+        subjectInfo: {
+            identifierType: normalizeText(claims['org.schema.Organization.identifier.additionalType']),
+            identifierValue: normalizeText(claims['org.schema.Organization.identifier.value']),
+            alternateName: normalizeText(claims['org.schema.Organization.alternateName']),
+            birthDate: normalizeText(claims['org.schema.Organization.foundingDate']),
+            ownerTelephone: normalizeText(claims['org.schema.Organization.owner.telephone']),
+        },
+        missingFields: normalizeStringList(claims['org.schema.FamilyRegistration.missingFields'] ?? claims.missingFields),
+        updatedAt: normalizeText(claims['org.schema.FamilyRegistration.updatedAt'] ?? claims.updatedAt),
+    };
+}

package/dist/utils/index.d.ts

@@ -28,6 +28,7 @@ export * from './discovery-normalization';
 export * from './format-converter';
 export * from './fhir-cid';
 export * from './fhir-search';
+export * from './family-organization-summary';
 export * from './gw-core-path';
 export * from './communication-fhir-r4';
 export * from './communication-document-reference';
@@ -41,13 +42,16 @@ export * from './communication-attached-bundle-session';
 export * from './confidential-storage-persistence';
 export * from './confidential-storage-test-data';
 export * from './permission-templates';
+export * from './professional-smart';
 export * from './related-person-list';
 export * from './clinical-resource-converters';
+export * from './clinical-bundle-summary';
 export * from './clinical-resource-view';
 export * from './fhir-validator';
 export * from './family-registration-test-data';
 export * from './individual-form-pdf';
 export * from './individual-organization-claims';
+export * from './legal-organization-onboarding-editor';
 export * from './organization-lifecycle';
 export * from './organization-did-binding';
 export * from './individual-organization-lifecycle';

package/dist/utils/index.js

@@ -28,6 +28,7 @@ export * from './discovery-normalization.js';
 export * from './format-converter.js';
 export * from './fhir-cid.js';
 export * from './fhir-search.js';
+export * from './family-organization-summary.js';
 export * from './gw-core-path.js';
 export * from './communication-fhir-r4.js';
 export * from './communication-document-reference.js';
@@ -41,13 +42,16 @@ export * from './communication-attached-bundle-session.js';
 export * from './confidential-storage-persistence.js';
 export * from './confidential-storage-test-data.js';
 export * from './permission-templates.js';
+export * from './professional-smart.js';
 export * from './related-person-list.js';
 export * from './clinical-resource-converters.js';
+export * from './clinical-bundle-summary.js';
 export * from './clinical-resource-view.js';
 export * from './fhir-validator.js';
 export * from './family-registration-test-data.js';
 export * from './individual-form-pdf.js';
 export * from './individual-organization-claims.js';
+export * from './legal-organization-onboarding-editor.js';
 export * from './organization-lifecycle.js';
 export * from './organization-did-binding.js';
 export * from './individual-organization-lifecycle.js';