grm-shared-library 1.1.200 → 1.1.201

package/dist/types/modules/partner/enums/partner-membership-status.enum.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Where one subject's membership with one partner has got to.
+ *
+ * A membership is an ENRICHMENT, never a gate. Nothing in this lifecycle can
+ * stop an emergency reaching a partner: a subject whose membership is
+ * INCOMPLETE_PROFILE or FAILED still has an SOS raised for them, just without a
+ * member id attached. That property is what makes it safe to provision
+ * memberships from a background worker rather than on the alert path.
+ */
+export declare enum PartnerMembershipStatus {
+    /** Decided that this subject needs a membership; not yet created at the partner. */
+    PENDING = "PENDING",
+    /**
+     * Blocked on personal details the partner requires and the platform does
+     * not hold - a date of birth, most often. `missingFields` names them, so an
+     * operator is told exactly what to collect rather than seeing a bare error.
+     */
+    INCOMPLETE_PROFILE = "INCOMPLETE_PROFILE",
+    /** A create call is in flight at the partner. */
+    PROVISIONING = "PROVISIONING",
+    /** The partner has issued a member id. */
+    ACTIVE = "ACTIVE",
+    /** Every attempt failed for a reason retrying cannot fix. */
+    FAILED = "FAILED",
+    /**
+     * A create was made and its outcome is UNKNOWN - the reply was lost, or the
+     * partner could not be asked afterwards whether it landed.
+     *
+     * Deliberately a dead end rather than another retry. A partner's member API
+     * is not idempotent, so retrying an attempt that may have succeeded is how
+     * one person acquires two memberships - and on a seat-limited plan the
+     * duplicate quietly consumes cover belonging to somebody else. A human
+     * checks with the partner and resolves it, exactly as an abandoned dispatch
+     * is handled.
+     */
+    NEEDS_REVIEW = "NEEDS_REVIEW",
+    /**
+     * The subscription behind the membership ended. The member is left in place
+     * at the partner - cancelling someone's ambulance cover is the partner's
+     * decision to action, not a side effect of a Clarion row changing - but the
+     * member id is no longer quoted on new emergencies.
+     */
+    CANCELLED = "CANCELLED"
+}
+/**
+ * Statuses from which the worker may make another attempt on its own.
+ *
+ * NEEDS_REVIEW and FAILED are deliberately absent: both need a human to decide,
+ * and an automatic retry past either is how a duplicate member gets created.
+ */
+export declare const RETRYABLE_PARTNER_MEMBERSHIP_STATUSES: readonly PartnerMembershipStatus[];
+/** Statuses that need an operator before anything else can happen. */
+export declare const PARTNER_MEMBERSHIP_ATTENTION_STATUSES: readonly PartnerMembershipStatus[];

package/dist/types/modules/partner/enums/partner-membership-subject-type.enum.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Who a membership belongs to, in Clarion's own vocabulary.
+ *
+ * Deliberately NOT "user": a corporate member may have no platform login, and a
+ * dependent is never a membership of their own - they are carried on the
+ * primary member's, because that is how partners price and structure cover.
+ */
+export declare enum PartnerMembershipSubjectType {
+    /** The platform user who holds an individual subscription. */
+    INDIVIDUAL_SUBSCRIBER = "INDIVIDUAL_SUBSCRIBER",
+    /** One member of a corporate client, covered by that client's subscription. */
+    CORPORATE_MEMBER = "CORPORATE_MEMBER"
+}

package/dist/types/modules/partner/index.d.ts

@@ -11,6 +11,13 @@ export * from './enums/partner-location-provider.enum';
 export * from './enums/partner-adapter-operation.enum';
 export * from './enums/incident-partner-routing-status.enum';
 export * from './enums/partner-dispatch-scope.enum';
+export * from './enums/partner-membership-status.enum';
+export * from './enums/partner-membership-package-scope.enum';
+export * from './enums/partner-membership-subject-type.enum';
+export * from './enums/partner-member-gender.enum';
+export * from './enums/partner-member-document-type.enum';
+export * from './enums/partner-member-profile-field.enum';
+export * from './enums/partner-member-state.enum';
 export * from './interfaces/partner-provider-descriptor';
 export * from './interfaces/partner-integration';
 export * from './interfaces/partner-coverage-rule';
@@ -22,6 +29,9 @@ export * from './interfaces/incident-partner-routing';
 export * from './interfaces/partner-routing-result';
 export * from './interfaces/partner-connection-test-result';
 export * from './interfaces/partner-dispatch-events';
+export * from './interfaces/partner-member-profile';
+export * from './interfaces/partner-membership-descriptor';
+export * from './interfaces/partner-membership';
 export * from './constants/partner-defaults.const';
 export * from './constants/partner-kafka.const';
 export * from './dtos/create-partner-integration.dto';
@@ -32,5 +42,11 @@ export * from './dtos/route-incident-to-partners.dto';
 export * from './dtos/partner-dispatch-decision.dto';
 export * from './dtos/amend-partner-dispatch.dto';
 export * from './dtos/update-incident-partner-routing.dto';
+export * from './dtos/partner-member-profile.dto';
+export * from './dtos/partner-member-profile-lookup.dto';
+export * from './dtos/update-partner-membership.dto';
+export * from './dtos/partner-membership-query.dto';
+export * from './dtos/sync-partner-membership.dto';
 export * from './utils/partner-routing.util';
 export * from './utils/partner-payload.util';
+export * from './utils/partner-membership.util';

package/dist/types/modules/partner/interfaces/partner-integration.d.ts

@@ -1,6 +1,7 @@
 import { CountryCode } from '../../country/enums/country-code.enum';
 import { PartnerIntegrationEnvironment } from '../enums/partner-integration-environment.enum';
 import { PartnerIntegrationStatus } from '../enums/partner-integration-status.enum';
+import { PartnerMembershipPackageScope } from '../enums/partner-membership-package-scope.enum';
 import { PartnerProviderCode } from '../enums/partner-provider-code.enum';
 import { PartnerRoutingMode } from '../enums/partner-routing-mode.enum';
 import { PartnerServiceCapability } from '../enums/partner-service-capability.enum';
@@ -42,9 +43,30 @@ export interface PartnerIntegration {
     enabled: boolean;
     /** Order in which partnerships are considered when several cover one incident. */
     priority: number;
+    /**
+     * Whether subscribers are registered with this partner as members ahead of
+     * any emergency.
+     *
+     * Off by default, and deliberately so: registering a person with a third
+     * party sends their name, telephone number and date of birth outside the
+     * platform, which is a decision an organization makes on purpose and not
+     * one that follows from saving a form.
+     */
+    membershipEnabled: boolean;
+    /** Which packages' subscribers are registered. Ignored when membership is off. */
+    membershipPackageScope: PartnerMembershipPackageScope;
+    /** Packages to register, when the scope is SELECTED. */
+    membershipPackageIds: number[];
     /** ISO 3166-1 alpha-2 country the partnership operates in. */
     countryCode: CountryCode;
     status: PartnerIntegrationStatus;
+    /**
+     * True when the registered adapter can create members for this provider at
+     * all. Served from the adapter descriptor, not stored - so a partnership
+     * configured before a partner gained memberships starts reporting it the
+     * moment the adapter does.
+     */
+    membershipSupported?: boolean;
     partnerContactName?: string | null;
     partnerContactPhone?: string | null;
     partnerContactEmail?: string | null;

package/dist/types/modules/partner/interfaces/partner-member-profile.d.ts

@@ -0,0 +1,65 @@
+import { PartnerMemberDocumentType } from '../enums/partner-member-document-type.enum';
+import { PartnerMemberGender } from '../enums/partner-member-gender.enum';
+/**
+ * A person, as a partner membership records them - provider-neutral.
+ *
+ * This is deliberately NOT a Clarion user, a billing client or a beneficiary.
+ * Those are three different rows in three different services, and a partner
+ * cares about none of that distinction: it wants a name, a number and enough
+ * identity to tell two people apart. Assembling one of these is the ONLY place
+ * that has to know where each fact lives, so adding a partner never means
+ * re-learning Clarion's data model.
+ *
+ * Every field except the name is optional here, because what a partner
+ * REQUIRES is the partner's business and is declared in its
+ * {@link PartnerMembershipDescriptor}. A profile that satisfies one partner may
+ * be short for another, and the platform reports exactly which fields are
+ * short rather than failing opaquely.
+ */
+export interface PartnerMemberProfile {
+    /** Full name as the partner should record it. */
+    fullName: string;
+    /** E.164, e.g. `+254712345678`. Normalized before it ever reaches here. */
+    phoneNumber?: string | null;
+    email?: string | null;
+    /**
+     * ISO-8601 CALENDAR DATE, `YYYY-MM-DD` - never a timestamp.
+     *
+     * A date of birth has no time and no zone, and sending one that does is how
+     * a member silently acquires a birthday a day either side of their real one
+     * depending on where the server happens to be.
+     */
+    dateOfBirth?: string | null;
+    gender?: PartnerMemberGender | null;
+    documentType?: PartnerMemberDocumentType | null;
+    /** Alphanumeric, as issued. Treated as personal data: masked in every log. */
+    documentNumber?: string | null;
+    /** ISO 3166-1 alpha-2, uppercase, e.g. `KE`. */
+    documentCountryCode?: string | null;
+    /**
+     * Partner-declared extras, keyed by the `key` of an
+     * `extraProfileFields` entry in that partner's membership descriptor.
+     *
+     * The typed fields above are the facts EVERY partner asks for, and they are
+     * resolved centrally from the platform's own records. This is for the ones
+     * only one partner wants - a policy number, a plan tier, a medical-aid
+     * number - which the admin renders a form for from the descriptor, exactly
+     * as it already does for a partnership's `configFields`. Without it, the
+     * cost of a partner needing one unanticipated field is a shared-library
+     * publish and a migration in three services.
+     */
+    attributes?: Record<string, string> | null;
+}
+/**
+ * A dependent carried on somebody else's membership - a spouse or child covered
+ * by the same subscription.
+ *
+ * `dependentReference` is Clarion's own stable handle for them (a billing
+ * beneficiary id), and it is what makes syncing idempotent: a dependent already
+ * sent is recognised on the next sync rather than added a second time.
+ */
+export interface PartnerMemberDependentProfile extends PartnerMemberProfile {
+    dependentReference: string;
+    /** e.g. `Spouse`. Free text; partners do not share a relationship vocabulary. */
+    relationship?: string | null;
+}

package/dist/types/modules/partner/interfaces/partner-membership-descriptor.d.ts

@@ -0,0 +1,108 @@
+import { PartnerMemberProfileField } from '../enums/partner-member-profile-field.enum';
+import { PartnerMemberState } from '../enums/partner-member-state.enum';
+/**
+ * One thing a partner needs to know about a person before it will register
+ * them, described the same way a partnership's `configFields` are.
+ *
+ * Deliberately NOT an enum. The enum below covers the facts every partner asks
+ * for, and those are resolved centrally from the platform's own records; this
+ * covers the ones only one partner wants - a policy number, a plan tier, a
+ * medical-aid number - which the admin renders a form for straight from the
+ * descriptor. Without it, a partner needing one unanticipated field costs a
+ * shared-library publish, a migration and a version bump in three services.
+ */
+export interface PartnerMemberProfileFieldDescriptor {
+    /**
+     * A {@link PartnerMemberProfileField} value for a well-known fact, or any
+     * other key for a partner-specific one. A well-known key is populated from
+     * the platform's records; anything else is collected by an operator and
+     * stored in `PartnerMemberProfile.attributes`.
+     */
+    key: string;
+    label: string;
+    description?: string;
+    required: boolean;
+    type: 'string' | 'number' | 'boolean' | 'enum' | 'date';
+    allowedValues?: string[];
+    /** Rejected before it is sent, so a malformed value never becomes a partner 400. */
+    pattern?: string;
+    maxLength?: number;
+    /** Where an operator is likely to find this, shown as help text. */
+    sourceHint?: string;
+}
+/**
+ * Why a partner cannot yet be told about somebody.
+ *
+ * MISSING and MALFORMED are not the same problem and do not have the same
+ * remedy: one needs the fact collected, the other needs the fact corrected.
+ * Reporting both as "missing" leaves an operator staring at a field that is
+ * plainly filled in, with nothing to do.
+ */
+export interface UnsatisfiedMemberProfileField {
+    field: string;
+    reason: 'MISSING' | 'MALFORMED';
+    /** One line an operator can act on. */
+    detail?: string;
+}
+/**
+ * What one partner needs before it will register a person as a member, and what
+ * it does with them afterwards.
+ *
+ * Published as part of the provider descriptor for exactly the same reason
+ * `configFields` is: the admin UI builds its "what is missing for this member"
+ * view from this, and the platform computes readiness from it generically, so a
+ * partner's requirements can never drift from the adapter that enforces them.
+ */
+export interface PartnerMembershipDescriptor {
+    /**
+     * Every fact this partner wants, well-known or partner-specific, in the
+     * order an operator should be asked for them.
+     */
+    profileFields: PartnerMemberProfileFieldDescriptor[];
+    /**
+     * The well-known facts this partner REFUSES a member without.
+     *
+     * Redundant with the `required` flags above and kept because it is what
+     * the platform's central resolution actually reads - it says which of the
+     * facts the PLATFORM holds must be present, without the caller having to
+     * filter a descriptor list by key membership.
+     */
+    requiredProfileFields: PartnerMemberProfileField[];
+    /** Well-known facts the partner accepts and uses, but does not insist on. */
+    optionalProfileFields: PartnerMemberProfileField[];
+    /** True when the partner carries dependents on a member's cover. */
+    supportsDependents: boolean;
+    /** Ceiling the partner imposes on dependents per member. Null means none stated. */
+    maxDependents: number | null;
+    /**
+     * True when the partner accepts a member id on an EMERGENCY.
+     *
+     * This is what makes provisioning worth doing at all. A partner that has
+     * memberships but never reads one on a dispatch gains an emergency nothing,
+     * and the platform will not spend an alert-path millisecond looking one up.
+     */
+    quotesMemberOnDispatch: boolean;
+    /**
+     * Member states whose id is worth putting on an emergency for THIS partner.
+     *
+     * Defaults to {@link DEFAULT_QUOTABLE_MEMBER_STATES}. A partner that
+     * rejects a request naming a suspended member says so here rather than
+     * having every caller learn its rules.
+     */
+    quotableStates?: PartnerMemberState[];
+    /**
+     * True when the partner will register a member with no government identity
+     * document at all.
+     *
+     * Governs whether the platform even OFFERS to collect one. An identity
+     * document number cannot be rotated and outlives any credential; it is
+     * collected only where a partner genuinely refuses to work without it.
+     */
+    identityDocumentOptional: boolean;
+    /**
+     * Human-readable note shown beside the membership settings in the admin -
+     * e.g. that newly created members serve a waiting period before cover
+     * begins. Operators need to know that; it is not inferable from the API.
+     */
+    notes?: string;
+}

package/dist/types/modules/partner/interfaces/partner-membership.d.ts

@@ -0,0 +1,149 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { PartnerDispatchFailureReason } from '../enums/partner-dispatch-failure-reason.enum';
+import { PartnerMemberState } from '../enums/partner-member-state.enum';
+import { PartnerMembershipStatus } from '../enums/partner-membership-status.enum';
+import { PartnerMembershipSubjectType } from '../enums/partner-membership-subject-type.enum';
+import { PartnerProviderCode } from '../enums/partner-provider-code.enum';
+import { PartnerMemberProfile } from './partner-member-profile';
+import { UnsatisfiedMemberProfileField } from './partner-membership-descriptor';
+/**
+ * One dependent's state at the partner.
+ *
+ * The important field is `partnerDependentId`: it records what the partner
+ * CONFIRMED, not what Clarion intended. Every diff runs against the confirmed
+ * set, because adding a dependent to a partner like Rescue.co is a one-way
+ * door - a duplicate cannot be withdrawn until the end of the term and
+ * permanently consumes one of the membership's seats, which the API only lets
+ * you increase. Reconciling against intent rather than confirmation is how a
+ * family's cover gets eaten by phantoms.
+ */
+export interface PartnerMembershipDependent {
+    /** Clarion's stable handle - a billing beneficiary id. Idempotency key for the sync. */
+    dependentReference: string;
+    /** The platform user this dependent is, when they have one. */
+    userId?: number | null;
+    /** The partner's own id, once it has issued one. Absent means NOT yet sent. */
+    partnerDependentId?: string | null;
+    /** The name as Clarion holds it. */
+    name: string;
+    /**
+     * The name the partner ACCEPTED, which many partners will not let change
+     * afterwards. Held separately so a later correction on our side is visible
+     * as a divergence rather than silently believed to have applied.
+     */
+    partnerName?: string | null;
+    /** True once the partner has accepted this dependent. */
+    synced: boolean;
+    /**
+     * True when Clarion has stopped covering them but the partner will only
+     * drop them at the end of the term. Recorded rather than acted on, because
+     * the divergence is real and somebody has to be able to see it.
+     */
+    pendingRemovalAtTermEnd?: boolean;
+    /** Sanitized reason the last sync of THIS dependent failed. Never a credential. */
+    lastErrorMessage?: string | null;
+    syncedAt?: string | null;
+}
+/**
+ * One Clarion subject's registration with one partner.
+ *
+ * The row exists so that when an emergency is raised, "who is this person to
+ * Rescue.co?" is a local primary-key lookup rather than a call to a partner in
+ * the middle of an alert. It is a CACHE of the partner's truth with a
+ * lifecycle, not the truth itself - which is why a stale or failed one degrades
+ * to sending the emergency without a member id rather than blocking it.
+ */
+export interface PartnerMembership {
+    id: number;
+    organizationId: number;
+    integrationId: number;
+    /** Copied from the partnership so history survives it being reconfigured. */
+    providerCode: PartnerProviderCode;
+    subjectType: PartnerMembershipSubjectType;
+    /**
+     * Clarion's stable identity for the subject, e.g. `individual-client:12` or
+     * `corporate-member:45`. Unique per partnership - this is what stops two
+     * activations creating two memberships for one person.
+     */
+    subjectReference: string;
+    /** The platform user, when the subject has one. The SOS-time lookup key. */
+    userId?: number | null;
+    subscriptionId?: number | null;
+    packageId?: number | null;
+    status: PartnerMembershipStatus;
+    /** The partner's member id (a UUID for Rescue.co). Present only when ACTIVE. */
+    partnerMemberId?: string | null;
+    /** The partner's own status word, passed through verbatim, e.g. `waitingPeriod`. */
+    partnerStatus?: string | null;
+    /**
+     * The partner's standing reduced to something every screen can rely on,
+     * without any of them learning a partner's vocabulary. The direct analogue
+     * of `engagementState` on a dispatch.
+     */
+    memberState?: PartnerMemberState | null;
+    /**
+     * When the partner's cover actually begins.
+     *
+     * Rescue.co returns a new member as `waitingPeriod` with a `startDate`
+     * some way off. Without this the admin can only say "Active", and an
+     * organization will tell a subscriber they are covered on the day they
+     * paid - which is the single most damaging thing this feature could get
+     * wrong.
+     */
+    coverageStartsAt?: string | null;
+    /** When the partner's cover ends. A membership past it is no longer quoted. */
+    coverageEndsAt?: string | null;
+    /** True when the partner has confirmed cover is in force right now. */
+    coverActive?: boolean;
+    /** Seats the partner CONFIRMED, which many partners will only let increase. */
+    partnerSeats?: number | null;
+    /** Short label quoted alongside the member id on an emergency, e.g. the package name. */
+    membershipLabel?: string | null;
+    /** The provider-neutral profile last sent, frozen for audit and drift detection. */
+    profile: PartnerMemberProfile;
+    /**
+     * What stops this profile being sent, and why - MISSING or MALFORMED.
+     *
+     * Empty unless the status is INCOMPLETE_PROFILE. This is what the admin
+     * renders as "collect a date of birth" or "this date of birth is not a
+     * date", rather than an operator reading a partner's 400.
+     */
+    unsatisfiedFields: UnsatisfiedMemberProfileField[];
+    dependents: PartnerMembershipDependent[];
+    attemptCount: number;
+    maxAttempts: number;
+    nextAttemptAt?: string | null;
+    failureReason?: PartnerDispatchFailureReason | null;
+    lastErrorCode?: string | null;
+    /** Sanitized - never contains a credential, token or document number. */
+    lastErrorMessage?: string | null;
+    countryCode: CountryCode;
+    /**
+     * The highest upstream sequence applied to this row.
+     *
+     * The fence that makes an unordered event stream safe. Billing publishes
+     * each lifecycle change on its OWN topic, and Kafka guarantees no ordering
+     * whatsoever across topics - so an `expired` and an `activated` emitted
+     * three seconds apart can be applied in either order. Without this, a
+     * cancelled subscription can end up ACTIVE with a live member id, and the
+     * reconciliation sweep will not correct it because the row looks healthy.
+     */
+    lastAppliedSequence?: number | null;
+    provisionedAt?: string | null;
+    lastSyncedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * What a dispatch is told about the caller's membership, when they have one.
+ *
+ * Resolved from the membership row before the payload is built, and OMITTED
+ * entirely rather than half-filled: an adapter should never have to reason
+ * about a membership that is present but unusable.
+ */
+export interface PartnerDispatchMembership {
+    partnerMemberId: string;
+    label?: string | null;
+    /** The partner's own status at the time it was resolved, for the audit trail. */
+    partnerStatus?: string | null;
+}

package/dist/types/modules/partner/interfaces/partner-provider-descriptor.d.ts

@@ -1,4 +1,5 @@
 import { PartnerIntegrationEnvironment } from '../enums/partner-integration-environment.enum';
+import type { PartnerMembershipDescriptor } from './partner-membership-descriptor';
 import { PartnerProviderCode } from '../enums/partner-provider-code.enum';
 import { PartnerServiceCapability } from '../enums/partner-service-capability.enum';
 /** A credential a partnership must supply before it can dispatch. */
@@ -80,6 +81,21 @@ export interface PartnerProviderDescriptor {
      * blind retry on a non-idempotent emergency API means two ambulances.
      */
     supportsDuplicateDetection: boolean;
+    /**
+     * True when the partner registers people as MEMBERS ahead of an emergency,
+     * and the adapter implements that.
+     *
+     * Membership is an enrichment, never a precondition: a partner that has it
+     * still accepts an emergency for somebody unknown to it. The flag governs
+     * whether the platform provisions members in the background at all, not
+     * whether it will dispatch.
+     */
+    supportsMembership: boolean;
+    /**
+     * What this partner needs to register a member, and what it does with one.
+     * Present exactly when {@link supportsMembership} is true.
+     */
+    membership?: PartnerMembershipDescriptor;
     /** False for reserved provider codes that have no working adapter yet. */
     available: boolean;
 }

package/dist/types/modules/partner/utils/partner-membership.util.d.ts

@@ -0,0 +1,156 @@
+import { PartnerMemberProfileField } from '../enums/partner-member-profile-field.enum';
+import { PartnerMembershipStatus } from '../enums/partner-membership-status.enum';
+import { PartnerMembershipSubjectType } from '../enums/partner-membership-subject-type.enum';
+import { PartnerMembershipPackageScope } from '../enums/partner-membership-package-scope.enum';
+import { PartnerMembershipDescriptor, UnsatisfiedMemberProfileField } from '../interfaces/partner-membership-descriptor';
+import { PartnerMemberProfile } from '../interfaces/partner-member-profile';
+/**
+ * A profile as it comes out of a database or off the wire: every field may be
+ * absent OR explicitly null.
+ *
+ * {@link PartnerMemberProfile} models a profile that has been ASSEMBLED, where
+ * a missing field is simply absent. Readiness is checked against what is
+ * actually stored, and a nullable column reads back as null - so checking
+ * against the assembled shape would reject the very data this exists to inspect.
+ */
+export type PartnerMemberProfileInput = {
+    [K in keyof PartnerMemberProfile]?: PartnerMemberProfile[K] | null;
+};
+/**
+ * Clarion's stable handle for a membership subject.
+ *
+ * Keyed on the PERSON wherever there is one, not on the subscription that paid
+ * for them. A partner registers a human being: an employee covered by their
+ * company who also buys personal cover is one member with one member id, and
+ * keying on the billing relationship would register them twice - two member ids
+ * for one person, two seats consumed, double-billed at the partner, and an
+ * emergency quoting whichever of the two the database happened to return first.
+ *
+ * Only a corporate member never linked to a platform login falls back to the
+ * relationship key, because for them there is no person key to use.
+ *
+ * Prefixed by kind so the two spaces can never collide on a bare numeric id.
+ * This is what the unique index on (integrationId, subjectReference) relies on
+ * to stop one person acquiring two memberships when an activation event is
+ * redelivered.
+ */
+export declare function buildMembershipSubjectReference(subject: {
+    subjectType: PartnerMembershipSubjectType;
+    subjectId: number;
+    userId?: number | null;
+}): string;
+/**
+ * Which of a partner's REQUIRED profile fields this profile cannot satisfy.
+ *
+ * Generic over the descriptor rather than per-partner, so a partner that starts
+ * insisting on a national id needs a one-line descriptor change and no new
+ * validation code. An empty result means the profile is ready to send.
+ */
+export declare function findMissingMemberProfileFields(profile: PartnerMemberProfileInput | null | undefined, descriptor: Pick<PartnerMembershipDescriptor, 'requiredProfileFields'>): PartnerMemberProfileField[];
+/**
+ * What stops this profile being sent, and WHY.
+ *
+ * "Missing" and "malformed" are different problems with different remedies:
+ * one needs the fact collected, the other needs it corrected. Reporting a
+ * mistyped date of birth as missing leaves an operator staring at a field that
+ * is plainly filled in, with nothing to do - and reporting nothing at all
+ * leaves the membership in FAILED with an empty list.
+ *
+ * Also checks any partner-declared `profileFields` marked required, whose
+ * values live in `attributes` - so a partner asking for a policy number gets
+ * the same treatment as one asking for a date of birth.
+ */
+export declare function findUnsatisfiedMemberProfileFields(profile: PartnerMemberProfileInput | null | undefined, descriptor: Pick<PartnerMembershipDescriptor, 'requiredProfileFields'> & Partial<Pick<PartnerMembershipDescriptor, 'profileFields'>>): UnsatisfiedMemberProfileField[];
+/**
+ * Whether a partnership should register the subscribers of one package.
+ *
+ * The single expression of membership eligibility, used by every trigger so
+ * they cannot disagree. Deliberately NOT derived from coverage rules: those
+ * answer "where does THIS EMERGENCY go", which is an incident-shaped question
+ * that a package cannot be asked - a partnership whose only rule matches on
+ * emergency type would evaluate as covering nobody, and one whose package names
+ * no incident types at all (which this platform reads as "covers everything")
+ * would buy a paid membership for every free subscriber.
+ */
+export declare function membershipRequired(integration: {
+    enabled?: boolean;
+    membershipEnabled?: boolean;
+    membershipPackageScope?: PartnerMembershipPackageScope;
+    membershipPackageIds?: number[] | null;
+}, packageId: number | null | undefined): boolean;
+/**
+ * Whether one profile field carries a usable value.
+ *
+ * A date of birth is checked for SHAPE as well as presence: an unparseable one
+ * is worse than an absent one, because it is sent, refused by the partner, and
+ * retried forever against a value that will never become valid.
+ */
+export declare function isMemberProfileFieldPresent(profile: PartnerMemberProfileInput, field: PartnerMemberProfileField): boolean;
+/** A real `YYYY-MM-DD` date, not merely one shaped like it (rejects 2026-02-30). */
+export declare function isCalendarDate(value: string): boolean;
+/**
+ * A date of birth reduced to the calendar date partners want.
+ *
+ * Accepts what the platform actually stores - a `Date`, a timestamp string, a
+ * bare date - and returns UTC, never local. Reading a stored instant in the
+ * server's zone is how a birthday drifts a day when a pod moves region.
+ */
+export declare function toPartnerCalendarDate(value: Date | string | null | undefined): string | undefined;
+/**
+ * Seats to buy for a member and their dependents.
+ *
+ * Always at least one - the member's own - and never more than the partner
+ * allows, so a subscription with more beneficiaries than a partner's ceiling
+ * buys the maximum rather than being refused outright.
+ */
+export declare function resolveMemberSeatCount(dependentCount: number, maxDependents: number | null | undefined): number;
+/**
+ * A person's name as a partner should record it, from whatever parts exist.
+ *
+ * Returns undefined rather than an empty or half-formed name: a member called
+ * " " is worse than a membership that is honestly reported as incomplete.
+ */
+export declare function buildMemberFullName(parts: {
+    name?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+}): string | undefined;
+/**
+ * Mask a document number for logs.
+ *
+ * A national id identifies a person as surely as their name and outlives any
+ * credential rotation, so it is treated more carefully than one: the last two
+ * characters are enough to match a support query against a record, and the mask
+ * is fixed width so the length of the original is not disclosed either.
+ */
+export declare function maskMemberDocumentNumber(value: string | null | undefined): string;
+/**
+ * Whether a membership may be quoted on an emergency right now.
+ *
+ * Deliberately does NOT require the partner's cover to have started. A member
+ * inside a waiting period is still that person's real member id, and telling
+ * the partner who is calling is accurate and useful whatever their cover state.
+ * What is excluded is a membership the partner has finished with: quoting an
+ * id past its term risks an outright rejection of the SOS, which costs an
+ * ambulance to add a field that was optional anyway.
+ */
+export declare function isUsableMembership(membership: {
+    status: PartnerMembershipStatus;
+    partnerMemberId?: string | null;
+    coverageEndsAt?: string | Date | null;
+}, now?: Date): boolean;
+/**
+ * Whether the PARTNER's cover has actually begun.
+ *
+ * Separate from {@link isUsableMembership} because the two answer different
+ * questions and conflating them misleads a human. Rescue.co returns a new
+ * member as `waitingPeriod`: they exist, they are quotable, and they are not
+ * yet covered. An admin screen that renders a green "Active" chip the day
+ * somebody paid will have told them they are covered when they are not.
+ */
+export declare function isMembershipCoverActive(membership: {
+    status: PartnerMembershipStatus;
+    partnerMemberId?: string | null;
+    coverageStartsAt?: string | Date | null;
+    coverageEndsAt?: string | Date | null;
+}, now?: Date): boolean;