@openinherit/sdk 1.0.0

package/dist/reference/types.gen.d.ts

@@ -0,0 +1,4602 @@
+export type ClientOptions = {
+    baseUrl: 'https://api.example.com/v1' | (string & {});
+};
+export type Error = {
+    error: {
+        /**
+         * Machine-readable error code
+         */
+        code: string;
+        /**
+         * Human-readable error description
+         */
+        message: string;
+        /**
+         * Additional structured detail about the error
+         */
+        details?: {
+            [key: string]: unknown;
+        };
+    };
+};
+export type PaginatedEstateList = {
+    /**
+     * Page of estate records
+     */
+    items: Array<Estate>;
+    /**
+     * Opaque cursor to fetch the next page; absent when hasMore is false
+     */
+    cursor?: string;
+    /**
+     * Whether further pages are available
+     */
+    hasMore: boolean;
+};
+export type ImportResult = {
+    /**
+     * Identifier assigned to the newly imported estate
+     */
+    estateId: string;
+    /**
+     * Highest conformance level achieved:
+     * 1 = Schema Valid, 2 = Referentially Intact, 3 = Jurisdiction Complete
+     *
+     */
+    conformanceLevel: 1 | 2 | 3;
+    /**
+     * Non-fatal warnings produced during import
+     */
+    warnings?: Array<string>;
+    /**
+     * Count of each entity type created during import
+     */
+    entitiesCreated?: {
+        persons?: number;
+        relationships?: number;
+        kinships?: number;
+        properties?: number;
+        assets?: number;
+        liabilities?: number;
+        bequests?: number;
+        trusts?: number;
+        executors?: number;
+        guardians?: number;
+        wishes?: number;
+        documents?: number;
+        attestations?: number;
+        proxyAuthorisations?: number;
+        dealerInterests?: number;
+        nonprobateTransfers?: number;
+    };
+};
+export type ExportJsonRequest = {
+    /**
+     * List of extension identifiers to include in the export
+     */
+    includeExtensions?: Array<string>;
+    /**
+     * Minimum conformance level required for export
+     */
+    conformanceLevel?: 1 | 2 | 3;
+};
+export type ExportPdfRequest = {
+    /**
+     * PDF template to use for rendering
+     */
+    template: 'full' | 'summary' | 'professional';
+    /**
+     * List of extension identifiers to include in the PDF
+     */
+    includeExtensions?: Array<string>;
+    /**
+     * Name of the person receiving the PDF (used in the document header)
+     */
+    recipientName?: string;
+};
+export type CompanionLink = {
+    /**
+     * UUID of the estate to link as a companion (e.g. a spouse's estate)
+     */
+    companionEstateId: string;
+};
+export type EstateSummary = {
+    /**
+     * Unique identifier for the estate
+     */
+    estateId: string;
+    /**
+     * Current lifecycle status of the estate
+     */
+    status: 'draft' | 'active' | 'locked' | 'archived';
+    jurisdiction: Jurisdiction;
+    /**
+     * Count of each entity type present in the estate
+     */
+    entityCounts: {
+        persons?: number;
+        relationships?: number;
+        kinships?: number;
+        properties?: number;
+        assets?: number;
+        liabilities?: number;
+        bequests?: number;
+        trusts?: number;
+        executors?: number;
+        guardians?: number;
+        wishes?: number;
+        documents?: number;
+        attestations?: number;
+        proxyAuthorisations?: number;
+        dealerInterests?: number;
+        nonprobateTransfers?: number;
+    };
+    totalEstimatedValue?: Money;
+    totalLiabilities?: Money;
+    netEstimatedValue?: Money;
+    /**
+     * Current conformance level:
+     * 0 = Not validated, 1 = Schema Valid,
+     * 2 = Referentially Intact, 3 = Jurisdiction Complete
+     *
+     */
+    conformanceLevel: 0 | 1 | 2 | 3;
+    /**
+     * Key completeness indicators for the estate
+     */
+    completeness?: {
+        hasWill?: boolean;
+        hasExecutor?: boolean;
+        hasGuardian?: boolean;
+        hasAttestation?: boolean;
+        allBequestsHaveBeneficiary?: boolean;
+    };
+    /**
+     * Indicators used to assess estate complexity
+     */
+    complexityIndicators?: {
+        /**
+         * Number of distinct jurisdictions involved
+         */
+        jurisdictionCount?: number;
+        hasTrusts?: boolean;
+        hasForcedHeirship?: boolean;
+        hasNonprobateTransfers?: boolean;
+        hasCrossJurisdictionAssets?: boolean;
+    };
+    /**
+     * Date the estate was last modified (ISO 8601)
+     */
+    lastModifiedAt: string;
+};
+/**
+ * Attestation
+ *
+ * Will execution formalities. Standalone — reused by estate, codicils, trusts, extensions. Supports written (E&W Wills Act s.9), oral (Islamic/customary), seal-based (Japanese inkan), kinyan-based (Jewish).
+ */
+export type Attestation = {
+    date?: string;
+    witnessPersonIds?: Array<string>;
+    method?: 'in_person' | 'video' | 'remote' | 'none' | 'kinyan_sudar' | 'kinyan_agav' | 'seal_based' | 'inkan_registered';
+    attestationType?: 'written_signed' | 'oral_witnessed' | 'oral_community' | 'seal_based';
+    solicitorSupervised?: boolean;
+    testatorSignedInPresenceOfWitnesses?: boolean;
+    witnessesSignedInPresenceOfTestator?: boolean;
+    witnessConflictCheck?: boolean;
+    witnessConflictCheckScope?: 'english_law' | 'halachic_broad' | 'shariah_standard' | 'civil_law_standard' | 'customary_oral' | 'community_testimony';
+    notes?: string;
+    [key: string]: unknown | string | Array<string> | 'in_person' | 'video' | 'remote' | 'none' | 'kinyan_sudar' | 'kinyan_agav' | 'seal_based' | 'inkan_registered' | 'written_signed' | 'oral_witnessed' | 'oral_community' | 'seal_based' | boolean | 'english_law' | 'halachic_broad' | 'shariah_standard' | 'civil_law_standard' | 'customary_oral' | 'community_testimony' | string | undefined;
+};
+/**
+ * Jurisdiction
+ *
+ * A legal jurisdiction identified by ISO 3166 codes.
+ */
+export type Jurisdiction = {
+    /**
+     * ISO 3166-1 alpha-2
+     */
+    country: string;
+    /**
+     * ISO 3166-2 subdivision code (e.g. GB-SCT, US-CA)
+     */
+    subdivision?: string;
+    legalSystem?: 'common_law' | 'civil_law' | 'mixed' | 'religious' | 'customary' | 'religious_islamic' | 'religious_jewish' | 'religious_hindu' | 'religious_canon' | 'plural';
+    /**
+     * Human-readable jurisdiction name (e.g. 'Scotland', 'California')
+     */
+    name?: string;
+};
+/**
+ * Money
+ *
+ * Monetary value in integer minor currency units with ISO 4217 code. Never floating point.
+ */
+export type Money = {
+    /**
+     * Value in smallest currency unit (e.g. 32500 = £325.00)
+     */
+    amount: number;
+    /**
+     * ISO 4217 three-letter code
+     */
+    currency: string;
+};
+export type TestamentaryCapacity = {
+    assessed?: boolean;
+    assessmentDate?: string;
+    assessorName?: string;
+    assessorRole?: string;
+    capacityConfirmed?: boolean;
+    goldenRuleComplied?: boolean;
+    notes?: string;
+};
+export type Codicil = {
+    id: string;
+    date: string;
+    description?: string;
+    attestation?: Attestation;
+    documentId?: string;
+};
+export type ForcedHeirship = {
+    applies?: boolean;
+    reservedPortion?: number;
+    disposableQuota?: number;
+    jurisdiction?: Jurisdiction;
+    claimNature?: 'property_share' | 'cash_claim' | 'usufruct' | 'court_discretion';
+    calculationBasis?: 'fixed' | 'per_child_sliding' | 'court_discretion' | 'conditional';
+    applicableTo?: 'children_only' | 'children_and_spouse' | 'all_descendants' | 'all_heirs';
+    deferralRule?: string;
+    effectiveDate?: string;
+    reformVersion?: string;
+    notes?: string;
+};
+export type AdjudicatingBody = {
+    type: 'secular_court' | 'religious_court' | 'beth_din' | 'shariah_court' | 'tribal_court' | 'family_court' | 'family_council' | 'community_elders' | 'partition_meeting' | 'karta_decision' | 'maori_land_court' | 'high_court';
+    name?: string;
+    jurisdiction?: Jurisdiction;
+    caseReference?: string;
+    authoritative?: boolean;
+};
+export type ParallelDistribution = {
+    system: string;
+    jurisdiction?: Jurisdiction;
+    description?: string;
+    notes?: string;
+};
+export type ProbateGrant = {
+    grantType?: string;
+    grantDate?: string;
+    grantReference?: string;
+    issuingCourt?: string;
+    jurisdiction?: Jurisdiction;
+    notes?: string;
+};
+export type DeathRecord = {
+    dateOfDeath?: string;
+    placeOfDeath?: string;
+    deathCertificateRef?: string;
+    domicileAtDeath?: Jurisdiction;
+    notes?: string;
+};
+export type SuccessionConflict = {
+    description: string;
+    systems?: Array<string>;
+    resolutionStatus?: 'unresolved' | 'resolved' | 'pending_court' | 'pending_arbitration';
+    notes?: string;
+};
+/**
+ * Estate
+ *
+ * The root estate record — will, intestacy, or trust-based succession plan. Contains testator details, jurisdiction, will formalities, forced heirship, probate grants, death record, multi-jurisdiction administration, and tax treaty positions.
+ */
+export type Estate = {
+    id: string;
+    testatorPersonId: string;
+    status: 'draft' | 'active' | 'locked' | 'archived';
+    jurisdiction: Jurisdiction;
+    willType?: 'secular' | 'religious' | 'dual' | 'composite' | 'oral_witnessed' | 'oral_customary' | 'holographic' | 'notarised' | 'privileged_will';
+    extensionWillType?: string;
+    companionEstateId?: string;
+    primaryInstrument?: 'will' | 'revocable_trust' | 'both' | 'intestacy';
+    defaultPropertyRegime?: 'community_property' | 'separate_property' | 'equitable_distribution' | 'deferred_community' | 'universal_community' | 'participation_in_acquisitions' | 'islamic_dower';
+    totalEstimatedValue?: Money;
+    attestation?: Attestation;
+    testamentaryCapacity?: TestamentaryCapacity;
+    codicils?: Array<Codicil>;
+    revokesDocumentIds?: Array<string>;
+    revocationClause?: boolean;
+    forcedHeirship?: ForcedHeirship;
+    adjudicatingBodies?: Array<AdjudicatingBody>;
+    parallelDistributions?: Array<ParallelDistribution>;
+    probateGrant?: ProbateGrant;
+    deathRecord?: DeathRecord;
+    successionConflicts?: Array<SuccessionConflict>;
+    choiceOfLaw?: {
+        chosenLaw?: Jurisdiction;
+        basis?: string;
+        documentRef?: string;
+    };
+    electiveShareRight?: {
+        available?: boolean;
+        electedAmount?: Money;
+        statute?: string;
+        notes?: string;
+    };
+    priorMatrimonialClaim?: {
+        exists?: boolean;
+        description?: string;
+        claimantPersonId?: string;
+        notes?: string;
+    };
+    noContestClause?: {
+        present?: boolean;
+        enforceability?: string;
+        notes?: string;
+    };
+    pretermittedHeirClaims?: Array<{
+        claimantPersonId?: string;
+        status?: string;
+        notes?: string;
+    }>;
+    testamentaryPromises?: Array<{
+        claimantPersonId?: string;
+        promiseDescription?: string;
+        status?: string;
+        notes?: string;
+    }>;
+    judicialVariationPower?: {
+        available?: boolean;
+        statute?: string;
+        notes?: string;
+    };
+    commorientesRule?: {
+        applicable?: boolean;
+        rule?: string;
+        jurisdiction?: Jurisdiction;
+        notes?: string;
+    };
+    ancillaryProbate?: Array<{
+        jurisdiction: Jurisdiction;
+        fiduciaryPersonId?: string;
+        status?: 'not_started' | 'applied' | 'granted' | 'completed' | 'waived';
+        grantReference?: string;
+        localCounsel?: string;
+        notes?: string;
+    }>;
+    registrations?: Array<{
+        registry: string;
+        registrationNumber?: string;
+        jurisdictionScope?: string;
+        registrationDate?: string;
+    }>;
+    reportingCurrency?: string;
+    conversionRates?: Array<{
+        fromCurrency: string;
+        toCurrency: string;
+        rate: number;
+        rateDate: string;
+        source?: string;
+    }>;
+    taxTreatyPositions?: Array<{
+        treaty: string;
+        primaryTaxingJurisdiction?: Jurisdiction;
+        claimedCredits?: string;
+        relevantArticle?: string;
+        notes?: string;
+    }>;
+    suggestedPractitionerNeeds?: Array<string>;
+    createdAt: string;
+    lastModifiedAt: string;
+    notes?: string;
+    [key: string]: unknown | string | 'draft' | 'active' | 'locked' | 'archived' | Jurisdiction | 'secular' | 'religious' | 'dual' | 'composite' | 'oral_witnessed' | 'oral_customary' | 'holographic' | 'notarised' | 'privileged_will' | string | 'will' | 'revocable_trust' | 'both' | 'intestacy' | 'community_property' | 'separate_property' | 'equitable_distribution' | 'deferred_community' | 'universal_community' | 'participation_in_acquisitions' | 'islamic_dower' | Money | Attestation | TestamentaryCapacity | Array<Codicil> | Array<string> | boolean | ForcedHeirship | Array<AdjudicatingBody> | Array<ParallelDistribution> | ProbateGrant | DeathRecord | Array<SuccessionConflict> | {
+        chosenLaw?: Jurisdiction;
+        basis?: string;
+        documentRef?: string;
+    } | {
+        available?: boolean;
+        electedAmount?: Money;
+        statute?: string;
+        notes?: string;
+    } | {
+        exists?: boolean;
+        description?: string;
+        claimantPersonId?: string;
+        notes?: string;
+    } | {
+        present?: boolean;
+        enforceability?: string;
+        notes?: string;
+    } | Array<{
+        claimantPersonId?: string;
+        status?: string;
+        notes?: string;
+    }> | Array<{
+        claimantPersonId?: string;
+        promiseDescription?: string;
+        status?: string;
+        notes?: string;
+    }> | {
+        available?: boolean;
+        statute?: string;
+        notes?: string;
+    } | {
+        applicable?: boolean;
+        rule?: string;
+        jurisdiction?: Jurisdiction;
+        notes?: string;
+    } | Array<{
+        jurisdiction: Jurisdiction;
+        fiduciaryPersonId?: string;
+        status?: 'not_started' | 'applied' | 'granted' | 'completed' | 'waived';
+        grantReference?: string;
+        localCounsel?: string;
+        notes?: string;
+    }> | Array<{
+        registry: string;
+        registrationNumber?: string;
+        jurisdictionScope?: string;
+        registrationDate?: string;
+    }> | string | Array<{
+        fromCurrency: string;
+        toCurrency: string;
+        rate: number;
+        rateDate: string;
+        source?: string;
+    }> | Array<{
+        treaty: string;
+        primaryTaxingJurisdiction?: Jurisdiction;
+        claimedCredits?: string;
+        relevantArticle?: string;
+        notes?: string;
+    }> | Array<string> | string | undefined;
+};
+/**
+ * PostalAddress
+ *
+ * A physical address. Culturally neutral — supports any global addressing convention.
+ */
+export type Address = {
+    /**
+     * Street number and name
+     */
+    streetAddress?: string;
+    /**
+     * Flat, suite, building, floor
+     */
+    addressLine2?: string;
+    /**
+     * City, town, village, or ward
+     */
+    addressLocality?: string;
+    /**
+     * State, prefecture, province, county
+     */
+    addressRegion?: string;
+    postalCode?: string;
+    /**
+     * ISO 3166-1 alpha-2
+     */
+    addressCountry?: string;
+    latitude?: number;
+    longitude?: number;
+    landmark?: string;
+    directionNotes?: string;
+    addressOrder?: 'western' | 'japanese' | 'indian' | 'arabic' | 'custom';
+};
+/**
+ * Identifier
+ *
+ * A typed external identifier. Use 'system' to namespace (e.g. 'urn:hmrc:nino').
+ */
+export type Identifier = {
+    /**
+     * Namespace URI or name
+     */
+    system?: string;
+    /**
+     * The identifier value
+     */
+    value: string;
+    /**
+     * Type label (e.g. 'passport', 'national_insurance', 'charity_number')
+     */
+    type?: string;
+};
+/**
+ * Person
+ *
+ * A person involved in the estate. Schema.org name alignment. Any Unicode script. Supports CJK phonetic readings, chieftaincy titles, clan/lineage identifiers, dual legal personalities, and tax residency across multiple jurisdictions.
+ */
+export type Person = {
+    id: string;
+    /**
+     * First/given name (Schema.org: givenName)
+     */
+    givenName: string;
+    /**
+     * Last/family/surname (Schema.org: familyName)
+     */
+    familyName?: string;
+    /**
+     * Middle name(s) (Schema.org: additionalName)
+     */
+    additionalName?: string;
+    /**
+     * Name the person prefers to be called
+     */
+    preferredName?: string;
+    phoneticReading?: {
+        givenName?: string;
+        familyName?: string;
+        fullName?: string;
+    };
+    titles?: Array<{
+        title: string;
+        type?: 'chieftaincy' | 'traditional' | 'religious' | 'professional' | 'honorific' | 'clan' | 'academic' | 'military' | 'other';
+    }>;
+    clanOrLineage?: string;
+    /**
+     * ISO 8601 date of birth
+     */
+    dateOfBirth?: string;
+    /**
+     * ISO 8601 date of death (if deceased)
+     */
+    dateOfDeath?: string;
+    gender?: 'male' | 'female' | 'non_binary' | 'other' | 'prefer_not_to_say' | 'unknown';
+    domicile?: Jurisdiction;
+    roles: Array<'testator' | 'beneficiary' | 'executor' | 'guardian' | 'trustee' | 'witness' | 'attorney' | 'proxy' | 'protector' | 'enforcer'>;
+    contact?: {
+        email?: string;
+        /**
+         * Phone number (E.164 recommended)
+         */
+        phone?: string;
+        address?: Address;
+    };
+    /**
+     * External identifiers (passport, national ID, etc.)
+     */
+    identifiers?: Array<Identifier>;
+    ritualName?: {
+        /**
+         * The full ritual/religious name
+         */
+        name: string;
+        /**
+         * Patronymic element (ben/bat, ibn/bint, etc.)
+         */
+        patronymic?: string;
+        /**
+         * Naming tradition: hebrew, arabic_nasab, hindu, buddhist, etc.
+         */
+        nameSystem?: string;
+    };
+    legalPersonalities?: Array<{
+        system: 'statutory' | 'customary' | 'religious' | 'traditional';
+        role: string;
+        jurisdiction?: Jurisdiction;
+        notes?: string;
+    }>;
+    taxResidency?: Array<{
+        jurisdiction: Jurisdiction;
+        taxpayerIdentifier?: string;
+        treatyPosition?: string;
+        fatcaStatus?: 'us_person' | 'non_us_person' | 'exempt' | 'unknown';
+    }>;
+    /**
+     * BCP 47 language tag for preferred language
+     */
+    language?: string;
+    notes?: string;
+    [key: string]: unknown | string | string | string | {
+        givenName?: string;
+        familyName?: string;
+        fullName?: string;
+    } | Array<{
+        title: string;
+        type?: 'chieftaincy' | 'traditional' | 'religious' | 'professional' | 'honorific' | 'clan' | 'academic' | 'military' | 'other';
+    }> | string | 'male' | 'female' | 'non_binary' | 'other' | 'prefer_not_to_say' | 'unknown' | Jurisdiction | Array<'testator' | 'beneficiary' | 'executor' | 'guardian' | 'trustee' | 'witness' | 'attorney' | 'proxy' | 'protector' | 'enforcer'> | {
+        email?: string;
+        /**
+         * Phone number (E.164 recommended)
+         */
+        phone?: string;
+        address?: Address;
+    } | Array<Identifier> | {
+        /**
+         * The full ritual/religious name
+         */
+        name: string;
+        /**
+         * Patronymic element (ben/bat, ibn/bint, etc.)
+         */
+        patronymic?: string;
+        /**
+         * Naming tradition: hebrew, arabic_nasab, hindu, buddhist, etc.
+         */
+        nameSystem?: string;
+    } | Array<{
+        system: 'statutory' | 'customary' | 'religious' | 'traditional';
+        role: string;
+        jurisdiction?: Jurisdiction;
+        notes?: string;
+    }> | Array<{
+        jurisdiction: Jurisdiction;
+        taxpayerIdentifier?: string;
+        treatyPosition?: string;
+        fatcaStatus?: 'us_person' | 'non_us_person' | 'exempt' | 'unknown';
+    }> | undefined;
+};
+export type Partner = {
+    /**
+     * Reference to a Person.id
+     */
+    personId: string;
+    /**
+     * Optional non-gendered label (e.g. 'First Wife', 'Partner A')
+     */
+    displayLabel?: string;
+    /**
+     * Position in partner list (1-based)
+     */
+    ordinal: number;
+};
+export type RelationshipEvent = {
+    type: 'CEREMONY' | 'REGISTRATION' | 'ENGAGEMENT' | 'MARRIAGE_CONTRACT' | 'PROPERTY_REGIME_CHANGE' | 'SEPARATION_INFORMAL' | 'SEPARATION_LEGAL' | 'DIVORCE_FILED' | 'DIVORCE_FINALISED' | 'FINANCIAL_ORDER' | 'ANNULMENT' | 'DISSOLUTION' | 'DEATH_OF_PARTNER' | 'RECONCILIATION' | 'VOID_DECLARATION' | 'MAHR_PAYMENT' | 'LOBOLA_PAYMENT';
+    /**
+     * ISO 8601 date
+     */
+    date: string;
+    jurisdiction?: Jurisdiction;
+    notes?: string;
+};
+export type JurisdictionalRecognition = {
+    jurisdiction: Jurisdiction;
+    recognised: boolean;
+    /**
+     * What this jurisdiction recognises it as (if different)
+     */
+    recognisedAs?: string;
+    notes?: string;
+};
+export type FinancialInstrument = unknown & {
+    type: 'MAHR' | 'KETUBAH' | 'LOBOLA' | 'PRENUPTIAL_AGREEMENT' | 'POSTNUPTIAL_AGREEMENT' | 'MARRIAGE_SETTLEMENT';
+    value?: Money;
+    status?: 'AGREED' | 'PAID' | 'PARTIALLY_PAID' | 'DEFERRED' | 'DISPUTED' | 'WAIVED';
+    description?: string;
+    /**
+     * Reference to a Document.id
+     */
+    documentRef?: string;
+    date?: string;
+    /**
+     * How this affects inheritance distribution
+     */
+    inheritanceImpact?: string;
+    maharDetails?: {
+        maharType?: 'prompt' | 'deferred' | 'combination';
+        recipientPersonId?: string;
+        linkedLiabilityId?: string;
+    };
+    ketubahDetails?: {
+        principalAmount?: Money;
+        tosefetAmount?: Money;
+        nedunya?: Money;
+        brideStatus?: 'virgin' | 'widow' | 'divorcee';
+        witnessPersonIds?: Array<string>;
+        officiatingRabbi?: string;
+    };
+    lobolaDetails?: {
+        negotiatedWith?: string;
+        includesLivestock?: boolean;
+        livestockCount?: number;
+    };
+};
+/**
+ * Relationship
+ *
+ * Spousal/partnership relationship. N-partner support (no structural two-partner limit). Event-based timeline (status derived from events). No gendered role names. Financial instruments with MAHR/KETUBAH subtype validation. Cross-jurisdiction recognition for dual civil/religious status.
+ */
+export type Relationship = {
+    id: string;
+    type: 'MARRIAGE_CIVIL' | 'MARRIAGE_RELIGIOUS' | 'MARRIAGE_CUSTOMARY' | 'MARRIAGE_COMMON_LAW' | 'CIVIL_PARTNERSHIP' | 'CIVIL_UNION' | 'DOMESTIC_PARTNERSHIP' | 'DE_FACTO' | 'COHABITATION' | 'ENGAGEMENT';
+    religiousSubtype?: string;
+    /**
+     * How the parties themselves describe this relationship
+     */
+    selfDeclaredType?: string;
+    /**
+     * The people in this relationship. Minimum 2, no structural upper limit.
+     */
+    partners: Array<Partner>;
+    /**
+     * Chronological events determining relationship status
+     */
+    events?: Array<RelationshipEvent>;
+    currentStatus?: 'ACTIVE' | 'SEPARATED_INFORMAL' | 'SEPARATED_LEGAL' | 'DIVORCED' | 'ANNULLED' | 'DISSOLVED' | 'WIDOWED' | 'VOID' | 'PUTATIVE';
+    /**
+     * Primary jurisdiction where this relationship was formed
+     */
+    jurisdiction?: Jurisdiction;
+    /**
+     * How other jurisdictions recognise (or don't) this relationship
+     */
+    jurisdictionalRecognition?: Array<JurisdictionalRecognition>;
+    /**
+     * Mahr, ketubah, lobola, prenuptial agreements, etc.
+     */
+    financialInstruments?: Array<FinancialInstrument>;
+    /**
+     * The marital property regime
+     */
+    propertyRegime?: 'COMMUNITY_OF_PROPERTY' | 'SEPARATION_OF_PROPERTY' | 'COMMUNITY_OF_ACQUESTS' | 'DEFERRED_COMMUNITY' | 'SEPARATE_AS_MODIFIED' | 'ISLAMIC_DOWER' | 'US_COMMUNITY_PROPERTY' | 'US_COMMUNITY_WITH_SURVIVORSHIP' | 'US_QUASI_COMMUNITY' | 'HINDU_SEPARATE';
+    notes?: string;
+    [key: string]: unknown | string | 'MARRIAGE_CIVIL' | 'MARRIAGE_RELIGIOUS' | 'MARRIAGE_CUSTOMARY' | 'MARRIAGE_COMMON_LAW' | 'CIVIL_PARTNERSHIP' | 'CIVIL_UNION' | 'DOMESTIC_PARTNERSHIP' | 'DE_FACTO' | 'COHABITATION' | 'ENGAGEMENT' | string | Array<Partner> | Array<RelationshipEvent> | 'ACTIVE' | 'SEPARATED_INFORMAL' | 'SEPARATED_LEGAL' | 'DIVORCED' | 'ANNULLED' | 'DISSOLVED' | 'WIDOWED' | 'VOID' | 'PUTATIVE' | Jurisdiction | Array<JurisdictionalRecognition> | Array<FinancialInstrument> | 'COMMUNITY_OF_PROPERTY' | 'SEPARATION_OF_PROPERTY' | 'COMMUNITY_OF_ACQUESTS' | 'DEFERRED_COMMUNITY' | 'SEPARATE_AS_MODIFIED' | 'ISLAMIC_DOWER' | 'US_COMMUNITY_PROPERTY' | 'US_COMMUNITY_WITH_SURVIVORSHIP' | 'US_QUASI_COMMUNITY' | 'HINDU_SEPARATE' | undefined;
+};
+/**
+ * Kinship
+ *
+ * A familial bond between two people. Essential for intestacy calculation — inheritance rules in every jurisdiction depend on parent-child, sibling, and other familial relationships. Direction: fromPersonId is the parent/elder, toPersonId is the child/younger (for parent-child types). Indian extensions may add PARENT_CHILD_COPARCENARY, KARTA_MEMBER. See extensions/india-hindu.json.
+ */
+export type Kinship = {
+    id: string;
+    type: 'PARENT_CHILD_BIOLOGICAL' | 'PARENT_CHILD_ADOPTED' | 'PARENT_CHILD_STEP' | 'PARENT_CHILD_FOSTER' | 'PARENT_CHILD_ACKNOWLEDGED' | 'SIBLING' | 'HALF_SIBLING_PATERNAL' | 'HALF_SIBLING_MATERNAL' | 'STEP_SIBLING' | 'GRANDPARENT_GRANDCHILD' | 'UNCLE_NEPHEW' | 'AUNT_NEPHEW';
+    /**
+     * Parent/elder person in the kinship (Person.id)
+     */
+    fromPersonId: string;
+    /**
+     * Child/younger person in the kinship (Person.id)
+     */
+    toPersonId: string;
+    /**
+     * Legal recognition status of this familial bond
+     */
+    legalStatus?: 'recognised' | 'contested' | 'pending' | 'unrecognised';
+    legitimacy?: 'legitimate' | 'illegitimate' | 'legitimated' | 'not_applicable';
+    /**
+     * Date of adoption order (for PARENT_CHILD_ADOPTED)
+     */
+    adoptionDate?: string;
+    /**
+     * Court order or adoption certificate reference
+     */
+    courtOrderRef?: string;
+    notes?: string;
+    [key: string]: unknown | string | 'PARENT_CHILD_BIOLOGICAL' | 'PARENT_CHILD_ADOPTED' | 'PARENT_CHILD_STEP' | 'PARENT_CHILD_FOSTER' | 'PARENT_CHILD_ACKNOWLEDGED' | 'SIBLING' | 'HALF_SIBLING_PATERNAL' | 'HALF_SIBLING_MATERNAL' | 'STEP_SIBLING' | 'GRANDPARENT_GRANDCHILD' | 'UNCLE_NEPHEW' | 'AUNT_NEPHEW' | 'recognised' | 'contested' | 'pending' | 'unrecognised' | 'legitimate' | 'illegitimate' | 'legitimated' | 'not_applicable' | string | string | undefined;
+};
+/**
+ * Property
+ *
+ * Real estate. Supports individual ownership, communal/family property (Nigeria), HUF coparcenary (India), government-vested land (Land Use Act), US community property, and informal/unregistered holdings.
+ */
+export type Property = {
+    id: string;
+    /**
+     * Display name (e.g. 'Family Home', '42 Acacia Avenue')
+     */
+    name: string;
+    propertyType?: 'detached_house' | 'semi_detached_house' | 'terraced_house' | 'flat' | 'maisonette' | 'bungalow' | 'cottage' | 'farmhouse' | 'barn_conversion' | 'land' | 'commercial' | 'mixed_use' | 'houseboat' | 'mobile_home' | 'other';
+    address?: Address;
+    estimatedValue?: Money;
+    professionalValuation?: Money;
+    valuationDate?: string;
+    valuationConfidence?: 'estimated' | 'professional' | 'probate' | 'unknown';
+    isPrimaryResidence?: boolean;
+    ownershipType?: 'sole' | 'joint_tenants' | 'tenants_in_common' | 'trust' | 'tenancy_by_entirety';
+    ownershipPercentage?: number;
+    ownershipModel?: 'individual' | 'joint' | 'communal_family' | 'huf_coparcenary' | 'tribal' | 'government_vested' | 'trust_held';
+    acquisitionType?: 'self_acquired' | 'ancestral_joint' | 'ancestral_severed' | 'inherited' | 'gifted' | 'stridhan' | 'communal' | 'waqf_endowed';
+    tenureType?: 'freehold' | 'leasehold' | 'certificate_of_occupancy' | 'customary_right_of_occupancy' | 'communal' | 'government_allocated' | 'traditional_authority_granted' | 'informal_unregistered';
+    registrationStatus?: 'formally_registered' | 'informally_held' | 'community_acknowledged' | 'disputed' | 'undocumented';
+    ownershipEvidence?: 'title_deed' | 'certificate_of_occupancy' | 'family_recognition' | 'community_testimony' | 'receipts_only' | 'none';
+    applicableSuccessionLaw?: {
+        jurisdiction: Jurisdiction;
+        lawName?: string;
+        section?: string;
+    };
+    custodianPersonId?: string;
+    successionRule?: 'testamentary' | 'intestacy' | 'customary_eldest_son' | 'customary_family_council' | 'customary_matrilineal' | 'survivorship' | 'not_individually_bequeathable';
+    governmentConsentRequired?: boolean;
+    mobilityType?: 'immoveable' | 'moveable' | 'mixed';
+    mortgageOutstanding?: Money;
+    characterClassification?: 'community' | 'separate' | 'quasi_community' | 'mixed' | 'not_applicable';
+    homesteadStatus?: {
+        isHomestead?: boolean;
+        exemptionAmount?: Money;
+        exemptionUnlimited?: boolean;
+        deviseRestriction?: boolean;
+        notes?: string;
+    };
+    passesOutsideEstate?: boolean;
+    statutoryLifeEstate?: {
+        beneficiaryPersonId?: string;
+        basis?: string;
+        conditions?: string;
+    };
+    notes?: string;
+    [key: string]: unknown | string | string | 'detached_house' | 'semi_detached_house' | 'terraced_house' | 'flat' | 'maisonette' | 'bungalow' | 'cottage' | 'farmhouse' | 'barn_conversion' | 'land' | 'commercial' | 'mixed_use' | 'houseboat' | 'mobile_home' | 'other' | Address | Money | string | 'estimated' | 'professional' | 'probate' | 'unknown' | boolean | 'sole' | 'joint_tenants' | 'tenants_in_common' | 'trust' | 'tenancy_by_entirety' | number | 'individual' | 'joint' | 'communal_family' | 'huf_coparcenary' | 'tribal' | 'government_vested' | 'trust_held' | 'self_acquired' | 'ancestral_joint' | 'ancestral_severed' | 'inherited' | 'gifted' | 'stridhan' | 'communal' | 'waqf_endowed' | 'freehold' | 'leasehold' | 'certificate_of_occupancy' | 'customary_right_of_occupancy' | 'communal' | 'government_allocated' | 'traditional_authority_granted' | 'informal_unregistered' | 'formally_registered' | 'informally_held' | 'community_acknowledged' | 'disputed' | 'undocumented' | 'title_deed' | 'certificate_of_occupancy' | 'family_recognition' | 'community_testimony' | 'receipts_only' | 'none' | {
+        jurisdiction: Jurisdiction;
+        lawName?: string;
+        section?: string;
+    } | 'testamentary' | 'intestacy' | 'customary_eldest_son' | 'customary_family_council' | 'customary_matrilineal' | 'survivorship' | 'not_individually_bequeathable' | 'immoveable' | 'moveable' | 'mixed' | 'community' | 'separate' | 'quasi_community' | 'mixed' | 'not_applicable' | {
+        isHomestead?: boolean;
+        exemptionAmount?: Money;
+        exemptionUnlimited?: boolean;
+        deviseRestriction?: boolean;
+        notes?: string;
+    } | {
+        beneficiaryPersonId?: string;
+        basis?: string;
+        conditions?: string;
+    } | string | undefined;
+};
+export type Photo = {
+    url: string;
+    caption?: string;
+};
+/**
+ * Asset
+ *
+ * A non-property asset: financial accounts, personal property, vehicles, digital assets, business interests, Islamic finance instruments, etc.
+ */
+export type Asset = {
+    id: string;
+    /**
+     * Display name for this asset
+     */
+    name: string;
+    category: 'bank_account' | 'savings_account' | 'investment' | 'pension' | 'shares' | 'premium_bonds' | 'cryptocurrency' | 'insurance' | 'vehicle' | 'jewellery' | 'art' | 'antiques' | 'collectibles' | 'furniture' | 'electronics' | 'musical_instruments' | 'books' | 'clothing' | 'kitchenware' | 'sports_equipment' | 'firearms' | 'wine_and_spirits' | 'tools' | 'garden_and_outdoor' | 'business_interest' | 'intellectual_property' | 'domain_name' | 'social_media_account' | 'digital_subscription' | 'sukuk' | 'takaful' | 'islamic_deposit' | 'other';
+    subcategory?: string;
+    estimatedValue?: Money;
+    professionalValuation?: Money;
+    valuationDate?: string;
+    valuationConfidence?: 'estimated' | 'professional' | 'probate' | 'unknown';
+    condition?: 'excellent' | 'good' | 'fair' | 'poor' | 'unknown' | 'not_applicable';
+    quantity?: number;
+    /**
+     * Where this asset is stored or held
+     */
+    location?: string;
+    /**
+     * Reference to a Property.id if located at a property
+     */
+    propertyId?: string;
+    /**
+     * Serial numbers, account numbers, policy refs, etc.
+     */
+    identifiers?: Array<Identifier>;
+    photos?: Array<Photo>;
+    possessionStatus?: 'possessed_at_death' | 'receivable' | 'contingent';
+    mobilityType?: 'immoveable' | 'moveable' | 'mixed';
+    acquisitionType?: 'self_acquired' | 'ancestral_joint' | 'ancestral_severed' | 'inherited' | 'gifted' | 'stridhan' | 'communal' | 'waqf_endowed';
+    registrationStatus?: 'formally_registered' | 'informally_held' | 'community_acknowledged' | 'disputed' | 'undocumented';
+    ownershipEvidence?: 'title_deed' | 'certificate_of_occupancy' | 'family_recognition' | 'community_testimony' | 'receipts_only' | 'none';
+    applicableSuccessionLaw?: {
+        jurisdiction: Jurisdiction;
+        lawName?: string;
+        section?: string;
+    };
+    beneficiaryDesignation?: {
+        primaryBeneficiaryPersonIds?: Array<string>;
+        contingentBeneficiaryPersonIds?: Array<string>;
+        designationType?: 'retirement_account' | 'life_insurance' | 'superannuation' | 'pod_account' | 'other';
+        linkedNonprobateTransferId?: string;
+    };
+    digitalAccessConsent?: {
+        consentGiven?: boolean;
+        scope?: 'full_access' | 'limited_access' | 'no_access';
+        designatedRecipientPersonId?: string;
+        onlineToolDirective?: boolean;
+    };
+    passesOutsideEstate?: boolean;
+    notes?: string;
+    [key: string]: unknown | string | string | 'bank_account' | 'savings_account' | 'investment' | 'pension' | 'shares' | 'premium_bonds' | 'cryptocurrency' | 'insurance' | 'vehicle' | 'jewellery' | 'art' | 'antiques' | 'collectibles' | 'furniture' | 'electronics' | 'musical_instruments' | 'books' | 'clothing' | 'kitchenware' | 'sports_equipment' | 'firearms' | 'wine_and_spirits' | 'tools' | 'garden_and_outdoor' | 'business_interest' | 'intellectual_property' | 'domain_name' | 'social_media_account' | 'digital_subscription' | 'sukuk' | 'takaful' | 'islamic_deposit' | 'other' | string | Money | string | 'estimated' | 'professional' | 'probate' | 'unknown' | 'excellent' | 'good' | 'fair' | 'poor' | 'unknown' | 'not_applicable' | number | Array<Identifier> | Array<Photo> | 'possessed_at_death' | 'receivable' | 'contingent' | 'immoveable' | 'moveable' | 'mixed' | 'self_acquired' | 'ancestral_joint' | 'ancestral_severed' | 'inherited' | 'gifted' | 'stridhan' | 'communal' | 'waqf_endowed' | 'formally_registered' | 'informally_held' | 'community_acknowledged' | 'disputed' | 'undocumented' | 'title_deed' | 'certificate_of_occupancy' | 'family_recognition' | 'community_testimony' | 'receipts_only' | 'none' | {
+        jurisdiction: Jurisdiction;
+        lawName?: string;
+        section?: string;
+    } | {
+        primaryBeneficiaryPersonIds?: Array<string>;
+        contingentBeneficiaryPersonIds?: Array<string>;
+        designationType?: 'retirement_account' | 'life_insurance' | 'superannuation' | 'pod_account' | 'other';
+        linkedNonprobateTransferId?: string;
+    } | {
+        consentGiven?: boolean;
+        scope?: 'full_access' | 'limited_access' | 'no_access';
+        designatedRecipientPersonId?: string;
+        onlineToolDirective?: boolean;
+    } | boolean | undefined;
+};
+/**
+ * Liability
+ *
+ * A debt or financial obligation. Includes mortgages, loans, credit cards, and cultural obligations (mahr, ketubah debt, lobola) that are priority debts in certain jurisdictions.
+ */
+export type Liability = {
+    id: string;
+    type: 'mortgage' | 'personal_loan' | 'credit_card' | 'overdraft' | 'student_loan' | 'car_finance' | 'hire_purchase' | 'mahr' | 'ketubah_debt' | 'lobola' | 'tax_liability' | 'funeral_costs' | 'care_fees' | 'mezonot' | 'other';
+    /**
+     * Name of the creditor or institution
+     */
+    creditor?: string;
+    /**
+     * Outstanding balance
+     */
+    amount: Money;
+    /**
+     * Reference to a Property.id or Asset.id this liability is secured against
+     */
+    securedAgainst?: string;
+    monthlyPayment?: Money;
+    /**
+     * Annual interest rate as percentage (e.g. 4.5 = 4.5%)
+     */
+    interestRate?: number;
+    startDate?: string;
+    endDate?: string;
+    /**
+     * Account or reference number
+     */
+    accountReference?: string;
+    notes?: string;
+    [key: string]: unknown | string | 'mortgage' | 'personal_loan' | 'credit_card' | 'overdraft' | 'student_loan' | 'car_finance' | 'hire_purchase' | 'mahr' | 'ketubah_debt' | 'lobola' | 'tax_liability' | 'funeral_costs' | 'care_fees' | 'mezonot' | 'other' | string | Money | number | string | undefined;
+};
+export type BeneficiaryOrganisation = {
+    name: string;
+    type: 'charity' | 'company' | 'unincorporated_association' | 'trust' | 'other';
+    registrationNumber?: string;
+    jurisdiction?: Jurisdiction;
+};
+export type LifeInterest = {
+    tenantForLifeId: string;
+    remaindermanId?: string;
+    remaindermanClassDefinition?: string;
+    interestType: 'use_and_income' | 'income_only' | 'use_only' | 'protective' | 'right_of_residence';
+};
+export type Substitution = {
+    beneficiaryId?: string;
+    classDefinition?: string;
+    beneficiaryOrganisation?: BeneficiaryOrganisation;
+    condition?: string;
+    perStirpes?: boolean;
+};
+export type PostDeathAction = {
+    type: 'disclaimer' | 'deed_of_variation' | 'appropriation' | 'assent';
+    date?: string;
+    description?: string;
+    documentId?: string;
+};
+export type InheritanceResponse = {
+    response: 'accepted' | 'renounced' | 'qualified_acceptance' | 'pending';
+    responseDate?: string;
+    responsePersonId?: string;
+    courtFiled?: boolean;
+    deadlineDate?: string;
+};
+/**
+ * Bequest
+ *
+ * A disposition of property or money in a will. Supports 7 core types (specific, pecuniary, demonstrative, general, residuary, life_interest, class) and extension types via extensionType (e.g. wasiyya, halachic_matanah).
+ */
+export type Bequest = unknown & {
+    id: string;
+    type: 'specific' | 'pecuniary' | 'demonstrative' | 'general' | 'residuary' | 'life_interest' | 'class';
+    extensionType?: string;
+    beneficiaryId?: string;
+    beneficiaryOrganisation?: BeneficiaryOrganisation;
+    classDefinition?: string;
+    lifeInterest?: LifeInterest;
+    amount?: Money;
+    sharePercentage?: number;
+    description?: string;
+    sourceAssetId?: string;
+    conditions?: Array<string>;
+    substitutions?: Array<Substitution>;
+    hotchpot?: boolean;
+    distributionMethod?: 'per_capita' | 'per_stirpes' | 'modified_per_stirpes' | 'per_capita_at_each_generation' | 'halachic_yerusha';
+    predeceaseRule?: 'lapse' | 'per_stirpes' | 'substitution' | 'accrual' | 'statutory_default';
+    constrainedBy?: 'testamentary_freedom' | 'customary_rule' | 'forced_heirship' | 'religious_rule' | 'coparcenary_survivorship';
+    customaryOverride?: boolean;
+    postDeathActions?: Array<PostDeathAction>;
+    inheritanceResponse?: InheritanceResponse;
+    notes?: string;
+    [key: string]: unknown | string | 'specific' | 'pecuniary' | 'demonstrative' | 'general' | 'residuary' | 'life_interest' | 'class' | string | BeneficiaryOrganisation | LifeInterest | Money | number | Array<string> | Array<Substitution> | boolean | 'per_capita' | 'per_stirpes' | 'modified_per_stirpes' | 'per_capita_at_each_generation' | 'halachic_yerusha' | 'lapse' | 'per_stirpes' | 'substitution' | 'accrual' | 'statutory_default' | 'testamentary_freedom' | 'customary_rule' | 'forced_heirship' | 'religious_rule' | 'coparcenary_survivorship' | Array<PostDeathAction> | InheritanceResponse | undefined;
+};
+export type TrustAppointee = {
+    personId: string;
+    role: 'trustee' | 'protector' | 'enforcer';
+};
+export type TrustBeneficiary = {
+    personId?: string;
+    classDefinition?: string;
+    organisationName?: string;
+    interestType: 'income' | 'capital' | 'both' | 'discretionary';
+};
+/**
+ * Trust
+ *
+ * A trust instrument — testamentary or inter vivos. Covers discretionary, bare, life interest, charitable, nil rate band, waqf (Islamic endowment), and offshore structures with governance features (reserved powers, flee clauses, protector powers).
+ */
+export type Trust = {
+    id: string;
+    name: string;
+    type: 'discretionary' | 'life_interest' | 'bare' | 'accumulation_and_maintenance' | 'disabled_persons' | 'charitable' | 'nil_rate_band' | 'waqf' | 'other';
+    trustees: Array<TrustAppointee>;
+    beneficiaries: Array<TrustBeneficiary>;
+    settlor?: string;
+    isTestamentary?: boolean;
+    createdDate?: string;
+    creationType?: 'testamentary' | 'inter_vivos_revocable' | 'inter_vivos_irrevocable';
+    revocability?: 'revocable' | 'irrevocable' | 'perpetual';
+    perpetual?: boolean;
+    vestingAge?: number;
+    vestingDate?: string;
+    vestingConditions?: Array<string>;
+    contingentInterests?: Array<string>;
+    trustPeriod?: string;
+    governingLaw?: Jurisdiction;
+    reservedPowers?: Array<{
+        powerType: 'investment' | 'distribution' | 'amendment' | 'revocation' | 'addition_of_beneficiaries' | 'removal_of_trustees' | 'change_of_governing_law';
+        heldByPersonId?: string;
+        conditions?: string;
+    }>;
+    fleeClause?: {
+        present?: boolean;
+        triggerEvents?: Array<string>;
+        destinationJurisdiction?: Jurisdiction;
+        automaticOrDiscretionary?: 'automatic' | 'discretionary';
+    };
+    protectorPowers?: Array<{
+        powerType: 'consent_to_distribution' | 'remove_trustee' | 'appoint_trustee' | 'change_governing_law' | 'veto_investment' | 'add_beneficiary' | 'exclude_beneficiary' | 'enforce_purpose';
+        protectorPersonId: string;
+        exerciseConditions?: string;
+    }>;
+    jurisdictionalRecognition?: Array<{
+        jurisdiction: Jurisdiction;
+        recognised: boolean;
+        recognisedAs?: string;
+        hagueTrustConventionApplies?: boolean;
+        notes?: string;
+    }>;
+    assetProtectionFeatures?: {
+        selfSettled?: boolean;
+        spendthriftClause?: boolean;
+        fraudulentTransferLookback?: string;
+        domesticationDate?: string;
+    };
+    notes?: string;
+    [key: string]: unknown | string | string | 'discretionary' | 'life_interest' | 'bare' | 'accumulation_and_maintenance' | 'disabled_persons' | 'charitable' | 'nil_rate_band' | 'waqf' | 'other' | Array<TrustAppointee> | Array<TrustBeneficiary> | boolean | string | 'testamentary' | 'inter_vivos_revocable' | 'inter_vivos_irrevocable' | 'revocable' | 'irrevocable' | 'perpetual' | number | Array<string> | Array<string> | Jurisdiction | Array<{
+        powerType: 'investment' | 'distribution' | 'amendment' | 'revocation' | 'addition_of_beneficiaries' | 'removal_of_trustees' | 'change_of_governing_law';
+        heldByPersonId?: string;
+        conditions?: string;
+    }> | {
+        present?: boolean;
+        triggerEvents?: Array<string>;
+        destinationJurisdiction?: Jurisdiction;
+        automaticOrDiscretionary?: 'automatic' | 'discretionary';
+    } | Array<{
+        powerType: 'consent_to_distribution' | 'remove_trustee' | 'appoint_trustee' | 'change_governing_law' | 'veto_investment' | 'add_beneficiary' | 'exclude_beneficiary' | 'enforce_purpose';
+        protectorPersonId: string;
+        exerciseConditions?: string;
+    }> | Array<{
+        jurisdiction: Jurisdiction;
+        recognised: boolean;
+        recognisedAs?: string;
+        hagueTrustConventionApplies?: boolean;
+        notes?: string;
+    }> | {
+        selfSettled?: boolean;
+        spendthriftClause?: boolean;
+        fraudulentTransferLookback?: string;
+        domesticationDate?: string;
+    } | undefined;
+};
+/**
+ * Executor
+ *
+ * A person appointed to administer an estate. Includes professional executors, administrators (intestacy), and administrators with will annexed.
+ */
+export type Executor = {
+    id: string;
+    /**
+     * Reference to a Person.id
+     */
+    personId: string;
+    role: 'primary' | 'secondary' | 'substitute' | 'administrator' | 'administrator_with_will_annexed';
+    isProfessional?: boolean;
+    /**
+     * Firm name if the executor is a professional (solicitor, accountant, trust corporation)
+     */
+    firmName?: string;
+    grantType?: 'grant_of_probate' | 'letters_of_administration' | 'letters_of_administration_with_will_annexed' | 'resealing' | 'european_certificate_of_succession';
+    grantDate?: string;
+    grantReference?: string;
+    issuingCourt?: string;
+    notes?: string;
+    [key: string]: unknown | string | 'primary' | 'secondary' | 'substitute' | 'administrator' | 'administrator_with_will_annexed' | boolean | string | 'grant_of_probate' | 'letters_of_administration' | 'letters_of_administration_with_will_annexed' | 'resealing' | 'european_certificate_of_succession' | string | undefined;
+};
+/**
+ * Guardian
+ *
+ * A guardian appointment for a minor child. Supports testamentary, court-appointed, shariah court, community-appointed, and religious court appointments. Guardianship structures include individual, collective, rotating, and family council determined.
+ */
+export type Guardian = {
+    id: string;
+    /**
+     * Reference to the guardian Person.id
+     */
+    guardianPersonId: string;
+    /**
+     * Reference to the child Person.id
+     */
+    childPersonId: string;
+    role: 'primary' | 'secondary' | 'substitute';
+    appointmentType: 'testamentary' | 'parental_responsibility' | 'court_appointed' | 'shariah_court_appointed' | 'community_appointed' | 'religious_court_appointed';
+    guardianshipStructure?: 'individual' | 'collective' | 'rotating' | 'family_council_determined';
+    familyCouncilDecisionRef?: string;
+    conditions?: string;
+    notes?: string;
+    [key: string]: unknown | string | 'primary' | 'secondary' | 'substitute' | 'testamentary' | 'parental_responsibility' | 'court_appointed' | 'shariah_court_appointed' | 'community_appointed' | 'religious_court_appointed' | 'individual' | 'collective' | 'rotating' | 'family_council_determined' | string | undefined;
+};
+/**
+ * Wish
+ *
+ * A non-binding (or culturally/religiously binding) wish — funeral, letter of wishes, care instructions, pet care, digital estate, distribution preferences.
+ */
+export type Wish = {
+    id: string;
+    type: 'funeral' | 'letter' | 'care' | 'distribution' | 'digital' | 'pets' | 'general';
+    title: string;
+    content?: string;
+    bindingNature?: 'non_binding' | 'culturally_obligatory' | 'religiously_obligatory' | 'legally_binding';
+    /**
+     * Person this wish is addressed to
+     */
+    addresseePersonId?: string;
+    /**
+     * Asset this wish relates to
+     */
+    relatedAssetId?: string;
+    notes?: string;
+    [key: string]: unknown | string | 'funeral' | 'letter' | 'care' | 'distribution' | 'digital' | 'pets' | 'general' | string | 'non_binding' | 'culturally_obligatory' | 'religiously_obligatory' | 'legally_binding' | undefined;
+};
+/**
+ * Document
+ *
+ * A document associated with an estate — wills, codicils, trust deeds, and religious documents (shtar_chov, ketubah_document, nikah_nama, etc.). Type is a free string (minLength 1) to accommodate jurisdiction-specific and religious document types.
+ */
+export type Document = {
+    id: string;
+    type: string;
+    title: string;
+    fileFormat?: string;
+    /**
+     * Storage reference (e.g. S3 URI, file path, or external system reference)
+     */
+    storageRef?: string;
+    fileSizeBytes?: number;
+    mimeType?: string;
+    createdDate?: string;
+    notes?: string;
+    [key: string]: unknown | string | string | string | number | string | undefined;
+};
+/**
+ * Nonprobate Transfer
+ *
+ * Assets that pass outside the probate estate — revocable trusts, TOD deeds, POD accounts, JTWROS, beneficiary designations, superannuation/CPF/EPF nominations.
+ */
+export type NonprobateTransfer = {
+    id: string;
+    type: 'revocable_trust' | 'tod_deed' | 'pod_account' | 'jtwros' | 'tenancy_by_entirety' | 'beneficiary_designation' | 'life_insurance_nomination' | 'superannuation_nomination' | 'cpf_nomination' | 'epf_nomination' | 'mandatory_savings_nomination';
+    designationType?: string;
+    description?: string;
+    trustId?: string;
+    propertyId?: string;
+    assetIds?: Array<string>;
+    beneficiaryPersonIds?: Array<string>;
+    contingentBeneficiaryPersonIds?: Array<string>;
+    survivingOwnerPersonIds?: Array<string>;
+    passesOutsideEstate: boolean;
+    bindingNomination?: boolean;
+    nominationExpiryDate?: string;
+    recordingReference?: string;
+    jurisdiction?: Jurisdiction;
+    notes?: string;
+    [key: string]: unknown | string | 'revocable_trust' | 'tod_deed' | 'pod_account' | 'jtwros' | 'tenancy_by_entirety' | 'beneficiary_designation' | 'life_insurance_nomination' | 'superannuation_nomination' | 'cpf_nomination' | 'epf_nomination' | 'mandatory_savings_nomination' | string | Array<string> | Array<string> | Array<string> | Array<string> | boolean | string | Jurisdiction | undefined;
+};
+export type ConsentRecord = {
+    consentGiven: boolean;
+    consentDate?: string;
+    consentMethod?: 'in_person_verbal' | 'in_person_written' | 'video_recorded' | 'witnessed_verbal' | 'phone_recorded' | 'assumed_cultural_norm';
+    witnesses?: Array<{
+        personId: string;
+        role?: string;
+        witnessedDate?: string;
+    }>;
+    documentRef?: string;
+    notes?: string;
+};
+/**
+ * Proxy Authorisation
+ *
+ * Authorises a proxy to act on behalf of a testator — information gathering, communication, negotiation, or full decision-making. Includes consent record with cultural consent methods.
+ */
+export type ProxyAuthorisation = {
+    id: string;
+    proxyPersonId: string;
+    testatorPersonId: string;
+    scope: 'full' | 'information_gathering' | 'communication' | 'negotiation' | 'decision_making';
+    consentRecord: ConsentRecord;
+    dealerNegotiationPermitted?: boolean;
+    startDate?: string;
+    expiryDate?: string;
+    revocationDate?: string;
+    auditTrailEnabled?: boolean;
+    notes?: string;
+    [key: string]: unknown | string | 'full' | 'information_gathering' | 'communication' | 'negotiation' | 'decision_making' | ConsentRecord | boolean | string | string | undefined;
+};
+export type InterestedParty = {
+    personId?: string;
+    name: string;
+    type: 'art_dealer' | 'antique_dealer' | 'property_investor' | 'auction_house' | 'gallery' | 'private_collector' | 'museum' | 'institution' | 'charity' | 'developer' | 'fund_manager' | 'family_office' | 'estate_agent' | 'solicitor_firm' | 'other';
+    contactDetails?: string;
+};
+export type AssetInterestItem = {
+    assetId?: string;
+    propertyId?: string;
+    interestLevel?: 'exploratory' | 'moderate' | 'strong' | 'committed';
+};
+export type CollectionInterest = unknown & {
+    name?: string;
+    assetIds?: Array<string>;
+    propertyIds?: Array<string>;
+    notes?: string;
+};
+export type OfferDetails = {
+    amount?: Money;
+    conditions?: Array<string>;
+    validUntil?: string;
+    offerDate?: string;
+    documentRef?: string;
+};
+/**
+ * Dealer Interest
+ *
+ * Level D data — records third-party interest in estate assets (art dealers, property investors, collectors). Privacy-controlled. Managed via proxy authorisation.
+ */
+export type DealerInterest = {
+    id: string;
+    interestedParty: InterestedParty;
+    assets?: Array<AssetInterestItem>;
+    collection?: CollectionInterest;
+    offerStatus: 'standing_interest' | 'verbal_offer' | 'written_offer' | 'formal_valuation' | 'conditional_offer' | 'accepted' | 'declined' | 'expired' | 'withdrawn';
+    offerDetails?: OfferDetails;
+    testatorDisposition?: 'willing_to_sell' | 'prefer_not_to_sell' | 'hold_for_executor' | 'deferred_to_family' | 'promised_to_institution' | 'undecided';
+    linkedBequestId?: string;
+    privacyLevel: 'testator_only' | 'proxy_visible' | 'executor_visible' | 'all_parties';
+    communicationInitiatedBy?: 'buyer' | 'testator' | 'proxy' | 'executor';
+    managedByProxyId?: string;
+    notes?: string;
+    [key: string]: unknown | string | InterestedParty | Array<AssetInterestItem> | CollectionInterest | 'standing_interest' | 'verbal_offer' | 'written_offer' | 'formal_valuation' | 'conditional_offer' | 'accepted' | 'declined' | 'expired' | 'withdrawn' | OfferDetails | 'willing_to_sell' | 'prefer_not_to_sell' | 'hold_for_executor' | 'deferred_to_family' | 'promised_to_institution' | 'undecided' | 'testator_only' | 'proxy_visible' | 'executor_visible' | 'all_parties' | 'buyer' | 'testator' | 'proxy' | 'executor' | string | undefined;
+};
+/**
+ * INHERIT v1 Root Schema
+ *
+ * Root entry point for an INHERIT v1 estate data interchange document. Contains a single estate and arrays of all entity types.
+ */
+export type Schema = {
+    inherit: 'https://openinherit.org/v1/schema.json';
+    version: 1;
+    exportedAt?: string;
+    exportedBy?: {
+        name?: string;
+        email?: string;
+        organisationName?: string;
+    };
+    generator?: {
+        name: string;
+        version?: string;
+        url?: string;
+    };
+    estate: Estate;
+    people: Array<Person>;
+    kinships: Array<Kinship>;
+    relationships: Array<Relationship>;
+    properties: Array<Property>;
+    assets: Array<Asset>;
+    liabilities: Array<Liability>;
+    bequests: Array<Bequest>;
+    trusts: Array<Trust>;
+    executors: Array<Executor>;
+    guardians: Array<Guardian>;
+    wishes: Array<Wish>;
+    documents: Array<Document>;
+    nonprobateTransfers: Array<NonprobateTransfer>;
+    proxyAuthorisations: Array<ProxyAuthorisation>;
+    dealerInterests: Array<DealerInterest>;
+    extensions?: Array<string>;
+    [key: string]: unknown | 'https://openinherit.org/v1/schema.json' | 1 | string | {
+        name?: string;
+        email?: string;
+        organisationName?: string;
+    } | {
+        name: string;
+        version?: string;
+        url?: string;
+    } | Estate | Array<Person> | Array<Kinship> | Array<Relationship> | Array<Property> | Array<Asset> | Array<Liability> | Array<Bequest> | Array<Trust> | Array<Executor> | Array<Guardian> | Array<Wish> | Array<Document> | Array<NonprobateTransfer> | Array<ProxyAuthorisation> | Array<DealerInterest> | Array<string> | undefined;
+};
+export type ValidationResult = {
+    valid: boolean;
+    /**
+     * 0 = Invalid, 1 = Schema Valid, 2 = Referentially Intact,
+     * 3 = Jurisdiction Complete
+     *
+     */
+    conformanceLevel: 0 | 1 | 2 | 3;
+    errors: Array<{
+        path: string;
+        message: string;
+        level: 'error' | 'warning' | 'info';
+    }>;
+};
+/**
+ * Unique identifier for the estate (UUID v4)
+ */
+export type EstateId = string;
+/**
+ * Opaque cursor for pagination — use the value returned in the previous response
+ */
+export type Cursor = string;
+/**
+ * Maximum number of items to return (1–100)
+ */
+export type Limit = number;
+export type ListEstatesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Opaque cursor for pagination — use the value returned in the previous response
+         */
+        cursor?: string;
+        /**
+         * Maximum number of items to return (1–100)
+         */
+        limit?: number;
+        /**
+         * Filter by estate status
+         */
+        status?: 'draft' | 'active' | 'locked' | 'archived';
+        /**
+         * Filter by jurisdiction code (ISO 3166-2)
+         */
+        jurisdiction?: string;
+    };
+    url: '/estates';
+};
+export type ListEstatesResponses = {
+    /**
+     * Paginated list of estates
+     */
+    200: PaginatedEstateList;
+};
+export type ListEstatesResponse = ListEstatesResponses[keyof ListEstatesResponses];
+export type CreateEstateData = {
+    body: Estate;
+    path?: never;
+    query?: never;
+    url: '/estates';
+};
+export type CreateEstateErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateEstateError = CreateEstateErrors[keyof CreateEstateErrors];
+export type CreateEstateResponses = {
+    /**
+     * Estate created successfully
+     */
+    201: Estate;
+};
+export type CreateEstateResponse = CreateEstateResponses[keyof CreateEstateResponses];
+export type DeleteEstateData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}';
+};
+export type DeleteEstateErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteEstateError = DeleteEstateErrors[keyof DeleteEstateErrors];
+export type DeleteEstateResponses = {
+    /**
+     * Estate deleted successfully
+     */
+    204: void;
+};
+export type DeleteEstateResponse = DeleteEstateResponses[keyof DeleteEstateResponses];
+export type GetEstateData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}';
+};
+export type GetEstateErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetEstateError = GetEstateErrors[keyof GetEstateErrors];
+export type GetEstateResponses = {
+    /**
+     * Estate retrieved successfully
+     */
+    200: Estate;
+};
+export type GetEstateResponse = GetEstateResponses[keyof GetEstateResponses];
+export type UpdateEstateData = {
+    body: Estate;
+    headers?: {
+        /**
+         * ETag value from a previous response for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}';
+};
+export type UpdateEstateErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+    /**
+     * Precondition failed — ETag mismatch
+     */
+    412: Error;
+};
+export type UpdateEstateError = UpdateEstateErrors[keyof UpdateEstateErrors];
+export type UpdateEstateResponses = {
+    /**
+     * Estate updated successfully
+     */
+    200: Estate;
+};
+export type UpdateEstateResponse = UpdateEstateResponses[keyof UpdateEstateResponses];
+export type ListPeopleData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/people';
+};
+export type ListPeopleResponses = {
+    /**
+     * List of people
+     */
+    200: {
+        items: Array<Person>;
+    };
+};
+export type ListPeopleResponse = ListPeopleResponses[keyof ListPeopleResponses];
+export type CreatePersonData = {
+    body: Person;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/people';
+};
+export type CreatePersonErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreatePersonError = CreatePersonErrors[keyof CreatePersonErrors];
+export type CreatePersonResponses = {
+    /**
+     * Person created successfully
+     */
+    201: Person;
+};
+export type CreatePersonResponse = CreatePersonResponses[keyof CreatePersonResponses];
+export type DeletePersonData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the person (UUID v4)
+         */
+        personId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/people/{personId}';
+};
+export type DeletePersonErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+    /**
+     * The request conflicts with the current state of the resource
+     */
+    409: Error;
+};
+export type DeletePersonError = DeletePersonErrors[keyof DeletePersonErrors];
+export type DeletePersonResponses = {
+    /**
+     * Person deleted successfully
+     */
+    204: void;
+};
+export type DeletePersonResponse = DeletePersonResponses[keyof DeletePersonResponses];
+export type GetPersonData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the person (UUID v4)
+         */
+        personId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/people/{personId}';
+};
+export type GetPersonErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetPersonError = GetPersonErrors[keyof GetPersonErrors];
+export type GetPersonResponses = {
+    /**
+     * Person retrieved successfully
+     */
+    200: Person;
+};
+export type GetPersonResponse = GetPersonResponses[keyof GetPersonResponses];
+export type UpdatePersonData = {
+    body: Person;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the person (UUID v4)
+         */
+        personId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/people/{personId}';
+};
+export type UpdatePersonErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdatePersonError = UpdatePersonErrors[keyof UpdatePersonErrors];
+export type UpdatePersonResponses = {
+    /**
+     * Person updated successfully
+     */
+    200: Person;
+};
+export type UpdatePersonResponse = UpdatePersonResponses[keyof UpdatePersonResponses];
+export type ReplacePersonData = {
+    body: Person;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the person (UUID v4)
+         */
+        personId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/people/{personId}';
+};
+export type ReplacePersonErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplacePersonError = ReplacePersonErrors[keyof ReplacePersonErrors];
+export type ReplacePersonResponses = {
+    /**
+     * Person replaced successfully
+     */
+    200: Person;
+};
+export type ReplacePersonResponse = ReplacePersonResponses[keyof ReplacePersonResponses];
+export type ListRelationshipsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/relationships';
+};
+export type ListRelationshipsResponses = {
+    /**
+     * List of relationships
+     */
+    200: {
+        items: Array<Relationship>;
+    };
+};
+export type ListRelationshipsResponse = ListRelationshipsResponses[keyof ListRelationshipsResponses];
+export type CreateRelationshipData = {
+    body: Relationship;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/relationships';
+};
+export type CreateRelationshipErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateRelationshipError = CreateRelationshipErrors[keyof CreateRelationshipErrors];
+export type CreateRelationshipResponses = {
+    /**
+     * Relationship created successfully
+     */
+    201: Relationship;
+};
+export type CreateRelationshipResponse = CreateRelationshipResponses[keyof CreateRelationshipResponses];
+export type DeleteRelationshipData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the relationship (UUID v4)
+         */
+        relationshipId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/relationships/{relationshipId}';
+};
+export type DeleteRelationshipErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteRelationshipError = DeleteRelationshipErrors[keyof DeleteRelationshipErrors];
+export type DeleteRelationshipResponses = {
+    /**
+     * Relationship deleted successfully
+     */
+    204: void;
+};
+export type DeleteRelationshipResponse = DeleteRelationshipResponses[keyof DeleteRelationshipResponses];
+export type GetRelationshipData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the relationship (UUID v4)
+         */
+        relationshipId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/relationships/{relationshipId}';
+};
+export type GetRelationshipErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetRelationshipError = GetRelationshipErrors[keyof GetRelationshipErrors];
+export type GetRelationshipResponses = {
+    /**
+     * Relationship retrieved successfully
+     */
+    200: Relationship;
+};
+export type GetRelationshipResponse = GetRelationshipResponses[keyof GetRelationshipResponses];
+export type UpdateRelationshipData = {
+    body: Relationship;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the relationship (UUID v4)
+         */
+        relationshipId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/relationships/{relationshipId}';
+};
+export type UpdateRelationshipErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateRelationshipError = UpdateRelationshipErrors[keyof UpdateRelationshipErrors];
+export type UpdateRelationshipResponses = {
+    /**
+     * Relationship updated successfully
+     */
+    200: Relationship;
+};
+export type UpdateRelationshipResponse = UpdateRelationshipResponses[keyof UpdateRelationshipResponses];
+export type ReplaceRelationshipData = {
+    body: Relationship;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the relationship (UUID v4)
+         */
+        relationshipId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/relationships/{relationshipId}';
+};
+export type ReplaceRelationshipErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceRelationshipError = ReplaceRelationshipErrors[keyof ReplaceRelationshipErrors];
+export type ReplaceRelationshipResponses = {
+    /**
+     * Relationship replaced successfully
+     */
+    200: Relationship;
+};
+export type ReplaceRelationshipResponse = ReplaceRelationshipResponses[keyof ReplaceRelationshipResponses];
+export type ListKinshipsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/kinships';
+};
+export type ListKinshipsResponses = {
+    /**
+     * List of kinships
+     */
+    200: {
+        items: Array<Kinship>;
+    };
+};
+export type ListKinshipsResponse = ListKinshipsResponses[keyof ListKinshipsResponses];
+export type CreateKinshipData = {
+    body: Kinship;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/kinships';
+};
+export type CreateKinshipErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateKinshipError = CreateKinshipErrors[keyof CreateKinshipErrors];
+export type CreateKinshipResponses = {
+    /**
+     * Kinship created successfully
+     */
+    201: Kinship;
+};
+export type CreateKinshipResponse = CreateKinshipResponses[keyof CreateKinshipResponses];
+export type DeleteKinshipData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the kinship (UUID v4)
+         */
+        kinshipId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/kinships/{kinshipId}';
+};
+export type DeleteKinshipErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteKinshipError = DeleteKinshipErrors[keyof DeleteKinshipErrors];
+export type DeleteKinshipResponses = {
+    /**
+     * Kinship deleted successfully
+     */
+    204: void;
+};
+export type DeleteKinshipResponse = DeleteKinshipResponses[keyof DeleteKinshipResponses];
+export type GetKinshipData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the kinship (UUID v4)
+         */
+        kinshipId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/kinships/{kinshipId}';
+};
+export type GetKinshipErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetKinshipError = GetKinshipErrors[keyof GetKinshipErrors];
+export type GetKinshipResponses = {
+    /**
+     * Kinship retrieved successfully
+     */
+    200: Kinship;
+};
+export type GetKinshipResponse = GetKinshipResponses[keyof GetKinshipResponses];
+export type UpdateKinshipData = {
+    body: Kinship;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the kinship (UUID v4)
+         */
+        kinshipId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/kinships/{kinshipId}';
+};
+export type UpdateKinshipErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateKinshipError = UpdateKinshipErrors[keyof UpdateKinshipErrors];
+export type UpdateKinshipResponses = {
+    /**
+     * Kinship updated successfully
+     */
+    200: Kinship;
+};
+export type UpdateKinshipResponse = UpdateKinshipResponses[keyof UpdateKinshipResponses];
+export type ReplaceKinshipData = {
+    body: Kinship;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the kinship (UUID v4)
+         */
+        kinshipId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/kinships/{kinshipId}';
+};
+export type ReplaceKinshipErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceKinshipError = ReplaceKinshipErrors[keyof ReplaceKinshipErrors];
+export type ReplaceKinshipResponses = {
+    /**
+     * Kinship replaced successfully
+     */
+    200: Kinship;
+};
+export type ReplaceKinshipResponse = ReplaceKinshipResponses[keyof ReplaceKinshipResponses];
+export type ListPropertiesData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/properties';
+};
+export type ListPropertiesResponses = {
+    /**
+     * List of properties
+     */
+    200: {
+        items: Array<Property>;
+    };
+};
+export type ListPropertiesResponse = ListPropertiesResponses[keyof ListPropertiesResponses];
+export type CreatePropertyData = {
+    body: Property;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/properties';
+};
+export type CreatePropertyErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreatePropertyError = CreatePropertyErrors[keyof CreatePropertyErrors];
+export type CreatePropertyResponses = {
+    /**
+     * Property created successfully
+     */
+    201: Property;
+};
+export type CreatePropertyResponse = CreatePropertyResponses[keyof CreatePropertyResponses];
+export type DeletePropertyData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the property (UUID v4)
+         */
+        propertyId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/properties/{propertyId}';
+};
+export type DeletePropertyErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+    /**
+     * The request conflicts with the current state of the resource
+     */
+    409: Error;
+};
+export type DeletePropertyError = DeletePropertyErrors[keyof DeletePropertyErrors];
+export type DeletePropertyResponses = {
+    /**
+     * Property deleted successfully
+     */
+    204: void;
+};
+export type DeletePropertyResponse = DeletePropertyResponses[keyof DeletePropertyResponses];
+export type GetPropertyData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the property (UUID v4)
+         */
+        propertyId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/properties/{propertyId}';
+};
+export type GetPropertyErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetPropertyError = GetPropertyErrors[keyof GetPropertyErrors];
+export type GetPropertyResponses = {
+    /**
+     * Property retrieved successfully
+     */
+    200: Property;
+};
+export type GetPropertyResponse = GetPropertyResponses[keyof GetPropertyResponses];
+export type UpdatePropertyData = {
+    body: Property;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the property (UUID v4)
+         */
+        propertyId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/properties/{propertyId}';
+};
+export type UpdatePropertyErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdatePropertyError = UpdatePropertyErrors[keyof UpdatePropertyErrors];
+export type UpdatePropertyResponses = {
+    /**
+     * Property updated successfully
+     */
+    200: Property;
+};
+export type UpdatePropertyResponse = UpdatePropertyResponses[keyof UpdatePropertyResponses];
+export type ReplacePropertyData = {
+    body: Property;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the property (UUID v4)
+         */
+        propertyId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/properties/{propertyId}';
+};
+export type ReplacePropertyErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplacePropertyError = ReplacePropertyErrors[keyof ReplacePropertyErrors];
+export type ReplacePropertyResponses = {
+    /**
+     * Property replaced successfully
+     */
+    200: Property;
+};
+export type ReplacePropertyResponse = ReplacePropertyResponses[keyof ReplacePropertyResponses];
+export type ListAssetsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/assets';
+};
+export type ListAssetsResponses = {
+    /**
+     * List of assets
+     */
+    200: {
+        items: Array<Asset>;
+    };
+};
+export type ListAssetsResponse = ListAssetsResponses[keyof ListAssetsResponses];
+export type CreateAssetData = {
+    body: Asset;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/assets';
+};
+export type CreateAssetErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateAssetError = CreateAssetErrors[keyof CreateAssetErrors];
+export type CreateAssetResponses = {
+    /**
+     * Asset created successfully
+     */
+    201: Asset;
+};
+export type CreateAssetResponse = CreateAssetResponses[keyof CreateAssetResponses];
+export type DeleteAssetData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the asset (UUID v4)
+         */
+        assetId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/assets/{assetId}';
+};
+export type DeleteAssetErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+    /**
+     * The request conflicts with the current state of the resource
+     */
+    409: Error;
+};
+export type DeleteAssetError = DeleteAssetErrors[keyof DeleteAssetErrors];
+export type DeleteAssetResponses = {
+    /**
+     * Asset deleted successfully
+     */
+    204: void;
+};
+export type DeleteAssetResponse = DeleteAssetResponses[keyof DeleteAssetResponses];
+export type GetAssetData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the asset (UUID v4)
+         */
+        assetId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/assets/{assetId}';
+};
+export type GetAssetErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetAssetError = GetAssetErrors[keyof GetAssetErrors];
+export type GetAssetResponses = {
+    /**
+     * Asset retrieved successfully
+     */
+    200: Asset;
+};
+export type GetAssetResponse = GetAssetResponses[keyof GetAssetResponses];
+export type UpdateAssetData = {
+    body: Asset;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the asset (UUID v4)
+         */
+        assetId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/assets/{assetId}';
+};
+export type UpdateAssetErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateAssetError = UpdateAssetErrors[keyof UpdateAssetErrors];
+export type UpdateAssetResponses = {
+    /**
+     * Asset updated successfully
+     */
+    200: Asset;
+};
+export type UpdateAssetResponse = UpdateAssetResponses[keyof UpdateAssetResponses];
+export type ReplaceAssetData = {
+    body: Asset;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the asset (UUID v4)
+         */
+        assetId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/assets/{assetId}';
+};
+export type ReplaceAssetErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceAssetError = ReplaceAssetErrors[keyof ReplaceAssetErrors];
+export type ReplaceAssetResponses = {
+    /**
+     * Asset replaced successfully
+     */
+    200: Asset;
+};
+export type ReplaceAssetResponse = ReplaceAssetResponses[keyof ReplaceAssetResponses];
+export type ListLiabilitiesData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/liabilities';
+};
+export type ListLiabilitiesResponses = {
+    /**
+     * List of liabilities
+     */
+    200: {
+        items: Array<Liability>;
+    };
+};
+export type ListLiabilitiesResponse = ListLiabilitiesResponses[keyof ListLiabilitiesResponses];
+export type CreateLiabilityData = {
+    body: Liability;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/liabilities';
+};
+export type CreateLiabilityErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateLiabilityError = CreateLiabilityErrors[keyof CreateLiabilityErrors];
+export type CreateLiabilityResponses = {
+    /**
+     * Liability created successfully
+     */
+    201: Liability;
+};
+export type CreateLiabilityResponse = CreateLiabilityResponses[keyof CreateLiabilityResponses];
+export type DeleteLiabilityData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the liability (UUID v4)
+         */
+        liabilityId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/liabilities/{liabilityId}';
+};
+export type DeleteLiabilityErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteLiabilityError = DeleteLiabilityErrors[keyof DeleteLiabilityErrors];
+export type DeleteLiabilityResponses = {
+    /**
+     * Liability deleted successfully
+     */
+    204: void;
+};
+export type DeleteLiabilityResponse = DeleteLiabilityResponses[keyof DeleteLiabilityResponses];
+export type GetLiabilityData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the liability (UUID v4)
+         */
+        liabilityId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/liabilities/{liabilityId}';
+};
+export type GetLiabilityErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetLiabilityError = GetLiabilityErrors[keyof GetLiabilityErrors];
+export type GetLiabilityResponses = {
+    /**
+     * Liability retrieved successfully
+     */
+    200: Liability;
+};
+export type GetLiabilityResponse = GetLiabilityResponses[keyof GetLiabilityResponses];
+export type UpdateLiabilityData = {
+    body: Liability;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the liability (UUID v4)
+         */
+        liabilityId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/liabilities/{liabilityId}';
+};
+export type UpdateLiabilityErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateLiabilityError = UpdateLiabilityErrors[keyof UpdateLiabilityErrors];
+export type UpdateLiabilityResponses = {
+    /**
+     * Liability updated successfully
+     */
+    200: Liability;
+};
+export type UpdateLiabilityResponse = UpdateLiabilityResponses[keyof UpdateLiabilityResponses];
+export type ReplaceLiabilityData = {
+    body: Liability;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the liability (UUID v4)
+         */
+        liabilityId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/liabilities/{liabilityId}';
+};
+export type ReplaceLiabilityErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceLiabilityError = ReplaceLiabilityErrors[keyof ReplaceLiabilityErrors];
+export type ReplaceLiabilityResponses = {
+    /**
+     * Liability replaced successfully
+     */
+    200: Liability;
+};
+export type ReplaceLiabilityResponse = ReplaceLiabilityResponses[keyof ReplaceLiabilityResponses];
+export type ListBequestsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/bequests';
+};
+export type ListBequestsResponses = {
+    /**
+     * List of bequests
+     */
+    200: {
+        items: Array<Bequest>;
+    };
+};
+export type ListBequestsResponse = ListBequestsResponses[keyof ListBequestsResponses];
+export type CreateBequestData = {
+    body: Bequest;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/bequests';
+};
+export type CreateBequestErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateBequestError = CreateBequestErrors[keyof CreateBequestErrors];
+export type CreateBequestResponses = {
+    /**
+     * Bequest created successfully
+     */
+    201: Bequest;
+};
+export type CreateBequestResponse = CreateBequestResponses[keyof CreateBequestResponses];
+export type DeleteBequestData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the bequest (UUID v4)
+         */
+        bequestId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/bequests/{bequestId}';
+};
+export type DeleteBequestErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteBequestError = DeleteBequestErrors[keyof DeleteBequestErrors];
+export type DeleteBequestResponses = {
+    /**
+     * Bequest deleted successfully
+     */
+    204: void;
+};
+export type DeleteBequestResponse = DeleteBequestResponses[keyof DeleteBequestResponses];
+export type GetBequestData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the bequest (UUID v4)
+         */
+        bequestId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/bequests/{bequestId}';
+};
+export type GetBequestErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetBequestError = GetBequestErrors[keyof GetBequestErrors];
+export type GetBequestResponses = {
+    /**
+     * Bequest retrieved successfully
+     */
+    200: Bequest;
+};
+export type GetBequestResponse = GetBequestResponses[keyof GetBequestResponses];
+export type UpdateBequestData = {
+    body: Bequest;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the bequest (UUID v4)
+         */
+        bequestId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/bequests/{bequestId}';
+};
+export type UpdateBequestErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateBequestError = UpdateBequestErrors[keyof UpdateBequestErrors];
+export type UpdateBequestResponses = {
+    /**
+     * Bequest updated successfully
+     */
+    200: Bequest;
+};
+export type UpdateBequestResponse = UpdateBequestResponses[keyof UpdateBequestResponses];
+export type ReplaceBequestData = {
+    body: Bequest;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the bequest (UUID v4)
+         */
+        bequestId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/bequests/{bequestId}';
+};
+export type ReplaceBequestErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceBequestError = ReplaceBequestErrors[keyof ReplaceBequestErrors];
+export type ReplaceBequestResponses = {
+    /**
+     * Bequest replaced successfully
+     */
+    200: Bequest;
+};
+export type ReplaceBequestResponse = ReplaceBequestResponses[keyof ReplaceBequestResponses];
+export type ListTrustsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/trusts';
+};
+export type ListTrustsResponses = {
+    /**
+     * List of trusts
+     */
+    200: {
+        items: Array<Trust>;
+    };
+};
+export type ListTrustsResponse = ListTrustsResponses[keyof ListTrustsResponses];
+export type CreateTrustData = {
+    body: Trust;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/trusts';
+};
+export type CreateTrustErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateTrustError = CreateTrustErrors[keyof CreateTrustErrors];
+export type CreateTrustResponses = {
+    /**
+     * Trust created successfully
+     */
+    201: Trust;
+};
+export type CreateTrustResponse = CreateTrustResponses[keyof CreateTrustResponses];
+export type DeleteTrustData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the trust (UUID v4)
+         */
+        trustId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/trusts/{trustId}';
+};
+export type DeleteTrustErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteTrustError = DeleteTrustErrors[keyof DeleteTrustErrors];
+export type DeleteTrustResponses = {
+    /**
+     * Trust deleted successfully
+     */
+    204: void;
+};
+export type DeleteTrustResponse = DeleteTrustResponses[keyof DeleteTrustResponses];
+export type GetTrustData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the trust (UUID v4)
+         */
+        trustId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/trusts/{trustId}';
+};
+export type GetTrustErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetTrustError = GetTrustErrors[keyof GetTrustErrors];
+export type GetTrustResponses = {
+    /**
+     * Trust retrieved successfully
+     */
+    200: Trust;
+};
+export type GetTrustResponse = GetTrustResponses[keyof GetTrustResponses];
+export type UpdateTrustData = {
+    body: Trust;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the trust (UUID v4)
+         */
+        trustId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/trusts/{trustId}';
+};
+export type UpdateTrustErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateTrustError = UpdateTrustErrors[keyof UpdateTrustErrors];
+export type UpdateTrustResponses = {
+    /**
+     * Trust updated successfully
+     */
+    200: Trust;
+};
+export type UpdateTrustResponse = UpdateTrustResponses[keyof UpdateTrustResponses];
+export type ReplaceTrustData = {
+    body: Trust;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the trust (UUID v4)
+         */
+        trustId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/trusts/{trustId}';
+};
+export type ReplaceTrustErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceTrustError = ReplaceTrustErrors[keyof ReplaceTrustErrors];
+export type ReplaceTrustResponses = {
+    /**
+     * Trust replaced successfully
+     */
+    200: Trust;
+};
+export type ReplaceTrustResponse = ReplaceTrustResponses[keyof ReplaceTrustResponses];
+export type ListExecutorsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/executors';
+};
+export type ListExecutorsResponses = {
+    /**
+     * List of executors
+     */
+    200: {
+        items: Array<Executor>;
+    };
+};
+export type ListExecutorsResponse = ListExecutorsResponses[keyof ListExecutorsResponses];
+export type CreateExecutorData = {
+    body: Executor;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/executors';
+};
+export type CreateExecutorErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateExecutorError = CreateExecutorErrors[keyof CreateExecutorErrors];
+export type CreateExecutorResponses = {
+    /**
+     * Executor created successfully
+     */
+    201: Executor;
+};
+export type CreateExecutorResponse = CreateExecutorResponses[keyof CreateExecutorResponses];
+export type DeleteExecutorData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the executor (UUID v4)
+         */
+        executorId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/executors/{executorId}';
+};
+export type DeleteExecutorErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteExecutorError = DeleteExecutorErrors[keyof DeleteExecutorErrors];
+export type DeleteExecutorResponses = {
+    /**
+     * Executor deleted successfully
+     */
+    204: void;
+};
+export type DeleteExecutorResponse = DeleteExecutorResponses[keyof DeleteExecutorResponses];
+export type GetExecutorData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the executor (UUID v4)
+         */
+        executorId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/executors/{executorId}';
+};
+export type GetExecutorErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetExecutorError = GetExecutorErrors[keyof GetExecutorErrors];
+export type GetExecutorResponses = {
+    /**
+     * Executor retrieved successfully
+     */
+    200: Executor;
+};
+export type GetExecutorResponse = GetExecutorResponses[keyof GetExecutorResponses];
+export type UpdateExecutorData = {
+    body: Executor;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the executor (UUID v4)
+         */
+        executorId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/executors/{executorId}';
+};
+export type UpdateExecutorErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateExecutorError = UpdateExecutorErrors[keyof UpdateExecutorErrors];
+export type UpdateExecutorResponses = {
+    /**
+     * Executor updated successfully
+     */
+    200: Executor;
+};
+export type UpdateExecutorResponse = UpdateExecutorResponses[keyof UpdateExecutorResponses];
+export type ReplaceExecutorData = {
+    body: Executor;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the executor (UUID v4)
+         */
+        executorId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/executors/{executorId}';
+};
+export type ReplaceExecutorErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceExecutorError = ReplaceExecutorErrors[keyof ReplaceExecutorErrors];
+export type ReplaceExecutorResponses = {
+    /**
+     * Executor replaced successfully
+     */
+    200: Executor;
+};
+export type ReplaceExecutorResponse = ReplaceExecutorResponses[keyof ReplaceExecutorResponses];
+export type ListGuardiansData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/guardians';
+};
+export type ListGuardiansResponses = {
+    /**
+     * List of guardians
+     */
+    200: {
+        items: Array<Guardian>;
+    };
+};
+export type ListGuardiansResponse = ListGuardiansResponses[keyof ListGuardiansResponses];
+export type CreateGuardianData = {
+    body: Guardian;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/guardians';
+};
+export type CreateGuardianErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateGuardianError = CreateGuardianErrors[keyof CreateGuardianErrors];
+export type CreateGuardianResponses = {
+    /**
+     * Guardian created successfully
+     */
+    201: Guardian;
+};
+export type CreateGuardianResponse = CreateGuardianResponses[keyof CreateGuardianResponses];
+export type DeleteGuardianData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the guardian (UUID v4)
+         */
+        guardianId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/guardians/{guardianId}';
+};
+export type DeleteGuardianErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteGuardianError = DeleteGuardianErrors[keyof DeleteGuardianErrors];
+export type DeleteGuardianResponses = {
+    /**
+     * Guardian deleted successfully
+     */
+    204: void;
+};
+export type DeleteGuardianResponse = DeleteGuardianResponses[keyof DeleteGuardianResponses];
+export type GetGuardianData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the guardian (UUID v4)
+         */
+        guardianId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/guardians/{guardianId}';
+};
+export type GetGuardianErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetGuardianError = GetGuardianErrors[keyof GetGuardianErrors];
+export type GetGuardianResponses = {
+    /**
+     * Guardian retrieved successfully
+     */
+    200: Guardian;
+};
+export type GetGuardianResponse = GetGuardianResponses[keyof GetGuardianResponses];
+export type UpdateGuardianData = {
+    body: Guardian;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the guardian (UUID v4)
+         */
+        guardianId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/guardians/{guardianId}';
+};
+export type UpdateGuardianErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateGuardianError = UpdateGuardianErrors[keyof UpdateGuardianErrors];
+export type UpdateGuardianResponses = {
+    /**
+     * Guardian updated successfully
+     */
+    200: Guardian;
+};
+export type UpdateGuardianResponse = UpdateGuardianResponses[keyof UpdateGuardianResponses];
+export type ReplaceGuardianData = {
+    body: Guardian;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the guardian (UUID v4)
+         */
+        guardianId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/guardians/{guardianId}';
+};
+export type ReplaceGuardianErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceGuardianError = ReplaceGuardianErrors[keyof ReplaceGuardianErrors];
+export type ReplaceGuardianResponses = {
+    /**
+     * Guardian replaced successfully
+     */
+    200: Guardian;
+};
+export type ReplaceGuardianResponse = ReplaceGuardianResponses[keyof ReplaceGuardianResponses];
+export type ListWishesData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/wishes';
+};
+export type ListWishesResponses = {
+    /**
+     * List of wishes
+     */
+    200: {
+        items: Array<Wish>;
+    };
+};
+export type ListWishesResponse = ListWishesResponses[keyof ListWishesResponses];
+export type CreateWishData = {
+    body: Wish;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/wishes';
+};
+export type CreateWishErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateWishError = CreateWishErrors[keyof CreateWishErrors];
+export type CreateWishResponses = {
+    /**
+     * Wish created successfully
+     */
+    201: Wish;
+};
+export type CreateWishResponse = CreateWishResponses[keyof CreateWishResponses];
+export type DeleteWishData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the wish (UUID v4)
+         */
+        wishId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/wishes/{wishId}';
+};
+export type DeleteWishErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteWishError = DeleteWishErrors[keyof DeleteWishErrors];
+export type DeleteWishResponses = {
+    /**
+     * Wish deleted successfully
+     */
+    204: void;
+};
+export type DeleteWishResponse = DeleteWishResponses[keyof DeleteWishResponses];
+export type GetWishData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the wish (UUID v4)
+         */
+        wishId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/wishes/{wishId}';
+};
+export type GetWishErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetWishError = GetWishErrors[keyof GetWishErrors];
+export type GetWishResponses = {
+    /**
+     * Wish retrieved successfully
+     */
+    200: Wish;
+};
+export type GetWishResponse = GetWishResponses[keyof GetWishResponses];
+export type UpdateWishData = {
+    body: Wish;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the wish (UUID v4)
+         */
+        wishId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/wishes/{wishId}';
+};
+export type UpdateWishErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateWishError = UpdateWishErrors[keyof UpdateWishErrors];
+export type UpdateWishResponses = {
+    /**
+     * Wish updated successfully
+     */
+    200: Wish;
+};
+export type UpdateWishResponse = UpdateWishResponses[keyof UpdateWishResponses];
+export type ReplaceWishData = {
+    body: Wish;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the wish (UUID v4)
+         */
+        wishId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/wishes/{wishId}';
+};
+export type ReplaceWishErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceWishError = ReplaceWishErrors[keyof ReplaceWishErrors];
+export type ReplaceWishResponses = {
+    /**
+     * Wish replaced successfully
+     */
+    200: Wish;
+};
+export type ReplaceWishResponse = ReplaceWishResponses[keyof ReplaceWishResponses];
+export type ListDocumentsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/documents';
+};
+export type ListDocumentsResponses = {
+    /**
+     * List of documents
+     */
+    200: {
+        items: Array<Document>;
+    };
+};
+export type ListDocumentsResponse = ListDocumentsResponses[keyof ListDocumentsResponses];
+export type CreateDocumentData = {
+    body: Document;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/documents';
+};
+export type CreateDocumentErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateDocumentError = CreateDocumentErrors[keyof CreateDocumentErrors];
+export type CreateDocumentResponses = {
+    /**
+     * Document created successfully
+     */
+    201: Document;
+};
+export type CreateDocumentResponse = CreateDocumentResponses[keyof CreateDocumentResponses];
+export type DeleteDocumentData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the document (UUID v4)
+         */
+        documentId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/documents/{documentId}';
+};
+export type DeleteDocumentErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteDocumentError = DeleteDocumentErrors[keyof DeleteDocumentErrors];
+export type DeleteDocumentResponses = {
+    /**
+     * Document deleted successfully
+     */
+    204: void;
+};
+export type DeleteDocumentResponse = DeleteDocumentResponses[keyof DeleteDocumentResponses];
+export type GetDocumentData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the document (UUID v4)
+         */
+        documentId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/documents/{documentId}';
+};
+export type GetDocumentErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetDocumentError = GetDocumentErrors[keyof GetDocumentErrors];
+export type GetDocumentResponses = {
+    /**
+     * Document retrieved successfully
+     */
+    200: Document;
+};
+export type GetDocumentResponse = GetDocumentResponses[keyof GetDocumentResponses];
+export type UpdateDocumentData = {
+    body: Document;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the document (UUID v4)
+         */
+        documentId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/documents/{documentId}';
+};
+export type UpdateDocumentErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateDocumentError = UpdateDocumentErrors[keyof UpdateDocumentErrors];
+export type UpdateDocumentResponses = {
+    /**
+     * Document updated successfully
+     */
+    200: Document;
+};
+export type UpdateDocumentResponse = UpdateDocumentResponses[keyof UpdateDocumentResponses];
+export type ReplaceDocumentData = {
+    body: Document;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the document (UUID v4)
+         */
+        documentId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/documents/{documentId}';
+};
+export type ReplaceDocumentErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceDocumentError = ReplaceDocumentErrors[keyof ReplaceDocumentErrors];
+export type ReplaceDocumentResponses = {
+    /**
+     * Document replaced successfully
+     */
+    200: Document;
+};
+export type ReplaceDocumentResponse = ReplaceDocumentResponses[keyof ReplaceDocumentResponses];
+export type ListAttestationsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/attestations';
+};
+export type ListAttestationsResponses = {
+    /**
+     * List of attestations
+     */
+    200: {
+        items: Array<Attestation>;
+    };
+};
+export type ListAttestationsResponse = ListAttestationsResponses[keyof ListAttestationsResponses];
+export type CreateAttestationData = {
+    body: Attestation;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/attestations';
+};
+export type CreateAttestationErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateAttestationError = CreateAttestationErrors[keyof CreateAttestationErrors];
+export type CreateAttestationResponses = {
+    /**
+     * Attestation created successfully
+     */
+    201: Attestation;
+};
+export type CreateAttestationResponse = CreateAttestationResponses[keyof CreateAttestationResponses];
+export type DeleteAttestationData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the attestation (UUID v4)
+         */
+        attestationId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/attestations/{attestationId}';
+};
+export type DeleteAttestationErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteAttestationError = DeleteAttestationErrors[keyof DeleteAttestationErrors];
+export type DeleteAttestationResponses = {
+    /**
+     * Attestation deleted successfully
+     */
+    204: void;
+};
+export type DeleteAttestationResponse = DeleteAttestationResponses[keyof DeleteAttestationResponses];
+export type GetAttestationData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the attestation (UUID v4)
+         */
+        attestationId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/attestations/{attestationId}';
+};
+export type GetAttestationErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetAttestationError = GetAttestationErrors[keyof GetAttestationErrors];
+export type GetAttestationResponses = {
+    /**
+     * Attestation retrieved successfully
+     */
+    200: Attestation;
+};
+export type GetAttestationResponse = GetAttestationResponses[keyof GetAttestationResponses];
+export type UpdateAttestationData = {
+    body: Attestation;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the attestation (UUID v4)
+         */
+        attestationId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/attestations/{attestationId}';
+};
+export type UpdateAttestationErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateAttestationError = UpdateAttestationErrors[keyof UpdateAttestationErrors];
+export type UpdateAttestationResponses = {
+    /**
+     * Attestation updated successfully
+     */
+    200: Attestation;
+};
+export type UpdateAttestationResponse = UpdateAttestationResponses[keyof UpdateAttestationResponses];
+export type ReplaceAttestationData = {
+    body: Attestation;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the attestation (UUID v4)
+         */
+        attestationId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/attestations/{attestationId}';
+};
+export type ReplaceAttestationErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceAttestationError = ReplaceAttestationErrors[keyof ReplaceAttestationErrors];
+export type ReplaceAttestationResponses = {
+    /**
+     * Attestation replaced successfully
+     */
+    200: Attestation;
+};
+export type ReplaceAttestationResponse = ReplaceAttestationResponses[keyof ReplaceAttestationResponses];
+export type ListNonprobateTransfersData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/nonprobate-transfers';
+};
+export type ListNonprobateTransfersResponses = {
+    /**
+     * List of nonprobate transfers
+     */
+    200: {
+        items: Array<NonprobateTransfer>;
+    };
+};
+export type ListNonprobateTransfersResponse = ListNonprobateTransfersResponses[keyof ListNonprobateTransfersResponses];
+export type CreateNonprobateTransferData = {
+    body: NonprobateTransfer;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/nonprobate-transfers';
+};
+export type CreateNonprobateTransferErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateNonprobateTransferError = CreateNonprobateTransferErrors[keyof CreateNonprobateTransferErrors];
+export type CreateNonprobateTransferResponses = {
+    /**
+     * NonprobateTransfer created successfully
+     */
+    201: NonprobateTransfer;
+};
+export type CreateNonprobateTransferResponse = CreateNonprobateTransferResponses[keyof CreateNonprobateTransferResponses];
+export type DeleteNonprobateTransferData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the nonprobate transfer (UUID v4)
+         */
+        transferId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/nonprobate-transfers/{transferId}';
+};
+export type DeleteNonprobateTransferErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteNonprobateTransferError = DeleteNonprobateTransferErrors[keyof DeleteNonprobateTransferErrors];
+export type DeleteNonprobateTransferResponses = {
+    /**
+     * NonprobateTransfer deleted successfully
+     */
+    204: void;
+};
+export type DeleteNonprobateTransferResponse = DeleteNonprobateTransferResponses[keyof DeleteNonprobateTransferResponses];
+export type GetNonprobateTransferData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the nonprobate transfer (UUID v4)
+         */
+        transferId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/nonprobate-transfers/{transferId}';
+};
+export type GetNonprobateTransferErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetNonprobateTransferError = GetNonprobateTransferErrors[keyof GetNonprobateTransferErrors];
+export type GetNonprobateTransferResponses = {
+    /**
+     * NonprobateTransfer retrieved successfully
+     */
+    200: NonprobateTransfer;
+};
+export type GetNonprobateTransferResponse = GetNonprobateTransferResponses[keyof GetNonprobateTransferResponses];
+export type UpdateNonprobateTransferData = {
+    body: NonprobateTransfer;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the nonprobate transfer (UUID v4)
+         */
+        transferId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/nonprobate-transfers/{transferId}';
+};
+export type UpdateNonprobateTransferErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateNonprobateTransferError = UpdateNonprobateTransferErrors[keyof UpdateNonprobateTransferErrors];
+export type UpdateNonprobateTransferResponses = {
+    /**
+     * NonprobateTransfer updated successfully
+     */
+    200: NonprobateTransfer;
+};
+export type UpdateNonprobateTransferResponse = UpdateNonprobateTransferResponses[keyof UpdateNonprobateTransferResponses];
+export type ReplaceNonprobateTransferData = {
+    body: NonprobateTransfer;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the nonprobate transfer (UUID v4)
+         */
+        transferId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/nonprobate-transfers/{transferId}';
+};
+export type ReplaceNonprobateTransferErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceNonprobateTransferError = ReplaceNonprobateTransferErrors[keyof ReplaceNonprobateTransferErrors];
+export type ReplaceNonprobateTransferResponses = {
+    /**
+     * NonprobateTransfer replaced successfully
+     */
+    200: NonprobateTransfer;
+};
+export type ReplaceNonprobateTransferResponse = ReplaceNonprobateTransferResponses[keyof ReplaceNonprobateTransferResponses];
+export type ListProxyAuthorisationsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/proxy-authorisations';
+};
+export type ListProxyAuthorisationsResponses = {
+    /**
+     * List of proxy authorisations
+     */
+    200: {
+        items: Array<ProxyAuthorisation>;
+    };
+};
+export type ListProxyAuthorisationsResponse = ListProxyAuthorisationsResponses[keyof ListProxyAuthorisationsResponses];
+export type CreateProxyAuthorisationData = {
+    body: ProxyAuthorisation;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/proxy-authorisations';
+};
+export type CreateProxyAuthorisationErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateProxyAuthorisationError = CreateProxyAuthorisationErrors[keyof CreateProxyAuthorisationErrors];
+export type CreateProxyAuthorisationResponses = {
+    /**
+     * ProxyAuthorisation created successfully
+     */
+    201: ProxyAuthorisation;
+};
+export type CreateProxyAuthorisationResponse = CreateProxyAuthorisationResponses[keyof CreateProxyAuthorisationResponses];
+export type DeleteProxyAuthorisationData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the proxy authorisation (UUID v4)
+         */
+        authorisationId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/proxy-authorisations/{authorisationId}';
+};
+export type DeleteProxyAuthorisationErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteProxyAuthorisationError = DeleteProxyAuthorisationErrors[keyof DeleteProxyAuthorisationErrors];
+export type DeleteProxyAuthorisationResponses = {
+    /**
+     * ProxyAuthorisation deleted successfully
+     */
+    204: void;
+};
+export type DeleteProxyAuthorisationResponse = DeleteProxyAuthorisationResponses[keyof DeleteProxyAuthorisationResponses];
+export type GetProxyAuthorisationData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the proxy authorisation (UUID v4)
+         */
+        authorisationId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/proxy-authorisations/{authorisationId}';
+};
+export type GetProxyAuthorisationErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetProxyAuthorisationError = GetProxyAuthorisationErrors[keyof GetProxyAuthorisationErrors];
+export type GetProxyAuthorisationResponses = {
+    /**
+     * ProxyAuthorisation retrieved successfully
+     */
+    200: ProxyAuthorisation;
+};
+export type GetProxyAuthorisationResponse = GetProxyAuthorisationResponses[keyof GetProxyAuthorisationResponses];
+export type UpdateProxyAuthorisationData = {
+    body: ProxyAuthorisation;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the proxy authorisation (UUID v4)
+         */
+        authorisationId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/proxy-authorisations/{authorisationId}';
+};
+export type UpdateProxyAuthorisationErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateProxyAuthorisationError = UpdateProxyAuthorisationErrors[keyof UpdateProxyAuthorisationErrors];
+export type UpdateProxyAuthorisationResponses = {
+    /**
+     * ProxyAuthorisation updated successfully
+     */
+    200: ProxyAuthorisation;
+};
+export type UpdateProxyAuthorisationResponse = UpdateProxyAuthorisationResponses[keyof UpdateProxyAuthorisationResponses];
+export type ReplaceProxyAuthorisationData = {
+    body: ProxyAuthorisation;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the proxy authorisation (UUID v4)
+         */
+        authorisationId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/proxy-authorisations/{authorisationId}';
+};
+export type ReplaceProxyAuthorisationErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceProxyAuthorisationError = ReplaceProxyAuthorisationErrors[keyof ReplaceProxyAuthorisationErrors];
+export type ReplaceProxyAuthorisationResponses = {
+    /**
+     * ProxyAuthorisation replaced successfully
+     */
+    200: ProxyAuthorisation;
+};
+export type ReplaceProxyAuthorisationResponse = ReplaceProxyAuthorisationResponses[keyof ReplaceProxyAuthorisationResponses];
+export type ListDealerInterestsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/dealer-interests';
+};
+export type ListDealerInterestsResponses = {
+    /**
+     * List of dealer interests
+     */
+    200: {
+        items: Array<DealerInterest>;
+    };
+};
+export type ListDealerInterestsResponse = ListDealerInterestsResponses[keyof ListDealerInterestsResponses];
+export type CreateDealerInterestData = {
+    body: DealerInterest;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/dealer-interests';
+};
+export type CreateDealerInterestErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type CreateDealerInterestError = CreateDealerInterestErrors[keyof CreateDealerInterestErrors];
+export type CreateDealerInterestResponses = {
+    /**
+     * DealerInterest created successfully
+     */
+    201: DealerInterest;
+};
+export type CreateDealerInterestResponse = CreateDealerInterestResponses[keyof CreateDealerInterestResponses];
+export type DeleteDealerInterestData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the dealer interest (UUID v4)
+         */
+        interestId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/dealer-interests/{interestId}';
+};
+export type DeleteDealerInterestErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type DeleteDealerInterestError = DeleteDealerInterestErrors[keyof DeleteDealerInterestErrors];
+export type DeleteDealerInterestResponses = {
+    /**
+     * DealerInterest deleted successfully
+     */
+    204: void;
+};
+export type DeleteDealerInterestResponse = DeleteDealerInterestResponses[keyof DeleteDealerInterestResponses];
+export type GetDealerInterestData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the dealer interest (UUID v4)
+         */
+        interestId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/dealer-interests/{interestId}';
+};
+export type GetDealerInterestErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetDealerInterestError = GetDealerInterestErrors[keyof GetDealerInterestErrors];
+export type GetDealerInterestResponses = {
+    /**
+     * DealerInterest retrieved successfully
+     */
+    200: DealerInterest;
+};
+export type GetDealerInterestResponse = GetDealerInterestResponses[keyof GetDealerInterestResponses];
+export type UpdateDealerInterestData = {
+    body: DealerInterest;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the dealer interest (UUID v4)
+         */
+        interestId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/dealer-interests/{interestId}';
+};
+export type UpdateDealerInterestErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UpdateDealerInterestError = UpdateDealerInterestErrors[keyof UpdateDealerInterestErrors];
+export type UpdateDealerInterestResponses = {
+    /**
+     * DealerInterest updated successfully
+     */
+    200: DealerInterest;
+};
+export type UpdateDealerInterestResponse = UpdateDealerInterestResponses[keyof UpdateDealerInterestResponses];
+export type ReplaceDealerInterestData = {
+    body: DealerInterest;
+    headers?: {
+        /**
+         * ETag value for optimistic concurrency control
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+        /**
+         * Unique identifier for the dealer interest (UUID v4)
+         */
+        interestId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/dealer-interests/{interestId}';
+};
+export type ReplaceDealerInterestErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ReplaceDealerInterestError = ReplaceDealerInterestErrors[keyof ReplaceDealerInterestErrors];
+export type ReplaceDealerInterestResponses = {
+    /**
+     * DealerInterest replaced successfully
+     */
+    200: DealerInterest;
+};
+export type ReplaceDealerInterestResponse = ReplaceDealerInterestResponses[keyof ReplaceDealerInterestResponses];
+export type ExportEstateJsonData = {
+    body?: ExportJsonRequest;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/export/json';
+};
+export type ExportEstateJsonErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ExportEstateJsonError = ExportEstateJsonErrors[keyof ExportEstateJsonErrors];
+export type ExportEstateJsonResponses = {
+    /**
+     * INHERIT document exported successfully
+     */
+    200: Schema;
+};
+export type ExportEstateJsonResponse = ExportEstateJsonResponses[keyof ExportEstateJsonResponses];
+export type ExportEstatePdfData = {
+    body: ExportPdfRequest;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/export/pdf';
+};
+export type ExportEstatePdfErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ExportEstatePdfError = ExportEstatePdfErrors[keyof ExportEstatePdfErrors];
+export type ExportEstatePdfResponses = {
+    /**
+     * PDF report generated successfully
+     */
+    200: Blob | File;
+};
+export type ExportEstatePdfResponse = ExportEstatePdfResponses[keyof ExportEstatePdfResponses];
+export type ImportEstateData = {
+    body: Schema;
+    path?: never;
+    query?: never;
+    url: '/estates/import';
+};
+export type ImportEstateErrors = {
+    /**
+     * The request body failed schema validation
+     */
+    400: Error;
+};
+export type ImportEstateError = ImportEstateErrors[keyof ImportEstateErrors];
+export type ImportEstateResponses = {
+    /**
+     * Estate imported successfully
+     */
+    201: ImportResult;
+};
+export type ImportEstateResponse = ImportEstateResponses[keyof ImportEstateResponses];
+export type ValidateEstateData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/validate';
+};
+export type ValidateEstateErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type ValidateEstateError = ValidateEstateErrors[keyof ValidateEstateErrors];
+export type ValidateEstateResponses = {
+    /**
+     * Validation result returned successfully
+     */
+    200: ValidationResult;
+};
+export type ValidateEstateResponse = ValidateEstateResponses[keyof ValidateEstateResponses];
+export type UnlinkCompanionData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/companion';
+};
+export type UnlinkCompanionErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type UnlinkCompanionError = UnlinkCompanionErrors[keyof UnlinkCompanionErrors];
+export type UnlinkCompanionResponses = {
+    /**
+     * Companion unlinked successfully
+     */
+    204: void;
+};
+export type UnlinkCompanionResponse = UnlinkCompanionResponses[keyof UnlinkCompanionResponses];
+export type GetCompanionData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/companion';
+};
+export type GetCompanionErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetCompanionError = GetCompanionErrors[keyof GetCompanionErrors];
+export type GetCompanionResponses = {
+    /**
+     * Companion estate summary returned successfully
+     */
+    200: EstateSummary;
+};
+export type GetCompanionResponse = GetCompanionResponses[keyof GetCompanionResponses];
+export type LinkCompanionData = {
+    body: CompanionLink;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/companion';
+};
+export type LinkCompanionErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+    /**
+     * The request conflicts with the current state of the resource
+     */
+    409: Error;
+};
+export type LinkCompanionError = LinkCompanionErrors[keyof LinkCompanionErrors];
+export type LinkCompanionResponses = {
+    /**
+     * Companion linked successfully
+     */
+    200: Estate;
+};
+export type LinkCompanionResponse = LinkCompanionResponses[keyof LinkCompanionResponses];
+export type GetEstateSummaryData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the estate (UUID v4)
+         */
+        estateId: string;
+    };
+    query?: never;
+    url: '/estates/{estateId}/summary';
+};
+export type GetEstateSummaryErrors = {
+    /**
+     * The requested resource was not found
+     */
+    404: Error;
+};
+export type GetEstateSummaryError = GetEstateSummaryErrors[keyof GetEstateSummaryErrors];
+export type GetEstateSummaryResponses = {
+    /**
+     * Estate summary returned successfully
+     */
+    200: EstateSummary;
+};
+export type GetEstateSummaryResponse = GetEstateSummaryResponses[keyof GetEstateSummaryResponses];
+//# sourceMappingURL=types.gen.d.ts.map