gdc-sdk-front-ts 0.6.2 → 0.6.6

package/dist/gdc-sdk-core-ts/src/actor-model.js

@@ -0,0 +1,112 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ActorCapabilities, ActorKinds, } from 'gdc-common-utils-ts/constants/actor-session';
+export { ActorCapabilities, ActorKinds };
+const actorCapabilityMatrix = {
+    [ActorKinds.HostOnboarding]: [],
+    [ActorKinds.OrganizationController]: [
+        ActorCapabilities.OrganizationCreateEmployee,
+        ActorCapabilities.OrganizationDisableEmployee,
+        ActorCapabilities.OrganizationPurgeEmployee,
+        ActorCapabilities.OrganizationRequestSmartToken,
+    ],
+    [ActorKinds.OrganizationEmployee]: [
+        ActorCapabilities.OrganizationIssueActivationCode,
+        ActorCapabilities.OrganizationRequestSmartToken,
+    ],
+    [ActorKinds.IndividualController]: [
+        ActorCapabilities.IndividualBootstrap,
+        ActorCapabilities.IndividualDisable,
+        ActorCapabilities.IndividualPurge,
+        ActorCapabilities.IndividualMemberDisable,
+        ActorCapabilities.IndividualMemberPurge,
+        ActorCapabilities.ConsentGrantProfessionalAccess,
+    ],
+    [ActorKinds.IndividualMember]: [
+        ActorCapabilities.IndividualImportIps,
+        ActorCapabilities.IndividualGenerateDigitalTwin,
+    ],
+    [ActorKinds.Professional]: [
+        ActorCapabilities.ProfessionalMedication,
+        ActorCapabilities.ProfessionalAppointment,
+        ActorCapabilities.ProfessionalRequestSmartToken,
+    ],
+};
+/**
+ * Filters a capability list so that only capabilities valid for the given actor remain.
+ *
+ * @param actorKind Actor role to evaluate against the capability matrix.
+ * @param capabilities Candidate capabilities to filter.
+ */
+export function filterCapabilitiesForActor(actorKind, capabilities) {
+    const allowed = new Set(actorCapabilityMatrix[actorKind]);
+    return [...new Set(capabilities.filter(capability => allowed.has(capability)))];
+}
+/**
+ * Expands a composite actor session descriptor into one facade descriptor per actor kind.
+ *
+ * Each resulting facade keeps only the capabilities that belong to its actor kind.
+ *
+ * @param descriptor Composite descriptor that may contain multiple actor kinds.
+ */
+export function expandActorSessionDescriptorToFacades(descriptor) {
+    return [...new Set(descriptor.actorKinds)].map(actorKind => ({
+        actorKind,
+        capabilities: filterCapabilitiesForActor(actorKind, descriptor.capabilities),
+        appType: descriptor.appType,
+        profileId: descriptor.profileId,
+        profileDid: descriptor.profileDid,
+        role: descriptor.role,
+    }));
+}
+/**
+ * Builds a normalized actor session descriptor from boolean actor flags.
+ *
+ * @param input Session metadata plus actor flags used to derive actor kinds and capabilities.
+ */
+export function buildActorSessionDescriptorFromActorFlags(input) {
+    const actorKinds = new Set();
+    const capabilities = new Set();
+    if (input.actorFlags.organizationController) {
+        actorKinds.add(ActorKinds.OrganizationController);
+        capabilities.add(ActorCapabilities.OrganizationCreateEmployee);
+        capabilities.add(ActorCapabilities.OrganizationDisableEmployee);
+        capabilities.add(ActorCapabilities.OrganizationPurgeEmployee);
+    }
+    if (input.actorFlags.organizationEmployee) {
+        actorKinds.add(ActorKinds.OrganizationEmployee);
+        capabilities.add(ActorCapabilities.OrganizationIssueActivationCode);
+    }
+    if (input.actorFlags.individualController) {
+        actorKinds.add(ActorKinds.IndividualController);
+        capabilities.add(ActorCapabilities.IndividualBootstrap);
+        capabilities.add(ActorCapabilities.IndividualDisable);
+        capabilities.add(ActorCapabilities.IndividualPurge);
+        capabilities.add(ActorCapabilities.IndividualMemberDisable);
+        capabilities.add(ActorCapabilities.IndividualMemberPurge);
+        capabilities.add(ActorCapabilities.ConsentGrantProfessionalAccess);
+    }
+    if (input.actorFlags.individualMember) {
+        actorKinds.add(ActorKinds.IndividualMember);
+        capabilities.add(ActorCapabilities.IndividualImportIps);
+        capabilities.add(ActorCapabilities.IndividualGenerateDigitalTwin);
+    }
+    if (input.actorFlags.professionalPhysician) {
+        actorKinds.add(ActorKinds.Professional);
+        capabilities.add(ActorCapabilities.ProfessionalAppointment);
+        capabilities.add(ActorCapabilities.ProfessionalMedication);
+        capabilities.add(ActorCapabilities.ProfessionalRequestSmartToken);
+    }
+    if (input.actorFlags.professionalParamedic) {
+        actorKinds.add(ActorKinds.Professional);
+        capabilities.add(ActorCapabilities.ProfessionalMedication);
+        capabilities.add(ActorCapabilities.ProfessionalRequestSmartToken);
+    }
+    return {
+        actorKinds: [...actorKinds],
+        capabilities: [...capabilities],
+        appType: input.appType,
+        profileId: input.profileId,
+        profileDid: input.profileDid,
+        role: input.role,
+    };
+}

package/dist/gdc-sdk-core-ts/src/app-identity.d.ts

@@ -0,0 +1,80 @@
+import type { AppInfo } from './session-model.js';
+export declare const DEFAULT_APP_VERSION = "v1.0";
+export type ResolvedAppInfo = Omit<AppInfo, 'appVersion'> & {
+    appVersion: string;
+};
+/**
+ * Resolves the host app identity into the canonical form expected by GW CORE.
+ *
+ * Rules:
+ * - `appId` is mandatory
+ * - URL/domain inputs are normalized to reverse-DNS using only the hostname
+ * - `appVersion` defaults to `v1.0`
+ *
+ * @example
+ * ```ts
+ * const resolved = resolveAppInfo({
+ *   appId: 'https://globaldatacare.es/portal',
+ *   appType: 'Family',
+ *   sector: 'health-care',
+ * });
+ *
+ * console.log(resolved.appId);
+ * // es.globaldatacare
+ *
+ * console.log(resolved.appVersion);
+ * // v1.0
+ * ```
+ */
+export declare function resolveAppInfo(appInfo: AppInfo): ResolvedAppInfo;
+/**
+ * Normalizes a GW CORE app identifier.
+ *
+ * When the input is a URL or bare hostname, the hostname is converted to
+ * reverse-DNS. Otherwise the trimmed literal value is preserved.
+ *
+ * @example
+ * ```ts
+ * normalizeAppId('https://globaldatacare.es/app');
+ * // 'es.globaldatacare'
+ * ```
+ *
+ * @example
+ * ```ts
+ * normalizeAppId('globaldatacare.es');
+ * // 'es.globaldatacare'
+ * ```
+ *
+ * @example
+ * ```ts
+ * normalizeAppId('es.globaldatacare.portal');
+ * // 'es.globaldatacare.portal'
+ * ```
+ */
+export declare function normalizeAppId(input: string): string;
+/**
+ * Returns the canonical GW CORE app version.
+ *
+ * @example
+ * ```ts
+ * normalizeAppVersion(undefined);
+ * // 'v1.0'
+ * ```
+ */
+export declare function normalizeAppVersion(input?: string): string;
+/**
+ * Builds the standard GW CORE request headers for the host app identity.
+ *
+ * @example
+ * ```ts
+ * const headers = buildAppHeaders({
+ *   appId: 'https://globaldatacare.es',
+ *   appType: 'Family',
+ *   sector: 'health-care',
+ * });
+ *
+ * console.log(headers);
+ * // { AppId: 'es.globaldatacare', AppVersion: 'v1.0' }
+ * ```
+ */
+export declare function buildAppHeaders(appInfo: AppInfo): Record<'AppId' | 'AppVersion', string>;

package/dist/gdc-sdk-core-ts/src/app-identity.js

@@ -0,0 +1,147 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+export const DEFAULT_APP_VERSION = 'v1.0';
+/**
+ * Resolves the host app identity into the canonical form expected by GW CORE.
+ *
+ * Rules:
+ * - `appId` is mandatory
+ * - URL/domain inputs are normalized to reverse-DNS using only the hostname
+ * - `appVersion` defaults to `v1.0`
+ *
+ * @example
+ * ```ts
+ * const resolved = resolveAppInfo({
+ *   appId: 'https://globaldatacare.es/portal',
+ *   appType: 'Family',
+ *   sector: 'health-care',
+ * });
+ *
+ * console.log(resolved.appId);
+ * // es.globaldatacare
+ *
+ * console.log(resolved.appVersion);
+ * // v1.0
+ * ```
+ */
+export function resolveAppInfo(appInfo) {
+    return {
+        ...appInfo,
+        appId: normalizeAppId(appInfo.appId),
+        appVersion: normalizeAppVersion(appInfo.appVersion),
+    };
+}
+/**
+ * Normalizes a GW CORE app identifier.
+ *
+ * When the input is a URL or bare hostname, the hostname is converted to
+ * reverse-DNS. Otherwise the trimmed literal value is preserved.
+ *
+ * @example
+ * ```ts
+ * normalizeAppId('https://globaldatacare.es/app');
+ * // 'es.globaldatacare'
+ * ```
+ *
+ * @example
+ * ```ts
+ * normalizeAppId('globaldatacare.es');
+ * // 'es.globaldatacare'
+ * ```
+ *
+ * @example
+ * ```ts
+ * normalizeAppId('es.globaldatacare.portal');
+ * // 'es.globaldatacare.portal'
+ * ```
+ */
+export function normalizeAppId(input) {
+    const raw = String(input || '').trim();
+    if (!raw) {
+        throw new Error('AppInfo.appId is required.');
+    }
+    const lowerRaw = raw.toLowerCase();
+    const hostname = tryExtractHostname(raw);
+    if (!hostname) {
+        return raw;
+    }
+    const normalizedHost = hostname
+        .trim()
+        .toLowerCase()
+        .replace(/\.+/g, '.')
+        .replace(/^\.+|\.+$/g, '');
+    if (!normalizedHost) {
+        throw new Error('AppInfo.appId must contain a valid hostname or stable identifier.');
+    }
+    if (!looksLikeReversibleHostname(normalizedHost)) {
+        return raw;
+    }
+    if (!shouldReverseHostname(lowerRaw, normalizedHost)) {
+        return normalizedHost;
+    }
+    return normalizedHost.split('.').reverse().join('.');
+}
+/**
+ * Returns the canonical GW CORE app version.
+ *
+ * @example
+ * ```ts
+ * normalizeAppVersion(undefined);
+ * // 'v1.0'
+ * ```
+ */
+export function normalizeAppVersion(input) {
+    const version = String(input || '').trim();
+    return version || DEFAULT_APP_VERSION;
+}
+/**
+ * Builds the standard GW CORE request headers for the host app identity.
+ *
+ * @example
+ * ```ts
+ * const headers = buildAppHeaders({
+ *   appId: 'https://globaldatacare.es',
+ *   appType: 'Family',
+ *   sector: 'health-care',
+ * });
+ *
+ * console.log(headers);
+ * // { AppId: 'es.globaldatacare', AppVersion: 'v1.0' }
+ * ```
+ */
+export function buildAppHeaders(appInfo) {
+    const resolved = resolveAppInfo(appInfo);
+    return {
+        AppId: resolved.appId,
+        AppVersion: resolved.appVersion,
+    };
+}
+function tryExtractHostname(raw) {
+    const candidate = raw.includes('://') ? raw : `https://${raw}`;
+    try {
+        const parsed = new URL(candidate);
+        return parsed.hostname || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function looksLikeReversibleHostname(hostname) {
+    if (!hostname.includes('.')) {
+        return false;
+    }
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) {
+        return false;
+    }
+    return hostname.split('.').every((label) => /^[a-z0-9-]+$/i.test(label) && !label.startsWith('-') && !label.endsWith('-'));
+}
+function shouldReverseHostname(raw, hostname) {
+    if (raw.includes('://') || raw.includes('/') || raw.includes(':')) {
+        return true;
+    }
+    const labels = hostname.split('.');
+    const lastLabel = labels[labels.length - 1];
+    if (lastLabel.length === 2) {
+        return true;
+    }
+    return ['com', 'org', 'net', 'edu', 'gov', 'mil', 'info', 'biz', 'io', 'app', 'dev'].includes(lastLabel);
+}

package/dist/gdc-sdk-core-ts/src/bootstrap-facade.d.ts

@@ -0,0 +1,165 @@
+import { ServiceCapability, type ServiceCapabilityValue, type ServiceCapabilityTokenValue } from 'gdc-common-utils-ts/constants/service-capabilities';
+import { ActorIdentityState } from './identity-model.js';
+export { ServiceCapability };
+export type { ServiceCapabilityValue, ServiceCapabilityTokenValue };
+/**
+ * Validation issue emitted by canonical activation/bootstrap validation.
+ */
+export type BootstrapValidationIssue = {
+    severity: 'error' | 'warning';
+    code: string;
+    message: string;
+};
+/**
+ * Runtime-neutral canonical `_activate` payload shape.
+ *
+ * Contract priority:
+ * - `vp_token` is canonical proof
+ * - `controller.*` is explicit key binding
+ * - legacy credential side-fields are compatibility only
+ */
+export type OrganizationActivationPayload = {
+    vp_token?: string;
+    controller?: {
+        did?: string;
+        sameAs?: string;
+        publicKeyJwk?: unknown;
+        jwks?: {
+            keys: Array<unknown>;
+        };
+    };
+    organization?: {
+        did?: string;
+        url?: string;
+        publicKeyJwk?: unknown;
+        jwks?: {
+            keys: Array<unknown>;
+        };
+    };
+    organizationCredential?: unknown;
+    representativeCredential?: unknown;
+    data?: Array<Record<string, unknown>>;
+};
+/**
+ * Declarative service capabilities persisted through
+ * `org.schema.Service.*` activation claims.
+ */
+export type OrganizationActivationServiceOptions = {
+    url?: string;
+    capabilities?: ReadonlyArray<ServiceCapabilityValue | ServiceCapabilityTokenValue | string>;
+    additionalClaims?: Record<string, unknown>;
+};
+/**
+ * Public activation input used by SDK runtimes when submitting a legal
+ * organization activation backed by an ICA proof.
+ *
+ * Service capabilities are mandatory in the teaching contract even if legacy
+ * compatibility paths still allow omitting them at runtime.
+ */
+export type OrganizationActivationInput = {
+    vpToken: string;
+    controller?: OrganizationActivationPayload['controller'];
+    organization?: OrganizationActivationPayload['organization'];
+    data?: Array<Record<string, unknown>>;
+    organizationCredential?: unknown;
+    representativeCredential?: unknown;
+    service?: OrganizationActivationServiceOptions;
+    additionalClaims?: Record<string, unknown>;
+};
+export interface OrganizationActivationDraft {
+    addServiceCapability(capability: ServiceCapabilityValue | ServiceCapabilityTokenValue | string): OrganizationActivationDraft;
+    addServiceCapabilities(capabilities: ReadonlyArray<ServiceCapabilityValue | ServiceCapabilityTokenValue | string>): OrganizationActivationDraft;
+    setServiceUrl(url: string): OrganizationActivationDraft;
+    mergeAdditionalClaims(claims: Record<string, unknown>): OrganizationActivationDraft;
+    buildServiceClaims(): Record<string, unknown>;
+    build(): OrganizationActivationPayload;
+}
+/**
+ * Runtime-neutral bootstrap facade.
+ *
+ * Implemented here:
+ * - payload builders
+ * - controller identity binding helper
+ * - canonical-vs-legacy validation
+ *
+ * Still pending in higher runtimes:
+ * - remote submission to GW/ICA
+ * - persistence side effects
+ * - DID publication orchestration
+ */
+export interface BootstrapFacade {
+    /**
+     * Builds the canonical organization activation payload.
+     */
+    buildOrganizationActivationRequest(input: {
+        vpToken: string;
+        controller?: OrganizationActivationPayload['controller'];
+        organization?: OrganizationActivationPayload['organization'];
+        data?: Array<Record<string, unknown>>;
+        organizationCredential?: unknown;
+        representativeCredential?: unknown;
+    }): OrganizationActivationPayload;
+    /**
+     * Builds the canonical `org.schema.Service.*` claims block for activation.
+     */
+    buildOrganizationActivationServiceClaims(input: OrganizationActivationServiceOptions): Record<string, unknown>;
+    /**
+     * Creates an activation draft builder that can be enriched incrementally
+     * before serializing the final `_activate` payload.
+     */
+    createOrganizationActivationDraft(input: {
+        vpToken: string;
+        controller?: OrganizationActivationPayload['controller'];
+        organization?: OrganizationActivationPayload['organization'];
+        data?: Array<Record<string, unknown>>;
+        organizationCredential?: unknown;
+        representativeCredential?: unknown;
+        service?: OrganizationActivationServiceOptions;
+        additionalClaims?: Record<string, unknown>;
+    }): OrganizationActivationDraft;
+    /**
+     * Preferred public alias for the activation builder.
+     *
+     * Keep `createOrganizationActivationDraft(...)` for compatibility while new
+     * documentation and SDK onboarding examples teach this clearer name.
+     */
+    createOrganizationActivation(input: OrganizationActivationInput): OrganizationActivationDraft;
+    /**
+     * Builds the canonical individual activation/bootstrap payload.
+     */
+    buildIndividualActivationRequest(input: {
+        vpToken: string;
+        controller?: OrganizationActivationPayload['controller'];
+        data?: Array<Record<string, unknown>>;
+    }): OrganizationActivationPayload;
+    /**
+     * Normalizes explicit controller binding input into actor identity state.
+     */
+    bindControllerIdentity(input: {
+        did: string;
+        sameAs?: string;
+        publicKeyJwk?: unknown;
+        jwks?: {
+            keys: Array<unknown>;
+        };
+    }): ActorIdentityState;
+    /**
+     * Validates canonical activation payload priority and reports warnings for
+     * deprecated compatibility fields.
+     */
+    validateActivationRequest(payload: OrganizationActivationPayload): {
+        ok: boolean;
+        errors: BootstrapValidationIssue[];
+        warnings: BootstrapValidationIssue[];
+    };
+}
+/**
+ * Factory for the runtime-neutral bootstrap facade.
+ *
+ * Naming contract:
+ * - SDK builder API: `serviceCapabilities`
+ * - persisted claim: `org.schema.Service.serviceType`
+ * - frontend UX/runtime facets remain a separate layer and must not be treated
+ *   as the persisted activation claim vocabulary
+ */
+export declare function createBootstrapFacade(): BootstrapFacade;

package/dist/gdc-sdk-core-ts/src/bootstrap-facade.js

@@ -0,0 +1,191 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+// Always create JSDoc, do not use strings inline in keys nor values, use types instead, and reuse the data test examples.
+import { ClaimsServiceSchemaorg, } from 'gdc-common-utils-ts/constants/schemaorg';
+import { ActorKinds } from 'gdc-common-utils-ts/constants/actor-session';
+import { serializeServiceCapabilityTokens, ServiceCapability, } from 'gdc-common-utils-ts/constants/service-capabilities';
+export { ServiceCapability };
+/**
+ * Factory for the runtime-neutral bootstrap facade.
+ *
+ * Naming contract:
+ * - SDK builder API: `serviceCapabilities`
+ * - persisted claim: `org.schema.Service.serviceType`
+ * - frontend UX/runtime facets remain a separate layer and must not be treated
+ *   as the persisted activation claim vocabulary
+ */
+export function createBootstrapFacade() {
+    function buildOrganizationActivationPayload(input) {
+        return {
+            vp_token: input.vpToken,
+            ...(input.controller ? { controller: input.controller } : {}),
+            ...(input.organization ? { organization: input.organization } : {}),
+            ...(input.data ? { data: input.data } : {}),
+            ...(input.organizationCredential !== undefined ? { organizationCredential: input.organizationCredential } : {}),
+            ...(input.representativeCredential !== undefined ? { representativeCredential: input.representativeCredential } : {}),
+        };
+    }
+    function buildOrganizationActivationServiceClaims(input) {
+        const claims = {
+            ...(input.additionalClaims || {}),
+        };
+        if (String(input.url || '').trim()) {
+            claims[ClaimsServiceSchemaorg.url] = String(input.url).trim();
+        }
+        const serializedCapabilities = serializeServiceCapabilityTokens(input.capabilities || []);
+        if (serializedCapabilities) {
+            claims[ClaimsServiceSchemaorg.serviceType] = serializedCapabilities;
+        }
+        return claims;
+    }
+    function validateActivationRequest(payload) {
+        const issues = [];
+        if (!String(payload.vp_token || '').trim()) {
+            issues.push({
+                severity: 'error',
+                code: 'missing-vp-token',
+                message: 'Canonical activation proof must be carried in vp_token.',
+            });
+        }
+        if (payload.organizationCredential !== undefined) {
+            issues.push({
+                severity: 'warning',
+                code: 'deprecated-organization-credential',
+                message: 'organizationCredential is deprecated compatibility input.',
+            });
+        }
+        if (payload.representativeCredential !== undefined) {
+            issues.push({
+                severity: 'warning',
+                code: 'deprecated-representative-credential',
+                message: 'representativeCredential is deprecated compatibility input.',
+            });
+        }
+        const controller = payload.controller;
+        if (controller && (controller.did || controller.sameAs) && !(controller.publicKeyJwk || controller.jwks?.keys?.length)) {
+            issues.push({
+                severity: 'error',
+                code: 'incomplete-controller-binding',
+                message: 'controller.did/controller.sameAs requires public key material.',
+            });
+        }
+        return {
+            ok: !issues.some((issue) => issue.severity === 'error'),
+            errors: issues.filter((issue) => issue.severity === 'error'),
+            warnings: issues.filter((issue) => issue.severity === 'warning'),
+        };
+    }
+    function createOrganizationActivationDraft(input) {
+        const state = {
+            serviceUrl: input.service?.url,
+            capabilities: [...(input.service?.capabilities || [])].map((item) => String(item).trim()).filter(Boolean),
+            additionalClaims: {
+                ...(input.additionalClaims || {}),
+                ...(input.service?.additionalClaims || {}),
+            },
+        };
+        const builder = {
+            addServiceCapability(capability) {
+                const normalized = String(capability || '').trim();
+                if (normalized && !state.capabilities.includes(normalized)) {
+                    state.capabilities.push(normalized);
+                }
+                return builder;
+            },
+            addServiceCapabilities(capabilities) {
+                for (const capability of capabilities) {
+                    builder.addServiceCapability(capability);
+                }
+                return builder;
+            },
+            setServiceUrl(url) {
+                state.serviceUrl = String(url || '').trim() || undefined;
+                return builder;
+            },
+            mergeAdditionalClaims(claims) {
+                state.additionalClaims = {
+                    ...state.additionalClaims,
+                    ...(claims || {}),
+                };
+                return builder;
+            },
+            buildServiceClaims() {
+                return buildOrganizationActivationServiceClaims({
+                    url: state.serviceUrl,
+                    capabilities: state.capabilities,
+                    additionalClaims: state.additionalClaims,
+                });
+            },
+            build() {
+                const serviceClaims = builder.buildServiceClaims();
+                const data = Array.isArray(input.data) && input.data.length
+                    ? input.data.map((entry) => {
+                        const currentMetaClaims = entry?.meta?.claims || {};
+                        const currentResourceClaims = entry?.resource?.meta?.claims || {};
+                        return {
+                            ...entry,
+                            meta: {
+                                ...(entry?.meta || {}),
+                                claims: {
+                                    ...currentMetaClaims,
+                                    ...serviceClaims,
+                                },
+                            },
+                            resource: {
+                                ...(entry?.resource || {}),
+                                meta: {
+                                    ...(entry?.resource?.meta || {}),
+                                    claims: {
+                                        ...currentResourceClaims,
+                                        ...serviceClaims,
+                                    },
+                                },
+                            },
+                        };
+                    })
+                    : undefined;
+                return buildOrganizationActivationPayload({
+                    vpToken: input.vpToken,
+                    controller: input.controller,
+                    organization: input.organization,
+                    data,
+                    organizationCredential: input.organizationCredential,
+                    representativeCredential: input.representativeCredential,
+                });
+            },
+        };
+        return builder;
+    }
+    return {
+        buildOrganizationActivationServiceClaims,
+        createOrganizationActivationDraft,
+        createOrganizationActivation(input) {
+            return createOrganizationActivationDraft(input);
+        },
+        buildOrganizationActivationRequest(input) {
+            return buildOrganizationActivationPayload(input);
+        },
+        buildIndividualActivationRequest(input) {
+            return {
+                vp_token: input.vpToken,
+                ...(input.controller ? { controller: input.controller } : {}),
+                ...(input.data ? { data: input.data } : {}),
+            };
+        },
+        bindControllerIdentity(input) {
+            const normalizedPublicKeyJwk = input.publicKeyJwk && typeof input.publicKeyJwk === 'object'
+                ? input.publicKeyJwk
+                : undefined;
+            const normalizedJwks = input.jwks?.keys?.length
+                ? { keys: input.jwks.keys.filter((item) => !!item && typeof item === 'object') }
+                : undefined;
+            return {
+                did: input.did,
+                kind: ActorKinds.OrganizationController,
+                ...(input.sameAs ? { sameAs: input.sameAs } : {}),
+                ...(normalizedPublicKeyJwk ? { publicKeyJwk: normalizedPublicKeyJwk } : {}),
+                ...(normalizedJwks ? { jwks: normalizedJwks } : {}),
+            };
+        },
+        validateActivationRequest,
+    };
+}