gdc-common-utils-ts 1.14.15 → 1.15.0

package/README.md

@@ -35,6 +35,7 @@ entry types, FHIR-like resources, and `resource.meta.claims` fit together,
 read first:
 
 - [`docs/101-COMMUNICATION_LAYERING.md`](docs/101-COMMUNICATION_LAYERING.md)
+- [`docs/101-BUNDLE_EDITOR_READER.md`](docs/101-BUNDLE_EDITOR_READER.md)
 
 ## Install
 

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

@@ -0,0 +1,88 @@
+import { buildEmployeeBatchBundle, buildEmployeeBatchEntry, buildEmployeeSearchBundle, EmployeeBundleOperations } from './employee';
+export type BundleOperation = (typeof EmployeeBundleOperations)[keyof typeof EmployeeBundleOperations];
+export type BuiltEmployeeBatchEntry = ReturnType<typeof buildEmployeeBatchEntry> & {
+    fullUrl?: string;
+};
+/**
+ * Generic bundle editor with an employee adapter surface.
+ *
+ * Current scope:
+ * - one declared business operation per bundle
+ * - active-entry editing through generic claim helpers
+ * - employee convenience setters layered on the same active entry
+ *
+ * This editor lives in `common-utils` because it is runtime-neutral and can be
+ * consumed by frontend SDKs, backend SDKs, and backend services.
+ */
+export declare class BundleEditor {
+    private bundleOperation;
+    private readonly entries;
+    private activeEntryIndex;
+    /** Declares which business operation the bundle is assembling. */
+    setBundleOperation(operation: BundleOperation): this;
+    /** Returns the operation currently assigned to this bundle. */
+    getBundleOperation(): BundleOperation | null;
+    /**
+     * Opens one new active entry.
+     *
+     * If the current bundle operation needs an identifier and none is supplied,
+     * a canonical `urn:uuid:*` identifier is generated and aligned across
+     * `fullUrl`, `resource.id`, and `org.schema.Person.identifier`.
+     */
+    newEntry(resourceId?: string): this;
+    /** Reopens an existing entry by identifier or `fullUrl`. */
+    openEntry(resourceId: string): this;
+    /** Closes the current active entry while preserving it inside the bundle draft. */
+    doneEntry(): this;
+    /** Returns a cloned snapshot of the currently staged entries. */
+    getEntries(): readonly BuiltEmployeeBatchEntry[];
+    /**
+     * Builds the final bundle payload for the declared operation.
+     *
+     * `search` returns one canonical search bundle.
+     * `purge` returns a batch bundle whose entries are routed later to
+     * `Employee/_purge`.
+     * `create` and `disable` return canonical batch bundles.
+     */
+    build(): ReturnType<typeof buildEmployeeBatchBundle> | ReturnType<typeof buildEmployeeSearchBundle>;
+    /** Reads one claim from the active entry. */
+    getClaim(key: string): unknown;
+    /** Checks whether the active entry contains one claim key. */
+    hasClaim(key: string): boolean;
+    /** Writes one claim on the active entry. */
+    setClaim(key: string, value: unknown): this;
+    /** Appends one claim value on the active entry. */
+    addClaim(key: string, value: unknown): this;
+    /** Removes one claim from the active entry. */
+    removeClaim(key: string): this;
+    /**
+     * Sets the active entry identifier.
+     *
+     * When informed, the value is synchronized into `fullUrl`, `resource.id`,
+     * and the canonical identifier claim.
+     * Empty values remove the identifier from all three places.
+     */
+    setIdentifier(identifier?: string | null): this;
+    /** Reads the active entry identifier from claims, resource id, or fullUrl. */
+    getIdentifier(): string | undefined;
+    /** Ensures the active entry carries one canonical identifier. */
+    ensureIdentifier(): string;
+    /** Sets the active entry `fullUrl` explicitly. */
+    setFullUrl(fullUrl?: string | null): this;
+    /** Returns the active entry `fullUrl` when present. */
+    getFullUrl(): string | undefined;
+    /** Convenience employee setter for email. */
+    setEmail(email: string): this;
+    /** Convenience employee setter for occupational role. */
+    setRole(role: string): this;
+    /** Convenience employee setter for `worksFor`. */
+    setWorksFor(worksFor: string): this;
+    /** Convenience employee setter for `memberOf`. */
+    setMemberOf(memberOf: string): this;
+    /** Convenience employee setter for `memberOf.taxID`. */
+    setMemberOfOrgTaxId(taxId: string): this;
+    private requireBundleOperation;
+    private getRequiredActiveEntry;
+    private getActiveEntryClaims;
+    private getActiveOrSingleSearchClaims;
+}

package/dist/utils/bundle-editor.js

@@ -0,0 +1,316 @@
+import { ClaimsPersonSchemaorg } from '../constants/schemaorg.js';
+import { EmployeeBatchEntryTypes, buildEmployeeBatchEntry, buildEmployeeClaims, buildEmployeePurgeBundle, buildEmployeeSearchBundle, EmployeeBundleMethods, EmployeeBundleOperations, } from './employee.js';
+function cloneEntry(entry) {
+    return JSON.parse(JSON.stringify(entry));
+}
+function cloneClaimValue(value) {
+    if (Array.isArray(value)) {
+        return [...value];
+    }
+    return value;
+}
+function normalizeOptionalIdentifier(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const normalized = String(value).trim();
+    return normalized ? normalized : undefined;
+}
+function createEmployeeIdentifierUrn() {
+    const cryptoLike = globalThis;
+    const uuid = typeof cryptoLike.crypto?.randomUUID === 'function'
+        ? cryptoLike.crypto.randomUUID()
+        : `employee-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    return `urn:uuid:${uuid}`;
+}
+function resolveRequestMethodForOperation(operation) {
+    switch (operation) {
+        case EmployeeBundleOperations.disable:
+            return EmployeeBundleMethods.disable;
+        case EmployeeBundleOperations.create:
+        case EmployeeBundleOperations.purge:
+        case EmployeeBundleOperations.search:
+        default:
+            return EmployeeBundleMethods.create;
+    }
+}
+function resolveEntryTypeForOperation(operation) {
+    switch (operation) {
+        case EmployeeBundleOperations.disable:
+            return EmployeeBatchEntryTypes.disable;
+        case EmployeeBundleOperations.purge:
+            return EmployeeBatchEntryTypes.purge;
+        case EmployeeBundleOperations.search:
+            return EmployeeBatchEntryTypes.search;
+        case EmployeeBundleOperations.create:
+        default:
+            return EmployeeBatchEntryTypes.create;
+    }
+}
+/**
+ * Generic bundle editor with an employee adapter surface.
+ *
+ * Current scope:
+ * - one declared business operation per bundle
+ * - active-entry editing through generic claim helpers
+ * - employee convenience setters layered on the same active entry
+ *
+ * This editor lives in `common-utils` because it is runtime-neutral and can be
+ * consumed by frontend SDKs, backend SDKs, and backend services.
+ */
+export class BundleEditor {
+    bundleOperation = null;
+    entries = [];
+    activeEntryIndex = null;
+    /** Declares which business operation the bundle is assembling. */
+    setBundleOperation(operation) {
+        this.bundleOperation = operation;
+        return this;
+    }
+    /** Returns the operation currently assigned to this bundle. */
+    getBundleOperation() {
+        return this.bundleOperation;
+    }
+    /**
+     * Opens one new active entry.
+     *
+     * If the current bundle operation needs an identifier and none is supplied,
+     * a canonical `urn:uuid:*` identifier is generated and aligned across
+     * `fullUrl`, `resource.id`, and `org.schema.Person.identifier`.
+     */
+    newEntry(resourceId) {
+        const operation = this.requireBundleOperation();
+        const normalizedIdentifier = operation === EmployeeBundleOperations.search
+            ? normalizeOptionalIdentifier(resourceId)
+            : (normalizeOptionalIdentifier(resourceId) || createEmployeeIdentifierUrn());
+        const claims = normalizedIdentifier
+            ? buildEmployeeClaims({ identifier: normalizedIdentifier })
+            : buildEmployeeClaims({});
+        const entry = buildEmployeeBatchEntry({
+            type: resolveEntryTypeForOperation(operation),
+            method: resolveRequestMethodForOperation(operation),
+            resourceId: normalizedIdentifier,
+            claims,
+        });
+        if (normalizedIdentifier) {
+            entry.fullUrl = normalizedIdentifier;
+        }
+        this.entries.push(entry);
+        this.activeEntryIndex = this.entries.length - 1;
+        return this;
+    }
+    /** Reopens an existing entry by identifier or `fullUrl`. */
+    openEntry(resourceId) {
+        const normalizedIdentifier = normalizeOptionalIdentifier(resourceId);
+        if (!normalizedIdentifier) {
+            throw new Error('openEntry requires a non-empty resource identifier.');
+        }
+        const nextIndex = this.entries.findIndex((entry) => {
+            const claims = entry.resource?.meta?.claims || {};
+            return normalizeOptionalIdentifier(entry.resource?.id) === normalizedIdentifier
+                || normalizeOptionalIdentifier(entry.fullUrl) === normalizedIdentifier
+                || normalizeOptionalIdentifier(claims[ClaimsPersonSchemaorg.identifier]) === normalizedIdentifier;
+        });
+        if (nextIndex < 0) {
+            throw new Error(`openEntry could not find resource identifier: ${normalizedIdentifier}`);
+        }
+        this.activeEntryIndex = nextIndex;
+        return this;
+    }
+    /** Closes the current active entry while preserving it inside the bundle draft. */
+    doneEntry() {
+        this.activeEntryIndex = null;
+        return this;
+    }
+    /** Returns a cloned snapshot of the currently staged entries. */
+    getEntries() {
+        return this.entries.map((entry) => cloneEntry(entry));
+    }
+    /**
+     * Builds the final bundle payload for the declared operation.
+     *
+     * `search` returns one canonical search bundle.
+     * `purge` returns a batch bundle whose entries are routed later to
+     * `Employee/_purge`.
+     * `create` and `disable` return canonical batch bundles.
+     */
+    build() {
+        const operation = this.requireBundleOperation();
+        if (operation === EmployeeBundleOperations.search) {
+            const claims = this.getActiveOrSingleSearchClaims();
+            return buildEmployeeSearchBundle({ claims });
+        }
+        if (operation === EmployeeBundleOperations.purge) {
+            return {
+                resourceType: 'Bundle',
+                type: 'batch',
+                entry: this.entries.map((entry) => {
+                    const identifier = normalizeOptionalIdentifier(entry.resource?.meta?.claims?.[ClaimsPersonSchemaorg.identifier]);
+                    if (!identifier) {
+                        throw new Error('Every purge entry requires org.schema.Person.identifier.');
+                    }
+                    return buildEmployeePurgeBundle({ identifier }).entry[0];
+                }),
+            };
+        }
+        return {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: this.entries.map((entry) => cloneEntry(entry)),
+        };
+    }
+    /** Reads one claim from the active entry. */
+    getClaim(key) {
+        return cloneClaimValue(this.getActiveEntryClaims()[String(key).trim()]);
+    }
+    /** Checks whether the active entry contains one claim key. */
+    hasClaim(key) {
+        return Object.prototype.hasOwnProperty.call(this.getActiveEntryClaims(), String(key).trim());
+    }
+    /** Writes one claim on the active entry. */
+    setClaim(key, value) {
+        const entry = this.getRequiredActiveEntry();
+        entry.resource = entry.resource || { resourceType: 'Employee', meta: { claims: {} } };
+        entry.resource.meta = entry.resource.meta || {};
+        entry.resource.meta.claims = {
+            ...(entry.resource.meta.claims || {}),
+            [String(key).trim()]: cloneClaimValue(value),
+        };
+        return this;
+    }
+    /** Appends one claim value on the active entry. */
+    addClaim(key, value) {
+        const normalizedKey = String(key).trim();
+        const current = this.getClaim(normalizedKey);
+        if (current === undefined) {
+            return this.setClaim(normalizedKey, value);
+        }
+        if (Array.isArray(current)) {
+            return this.setClaim(normalizedKey, [...current, cloneClaimValue(value)]);
+        }
+        return this.setClaim(normalizedKey, [current, cloneClaimValue(value)]);
+    }
+    /** Removes one claim from the active entry. */
+    removeClaim(key) {
+        const entry = this.getRequiredActiveEntry();
+        const claims = {
+            ...(entry.resource?.meta?.claims || {}),
+        };
+        delete claims[String(key).trim()];
+        entry.resource = entry.resource || { resourceType: 'Employee', meta: { claims: {} } };
+        entry.resource.meta = entry.resource.meta || {};
+        entry.resource.meta.claims = claims;
+        return this;
+    }
+    /**
+     * Sets the active entry identifier.
+     *
+     * When informed, the value is synchronized into `fullUrl`, `resource.id`,
+     * and the canonical identifier claim.
+     * Empty values remove the identifier from all three places.
+     */
+    setIdentifier(identifier) {
+        const normalized = normalizeOptionalIdentifier(identifier);
+        const entry = this.getRequiredActiveEntry();
+        if (!normalized) {
+            this.removeClaim(ClaimsPersonSchemaorg.identifier);
+            delete entry.resource?.id;
+            delete entry.fullUrl;
+            return this;
+        }
+        this.setClaim(ClaimsPersonSchemaorg.identifier, normalized);
+        entry.resource = entry.resource || { resourceType: 'Employee', meta: { claims: {} } };
+        entry.resource.id = normalized;
+        entry.fullUrl = normalized;
+        return this;
+    }
+    /** Reads the active entry identifier from claims, resource id, or fullUrl. */
+    getIdentifier() {
+        const entry = this.getRequiredActiveEntry();
+        return normalizeOptionalIdentifier(entry.resource?.meta?.claims?.[ClaimsPersonSchemaorg.identifier]
+            || entry.resource?.id
+            || entry.fullUrl);
+    }
+    /** Ensures the active entry carries one canonical identifier. */
+    ensureIdentifier() {
+        const existing = this.getIdentifier();
+        if (existing) {
+            return existing;
+        }
+        const generated = createEmployeeIdentifierUrn();
+        this.setIdentifier(generated);
+        return generated;
+    }
+    /** Sets the active entry `fullUrl` explicitly. */
+    setFullUrl(fullUrl) {
+        const entry = this.getRequiredActiveEntry();
+        const normalized = normalizeOptionalIdentifier(fullUrl);
+        if (!normalized) {
+            delete entry.fullUrl;
+            return this;
+        }
+        entry.fullUrl = normalized;
+        return this;
+    }
+    /** Returns the active entry `fullUrl` when present. */
+    getFullUrl() {
+        return normalizeOptionalIdentifier(this.getRequiredActiveEntry().fullUrl);
+    }
+    /** Convenience employee setter for email. */
+    setEmail(email) {
+        return this.setClaim(ClaimsPersonSchemaorg.email, String(email).trim());
+    }
+    /** Convenience employee setter for occupational role. */
+    setRole(role) {
+        return this.setClaim(ClaimsPersonSchemaorg.hasOccupationalRoleValue, String(role).trim());
+    }
+    /** Convenience employee setter for `worksFor`. */
+    setWorksFor(worksFor) {
+        return this.setClaim(ClaimsPersonSchemaorg.worksFor, String(worksFor).trim());
+    }
+    /** Convenience employee setter for `memberOf`. */
+    setMemberOf(memberOf) {
+        return this.setClaim(ClaimsPersonSchemaorg.memberOf, String(memberOf).trim());
+    }
+    /** Convenience employee setter for `memberOf.taxID`. */
+    setMemberOfOrgTaxId(taxId) {
+        return this.setClaim(ClaimsPersonSchemaorg.memberOfOrgTaxId, String(taxId).trim());
+    }
+    requireBundleOperation() {
+        if (!this.bundleOperation) {
+            throw new Error('BundleEditor requires setBundleOperation(...) before newEntry() or build().');
+        }
+        return this.bundleOperation;
+    }
+    getRequiredActiveEntry() {
+        if (this.activeEntryIndex === null) {
+            throw new Error('BundleEditor requires one active entry. Call newEntry(...) or openEntry(...) first.');
+        }
+        return this.entries[this.activeEntryIndex];
+    }
+    getActiveEntryClaims() {
+        return {
+            ...(this.getRequiredActiveEntry().resource?.meta?.claims || {}),
+        };
+    }
+    getActiveOrSingleSearchClaims() {
+        if (this.entries.length === 0) {
+            return {};
+        }
+        if (this.entries.length > 1) {
+            throw new Error('Search bundles currently support one search entry per bundle.');
+        }
+        const claims = this.entries[0].resource?.meta?.claims || {};
+        const searchClaims = {};
+        for (const [key, value] of Object.entries(claims)) {
+            if (value === undefined
+                || value === null
+                || typeof value === 'string'
+                || typeof value === 'number'
+                || typeof value === 'boolean') {
+                searchClaims[key] = value;
+            }
+        }
+        return searchClaims;
+    }
+}

package/dist/utils/communication-attached-bundle-session.d.ts

@@ -38,6 +38,8 @@ export type AddContainedDocumentToActiveEntryInput = Readonly<{
  * - `Communication.content-attachment-data` is always derived from the
  *   in-memory bundle after each committed update.
  * - saving can release active entry memory via `saveAndReleaseActiveEntry()`.
+ * - consent onboarding should prefer semantic helpers first, but this session
+ *   also exposes direct claim-level editing on the selected active entry.
  */
 export declare class CommunicationAttachedBundleSession {
     private communicationClaims;
@@ -53,6 +55,16 @@ export declare class CommunicationAttachedBundleSession {
     getActiveEntryIndex(): number | null;
     /** Returns a deep copy of the active entry when selected. */
     getActiveEntry(): BundleEntry | null;
+    /** Returns one claim from the currently selected active entry. */
+    getActiveEntryClaim(key: string): unknown;
+    /** Returns whether the currently selected active entry carries one claim key. */
+    hasActiveEntryClaim(key: string): boolean;
+    /** Sets one claim on the currently selected active entry and syncs the bundle attachment. */
+    setActiveEntryClaim(key: string, value: unknown): this;
+    /** Appends one claim value on the currently selected active entry and syncs the bundle attachment. */
+    addActiveEntryClaim(key: string, value: unknown): this;
+    /** Removes one claim from the currently selected active entry and syncs the bundle attachment. */
+    removeActiveEntryClaim(key: string): this;
     /** Selects an active entry by index or fullUrl. */
     selectActiveEntry(selection: ActiveEntrySelection): this;
     /** Clears active entry selection from memory. */
@@ -164,6 +176,8 @@ export declare class CommunicationAttachedBundleSession {
      * Resolves the entry URL (`fullUrl`) for a given entry/resource identifier.
      */
     getEntryUrl(entryId: string): string | undefined;
+    private getRequiredActiveEntry;
+    private getRequiredActiveEntryClaims;
     private decodeBundleFromClaims;
     private syncAttachmentFromBundle;
     private resolveCurrentSubject;

package/dist/utils/communication-attached-bundle-session.js

@@ -18,6 +18,8 @@ import { MedicationStatementClaim, } from '../models/interoperable-claims/medica
  * - `Communication.content-attachment-data` is always derived from the
  *   in-memory bundle after each committed update.
  * - saving can release active entry memory via `saveAndReleaseActiveEntry()`.
+ * - consent onboarding should prefer semantic helpers first, but this session
+ *   also exposes direct claim-level editing on the selected active entry.
  */
 export class CommunicationAttachedBundleSession {
     communicationClaims;
@@ -55,6 +57,70 @@ export class CommunicationAttachedBundleSession {
         }
         return cloneEntry(this.bundleInMemory.data[this.activeEntryIndex]);
     }
+    /** Returns one claim from the currently selected active entry. */
+    getActiveEntryClaim(key) {
+        const claims = this.getRequiredActiveEntryClaims();
+        return cloneUnknownValue(claims[key]);
+    }
+    /** Returns whether the currently selected active entry carries one claim key. */
+    hasActiveEntryClaim(key) {
+        const claims = this.getRequiredActiveEntryClaims();
+        return Object.prototype.hasOwnProperty.call(claims, key);
+    }
+    /** Sets one claim on the currently selected active entry and syncs the bundle attachment. */
+    setActiveEntryClaim(key, value) {
+        const current = cloneEntry(this.getRequiredActiveEntry());
+        const resource = ensureEntryResource(current, this.mode);
+        resource.meta = resource.meta || {};
+        resource.meta.claims = {
+            ...(resource.meta.claims || {}),
+            [String(key).trim()]: cloneUnknownValue(value),
+        };
+        current.resource = resource;
+        this.bundleInMemory.data[this.activeEntryIndex] = current;
+        this.syncAttachmentFromBundle();
+        return this;
+    }
+    /** Appends one claim value on the currently selected active entry and syncs the bundle attachment. */
+    addActiveEntryClaim(key, value) {
+        const current = cloneEntry(this.getRequiredActiveEntry());
+        const resource = ensureEntryResource(current, this.mode);
+        resource.meta = resource.meta || {};
+        const claims = {
+            ...(resource.meta.claims || {}),
+        };
+        const normalizedKey = String(key).trim();
+        const currentValue = claims[normalizedKey];
+        if (currentValue === undefined) {
+            claims[normalizedKey] = cloneUnknownValue(value);
+        }
+        else if (Array.isArray(currentValue)) {
+            claims[normalizedKey] = [...currentValue, cloneUnknownValue(value)];
+        }
+        else {
+            claims[normalizedKey] = [currentValue, cloneUnknownValue(value)];
+        }
+        resource.meta.claims = claims;
+        current.resource = resource;
+        this.bundleInMemory.data[this.activeEntryIndex] = current;
+        this.syncAttachmentFromBundle();
+        return this;
+    }
+    /** Removes one claim from the currently selected active entry and syncs the bundle attachment. */
+    removeActiveEntryClaim(key) {
+        const current = cloneEntry(this.getRequiredActiveEntry());
+        const resource = ensureEntryResource(current, this.mode);
+        resource.meta = resource.meta || {};
+        const claims = {
+            ...(resource.meta.claims || {}),
+        };
+        delete claims[String(key).trim()];
+        resource.meta.claims = claims;
+        current.resource = resource;
+        this.bundleInMemory.data[this.activeEntryIndex] = current;
+        this.syncAttachmentFromBundle();
+        return this;
+    }
     /** Selects an active entry by index or fullUrl. */
     selectActiveEntry(selection) {
         if (typeof selection.index === 'number') {
@@ -297,6 +363,20 @@ export class CommunicationAttachedBundleSession {
         const query = new BundleQuery(this.bundleInMemory);
         return query.getEntryUrl(entryId);
     }
+    getRequiredActiveEntry() {
+        if (this.activeEntryIndex === null) {
+            throw new Error('No active entry selected.');
+        }
+        return this.bundleInMemory.data[this.activeEntryIndex];
+    }
+    getRequiredActiveEntryClaims() {
+        const current = cloneEntry(this.getRequiredActiveEntry());
+        const resource = ensureEntryResource(current, this.mode);
+        resource.meta = resource.meta || {};
+        return {
+            ...(resource.meta.claims || {}),
+        };
+    }
     decodeBundleFromClaims(claims) {
         const encoded = asTrimmedString(claims[CommunicationClaim.ContentAttachmentData]);
         if (!encoded) {
@@ -495,6 +575,12 @@ function cloneBundle(bundle) {
 function cloneEntry(entry) {
     return JSON.parse(JSON.stringify(entry));
 }
+function cloneUnknownValue(value) {
+    if (value === undefined) {
+        return value;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
 function asTrimmedString(value) {
     if (value === undefined || value === null) {
         return '';

package/dist/utils/employee.d.ts

@@ -21,12 +21,39 @@ export type EmployeeBatchEntryInput = Readonly<{
 export type EmployeeBatchBundleInput = Readonly<{
     entries: readonly EmployeeBatchEntryInput[];
 }>;
+export type EmployeePurgeBundleInput = Readonly<{
+    identifier: string;
+    resourceId?: string;
+    resourceType?: 'Employee';
+    requestType?: (typeof EmployeeBatchEntryTypes)['purge'];
+}>;
 export type EmployeeSearchBundleInput = Readonly<{
     claims?: Record<string, EmployeeSearchValue | undefined>;
     method?: 'GET' | 'POST';
     encoding?: SearchRequestEncoding;
     resourceType?: 'Employee';
 }>;
+export declare const EmployeeBundleOperations: Readonly<{
+    readonly create: "create";
+    readonly search: "search";
+    readonly disable: "disable";
+    readonly purge: "purge";
+}>;
+export declare const EmployeeBundleMethods: Readonly<{
+    readonly create: "POST";
+    readonly search: "POST";
+    readonly disable: "DELETE";
+    readonly purge: "POST";
+}>;
+export declare const EmployeeBundleRoutes: Readonly<{
+    readonly search: "Employee/_search";
+}>;
+export declare const EmployeeBatchEntryTypes: Readonly<{
+    readonly create: "Employee-create-request-v1.0";
+    readonly disable: "Employee-disable-request-v1.0";
+    readonly search: "Employee-search-request-v1.0";
+    readonly purge: "Employee-purge-request-v1.0";
+}>;
 /**
  * Builds canonical `org.schema.Person.*` employee claims from semantic input.
  */
@@ -60,6 +87,19 @@ export declare function buildEmployeeBatchBundle(input: EmployeeBatchBundleInput
     type: 'batch';
     entry: Array<ReturnType<typeof buildEmployeeBatchEntry>>;
 };
+/**
+ * Builds the canonical employee purge batch bundle.
+ *
+ * Purge is a terminal lifecycle operation routed to the explicit
+ * `Employee/_purge` endpoint by runtime layers. The bundle selector should be
+ * one concrete employee identity, therefore this helper keeps the payload
+ * focused on the canonical employee identifier.
+ */
+export declare function buildEmployeePurgeBundle(input: EmployeePurgeBundleInput): {
+    resourceType: 'Bundle';
+    type: 'batch';
+    entry: Array<ReturnType<typeof buildEmployeeBatchEntry>>;
+};
 /**
  * Builds the legacy query-string employee search target kept for compatibility
  * with older `_search` wrappers.

package/dist/utils/employee.js

@@ -1,5 +1,26 @@
 import { ClaimsPersonSchemaorg } from '../constants/schemaorg.js';
 import { buildFhirParametersResourceFromSearchParams, buildSearchQueryString, } from './fhir-search.js';
+export const EmployeeBundleOperations = Object.freeze({
+    create: 'create',
+    search: 'search',
+    disable: 'disable',
+    purge: 'purge',
+});
+export const EmployeeBundleMethods = Object.freeze({
+    create: 'POST',
+    search: 'POST',
+    disable: 'DELETE',
+    purge: 'POST',
+});
+export const EmployeeBundleRoutes = Object.freeze({
+    search: 'Employee/_search',
+});
+export const EmployeeBatchEntryTypes = Object.freeze({
+    create: 'Employee-create-request-v1.0',
+    disable: 'Employee-disable-request-v1.0',
+    search: 'Employee-search-request-v1.0',
+    purge: 'Employee-purge-request-v1.0',
+});
 function cloneClaims(claims) {
     return { ...(claims || {}) };
 }
@@ -15,15 +36,15 @@ function normalizeEmployeeSearchClaims(claims) {
 function inferEmployeeEntryType(method) {
     switch (method) {
         case 'DELETE':
-            return 'Employee-delete-request-v1.0';
+            return EmployeeBatchEntryTypes.disable;
         case 'PUT':
         case 'PATCH':
             return 'Employee-update-request-v1.0';
         case 'GET':
-            return 'Employee-search-request-v1.0';
+            return EmployeeBatchEntryTypes.search;
         case 'POST':
         default:
-            return 'Employee-create-request-v1.0';
+            return EmployeeBatchEntryTypes.create;
     }
 }
 /**
@@ -85,6 +106,28 @@ export function buildEmployeeBatchBundle(input) {
         entry: [...input.entries].map((entry) => buildEmployeeBatchEntry(entry)),
     };
 }
+/**
+ * Builds the canonical employee purge batch bundle.
+ *
+ * Purge is a terminal lifecycle operation routed to the explicit
+ * `Employee/_purge` endpoint by runtime layers. The bundle selector should be
+ * one concrete employee identity, therefore this helper keeps the payload
+ * focused on the canonical employee identifier.
+ */
+export function buildEmployeePurgeBundle(input) {
+    const identifier = input.identifier.trim();
+    return buildEmployeeBatchBundle({
+        entries: [
+            {
+                type: input.requestType || EmployeeBatchEntryTypes.purge,
+                method: EmployeeBundleMethods.purge,
+                resourceId: input.resourceId || identifier,
+                resourceType: input.resourceType,
+                claims: buildEmployeeClaims({ identifier }),
+            },
+        ],
+    });
+}
 /**
  * Builds the legacy query-string employee search target kept for compatibility
  * with older `_search` wrappers.
@@ -103,7 +146,7 @@ export function buildEmployeeSearchQuery(input = {}) {
 export function buildEmployeeSearchBundle(input = {}) {
     const resourceType = input.resourceType || 'Employee';
     const claims = normalizeEmployeeSearchClaims(input.claims);
-    const method = input.method || (input.encoding === 'get-query' ? 'GET' : 'POST');
+    const method = input.method || (input.encoding === 'get-query' ? 'GET' : EmployeeBundleMethods.search);
     if (method === 'GET') {
         return {
             resourceType: 'Bundle',
@@ -124,8 +167,8 @@ export function buildEmployeeSearchBundle(input = {}) {
         entry: [
             {
                 request: {
-                    method: 'POST',
-                    url: `${resourceType}/_search`,
+                    method: EmployeeBundleMethods.search,
+                    url: EmployeeBundleRoutes.search,
                 },
                 resource: buildFhirParametersResourceFromSearchParams(claims),
             },

package/dist/utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './activation-policy';
 export * from './base-convert';
 export * from './baseN';
 export * from './bundle';
+export * from './bundle-editor';
 export * from './bundle-query';
 export * from '../claims';
 export * from './content';

package/dist/utils/index.js

@@ -3,6 +3,7 @@ export * from './activation-policy.js';
 export * from './base-convert.js';
 export * from './baseN.js';
 export * from './bundle.js';
+export * from './bundle-editor.js';
 export * from './bundle-query.js';
 export * from '../claims/index.js';
 export * from './content.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "1.14.15",
+  "version": "1.15.0",
   "publishConfig": {
     "access": "public"
   },