gdc-common-utils-ts 1.24.1 → 2.0.1

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

@@ -0,0 +1,425 @@
+import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
+import { buildSearchBundle, buildFhirParametersResourceFromSearchParams, SearchBundleTypes, } from './fhir-search.js';
+/**
+ * Canonical participant-token prefixes used by communication search helpers.
+ */
+export const CommunicationParticipantPrefixes = Object.freeze({
+    Did: 'did:',
+    Email: 'email:',
+    Mailto: 'mailto:',
+    Tel: 'tel:',
+    Phone: 'phone:',
+    Wildcard: '*',
+});
+/**
+ * Canonical parameter names supported by `Communication/_search`.
+ */
+export const CommunicationParticipantSearchParameterNames = Object.freeze({
+    Subject: 'subject',
+    Actor: 'actor',
+    Sender: 'sender',
+    Recipient: 'recipient',
+    User: 'user',
+    Target: 'target',
+    PeriodStart: 'period-start',
+    PeriodEnd: 'period-end',
+    Page: 'page',
+    Count: 'count',
+});
+/**
+ * Backward-compatible aliases still accepted while callers migrate to the
+ * canonical control names.
+ */
+export const CommunicationParticipantSearchParameterAliases = Object.freeze({
+    SentFrom: 'sent-from',
+    SentTo: 'sent-to',
+});
+/**
+ * Indexed-attribute names used by communication projections.
+ */
+export const CommunicationParticipantIndexNames = Object.freeze({
+    Subject: CommunicationClaim.Subject,
+    Participant: 'Communication.participant-token',
+    Sender: 'Communication.sender-token',
+    Recipient: 'Communication.recipient-token',
+});
+const COMMUNICATION_PARTICIPANT_INDEX_ATTRIBUTE_UNIQUE = Object.freeze({
+    subject: true,
+    participant: false,
+    sender: false,
+    recipient: false,
+});
+const COMMUNICATION_PARTICIPANT_SEARCH_KEYS = Object.freeze([
+    CommunicationParticipantSearchParameterNames.Subject,
+    CommunicationParticipantSearchParameterNames.Actor,
+    CommunicationParticipantSearchParameterNames.Sender,
+    CommunicationParticipantSearchParameterNames.Recipient,
+    CommunicationParticipantSearchParameterNames.User,
+    CommunicationParticipantSearchParameterNames.Target,
+    CommunicationParticipantSearchParameterNames.PeriodStart,
+    CommunicationParticipantSearchParameterNames.PeriodEnd,
+    CommunicationParticipantSearchParameterNames.Page,
+    CommunicationParticipantSearchParameterNames.Count,
+    CommunicationParticipantSearchParameterAliases.SentFrom,
+    CommunicationParticipantSearchParameterAliases.SentTo,
+]);
+export function normalizeCommunicationParticipantToken(value) {
+    const trimmed = String(value || '').trim();
+    if (!trimmed)
+        return '';
+    if (trimmed === CommunicationParticipantPrefixes.Wildcard) {
+        return CommunicationParticipantPrefixes.Wildcard;
+    }
+    const lower = trimmed.toLowerCase();
+    if (lower.startsWith(CommunicationParticipantPrefixes.Did)) {
+        return `${CommunicationParticipantPrefixes.Did}${trimmed.slice(CommunicationParticipantPrefixes.Did.length)}`;
+    }
+    if (lower.startsWith(CommunicationParticipantPrefixes.Mailto)) {
+        const email = trimmed.slice(CommunicationParticipantPrefixes.Mailto.length).trim().toLowerCase();
+        return email ? `${CommunicationParticipantPrefixes.Email}${email}` : '';
+    }
+    if (lower.startsWith(CommunicationParticipantPrefixes.Email)) {
+        const email = trimmed.slice(CommunicationParticipantPrefixes.Email.length).trim().toLowerCase();
+        return email ? `${CommunicationParticipantPrefixes.Email}${email}` : '';
+    }
+    if (looksLikeEmailIdentifier(trimmed)) {
+        return `${CommunicationParticipantPrefixes.Email}${trimmed.toLowerCase()}`;
+    }
+    if (lower.startsWith(CommunicationParticipantPrefixes.Phone)) {
+        return normalizeTelephoneParticipantToken(trimmed.slice(CommunicationParticipantPrefixes.Phone.length));
+    }
+    if (lower.startsWith(CommunicationParticipantPrefixes.Tel)) {
+        return normalizeTelephoneParticipantToken(trimmed.slice(CommunicationParticipantPrefixes.Tel.length));
+    }
+    if (looksLikePhoneIdentifier(trimmed)) {
+        return normalizeTelephoneParticipantToken(trimmed);
+    }
+    return trimmed;
+}
+export function normalizeCommunicationParticipantTokenList(value) {
+    const values = toFlatStringList(value)
+        .map((item) => normalizeCommunicationParticipantToken(item))
+        .filter(Boolean);
+    return Array.from(new Set(values));
+}
+export function isCommunicationParticipantWildcardToken(value) {
+    return normalizeCommunicationParticipantToken(value) === CommunicationParticipantPrefixes.Wildcard;
+}
+export function buildCommunicationParticipantSearchParameters(input) {
+    return buildFhirParametersResourceFromSearchParams(communicationParticipantSearchInputToSearchParams(input));
+}
+export function buildCommunicationParticipantSearchBundle(input) {
+    return buildSearchBundle({
+        resourceType: ResourceTypesFhirR4.Communication,
+        encoding: 'post-parameters',
+        bundleType: SearchBundleTypes.Search,
+        searchParams: communicationParticipantSearchInputToSearchParams(input),
+    });
+}
+export function parseCommunicationParticipantSearchCriteria(input) {
+    const flat = extractFlatCommunicationParticipantSearchMap(input);
+    return {
+        subjectActorIds: withoutWildcard(flat[CommunicationParticipantSearchParameterNames.Subject]),
+        anySubject: hasWildcard(flat[CommunicationParticipantSearchParameterNames.Subject]),
+        actorIds: withoutWildcard(flat[CommunicationParticipantSearchParameterNames.Actor]),
+        anyActor: hasWildcard(flat[CommunicationParticipantSearchParameterNames.Actor]),
+        senderActorIds: withoutWildcard(flat[CommunicationParticipantSearchParameterNames.Sender]),
+        anySender: hasWildcard(flat[CommunicationParticipantSearchParameterNames.Sender]),
+        recipientActorIds: withoutWildcard(flat[CommunicationParticipantSearchParameterNames.Recipient]),
+        anyRecipient: hasWildcard(flat[CommunicationParticipantSearchParameterNames.Recipient]),
+        userActorIds: withoutWildcard(flat[CommunicationParticipantSearchParameterNames.User]),
+        anyUser: hasWildcard(flat[CommunicationParticipantSearchParameterNames.User]),
+        targetActorIds: withoutWildcard(flat[CommunicationParticipantSearchParameterNames.Target]),
+        anyTarget: hasWildcard(flat[CommunicationParticipantSearchParameterNames.Target]),
+        claimSearchParams: buildClaimSearchParams(flat),
+        periodStart: firstDefinedDateValue(flat[CommunicationParticipantSearchParameterNames.PeriodStart][0], flat[CommunicationParticipantSearchParameterAliases.SentFrom][0]),
+        periodEnd: firstDefinedDateValue(flat[CommunicationParticipantSearchParameterNames.PeriodEnd][0], flat[CommunicationParticipantSearchParameterAliases.SentTo][0]),
+        page: normalizePageValue(flat[CommunicationParticipantSearchParameterNames.Page][0]),
+        count: normalizePositiveInteger(flat[CommunicationParticipantSearchParameterNames.Count][0]),
+    };
+}
+export function buildCommunicationParticipantIndexAttributes(projection) {
+    const subjectTokens = normalizeCommunicationParticipantTokenList(projection.subject);
+    const senderTokens = normalizeCommunicationParticipantTokenList(projection.sender ?? projection.from);
+    const recipientTokens = normalizeCommunicationParticipantTokenList(projection.recipients ?? projection.to);
+    const participantTokens = Array.from(new Set([...senderTokens, ...recipientTokens]));
+    const attributes = [];
+    for (const subjectToken of subjectTokens) {
+        attributes.push({
+            name: CommunicationParticipantIndexNames.Subject,
+            value: subjectToken,
+            unique: COMMUNICATION_PARTICIPANT_INDEX_ATTRIBUTE_UNIQUE.subject,
+        });
+    }
+    for (const senderToken of senderTokens) {
+        attributes.push({
+            name: CommunicationParticipantIndexNames.Sender,
+            value: senderToken,
+            unique: COMMUNICATION_PARTICIPANT_INDEX_ATTRIBUTE_UNIQUE.sender,
+        });
+    }
+    for (const recipientToken of recipientTokens) {
+        attributes.push({
+            name: CommunicationParticipantIndexNames.Recipient,
+            value: recipientToken,
+            unique: COMMUNICATION_PARTICIPANT_INDEX_ATTRIBUTE_UNIQUE.recipient,
+        });
+    }
+    for (const participantToken of participantTokens) {
+        attributes.push({
+            name: CommunicationParticipantIndexNames.Participant,
+            value: participantToken,
+            unique: COMMUNICATION_PARTICIPANT_INDEX_ATTRIBUTE_UNIQUE.participant,
+        });
+    }
+    return dedupeIndexedAttributes(attributes);
+}
+export function matchesCommunicationParticipantSearch(projection, criteria) {
+    const subjectTokens = normalizeCommunicationParticipantTokenList(projection.subject);
+    const senderTokens = normalizeCommunicationParticipantTokenList(projection.sender ?? projection.from);
+    const recipientTokens = normalizeCommunicationParticipantTokenList(projection.recipients ?? projection.to);
+    const participantTokens = Array.from(new Set([...senderTokens, ...recipientTokens]));
+    const sent = normalizeDateParameter(projection.sent);
+    const categoryTokens = normalizeScalarClaimTokenList(projection.category);
+    const topicTokens = normalizeScalarClaimTokenList(projection.topic);
+    return matchesOperand(subjectTokens, criteria.subjectActorIds, criteria.anySubject)
+        && matchesOperand(participantTokens, criteria.actorIds, criteria.anyActor)
+        && matchesOperand(senderTokens, criteria.senderActorIds, criteria.anySender)
+        && matchesOperand(recipientTokens, criteria.recipientActorIds, criteria.anyRecipient)
+        && matchesOperand(participantTokens, criteria.userActorIds, criteria.anyUser)
+        && matchesOperand(participantTokens, criteria.targetActorIds, criteria.anyTarget)
+        && matchesClaimSearchParams(criteria.claimSearchParams, {
+            [CommunicationClaim.Subject]: subjectTokens,
+            [CommunicationClaim.Sender]: senderTokens,
+            [CommunicationClaim.Recipient]: recipientTokens,
+            [CommunicationClaim.Category]: categoryTokens,
+            [CommunicationClaim.Topic]: topicTokens,
+        })
+        && matchesDateRange(sent, criteria.periodStart, criteria.periodEnd);
+}
+export function paginateCommunicationParticipantMatches(records, criteria) {
+    const page = normalizePageValue(criteria.page);
+    const count = normalizePositiveInteger(criteria.count);
+    if (!count) {
+        return [...records];
+    }
+    const offset = (page - 1) * count;
+    return records.slice(offset, offset + count);
+}
+function dedupeIndexedAttributes(attributes) {
+    const seen = new Set();
+    const result = [];
+    for (const attribute of attributes) {
+        const key = `${attribute.name}\u0000${attribute.value}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(attribute);
+    }
+    return result;
+}
+function matchesOperand(actualTokens, expectedTokens, anyExpected) {
+    if (anyExpected || expectedTokens.length === 0)
+        return true;
+    if (actualTokens.length === 0)
+        return false;
+    return expectedTokens.some((expectedToken) => actualTokens.includes(expectedToken));
+}
+function matchesDateRange(sent, sentFrom, sentTo) {
+    if (!sentFrom && !sentTo)
+        return true;
+    if (!sent)
+        return false;
+    if (sentFrom && sent < sentFrom)
+        return false;
+    if (sentTo && sent > sentTo)
+        return false;
+    return true;
+}
+function hasWildcard(values) {
+    return values.includes(CommunicationParticipantPrefixes.Wildcard);
+}
+function withoutWildcard(values) {
+    return values.filter((value) => value !== CommunicationParticipantPrefixes.Wildcard);
+}
+function extractFlatCommunicationParticipantSearchMap(input) {
+    const result = Object.fromEntries(COMMUNICATION_PARTICIPANT_SEARCH_KEYS.map((key) => [key, []]));
+    if (!input || typeof input !== 'object') {
+        return result;
+    }
+    if (input.resourceType === 'Parameters' && Array.isArray(input.parameter)) {
+        for (const parameter of input.parameter) {
+            const name = String(parameter?.name || '').trim();
+            if (!name) {
+                continue;
+            }
+            const rawValue = parameter.valueString
+                ?? parameter.valueUri
+                ?? parameter.valueCode
+                ?? parameter.valueReference?.reference
+                ?? parameter.valueCoding?.code
+                ?? parameter.valueInteger
+                ?? parameter.valueDecimal;
+            if (!result[name]) {
+                result[name] = [];
+            }
+            result[name].push(...normalizeSearchValueList(name, rawValue));
+        }
+        return normalizeFlatSearchMap(result);
+    }
+    for (const key of COMMUNICATION_PARTICIPANT_SEARCH_KEYS) {
+        result[key] = normalizeSearchValueList(key, input[key]);
+    }
+    for (const [key, value] of Object.entries(input)) {
+        if (COMMUNICATION_PARTICIPANT_SEARCH_KEYS.includes(key)) {
+            continue;
+        }
+        result[key] = normalizeSearchValueList(key, value);
+    }
+    return normalizeFlatSearchMap(result);
+}
+function normalizeFlatSearchMap(result) {
+    for (const key of COMMUNICATION_PARTICIPANT_SEARCH_KEYS) {
+        result[key] = Array.from(new Set(result[key].filter(Boolean)));
+    }
+    return result;
+}
+function communicationParticipantSearchInputToSearchParams(input) {
+    const normalizedSearchParams = normalizeClaimSearchParams(input.searchParams);
+    return {
+        ...normalizedSearchParams,
+        [CommunicationParticipantSearchParameterNames.Subject]: normalizeCommunicationParticipantTokenList(input.subject),
+        [CommunicationParticipantSearchParameterNames.Actor]: normalizeCommunicationParticipantTokenList(input.actorId),
+        [CommunicationParticipantSearchParameterNames.Sender]: normalizeCommunicationParticipantTokenList(input.senderActorId),
+        [CommunicationParticipantSearchParameterNames.Recipient]: normalizeCommunicationParticipantTokenList(input.recipientActorId),
+        [CommunicationParticipantSearchParameterNames.User]: normalizeCommunicationParticipantTokenList(input.userActorId),
+        [CommunicationParticipantSearchParameterNames.Target]: normalizeCommunicationParticipantTokenList(input.targetActorId),
+        [CommunicationParticipantSearchParameterNames.PeriodStart]: firstDefinedDateValue(input.periodStart, input.sentFrom),
+        [CommunicationParticipantSearchParameterNames.PeriodEnd]: firstDefinedDateValue(input.periodEnd, input.sentTo),
+        [CommunicationParticipantSearchParameterNames.Page]: normalizePositiveInteger(input.page),
+        [CommunicationParticipantSearchParameterNames.Count]: normalizePositiveInteger(input.count),
+    };
+}
+function normalizeClaimSearchParams(searchParams) {
+    const result = {};
+    for (const [key, value] of Object.entries(searchParams || {})) {
+        const normalizedKey = String(key || '').trim();
+        if (!normalizedKey) {
+            continue;
+        }
+        if (isParticipantClaimKey(normalizedKey)) {
+            result[normalizedKey] = normalizeCommunicationParticipantTokenList(value);
+            continue;
+        }
+        result[normalizedKey] = normalizeScalarSearchValue(value);
+    }
+    return result;
+}
+function buildClaimSearchParams(flat) {
+    const result = {};
+    for (const [key, values] of Object.entries(flat)) {
+        if (COMMUNICATION_PARTICIPANT_SEARCH_KEYS.includes(key)) {
+            continue;
+        }
+        if (values.length === 0) {
+            continue;
+        }
+        result[key] = Array.from(new Set(values));
+    }
+    return result;
+}
+function matchesClaimSearchParams(expectedSearchParams, projectionIndex) {
+    for (const [claimKey, expectedValues] of Object.entries(expectedSearchParams)) {
+        const actualValues = projectionIndex[claimKey] || [];
+        if (!matchesOperand(actualValues, withoutWildcard(expectedValues), hasWildcard(expectedValues))) {
+            return false;
+        }
+    }
+    return true;
+}
+function normalizeSearchValueList(key, value) {
+    return isParticipantKey(key)
+        ? normalizeCommunicationParticipantTokenList(value)
+        : normalizeScalarClaimTokenList(value);
+}
+function normalizeScalarClaimTokenList(value) {
+    return Array.from(new Set(toFlatStringList(value)));
+}
+function normalizeScalarSearchValue(value) {
+    if (Array.isArray(value)) {
+        const normalized = value.map((item) => String(item).trim()).filter(Boolean);
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const normalized = String(value).trim();
+    return normalized || undefined;
+}
+function isParticipantKey(key) {
+    return isParticipantControlKey(key) || isParticipantClaimKey(key);
+}
+function isParticipantControlKey(key) {
+    return key === CommunicationParticipantSearchParameterNames.Subject
+        || key === CommunicationParticipantSearchParameterNames.Actor
+        || key === CommunicationParticipantSearchParameterNames.Sender
+        || key === CommunicationParticipantSearchParameterNames.Recipient
+        || key === CommunicationParticipantSearchParameterNames.User
+        || key === CommunicationParticipantSearchParameterNames.Target;
+}
+function isParticipantClaimKey(key) {
+    return key === CommunicationClaim.Subject
+        || key === CommunicationClaim.Sender
+        || key === CommunicationClaim.Recipient;
+}
+function firstDefinedDateValue(...values) {
+    for (const value of values) {
+        const normalized = normalizeDateParameter(value);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
+function toFlatStringList(value) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => toFlatStringList(item));
+    }
+    const trimmed = String(value || '').trim();
+    if (!trimmed) {
+        return [];
+    }
+    return trimmed.split(',').map((item) => item.trim()).filter(Boolean);
+}
+function looksLikeEmailIdentifier(value) {
+    return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(String(value || '').trim());
+}
+function looksLikePhoneIdentifier(value) {
+    const normalized = String(value || '').trim();
+    return /^[+()0-9.\-\s]{6,}$/.test(normalized);
+}
+function normalizeTelephoneParticipantToken(value) {
+    const trimmed = String(value || '').trim();
+    if (!trimmed)
+        return '';
+    const hasExplicitPlus = trimmed.startsWith('+');
+    const digits = trimmed.replace(/[^0-9]/g, '');
+    if (!digits)
+        return '';
+    return `${CommunicationParticipantPrefixes.Tel}${hasExplicitPlus ? '+' : ''}${digits}`;
+}
+function normalizeDateParameter(value) {
+    const trimmed = String(value || '').trim();
+    return trimmed || undefined;
+}
+function normalizePositiveInteger(value) {
+    const numeric = typeof value === 'number' ? value : Number(String(value || '').trim());
+    if (!Number.isInteger(numeric) || numeric <= 0) {
+        return undefined;
+    }
+    return numeric;
+}
+function normalizePageValue(value) {
+    return normalizePositiveInteger(value) || 1;
+}

package/dist/utils/communication-retention-policy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Environment variable controlling whether communication retention is disabled.
+ *
+ * Default behavior:
+ * - unset => retention stays enabled
+ * - `false` => retention stays enabled
+ * - `true` => retention is disabled and purge flows may remove communications
+ */
+export declare const CommunicationRetentionEnv: Readonly<{
+    readonly Disabled: "COMMUNICATION_RETENTION_DISABLED";
+}>;
+/**
+ * Canonical retention decisions reused by lifecycle/purge flows.
+ */
+export declare const CommunicationRetentionDecisions: Readonly<{
+    readonly SkipPurge: "skip-purge";
+    readonly AllowPurge: "allow-purge";
+}>;
+export type CommunicationRetentionDecision = typeof CommunicationRetentionDecisions[keyof typeof CommunicationRetentionDecisions];
+/**
+ * Returns whether the communication-retention safety rail is disabled.
+ *
+ * This helper intentionally defaults to `false`. Production callers must opt in
+ * explicitly to purge communication records by setting
+ * `COMMUNICATION_RETENTION_DISABLED=true`.
+ */
+export declare function isCommunicationRetentionDisabled(env?: Readonly<Record<string, unknown>>): boolean;
+/**
+ * Resolves the retention decision that lifecycle/purge code should apply to
+ * communication records.
+ */
+export declare function resolveCommunicationRetentionDecision(env?: Readonly<Record<string, unknown>>): CommunicationRetentionDecision;

package/dist/utils/communication-retention-policy.js

@@ -0,0 +1,41 @@
+/**
+ * Environment variable controlling whether communication retention is disabled.
+ *
+ * Default behavior:
+ * - unset => retention stays enabled
+ * - `false` => retention stays enabled
+ * - `true` => retention is disabled and purge flows may remove communications
+ */
+export const CommunicationRetentionEnv = Object.freeze({
+    Disabled: 'COMMUNICATION_RETENTION_DISABLED',
+});
+/**
+ * Canonical retention decisions reused by lifecycle/purge flows.
+ */
+export const CommunicationRetentionDecisions = Object.freeze({
+    SkipPurge: 'skip-purge',
+    AllowPurge: 'allow-purge',
+});
+function normalizeBooleanText(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized || undefined;
+}
+/**
+ * Returns whether the communication-retention safety rail is disabled.
+ *
+ * This helper intentionally defaults to `false`. Production callers must opt in
+ * explicitly to purge communication records by setting
+ * `COMMUNICATION_RETENTION_DISABLED=true`.
+ */
+export function isCommunicationRetentionDisabled(env = process.env) {
+    return normalizeBooleanText(env[CommunicationRetentionEnv.Disabled]) === 'true';
+}
+/**
+ * Resolves the retention decision that lifecycle/purge code should apply to
+ * communication records.
+ */
+export function resolveCommunicationRetentionDecision(env = process.env) {
+    return isCommunicationRetentionDisabled(env)
+        ? CommunicationRetentionDecisions.AllowPurge
+        : CommunicationRetentionDecisions.SkipPurge;
+}

package/dist/utils/communication-search-editor.d.ts

@@ -0,0 +1,54 @@
+import type { FhirParametersResource } from './fhir-search.js';
+import { buildCommunicationParticipantSearchBundle, type CommunicationParticipantSearchInput } from './communication-participant-search.js';
+export declare const CommunicationSearchEntryTypes: Readonly<{
+    readonly Search: "Communication-search-request-v1.0";
+}>;
+export declare const CommunicationSearchOperationTypes: Readonly<{
+    readonly Search: "search";
+}>;
+export type CommunicationSearchState = Readonly<{
+    searchParams: Readonly<Record<string, string | number | boolean | readonly (string | number | boolean)[] | undefined>>;
+    periodStart?: string;
+    periodEnd?: string;
+    page?: number;
+    count?: number;
+}>;
+/**
+ * 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 declare class CommunicationSearchEditor {
+    private draft;
+    constructor(initial?: Partial<CommunicationSearchState>);
+    setSearchParams(value: Readonly<Record<string, string | number | boolean | readonly (string | number | boolean)[] | undefined>>): this;
+    setSearchParam(claimKey: string, value: string | number | boolean | readonly (string | number | boolean)[] | undefined): this;
+    setSearchParamSender(value: string | readonly string[]): this;
+    setSearchParamRecipient(value: string | readonly string[]): this;
+    setSearchParamCategory(value: string | readonly string[]): this;
+    setSearchParamTopic(value: string): this;
+    getSearchParams(): Readonly<Record<string, string | number | boolean | readonly (string | number | boolean)[] | undefined>>;
+    setPeriodStart(value: string): this;
+    setPeriodEnd(value: string): this;
+    setPaginationCount(value: number): this;
+    setPageNumber(value: number): this;
+    getState(): CommunicationSearchState;
+    toSearchInput(): CommunicationParticipantSearchInput;
+    buildRequest(): FhirParametersResource;
+    buildEntry(): {
+        type: string;
+        request: {
+            method: 'POST';
+            url: string;
+        };
+        resource: FhirParametersResource;
+        meta: {
+            operationType: string;
+        };
+    };
+    buildBundle(): ReturnType<typeof buildCommunicationParticipantSearchBundle>;
+}