gdc-sdk-node-ts 0.1.1

package/dist/resource-operations.js

@@ -0,0 +1,184 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { HealthcareBasicSections } from 'gdc-common-utils-ts/constants';
+export async function createOrganizationEmployeeWithDeps(routeCtx, input, options, deps) {
+    const payload = {
+        jti: `jti-${createRuntimeUuid()}`,
+        iss: routeCtx.tenantId,
+        aud: routeCtx.tenantId,
+        type: 'application/didcomm-plain+json',
+        thid: `employee-${createRuntimeUuid()}`,
+        body: {
+            data: [{
+                    type: input.dataType || 'Employee-create-request-v1.0',
+                    request: { method: 'POST' },
+                    meta: { claims: input.employeeClaims || {} },
+                    resource: { meta: { claims: input.employeeClaims || {} } },
+                }],
+        },
+    };
+    return deps.submitAndPoll(deps.employeeBatchPath(routeCtx), deps.employeePollPath(routeCtx), payload, options);
+}
+export async function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx, input, deps) {
+    const payload = {
+        thid: input.compositionPayload.thid || `composition-${createRuntimeUuid()}`,
+        ...input.compositionPayload,
+    };
+    const submitPath = (input.format || 'r4') === 'api'
+        ? deps.individualCompositionR4BatchPath(routeCtx).replace('/org.hl7.fhir.r4/', '/org.hl7.fhir.api/')
+        : deps.individualCompositionR4BatchPath(routeCtx);
+    const pollPath = (input.format || 'r4') === 'api'
+        ? deps.individualCompositionR4PollPath(routeCtx).replace('/org.hl7.fhir.r4/', '/org.hl7.fhir.api/')
+        : deps.individualCompositionR4PollPath(routeCtx);
+    return deps.submitAndPoll(submitPath, pollPath, payload, input.pollOptions);
+}
+export async function upsertRelatedPersonAndPollWithDeps(routeCtx, input, deps) {
+    const payload = {
+        thid: input.relatedPersonPayload.thid || `relatedperson-${createRuntimeUuid()}`,
+        ...input.relatedPersonPayload,
+    };
+    return deps.submitAndPoll(deps.individualRelatedPersonBatchPath(routeCtx), deps.individualRelatedPersonPollPath(routeCtx), payload, input.pollOptions);
+}
+export async function ingestCommunicationAndUpdateIndexWithDeps(routeCtx, input, deps) {
+    const payload = {
+        thid: input.communicationPayload.thid || `communication-${createRuntimeUuid()}`,
+        ...input.communicationPayload,
+    };
+    const pathFormatSegment = normalizeCommunicationPathFormatSegment(input.pathFormatSegment);
+    const convertedPayload = pathFormatSegment === 'org.hl7.fhir.r4'
+        ? (deps.transformPayloadForFhirR4
+            ? deps.transformPayloadForFhirR4(payload, input.autoConvertClaimsToFhirR4 !== false)
+            : payload)
+        : payload;
+    return deps.submitAndPoll(deps.individualCommunicationBatchPath(routeCtx, pathFormatSegment), deps.individualCommunicationPollPath(routeCtx, pathFormatSegment), convertedPayload, input.pollOptions);
+}
+export async function searchClinicalBundleWithDeps(routeCtx, input, deps) {
+    const query = buildBundleSearchQuery(input);
+    const payload = {
+        thid: input.requestThid || `bundle-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [{ request: { method: 'GET', url: query } }],
+        },
+    };
+    return deps.submitAndPoll(deps.bundleSearchPath(routeCtx), deps.bundleSearchPollPath(routeCtx), payload, input.pollOptions);
+}
+export async function searchLatestIpsWithDeps(routeCtx, input, deps) {
+    return deps.searchClinicalBundle(routeCtx, {
+        ...input,
+        section: input.section || HealthcareBasicSections.PatientSummaryDocument.claim,
+        includedTypes: ['Composition', 'DocumentReference'],
+    });
+}
+export async function grantProfessionalAccessWithDeps(routeCtx, input, deps) {
+    const built = deps.buildConsentClaimsWithCid({
+        subjectDid: input.subjectDid,
+        subjectPhone: input.subjectPhone,
+        subjectGivenName: input.subjectGivenName,
+        actor: input.actorId ?? input.actor,
+        actorRole: input.actorRole,
+        purpose: input.purpose,
+        actions: input.actions,
+        consentIdentifier: input.consentIdentifier,
+        consentDate: input.consentDate,
+        decision: input.decision,
+        attachmentContentType: input.attachmentContentType,
+        attachmentBase64: input.attachmentBase64,
+    }, {
+        consentIdentifierFactory: () => `urn:uuid:${createRuntimeUuid()}`,
+    });
+    const thid = `consent-${createRuntimeUuid()}`;
+    const consentPayload = {
+        thid,
+        body: {
+            data: [{
+                    type: input.dataType || 'Consent-grant-request-v1.0',
+                    meta: { claims: built.consentClaims },
+                    resource: { resourceType: 'Consent', meta: { claims: built.consentClaims } },
+                }],
+        },
+    };
+    const consent = await deps.submitAndPoll(deps.individualConsentR4BatchPath(routeCtx), deps.individualConsentR4PollPath(routeCtx), consentPayload, input.pollOptions);
+    return {
+        thid,
+        consent,
+        actorIdentifier: built.actorIdentifier,
+        subjectIdentifier: built.subjectIdentifier,
+        consentClaims: built.consentClaims,
+        claimsCid: built.claimsCid,
+    };
+}
+export async function generateDigitalTwinFromSubjectDataWithDeps(routeCtx, input, deps) {
+    const payload = {
+        thid: input.compositionPayload.thid || `digital-twin-${createRuntimeUuid()}`,
+        ...input.compositionPayload,
+    };
+    const submitPath = (input.format || 'r4') === 'api'
+        ? deps.digitalTwinCompositionApiBatchPath(routeCtx)
+        : deps.digitalTwinCompositionR4BatchPath(routeCtx);
+    const pollPath = (input.format || 'r4') === 'api'
+        ? deps.digitalTwinCompositionApiPollPath(routeCtx)
+        : deps.digitalTwinCompositionR4PollPath(routeCtx);
+    return deps.submitAndPoll(submitPath, pollPath, payload, input.pollOptions);
+}
+function normalizeCommunicationPathFormatSegment(raw) {
+    const value = String(raw || '').trim().toLowerCase();
+    if (!value || value === 'api' || value === 'org.hl7.fhir.api')
+        return 'org.hl7.fhir.api';
+    if (value === 'r4' || value === 'fhir.r4' || value === 'org.hl7.fhir.r4')
+        return 'org.hl7.fhir.r4';
+    return 'org.hl7.fhir.api';
+}
+function createRuntimeUuid() {
+    const fromCrypto = globalThis.crypto?.randomUUID?.();
+    if (fromCrypto) {
+        return fromCrypto;
+    }
+    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function buildBundleSearchQuery(input) {
+    const params = new URLSearchParams();
+    params.set('subject', input.subject);
+    const sectionValues = normalizeToCsv(input.section);
+    if (sectionValues)
+        params.set('composition.section', sectionValues);
+    const typeValues = normalizeToCsv(input.includedTypes);
+    if (typeValues)
+        params.set('_type', typeValues);
+    if (input.date?.start)
+        params.set('start', input.date.start);
+    if (input.date?.end)
+        params.set('end', input.date.end);
+    const codeValues = normalizeToCsv(input.code);
+    if (codeValues)
+        params.set('code', codeValues);
+    const categoryValues = normalizeToCsv(input.category);
+    if (categoryValues)
+        params.set('category', categoryValues);
+    const authorValues = normalizeToCsv(input.author);
+    if (authorValues)
+        params.set('author', authorValues);
+    if (input.thid)
+        params.set('thid', input.thid);
+    if (input.pthid)
+        params.set('pthid', input.pthid);
+    if (input.channelId)
+        params.set('channelId', input.channelId);
+    if (input.partOf)
+        params.set('part-of', input.partOf);
+    if (input.extraSearchParams) {
+        for (const [key, value] of Object.entries(input.extraSearchParams)) {
+            if (value === undefined || value === null || String(value).trim() === '')
+                continue;
+            params.set(key, String(value));
+        }
+    }
+    return `Bundle?type=document&${params.toString()}`;
+}
+function normalizeToCsv(value) {
+    if (!value)
+        return '';
+    if (Array.isArray(value))
+        return value.map((v) => String(v).trim()).filter(Boolean).join(',');
+    return String(value).trim();
+}

package/dist/runtime-contracts.d.ts

@@ -0,0 +1,65 @@
+import type { NodeOperatorNetworkType } from 'gdc-common-utils-ts/constants/network';
+import type { DataPersistencePolicy } from '../../gdc-sdk-core-ts/dist/index.js';
+export type LegacyNodeSourcePackage = never;
+/**
+ * Deployment/runtime form factor of the Node SDK host process itself.
+ */
+export type NodeRuntimeMode = 'server' | 'bff' | 'cloud-function' | 'worker';
+/**
+ * Interoperability strictness mode of the runtime.
+ *
+ * - `demo`: accept looser/demo-oriented payload shaping
+ * - `compat`: accept compatibility-oriented payload shaping
+ * - `strict`: enforce the canonical contract as much as the runtime allows
+ */
+export type NodeInteropMode = 'demo' | 'compat' | 'strict';
+/**
+ * Route context for tenant-scoped GW calls.
+ *
+ * This is not the web-portal context. It identifies the target tenant route in
+ * the node operator / GW:
+ * - `tenantId`: canonical tenant identifier
+ * - `jurisdiction`: legal jurisdiction
+ * - `sector`: functional sector path segment
+ */
+export type TenantContext = {
+    tenantId: string;
+    jurisdiction: string;
+    sector: string;
+};
+/**
+ * Discovery/bootstrap context for a node operator environment.
+ *
+ * This describes the operator network/environment itself. It does not replace
+ * the tenant route context used by tenant-scoped GW endpoints.
+ */
+export type NodeOperatorContext = {
+    networkType: NodeOperatorNetworkType;
+    jurisdiction: string;
+    operatorDid?: string;
+    baseUrl?: string;
+};
+export type NodeFetchLike = typeof fetch;
+/**
+ * Node runtime configuration for backend/BFF integrations.
+ */
+export type NodeRuntimeConfig = {
+    runtimeMode: NodeRuntimeMode;
+    interopMode?: NodeInteropMode;
+    fetcher: NodeFetchLike;
+    persistencePolicy?: DataPersistencePolicy;
+    walletProvider?: unknown;
+    cryptoProvider?: unknown;
+    storageProvider?: unknown;
+    outboxRepositoryFactory?: unknown;
+    defaultTenantId?: string;
+    defaultJurisdiction?: string;
+    defaultSector?: string;
+};
+export type NodePackageStatus = {
+    packageName: 'gdc-sdk-node-ts';
+    dependsOnCorePackage: 'gdc-sdk-core-ts';
+    legacySourcePackages: LegacyNodeSourcePackage[];
+    status: 'bootstrap';
+};
+export declare const GDC_SDK_NODE_STATUS: NodePackageStatus;

package/dist/runtime-contracts.js

@@ -0,0 +1,7 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+export const GDC_SDK_NODE_STATUS = {
+    packageName: 'gdc-sdk-node-ts',
+    dependsOnCorePackage: 'gdc-sdk-core-ts',
+    legacySourcePackages: [],
+    status: 'bootstrap',
+};

package/dist/session.d.ts

@@ -0,0 +1,64 @@
+import type { ActorKind, Capability } from '../../gdc-sdk-core-ts/dist/index.js';
+import { HostOnboardingSdk } from './orchestration/host-onboarding-sdk.js';
+import { IndividualControllerSdk } from './orchestration/individual-controller-sdk.js';
+import { IndividualMemberSdk } from './orchestration/individual-member-sdk.js';
+import { OrganizationControllerSdk } from './orchestration/organization-controller-sdk.js';
+import { OrganizationEmployeeSdk } from './orchestration/organization-employee-sdk.js';
+import { ProfessionalSdk } from './orchestration/professional-sdk.js';
+import type { RuntimeClient } from './orchestration/client-port.js';
+export type NodeCapability = Capability | 'host.activate_organization' | 'host.confirm_order' | 'organization.activate_device' | 'individual.ingest_communication' | 'individual.upsert_related_person' | 'token.request_smart';
+export type NodeActorSessionContext = {
+    actorKind: ActorKind;
+    actorDid?: string;
+    subjectDid?: string;
+    capabilities?: NodeCapability[];
+};
+/**
+ * Preferred neutral actor-session context contract.
+ *
+ * Keep `NodeActorSessionContext` only as a compatibility alias while names are
+ * converged across runtimes.
+ */
+export type ActorSessionContext = NodeActorSessionContext;
+/**
+ * Preferred neutral actor session abstraction for runtime packages.
+ *
+ * Keep `NodeActorSession` only as a compatibility alias while package naming is
+ * converged across node/front/other runtimes.
+ */
+export declare class ActorSession {
+    readonly actorKind: ActorKind;
+    readonly actorDid?: string;
+    readonly subjectDid?: string;
+    readonly capabilities: NodeCapability[];
+    private readonly client?;
+    constructor(context: ActorSessionContext, client?: RuntimeClient);
+    is(actorKind: ActorKind): boolean;
+    assertActorKind(actorKind: ActorKind): void;
+    asHostOnboarding(): HostOnboardingSdk;
+    asOrganizationController(): OrganizationControllerSdk;
+    asOrganizationEmployee(): OrganizationEmployeeSdk;
+    asIndividualController(): IndividualControllerSdk;
+    asIndividualMember(): IndividualMemberSdk;
+    asProfessional(): ProfessionalSdk;
+    private requireClient;
+}
+/**
+ * @deprecated Prefer `ActorSessionContext`.
+ */
+export declare class NodeActorSession {
+    private readonly inner;
+    constructor(context: NodeActorSessionContext, client?: RuntimeClient);
+    get actorKind(): ActorKind;
+    get actorDid(): string | undefined;
+    get subjectDid(): string | undefined;
+    get capabilities(): NodeCapability[];
+    is(actorKind: ActorKind): boolean;
+    assertActorKind(actorKind: ActorKind): void;
+    asHostOnboarding(): HostOnboardingSdk;
+    asOrganizationController(): OrganizationControllerSdk;
+    asOrganizationEmployee(): OrganizationEmployeeSdk;
+    asIndividualController(): IndividualControllerSdk;
+    asIndividualMember(): IndividualMemberSdk;
+    asProfessional(): ProfessionalSdk;
+}

package/dist/session.js

@@ -0,0 +1,80 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { HostOnboardingSdk } from './orchestration/host-onboarding-sdk.js';
+import { IndividualControllerSdk } from './orchestration/individual-controller-sdk.js';
+import { IndividualMemberSdk } from './orchestration/individual-member-sdk.js';
+import { OrganizationControllerSdk } from './orchestration/organization-controller-sdk.js';
+import { OrganizationEmployeeSdk } from './orchestration/organization-employee-sdk.js';
+import { ProfessionalSdk } from './orchestration/professional-sdk.js';
+/**
+ * Preferred neutral actor session abstraction for runtime packages.
+ *
+ * Keep `NodeActorSession` only as a compatibility alias while package naming is
+ * converged across node/front/other runtimes.
+ */
+export class ActorSession {
+    constructor(context, client) {
+        this.actorKind = context.actorKind;
+        this.actorDid = context.actorDid;
+        this.subjectDid = context.subjectDid;
+        this.capabilities = [...new Set(context.capabilities || [])];
+        this.client = client;
+    }
+    is(actorKind) {
+        return this.actorKind === actorKind;
+    }
+    assertActorKind(actorKind) {
+        if (!this.is(actorKind)) {
+            throw new Error(`ActorSession is '${this.actorKind}' and cannot be used as '${actorKind}'.`);
+        }
+    }
+    asHostOnboarding() {
+        this.assertActorKind('host_onboarding');
+        return new HostOnboardingSdk(this.requireClient());
+    }
+    asOrganizationController() {
+        this.assertActorKind('organization_controller');
+        return new OrganizationControllerSdk(this.requireClient());
+    }
+    asOrganizationEmployee() {
+        this.assertActorKind('organization_employee');
+        return new OrganizationEmployeeSdk(this.requireClient());
+    }
+    asIndividualController() {
+        this.assertActorKind('individual_controller');
+        return new IndividualControllerSdk(this.requireClient());
+    }
+    asIndividualMember() {
+        this.assertActorKind('individual_member');
+        return new IndividualMemberSdk(this.requireClient());
+    }
+    asProfessional() {
+        this.assertActorKind('professional');
+        return new ProfessionalSdk(this.requireClient());
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new Error('ActorSession requires a runtime client to materialize actor facades.');
+        }
+        return this.client;
+    }
+}
+/**
+ * @deprecated Prefer `ActorSessionContext`.
+ */
+export class NodeActorSession {
+    constructor(context, client) {
+        this.inner = new ActorSession(context, client);
+    }
+    get actorKind() { return this.inner.actorKind; }
+    get actorDid() { return this.inner.actorDid; }
+    get subjectDid() { return this.inner.subjectDid; }
+    get capabilities() { return this.inner.capabilities; }
+    is(actorKind) { return this.inner.is(actorKind); }
+    assertActorKind(actorKind) { this.inner.assertActorKind(actorKind); }
+    asHostOnboarding() { return this.inner.asHostOnboarding(); }
+    asOrganizationController() { return this.inner.asOrganizationController(); }
+    asOrganizationEmployee() { return this.inner.asOrganizationEmployee(); }
+    asIndividualController() { return this.inner.asIndividualController(); }
+    asIndividualMember() { return this.inner.asIndividualMember(); }
+    asProfessional() { return this.inner.asProfessional(); }
+}

package/dist/simple-device-activation.d.ts

@@ -0,0 +1,44 @@
+import type { PollOptions, SubmitAndPollResult } from './orchestration/client-port.js';
+import type { RouteContext } from './simple-individual-onboarding.js';
+export type EmployeeDeviceActivationInput = {
+    activationCode: string;
+    idToken: string;
+    dcrPayload: Record<string, unknown>;
+    pollOptions?: PollOptions;
+};
+export type EmployeeDeviceActivationRequestInput = {
+    tenantId?: string;
+    jurisdiction?: string;
+    sector?: string;
+    activationCode: string;
+    idToken: string;
+    dcrPayload: Record<string, unknown>;
+    timeoutSeconds?: number;
+    intervalSeconds?: number;
+};
+export type EmployeeDeviceActivationResult = {
+    initialAccessToken: string;
+    exchange: SubmitAndPollResult;
+    dcr: SubmitAndPollResult;
+};
+type ActivateEmployeeDeviceDeps = {
+    routeCtx: RouteContext;
+    input: EmployeeDeviceActivationInput;
+    identityTokenExchangePath: (ctx: RouteContext) => string;
+    identityTokenExchangePollPath: (ctx: RouteContext) => string;
+    identityDeviceDcrPath: (ctx: RouteContext) => string;
+    identityDeviceDcrPollPath: (ctx: RouteContext) => string;
+    submitAndPollWithBearerToken: (bearerToken: string | undefined, submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+};
+type ActivateEmployeeDeviceRequestDeps = {
+    routeCtx: RouteContext;
+    input: EmployeeDeviceActivationRequestInput;
+    defaultTimeoutMs?: number;
+    defaultIntervalMs?: number;
+    activateEmployeeDeviceWithActivationCode: (routeCtx: RouteContext, input: EmployeeDeviceActivationInput) => Promise<EmployeeDeviceActivationResult>;
+};
+export declare function activateEmployeeDeviceWithActivationCodeWithDeps(deps: ActivateEmployeeDeviceDeps): Promise<EmployeeDeviceActivationResult>;
+export declare function activateEmployeeDeviceWithActivationRequestWithDeps(deps: ActivateEmployeeDeviceRequestDeps): Promise<EmployeeDeviceActivationResult>;
+export {};

package/dist/simple-device-activation.js

@@ -0,0 +1,44 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { resolvePollOptionsFromSeconds } from './simple-poll-options.js';
+export async function activateEmployeeDeviceWithActivationCodeWithDeps(deps) {
+    const exchangePayload = {
+        thid: `exchange-${createRuntimeUuid()}`,
+        subject_token: deps.input.activationCode,
+    };
+    const exchange = await deps.submitAndPollWithBearerToken(deps.input.idToken, deps.identityTokenExchangePath(deps.routeCtx), deps.identityTokenExchangePollPath(deps.routeCtx), exchangePayload, deps.input.pollOptions);
+    const pollBody = exchange.poll.body || {};
+    const exchangeBody = (pollBody.body || pollBody);
+    const initialAccessToken = String(exchangeBody.initial_access_token || exchangeBody.access_token || '').trim();
+    if (!initialAccessToken) {
+        throw new Error('activateEmployeeDeviceWithActivationCode: missing initial_access_token in exchange response.');
+    }
+    const dcrPayload = {
+        thid: `dcr-${createRuntimeUuid()}`,
+        ...deps.input.dcrPayload,
+    };
+    const dcr = await deps.submitAndPollWithBearerToken(initialAccessToken, deps.identityDeviceDcrPath(deps.routeCtx), deps.identityDeviceDcrPollPath(deps.routeCtx), dcrPayload, deps.input.pollOptions);
+    return {
+        initialAccessToken,
+        exchange,
+        dcr,
+    };
+}
+export async function activateEmployeeDeviceWithActivationRequestWithDeps(deps) {
+    const pollOptions = resolvePollOptionsFromSeconds(deps.input.timeoutSeconds, deps.input.intervalSeconds, {
+        timeoutMs: deps.defaultTimeoutMs,
+        intervalMs: deps.defaultIntervalMs,
+    });
+    return deps.activateEmployeeDeviceWithActivationCode(deps.routeCtx, {
+        activationCode: deps.input.activationCode,
+        idToken: deps.input.idToken,
+        dcrPayload: deps.input.dcrPayload,
+        pollOptions,
+    });
+}
+function createRuntimeUuid() {
+    const fromCrypto = globalThis.crypto?.randomUUID?.();
+    if (fromCrypto) {
+        return fromCrypto;
+    }
+    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}

package/dist/simple-host-onboarding.d.ts

@@ -0,0 +1,27 @@
+import type { PollOptions, SubmitAndPollResult } from './orchestration/client-port.js';
+export type HostRouteContext = {
+    jurisdiction: string;
+    sector: string;
+};
+export type LegalOrganizationOrderInput = {
+    offerId: string;
+    jurisdiction?: string;
+    sector?: string;
+    dataType?: string;
+    additionalClaims?: Record<string, unknown>;
+    timeoutSeconds?: number;
+    intervalSeconds?: number;
+};
+type ConfirmLegalOrganizationOrderDeps = {
+    input: LegalOrganizationOrderInput;
+    hostCtx: HostRouteContext;
+    defaultTimeoutMs?: number;
+    defaultIntervalMs?: number;
+    hostRegistryOrderBatchPath: (ctx: HostRouteContext) => string;
+    hostRegistryOrderPollPath: (ctx: HostRouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, options?: PollOptions) => Promise<SubmitAndPollResult>;
+};
+export declare function confirmLegalOrganizationOrderWithDeps(deps: ConfirmLegalOrganizationOrderDeps): Promise<SubmitAndPollResult>;
+export {};

package/dist/simple-host-onboarding.js

@@ -0,0 +1,39 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { resolvePollOptionsFromSeconds } from './simple-poll-options.js';
+export async function confirmLegalOrganizationOrderWithDeps(deps) {
+    const offerId = String(deps.input.offerId || '').trim();
+    if (!offerId) {
+        throw new Error('confirmLegalOrganizationOrder requires offerId.');
+    }
+    const claims = {
+        '@context': 'org.schema',
+        'Order.acceptedOffer.identifier': offerId,
+        ...(deps.input.additionalClaims || {}),
+    };
+    const payload = {
+        jti: `jti-${createRuntimeUuid()}`,
+        iss: 'did:web:controller.example.com',
+        aud: 'did:web:host.example.com',
+        type: 'application/didcomm-plain+json',
+        thid: `order-${createRuntimeUuid()}`,
+        body: {
+            data: [{
+                    type: deps.input.dataType || 'Organization-order-request-v1.0',
+                    meta: { claims },
+                    resource: { meta: { claims } },
+                }],
+        },
+    };
+    const pollOptions = resolvePollOptionsFromSeconds(deps.input.timeoutSeconds, deps.input.intervalSeconds, {
+        timeoutMs: deps.defaultTimeoutMs,
+        intervalMs: deps.defaultIntervalMs,
+    });
+    return deps.submitAndPoll(deps.hostRegistryOrderBatchPath(deps.hostCtx), deps.hostRegistryOrderPollPath(deps.hostCtx), payload, pollOptions);
+}
+function createRuntimeUuid() {
+    const fromCrypto = globalThis.crypto?.randomUUID?.();
+    if (fromCrypto) {
+        return fromCrypto;
+    }
+    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}

package/dist/simple-individual-onboarding.d.ts

@@ -0,0 +1,27 @@
+import type { PollOptions, SubmitAndPollResult } from './orchestration/client-port.js';
+export type RouteContext = {
+    tenantId: string;
+    jurisdiction: string;
+    sector: string;
+};
+export type IndividualOrganizationConfirmOrderInput = {
+    tenantId?: string;
+    jurisdiction?: string;
+    sector?: string;
+    offerId: string;
+    timeoutSeconds?: number;
+    intervalSeconds?: number;
+};
+type ConfirmIndividualOrganizationOrderDeps = {
+    input: IndividualOrganizationConfirmOrderInput;
+    routeCtx: RouteContext;
+    defaultTimeoutMs?: number;
+    defaultIntervalMs?: number;
+    individualFamilyOrderBatchPath: (ctx: RouteContext) => string;
+    individualFamilyOrderPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, options?: PollOptions) => Promise<SubmitAndPollResult>;
+};
+export declare function confirmIndividualOrganizationOrderWithDeps(deps: ConfirmIndividualOrganizationOrderDeps): Promise<SubmitAndPollResult>;
+export {};

package/dist/simple-individual-onboarding.js

@@ -0,0 +1,38 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { resolvePollOptionsFromSeconds } from './simple-poll-options.js';
+export async function confirmIndividualOrganizationOrderWithDeps(deps) {
+    const offerId = String(deps.input.offerId || '').trim();
+    if (!offerId) {
+        throw new Error('confirmIndividualOrganizationOrder requires offerId.');
+    }
+    const orderClaims = {
+        '@context': 'org.schema',
+        'Order.acceptedOffer.identifier': offerId,
+    };
+    const payload = {
+        jti: `jti-${createRuntimeUuid()}`,
+        iss: deps.routeCtx.tenantId,
+        aud: deps.routeCtx.tenantId,
+        type: 'application/didcomm-plain+json',
+        thid: `family-order-${createRuntimeUuid()}`,
+        body: {
+            data: [{
+                    type: 'Family-order-request-v1.0',
+                    meta: { claims: orderClaims },
+                    resource: { meta: { claims: orderClaims } },
+                }],
+        },
+    };
+    const pollOptions = resolvePollOptionsFromSeconds(deps.input.timeoutSeconds, deps.input.intervalSeconds, {
+        timeoutMs: deps.defaultTimeoutMs,
+        intervalMs: deps.defaultIntervalMs,
+    });
+    return deps.submitAndPoll(deps.individualFamilyOrderBatchPath(deps.routeCtx), deps.individualFamilyOrderPollPath(deps.routeCtx), payload, pollOptions);
+}
+function createRuntimeUuid() {
+    const fromCrypto = globalThis.crypto?.randomUUID?.();
+    if (fromCrypto) {
+        return fromCrypto;
+    }
+    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}

package/dist/simple-individual-start.d.ts

@@ -0,0 +1,45 @@
+import type { PollOptions, SubmitAndPollResult } from './orchestration/client-port.js';
+import type { RouteContext } from './simple-individual-onboarding.js';
+export type IndividualOrganizationBootstrapInput = {
+    tenantId?: string;
+    jurisdiction?: string;
+    sector?: string;
+    alternateName: string;
+    controllerEmail?: string;
+    controllerTelephone?: string;
+    controllerRole?: string;
+    additionalClaims?: Record<string, unknown>;
+    timeoutSeconds?: number;
+    intervalSeconds?: number;
+};
+export type OfferPreview = {
+    offerId?: string;
+    amount?: string;
+    currency?: string;
+    seats?: number | undefined;
+    planName?: string;
+    sku?: string;
+    paymentMethod?: string;
+    checkoutUrl?: string;
+};
+export type IndividualOrganizationStartResult = {
+    registration: SubmitAndPollResult;
+    offerId: string;
+    offerPreview: OfferPreview;
+};
+type StartIndividualOrganizationDeps = {
+    input: IndividualOrganizationBootstrapInput;
+    routeCtx: RouteContext;
+    defaultTimeoutMs?: number;
+    defaultIntervalMs?: number;
+    individualFamilyOrganizationBatchPath: (ctx: RouteContext) => string;
+    individualFamilyOrganizationPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, options?: PollOptions) => Promise<SubmitAndPollResult>;
+    assertFirstDidcommEntrySuccess?: (result: SubmitAndPollResult, contextLabel: string) => void;
+    getOfferIdFromResponse: (result: SubmitAndPollResult) => string | undefined;
+    getOfferPreviewFromResponse: (result: SubmitAndPollResult) => OfferPreview;
+};
+export declare function startIndividualOrganizationWithDeps(deps: StartIndividualOrganizationDeps): Promise<IndividualOrganizationStartResult>;
+export {};