gdc-common-utils-ts 1.24.1 → 2.0.1

package/dist/utils/communication-search-editor.js

@@ -0,0 +1,156 @@
+import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
+import { buildCommunicationParticipantSearchBundle, buildCommunicationParticipantSearchParameters, normalizeCommunicationParticipantTokenList, } from './communication-participant-search.js';
+export const CommunicationSearchEntryTypes = Object.freeze({
+    Search: 'Communication-search-request-v1.0',
+});
+export const CommunicationSearchOperationTypes = Object.freeze({
+    Search: 'search',
+});
+function normalizeText(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized || undefined;
+}
+function normalizeInteger(value) {
+    const numeric = typeof value === 'number' ? value : Number(String(value ?? '').trim());
+    return Number.isInteger(numeric) && numeric > 0 ? numeric : undefined;
+}
+function normalizeSearchParamValue(claimKey, value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        if (isParticipantClaimKey(claimKey)) {
+            return normalizeCommunicationParticipantTokenList(value);
+        }
+        const normalized = value
+            .map((item) => typeof item === 'string' ? item.trim() : item)
+            .filter((item) => item !== '' && item !== undefined && item !== null);
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    if (isParticipantClaimKey(claimKey)) {
+        const normalized = normalizeCommunicationParticipantTokenList(value);
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    return normalizeText(value);
+}
+function cloneDraft(draft) {
+    const searchParams = {};
+    for (const [key, value] of Object.entries(draft?.searchParams || {})) {
+        const normalizedKey = normalizeText(key);
+        if (!normalizedKey) {
+            continue;
+        }
+        const normalizedValue = normalizeSearchParamValue(normalizedKey, value);
+        if (normalizedValue !== undefined) {
+            searchParams[normalizedKey] = normalizedValue;
+        }
+    }
+    return {
+        searchParams,
+        periodStart: normalizeText(draft?.periodStart),
+        periodEnd: normalizeText(draft?.periodEnd),
+        page: normalizeInteger(draft?.page),
+        count: normalizeInteger(draft?.count),
+    };
+}
+function isParticipantClaimKey(claimKey) {
+    return claimKey === CommunicationClaim.Subject
+        || claimKey === CommunicationClaim.Sender
+        || claimKey === CommunicationClaim.Recipient;
+}
+/**
+ * High-level chainable editor for `Communication/_search`.
+ *
+ * Design goals:
+ * - keep business filters near the caller instead of forcing ad-hoc `Parameters`
+ * - reuse canonical `CommunicationClaim.*` keys for search params
+ * - keep shared controls (`periodStart`, `periodEnd`, `page`, `count`) outside
+ *   the claim bag because they are search controls, not resource claims
+ */
+export class CommunicationSearchEditor {
+    draft;
+    constructor(initial) {
+        this.draft = cloneDraft(initial);
+    }
+    setSearchParams(value) {
+        this.draft = cloneDraft({ ...this.draft, searchParams: value });
+        return this;
+    }
+    setSearchParam(claimKey, value) {
+        this.draft = cloneDraft({
+            ...this.draft,
+            searchParams: {
+                ...this.draft.searchParams,
+                [claimKey]: value,
+            },
+        });
+        return this;
+    }
+    setSearchParamSender(value) {
+        return this.setSearchParam(CommunicationClaim.Sender, value);
+    }
+    setSearchParamRecipient(value) {
+        return this.setSearchParam(CommunicationClaim.Recipient, value);
+    }
+    setSearchParamCategory(value) {
+        return this.setSearchParam(CommunicationClaim.Category, value);
+    }
+    setSearchParamTopic(value) {
+        return this.setSearchParam(CommunicationClaim.Topic, value);
+    }
+    getSearchParams() {
+        return { ...this.draft.searchParams };
+    }
+    setPeriodStart(value) {
+        this.draft = cloneDraft({ ...this.draft, periodStart: value });
+        return this;
+    }
+    setPeriodEnd(value) {
+        this.draft = cloneDraft({ ...this.draft, periodEnd: value });
+        return this;
+    }
+    setPaginationCount(value) {
+        this.draft = cloneDraft({ ...this.draft, count: value });
+        return this;
+    }
+    setPageNumber(value) {
+        this.draft = cloneDraft({ ...this.draft, page: value });
+        return this;
+    }
+    getState() {
+        return cloneDraft(this.draft);
+    }
+    toSearchInput() {
+        return {
+            searchParams: this.draft.searchParams,
+            periodStart: this.draft.periodStart,
+            periodEnd: this.draft.periodEnd,
+            page: this.draft.page,
+            count: this.draft.count,
+        };
+    }
+    buildRequest() {
+        return buildCommunicationParticipantSearchParameters(this.toSearchInput());
+    }
+    buildEntry() {
+        const built = this.buildBundle().entry[0];
+        return {
+            type: CommunicationSearchEntryTypes.Search,
+            request: {
+                method: 'POST',
+                url: built?.request.url || `${ResourceTypesFhirR4.Communication}/_search`,
+            },
+            resource: built?.resource || this.buildRequest(),
+            meta: {
+                operationType: CommunicationSearchOperationTypes.Search,
+            },
+        };
+    }
+    buildBundle() {
+        return buildCommunicationParticipantSearchBundle(this.toSearchInput());
+    }
+}

package/dist/utils/fhir-search.d.ts

@@ -1,6 +1,19 @@
 import { ParameterData } from '../models/params';
 export type SearchParameterPrimitive = string | number | boolean | readonly (string | number | boolean)[];
 export type SearchRequestEncoding = 'get-query' | 'post-parameters';
+/**
+ * Canonical business-level bundle types used by search request/response flows.
+ */
+export declare const SearchBundleTypes: Readonly<{
+    readonly Search: "search";
+    readonly SearchResponse: "search-response";
+}>;
+export type SearchBundleOptions = Readonly<{
+    resourceType: string;
+    searchParams?: Readonly<Record<string, SearchParameterPrimitive | undefined>>;
+    encoding?: SearchRequestEncoding;
+    bundleType?: (typeof SearchBundleTypes)[keyof typeof SearchBundleTypes];
+}>;
 export type FhirParametersParameter = {
     name: string;
     valueString?: string;
@@ -24,3 +37,22 @@ export type FhirParametersResource = {
 export declare function buildSearchQueryString(searchParams: Readonly<Record<string, SearchParameterPrimitive | undefined>>): string;
 export declare function buildFhirParametersResourceFromSearchParams(searchParams: Readonly<Record<string, SearchParameterPrimitive | undefined>>): FhirParametersResource;
 export declare function buildFhirParametersResourceFromParameterData(parameters: ReadonlyArray<ParameterData>): FhirParametersResource;
+/**
+ * Builds one search bundle entry using either GET query parameters or POST
+ * `Parameters`.
+ */
+export declare function buildSearchBundleEntry(input: SearchBundleOptions): {
+    request: {
+        method: 'GET' | 'POST';
+        url: string;
+    };
+    resource?: FhirParametersResource;
+};
+/**
+ * Builds a one-entry batch bundle for runtime-neutral search operations.
+ */
+export declare function buildSearchBundle(input: SearchBundleOptions): {
+    resourceType: 'Bundle';
+    type: (typeof SearchBundleTypes)[keyof typeof SearchBundleTypes];
+    entry: Array<ReturnType<typeof buildSearchBundleEntry>>;
+};

package/dist/utils/fhir-search.js

@@ -1,3 +1,10 @@
+/**
+ * Canonical business-level bundle types used by search request/response flows.
+ */
+export const SearchBundleTypes = Object.freeze({
+    Search: 'search',
+    SearchResponse: 'search-response',
+});
 function normalizeSearchPrimitiveValues(value) {
     const values = Array.isArray(value) ? [...value] : [value];
     return values
@@ -82,3 +89,41 @@ export function buildFhirParametersResourceFromParameterData(parameters) {
             .filter((parameter) => Boolean(parameter)),
     };
 }
+/**
+ * Builds one search bundle entry using either GET query parameters or POST
+ * `Parameters`.
+ */
+export function buildSearchBundleEntry(input) {
+    const resourceType = String(input.resourceType || '').trim();
+    const encoding = input.encoding || 'post-parameters';
+    const searchParams = input.searchParams || {};
+    if (!resourceType) {
+        throw new Error('buildSearchBundleEntry requires resourceType.');
+    }
+    if (encoding === 'get-query') {
+        const query = buildSearchQueryString(searchParams);
+        return {
+            request: {
+                method: 'GET',
+                url: query ? `${resourceType}?${query}` : resourceType,
+            },
+        };
+    }
+    return {
+        request: {
+            method: 'POST',
+            url: `${resourceType}/_search`,
+        },
+        resource: buildFhirParametersResourceFromSearchParams(searchParams),
+    };
+}
+/**
+ * Builds a one-entry batch bundle for runtime-neutral search operations.
+ */
+export function buildSearchBundle(input) {
+    return {
+        resourceType: 'Bundle',
+        type: input.bundleType || SearchBundleTypes.Search,
+        entry: [buildSearchBundleEntry(input)],
+    };
+}

package/dist/utils/index.d.ts

@@ -33,6 +33,10 @@ export * from './communication-fhir-r4';
 export * from './communication-document-reference';
 export * from './communication-bundle-document-request';
 export * from './communication-identity';
+export * from './communication-search-editor';
+export * from './communication-participant-search';
+export * from './communication-participant-search-test-data';
+export * from './communication-retention-policy';
 export * from './communication-attached-bundle-session';
 export * from './confidential-storage-persistence';
 export * from './confidential-storage-test-data';
@@ -44,6 +48,7 @@ export * from './fhir-validator';
 export * from './family-registration-test-data';
 export * from './individual-form-pdf';
 export * from './individual-organization-claims';
+export * from './organization-lifecycle';
 export * from './individual-organization-lifecycle';
 export * from './individual-onboarding-editor';
 export * from './individual-onboarding-document-reference';
@@ -53,6 +58,8 @@ export * from './invoice-bundle';
 export * from './ips-bundle-claims';
 export * from './interoperable-resource-operation';
 export * from './jwt';
+export * from './jwk-thumbprint';
+export * from './legal-organization-onboarding';
 export * from './license';
 export * from './license-commercial-search';
 export * from './license-list-search';
@@ -69,5 +76,6 @@ export * from './object-sanitize';
 export * from './permission-templates';
 export * from './smart-scope';
 export * from './service-act-reasons';
+export * from './same-as';
 export * from './activation-request';
 export * from './vp-token';

package/dist/utils/index.js

@@ -33,6 +33,10 @@ export * from './communication-fhir-r4.js';
 export * from './communication-document-reference.js';
 export * from './communication-bundle-document-request.js';
 export * from './communication-identity.js';
+export * from './communication-search-editor.js';
+export * from './communication-participant-search.js';
+export * from './communication-participant-search-test-data.js';
+export * from './communication-retention-policy.js';
 export * from './communication-attached-bundle-session.js';
 export * from './confidential-storage-persistence.js';
 export * from './confidential-storage-test-data.js';
@@ -44,6 +48,7 @@ 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 './organization-lifecycle.js';
 export * from './individual-organization-lifecycle.js';
 export * from './individual-onboarding-editor.js';
 export * from './individual-onboarding-document-reference.js';
@@ -53,6 +58,8 @@ export * from './invoice-bundle.js';
 export * from './ips-bundle-claims.js';
 export * from './interoperable-resource-operation.js';
 export * from './jwt.js';
+export * from './jwk-thumbprint.js';
+export * from './legal-organization-onboarding.js';
 export * from './license.js';
 export * from './license-commercial-search.js';
 export * from './license-list-search.js';
@@ -69,5 +76,6 @@ export * from './object-sanitize.js';
 export * from './permission-templates.js';
 export * from './smart-scope.js';
 export * from './service-act-reasons.js';
+export * from './same-as.js';
 export * from './activation-request.js';
 export * from './vp-token.js';

package/dist/utils/individual-organization-lifecycle.d.ts

@@ -47,7 +47,7 @@ export type IndividualOrganizationLifecyclePayload = Readonly<{
         data: IndividualOrganizationLifecycleDataEntry[];
     };
 }>;
-export type IndividualOrganizationLifecycleDraftState = Readonly<{
+export type IndividualOrganizationLifecycleEditorState = Readonly<{
     operation: IndividualOrganizationLifecycleOperation;
     claims: IndividualOrganizationLifecycleClaims;
     resourceId?: string;
@@ -76,7 +76,7 @@ export declare function buildCurrentIndividualOrganizationLifecycleDataEntry(inp
  */
 export declare function buildCurrentIndividualOrganizationLifecyclePayload(input: IndividualOrganizationLifecyclePayloadInput): IndividualOrganizationLifecyclePayload;
 /**
- * High-level chainable draft for hosted individual/family lifecycle work.
+ * High-level chainable editor for hosted individual/family lifecycle work.
  *
  * Teaching goal:
  * - authors one canonical flat `org.schema.Organization.*` claim set
@@ -84,11 +84,12 @@ export declare function buildCurrentIndividualOrganizationLifecyclePayload(input
  * - can emit either a semantic lifecycle message or the current GW CORE
  *   payload shape used by `sdk-node`
  */
-export declare class IndividualOrganizationLifecycleDraft {
+export declare class IndividualOrganizationLifecycleEditor {
     private draft;
-    constructor(initial?: Partial<IndividualOrganizationLifecycleDraftState>);
+    constructor(initial?: Partial<IndividualOrganizationLifecycleEditorState>);
     mergeClaims(claims: IndividualOrganizationLifecycleClaims): this;
     setClaims(claims: IndividualOrganizationLifecycleClaims): this;
+    setContext(context: string): this;
     setIdentifier(identifier: string): this;
     setAlternateName(alternateName: string): this;
     setOwnerEmail(email: string): this;
@@ -96,8 +97,17 @@ export declare class IndividualOrganizationLifecycleDraft {
     setResourceId(resourceId?: string): this;
     setRequestType(requestType: string): this;
     setThreadId(thid: string): this;
+    getIdentifier(): string | undefined;
+    getContext(): string | undefined;
+    getAlternateName(): string | undefined;
+    getOwnerEmail(): string | undefined;
+    getOperation(): IndividualOrganizationLifecycleOperation;
+    getResourceId(): string | undefined;
+    getRequestType(): string | undefined;
+    getThreadId(): string | undefined;
     getClaims(): IndividualOrganizationLifecycleClaims;
-    getDraft(): IndividualOrganizationLifecycleDraftState;
+    getState(): IndividualOrganizationLifecycleEditorState;
+    getEditorState(): IndividualOrganizationLifecycleEditorState;
     toSemanticMessage(): IndividualOrganizationLifecycleSemanticMessage;
     buildCurrentGwDataEntry(): IndividualOrganizationLifecycleDataEntry;
     buildCurrentGwPayload(): IndividualOrganizationLifecyclePayload;

package/dist/utils/individual-organization-lifecycle.js

@@ -17,7 +17,10 @@ function normalizeText(value) {
 function normalizeDraft(draft) {
     return {
         operation: draft?.operation || IndividualOrganizationLifecycleOperations.Disable,
-        claims: cloneClaims(draft?.claims),
+        claims: {
+            '@context': 'org.schema',
+            ...cloneClaims(draft?.claims),
+        },
         resourceId: normalizeText(draft?.resourceId),
         requestType: normalizeText(draft?.requestType),
         thid: normalizeText(draft?.thid),
@@ -75,7 +78,7 @@ export function buildCurrentIndividualOrganizationLifecyclePayload(input) {
     };
 }
 /**
- * High-level chainable draft for hosted individual/family lifecycle work.
+ * High-level chainable editor for hosted individual/family lifecycle work.
  *
  * Teaching goal:
  * - authors one canonical flat `org.schema.Organization.*` claim set
@@ -83,7 +86,7 @@ export function buildCurrentIndividualOrganizationLifecyclePayload(input) {
  * - can emit either a semantic lifecycle message or the current GW CORE
  *   payload shape used by `sdk-node`
  */
-export class IndividualOrganizationLifecycleDraft {
+export class IndividualOrganizationLifecycleEditor {
     draft;
     constructor(initial) {
         this.draft = normalizeDraft(initial);
@@ -96,6 +99,15 @@ export class IndividualOrganizationLifecycleDraft {
         this.draft = patchDraft(this.draft, { claims });
         return this;
     }
+    setContext(context) {
+        this.draft = patchDraft(this.draft, {
+            claims: {
+                ...this.draft.claims,
+                '@context': String(context).trim(),
+            },
+        });
+        return this;
+    }
     setIdentifier(identifier) {
         this.draft = patchDraft(this.draft, {
             claims: {
@@ -139,12 +151,47 @@ export class IndividualOrganizationLifecycleDraft {
         this.draft = patchDraft(this.draft, { thid });
         return this;
     }
+    getIdentifier() {
+        const value = this.draft.claims[ClaimsOrganizationSchemaorg.identifier];
+        const normalized = normalizeText(value);
+        return normalized || undefined;
+    }
+    getContext() {
+        const value = this.draft.claims['@context'];
+        const normalized = normalizeText(value);
+        return normalized || undefined;
+    }
+    getAlternateName() {
+        const value = this.draft.claims[ClaimsOrganizationSchemaorg.alternateName];
+        const normalized = normalizeText(value);
+        return normalized || undefined;
+    }
+    getOwnerEmail() {
+        const value = this.draft.claims[ClaimsOrganizationSchemaorg.ownerEmail];
+        const normalized = normalizeText(value);
+        return normalized || undefined;
+    }
+    getOperation() {
+        return this.draft.operation;
+    }
+    getResourceId() {
+        return normalizeText(this.draft.resourceId) || undefined;
+    }
+    getRequestType() {
+        return normalizeText(this.draft.requestType) || undefined;
+    }
+    getThreadId() {
+        return normalizeText(this.draft.thid) || undefined;
+    }
     getClaims() {
         return cloneClaims(this.draft.claims);
     }
-    getDraft() {
+    getState() {
         return normalizeDraft(this.draft);
     }
+    getEditorState() {
+        return this.getState();
+    }
     toSemanticMessage() {
         return {
             operation: this.draft.operation,
@@ -156,7 +203,7 @@ export class IndividualOrganizationLifecycleDraft {
     buildCurrentGwDataEntry() {
         const requestType = normalizeText(this.draft.requestType);
         if (!requestType) {
-            throw new Error('IndividualOrganizationLifecycleDraft.buildCurrentGwDataEntry requires requestType.');
+            throw new Error('IndividualOrganizationLifecycleEditor.buildCurrentGwDataEntry requires requestType.');
         }
         return buildCurrentIndividualOrganizationLifecycleDataEntry({
             claims: this.getClaims(),
@@ -167,7 +214,7 @@ export class IndividualOrganizationLifecycleDraft {
     buildCurrentGwPayload() {
         const requestType = normalizeText(this.draft.requestType);
         if (!requestType) {
-            throw new Error('IndividualOrganizationLifecycleDraft.buildCurrentGwPayload requires requestType.');
+            throw new Error('IndividualOrganizationLifecycleEditor.buildCurrentGwPayload requires requestType.');
         }
         return {
             thid: this.draft.thid || createLifecycleThreadId(this.draft.operation),

package/dist/utils/interoperable-resource-operation.d.ts

@@ -16,7 +16,7 @@ export declare const InteroperableLifecycleStatuses: Readonly<{
 }>;
 export type InteroperableLifecycleStatus = typeof InteroperableLifecycleStatuses[keyof typeof InteroperableLifecycleStatuses];
 export type InteroperableSearchParams = Readonly<Record<string, SearchParameterPrimitive | undefined>>;
-export type InteroperableResourceOperationDraft = Readonly<{
+export type InteroperableResourceOperationState = Readonly<{
     resourceType: string;
     identifierClaimKey: string;
     identifierValue?: string;
@@ -45,7 +45,7 @@ export interface InteroperableResourceOperationEditor {
     mergeClaims(claims: Record<string, unknown>): InteroperableResourceOperationEditor;
     setLifecycleStatus(value: InteroperableLifecycleStatus): InteroperableResourceOperationEditor;
     importFhirResource(resource: FhirResource): InteroperableResourceOperationEditor;
-    getDraft(): InteroperableResourceOperationDraft;
+    getState(): InteroperableResourceOperationState;
     getBusinessIdentifier(): string | undefined;
     getClaims(): Record<string, unknown>;
     buildLifecycleResource(): {
@@ -140,7 +140,7 @@ export declare function buildInteroperableSearchPath(resourceType: string): stri
  * - `resource.meta.status` carries lifecycle state without overloading
  *   resource-specific FHIR fields such as `status` or `active`
  */
-export declare function buildLifecycleOperationResource(draft: InteroperableResourceOperationDraft): {
+export declare function buildLifecycleOperationResource(state: InteroperableResourceOperationState): {
     resourceType: string;
     id?: string;
     identifier?: Array<{
@@ -155,4 +155,4 @@ export declare function buildLifecycleOperationResource(draft: InteroperableReso
 /**
  * Creates the shared chainable editor for search/disable/purge request shapes.
  */
-export declare function createInteroperableResourceOperationEditor(initial?: Partial<InteroperableResourceOperationDraft>): InteroperableResourceOperationEditor;
+export declare function createInteroperableResourceOperationEditor(initial?: Partial<InteroperableResourceOperationState>): InteroperableResourceOperationEditor;

package/dist/utils/interoperable-resource-operation.js

@@ -24,23 +24,23 @@ function cloneClaims(claims) {
 function resolveDefaultIdentifierClaimKey(resourceType) {
     return `${String(resourceType || '').trim()}.identifier`;
 }
-function normalizeDraft(draft) {
-    const resourceType = normalizeText(draft?.resourceType) || 'Resource';
+function normalizeDraft(state) {
+    const resourceType = normalizeText(state?.resourceType) || 'Resource';
     return {
         resourceType,
-        identifierClaimKey: normalizeText(draft?.identifierClaimKey) || resolveDefaultIdentifierClaimKey(resourceType),
-        identifierValue: normalizeText(draft?.identifierValue),
-        identifierSystem: normalizeText(draft?.identifierSystem),
-        resourceId: normalizeText(draft?.resourceId),
-        claims: cloneClaims(draft?.claims),
-        lifecycleStatus: draft?.lifecycleStatus,
+        identifierClaimKey: normalizeText(state?.identifierClaimKey) || resolveDefaultIdentifierClaimKey(resourceType),
+        identifierValue: normalizeText(state?.identifierValue),
+        identifierSystem: normalizeText(state?.identifierSystem),
+        resourceId: normalizeText(state?.resourceId),
+        claims: cloneClaims(state?.claims),
+        lifecycleStatus: state?.lifecycleStatus,
     };
 }
-function patchDraft(draft, patch) {
+function patchDraft(state, patch) {
     return normalizeDraft({
-        ...draft,
+        ...state,
         ...patch,
-        claims: patch.claims ? cloneClaims(patch.claims) : cloneClaims(draft.claims),
+        claims: patch.claims ? cloneClaims(patch.claims) : cloneClaims(state.claims),
     });
 }
 /**
@@ -118,23 +118,23 @@ export function buildInteroperableSearchPath(resourceType) {
  * - `resource.meta.status` carries lifecycle state without overloading
  *   resource-specific FHIR fields such as `status` or `active`
  */
-export function buildLifecycleOperationResource(draft) {
-    const claims = cloneClaims(draft.claims);
-    if (draft.identifierValue && !normalizeText(claims[draft.identifierClaimKey])) {
-        claims[draft.identifierClaimKey] = draft.identifierValue;
+export function buildLifecycleOperationResource(state) {
+    const claims = cloneClaims(state.claims);
+    if (state.identifierValue && !normalizeText(claims[state.identifierClaimKey])) {
+        claims[state.identifierClaimKey] = state.identifierValue;
     }
     return {
-        resourceType: draft.resourceType,
-        ...(draft.resourceId ? { id: draft.resourceId } : {}),
-        ...(draft.identifierValue ? {
+        resourceType: state.resourceType,
+        ...(state.resourceId ? { id: state.resourceId } : {}),
+        ...(state.identifierValue ? {
             identifier: [{
-                    value: draft.identifierValue,
-                    ...(draft.identifierSystem ? { system: draft.identifierSystem } : {}),
+                    value: state.identifierValue,
+                    ...(state.identifierSystem ? { system: state.identifierSystem } : {}),
                 }],
         } : {}),
         meta: {
             claims,
-            ...(draft.lifecycleStatus ? { status: draft.lifecycleStatus } : {}),
+            ...(state.lifecycleStatus ? { status: state.lifecycleStatus } : {}),
         },
     };
 }
@@ -192,7 +192,7 @@ export function createInteroperableResourceOperationEditor(initial) {
             });
             return editor;
         },
-        getDraft() {
+        getState() {
             return normalizeDraft(draft);
         },
         getBusinessIdentifier() {

package/dist/utils/jwk-thumbprint.d.ts

@@ -0,0 +1,40 @@
+import { PublicJwk } from '../interfaces/Cryptography.types';
+/**
+ * Minimal RSA public JWK shape needed for RFC 7638 thumbprint derivation.
+ */
+export type RsaPublicJwk = {
+    kty: 'RSA';
+    e: string;
+    n: string;
+    kid?: string;
+    alg?: string;
+    use?: string;
+};
+/**
+ * Public JWK shapes supported by the RFC 7638 thumbprint helpers.
+ *
+ * Notes:
+ * - classic EC keys are identified by `kty: 'EC'` and use `crv`, `x`, `y`
+ * - this includes `secp256k1`, represented as `crv: 'secp256k1'`
+ * - ML-DSA keys are represented in this codebase as `kty: 'AKP'` and use
+ *   `alg` plus `pub`; they do not use `crv`
+ */
+export type ThumbprintableJwk = PublicJwk | RsaPublicJwk;
+/**
+ * Computes the RFC 7638 JWK thumbprint as a bare base64url string.
+ *
+ * Canonical fields per supported key family:
+ * - `EC`: `kty`, `crv`, `x`, `y`
+ * - `RSA`: `kty`, `e`, `n`
+ * - `OKP`: `kty`, `crv`, `x`
+ * - `AKP` / ML-DSA: `kty`, `alg`, `pub`
+ *
+ * For classical EC keys, the curve is taken from `crv`, so keys such as
+ * `secp256k1` are handled naturally through `crv: 'secp256k1'`.
+ */
+export declare function computeRfc7638JwkThumbprint(jwk: ThumbprintableJwk): string;
+/**
+ * Returns the RFC 9278 thumbprint URI form:
+ * `urn:ietf:params:oauth:jwk-thumbprint:sha-256:<base64url>`
+ */
+export declare function toJwkThumbprintSha256Urn(jwk: ThumbprintableJwk): string;