grm-shared-library 1.1.199 → 1.1.201

package/dist/types/modules/partner/dtos/sync-partner-membership.dto.d.ts

@@ -0,0 +1,114 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { PartnerMembershipSubjectType } from '../enums/partner-membership-subject-type.enum';
+/**
+ * One dependent carried on the subject's cover, BY REFERENCE.
+ *
+ * Deliberately carries no personal detail. This payload travels over Kafka,
+ * where it is retained for as long as the topic is and is readable by anything
+ * with consumer access - which is the wrong place for a child's date of birth.
+ * The receiving service resolves the person from clarion-authentication, the
+ * one service that owns people, at the moment it actually needs them.
+ */
+export declare class SyncPartnerMembershipDependentDto {
+    /**
+     * Clarion's stable handle for this dependent - the billing beneficiary id.
+     *
+     * Idempotency turns on this: a dependent already sent to a partner is
+     * recognised by it on the next sync rather than added a second time, which
+     * on a seat-limited membership would otherwise consume the cover of somebody
+     * who has not been added yet.
+     */
+    dependentReference: string;
+    /** The platform user this dependent is, so their details can be resolved. */
+    userId?: number;
+    relationship?: string;
+}
+/**
+ * "Here is everything true about this person's cover right now - make the
+ * partner's records agree." The single internal contract for membership
+ * provisioning, and deliberately a STATE statement rather than a change
+ * notification.
+ *
+ * Carries IDENTIFIERS AND COMMERCIAL FACTS ONLY - never a person's details.
+ * The subject's name, phone, date of birth and identity document are resolved
+ * from clarion-authentication when they are needed, because this payload is
+ * published on a Kafka topic: whatever is put in it is retained for the topic's
+ * lifetime and readable by every consumer, present and future. A date of birth
+ * does not belong there, and once it is there it cannot be recalled.
+ *
+ * It is otherwise SELF-CONTAINED - clarion-partner-services never calls back
+ * into clarion-billing to finish the job, the same rule
+ * `RouteIncidentToPartnersDto` follows, because the service that owns
+ * emergencies must not acquire a synchronous dependency on the service that
+ * owns money.
+ *
+ * It carries NO partnership id. Which partners a subscriber should be
+ * registered with is decided from coverage rules inside
+ * clarion-partner-services, because that is where the partnerships live;
+ * clarion-billing states the FACTS (who, what they bought, what it covers) and
+ * makes no partner decisions at all.
+ */
+export declare class SyncPartnerMembershipDto {
+    /**
+     * Monotonic upstream sequence, taken from clarion-billing's own outbox id.
+     *
+     * The ONLY defence against an unordered stream. Billing publishes each
+     * lifecycle change on its own topic and Kafka guarantees no ordering across
+     * topics, so `active: false` and `active: true` for one subscriber can and
+     * do arrive in either order. The consumer applies an event only when this
+     * exceeds what the row has already seen, which turns "whichever arrived
+     * last wins" into "whichever HAPPENED last wins".
+     */
+    sequence?: number;
+    /**
+     * Stable id of this event, stamped once by the producer and unchanged
+     * across every republish of the same outbox row. The consumer records it
+     * to collapse redeliveries.
+     */
+    eventId?: string;
+    organizationId: number;
+    subjectType: PartnerMembershipSubjectType;
+    /** The individual client id, or the corporate client member id. */
+    subjectId: number;
+    /** The platform user, when the subject has one. Absent for an un-linked corporate member. */
+    userId?: number;
+    subscriptionId?: number;
+    packageId?: number;
+    /** Quoted to the partner alongside the member id, so their operator sees the plan. */
+    packageName?: string;
+    countryCode?: CountryCode;
+    /**
+     * Months in one billing period - 1 for monthly, 12 for annual, null or
+     * absent for a one-off purchase. Provider-neutral on purpose: a partner's
+     * own billing vocabulary is the adapter's business, and clarion-billing's
+     * `BillingCycle` enum has no place in this contract.
+     */
+    billingIntervalMonths?: number;
+    /**
+     * Whether the cover is live. False ends the membership on this side; the
+     * member is NOT deleted at the partner, because cancelling somebody's
+     * ambulance cover is a decision for the partner to action, not a side
+     * effect of a Clarion row changing.
+     */
+    active: boolean;
+    /**
+     * Incident types the package covers. An EMPTY array means it covers
+     * everything - that is clarion-billing's existing semantics for
+     * `BillingPackage.incidentTypeIds`, and inverting it here would silently
+     * un-cover every package that has never named a type.
+     */
+    coveredIncidentTypeIds: number[];
+    /**
+     * The COMPLETE current set of dependents, not a delta.
+     *
+     * This is the whole reason the contract is one state event rather than
+     * several change events. Beneficiary changes and subscription changes are
+     * published on different topics with no ordering between them, so a
+     * dependent-added event routinely arrives before the subscription that owns
+     * it. Applying deltas from an unordered stream to a partner that will not
+     * let a dependent be withdrawn until the end of the term produces duplicate
+     * dependents and permanently burns seats. A full set, applied under the
+     * sequence fence, converges from any order of arrival.
+     */
+    dependents?: SyncPartnerMembershipDependentDto[];
+}

package/dist/types/modules/partner/dtos/update-partner-membership.dto.d.ts

@@ -0,0 +1,18 @@
+import { PartnerMemberProfileDto } from './partner-member-profile.dto';
+/**
+ * An operator completing or correcting the details behind one membership.
+ *
+ * The subject, the partnership and the subscription are NOT settable: a
+ * membership belongs to the person the platform decided it belongs to, and
+ * letting an edit re-point it at somebody else would silently transfer one
+ * person's ambulance cover to another.
+ */
+export declare class UpdatePartnerMembershipDto {
+    profile?: PartnerMemberProfileDto;
+    /**
+     * Queue another provisioning attempt straight away, rather than waiting for
+     * the worker's next pass. What an operator wants after filling in the field
+     * that was blocking it.
+     */
+    retryNow?: boolean;
+}

package/dist/types/modules/partner/enums/partner-adapter-operation.enum.d.ts

@@ -22,5 +22,11 @@ export declare enum PartnerAdapterOperation {
      * Used after a timeout, where the request might have landed but the reply
      * never arrived - the one case where re-sending could produce a duplicate.
      */
-    LOOKUP = "LOOKUP"
+    LOOKUP = "LOOKUP",
+    /** Registering a person with the partner as a member, ahead of any emergency. */
+    PROVISION_MEMBERSHIP = "PROVISION_MEMBERSHIP",
+    /** Asking the partner whether it already knows this person as a member. */
+    LOOKUP_MEMBERSHIP = "LOOKUP_MEMBERSHIP",
+    /** Adding or correcting the dependents carried on an existing membership. */
+    SYNC_MEMBERSHIP_DEPENDENTS = "SYNC_MEMBERSHIP_DEPENDENTS"
 }

package/dist/types/modules/partner/enums/partner-member-document-type.enum.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The kind of identity document a partner membership records.
+ *
+ * Neutral values; each adapter maps them onto its own partner's spelling.
+ */
+export declare enum PartnerMemberDocumentType {
+    PASSPORT = "PASSPORT",
+    NATIONAL_ID = "NATIONAL_ID",
+    DRIVING_LICENCE = "DRIVING_LICENCE",
+    /** Any other government-issued identifier. */
+    OTHER = "OTHER"
+}

package/dist/types/modules/partner/enums/partner-member-gender.enum.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gender, in the platform's own vocabulary.
+ *
+ * Values are NEUTRAL, not any one partner's wire literals. Rescue.co happens to
+ * spell these lowercase; the next partner will spell them differently, and a
+ * shared enum carrying the first partner's spelling makes every later adapter
+ * translate away from a standard that was never a standard.
+ */
+export declare enum PartnerMemberGender {
+    MALE = "MALE",
+    FEMALE = "FEMALE",
+    OTHER = "OTHER",
+    UNSPECIFIED = "UNSPECIFIED"
+}

package/dist/types/modules/partner/enums/partner-member-profile-field.enum.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The provider-neutral facts about a person that a partner membership may need.
+ *
+ * The VALUES are the property names on {@link PartnerMemberProfile}, which is
+ * what lets "which of this partner's required fields are missing?" be a generic
+ * loop rather than a per-partner if-ladder - the same trick that lets one admin
+ * form serve every partner's `configFields`.
+ */
+export declare enum PartnerMemberProfileField {
+    FULL_NAME = "fullName",
+    PHONE_NUMBER = "phoneNumber",
+    EMAIL = "email",
+    DATE_OF_BIRTH = "dateOfBirth",
+    GENDER = "gender",
+    DOCUMENT_TYPE = "documentType",
+    DOCUMENT_NUMBER = "documentNumber",
+    DOCUMENT_COUNTRY_CODE = "documentCountryCode"
+}

package/dist/types/modules/partner/enums/partner-member-state.enum.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A member's standing with a partner, reduced to something every screen and
+ * report can rely on without learning any partner's vocabulary.
+ *
+ * The direct analogue of {@link PartnerEngagementState} for dispatches, and it
+ * exists for the same reason: partners describe the same five situations with
+ * completely different words, and the alternative is every consumer growing a
+ * per-partner if-ladder. Rescue.co's own `status` is still persisted verbatim
+ * alongside it, because an operator ringing the partner needs the word THEY use.
+ *
+ * The distinction that matters most is PENDING_ACTIVATION vs ACTIVE. A member
+ * can exist, hold a real member id and be worth naming on an emergency, and
+ * still not be covered - Rescue.co returns a brand-new member as
+ * `waitingPeriod`. An admin screen that collapses the two tells a subscriber
+ * they are covered on the day they paid, which is the most damaging thing this
+ * feature could get wrong.
+ */
+export declare enum PartnerMemberState {
+    /** Registered, but the partner's cover has not started. */
+    PENDING_ACTIVATION = "PENDING_ACTIVATION",
+    /** Cover is in force. */
+    ACTIVE = "ACTIVE",
+    /** Temporarily not in force - non-payment, a partner-side hold. */
+    SUSPENDED = "SUSPENDED",
+    /** The term ended or the partner cancelled them. */
+    LAPSED = "LAPSED",
+    /** The partner said something this adapter does not recognise. */
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * States in which a member id is worth putting on an emergency.
+ *
+ * PENDING_ACTIVATION is included deliberately: naming the caller is accurate
+ * and useful whatever their cover state, and a partner's own operator is better
+ * off knowing who is calling. LAPSED is excluded because quoting a member id
+ * the partner has finished with risks an outright rejection of the SOS - which
+ * would cost an ambulance to add a field that was optional in the first place.
+ */
+export declare const DEFAULT_QUOTABLE_MEMBER_STATES: readonly PartnerMemberState[];

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

@@ -0,0 +1,19 @@
+/**
+ * Which of an organization's packages have their subscribers registered as
+ * members with a partner.
+ *
+ * A separate axis from coverage rules, on purpose. Coverage rules answer "where
+ * does THIS EMERGENCY go", which is an incident-shaped question 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, and export a date of birth, for every free subscriber.
+ *
+ * So membership eligibility is stated, not inferred.
+ */
+export declare enum PartnerMembershipPackageScope {
+    /** Every package the organization sells. The default once membership is on. */
+    ALL = "ALL",
+    /** Only the packages named in `membershipPackageIds`. */
+    SELECTED = "SELECTED"
+}

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;
+}