@vimine/sdk 0.2.0

package/dist/types.d.ts

@@ -0,0 +1,782 @@
+/** Permissions a member (user scopes) or an association's own system (client scopes) may hold. */
+export type Scope = 'profile:read' | 'profile:write' | 'membership:read' | 'membership:request' | 'statuto:accept' | 'network:manage' | 'identity:signup' | 'enroll:write' | 'verify:read' | 'memberships:read' | 'checkins:write' | 'webhooks:manage' | 'events:read' | 'registrations:read' | 'registrations:write';
+/** `rejected`: the request for admission was not accepted (a different act from `revoked`, which excludes a member). */
+export type MembershipStatus = 'pending' | 'active' | 'suspended' | 'revoked' | 'rejected';
+/** What the card is worth right now: `valid`, `expired`, `statuto_required` (re-acceptance overdue) or `inactive`. */
+/** `not_yet_valid`: active and unexpired, but inside the association's usability delay — see `Membership.valid_from`. */
+export type MembershipVerdict = 'valid' | 'expired' | 'not_yet_valid' | 'statuto_required' | 'inactive';
+export interface TokenResponse {
+    access_token: string;
+    token_type: 'Bearer';
+    expires_in: number;
+    refresh_token?: string;
+    scope: string;
+    /** Pairwise subject of the member (per association); absent on client tokens. */
+    sub?: string;
+}
+export interface ClientInfo {
+    client_id: string;
+    name: string;
+    kind: 'public' | 'native' | 'confidential' | 'first_party';
+    aps: {
+        slug: string;
+        name: string;
+        brandcolor: string | null;
+        picture_url: string | null;
+    };
+    scopes: Array<{
+        code: Scope;
+        label: string;
+    }>;
+}
+/**
+ * A language the platform speaks (`it`, `en` today). Wherever the API takes one it also takes a regional tag
+ * (`en-GB`) and reduces it; a language it does not speak is ignored, never an error — except on `PATCH /v1/me`.
+ */
+export type Locale = 'it' | 'en';
+/** Ask for the association's copy in a language (`?locale=`). Default: the member's own, then `Accept-Language`, then the association's. */
+export interface LocaleParam {
+    locale?: Locale | string;
+}
+export interface Me {
+    sub: string;
+    email: string;
+    email_verified: boolean;
+    first_name: string | null;
+    last_name: string | null;
+    phone: string | null;
+    /** ISO date (YYYY-MM-DD) */
+    dob: string | null;
+    /** Demographic only: it is never cross-checked against a fiscal code. */
+    gender: 'M' | 'F' | null;
+    /** Comune (born in Italy) or city, free text (born abroad). */
+    birthplace: string | null;
+    /** Country of birth, ISO 3166-1 alpha-2. */
+    birth_country: string | null;
+    /** Optional: a person may have none. */
+    codicefiscale: string | null;
+    /** How the person is identified; `null` = not identified yet (they cannot request a membership). */
+    codicefiscale_check: CodiceFiscaleCheck | null;
+    /** The language the person chose for the platform and its mails; `null` = never chosen (the request's, then the association's, applies). */
+    locale: Locale | null;
+    updated_at: string | null;
+}
+/**
+ * How a person is identified — by a fiscal code OR by their particulars (date, place and country of birth), never
+ * neither. `matched`: a fiscal code that agrees with the particulars; `mismatch_confirmed`: a code that disagrees,
+ * confirmed by the person as the one on their health card; `absent`: no code, the particulars identify them.
+ */
+export type CodiceFiscaleCheck = 'matched' | 'mismatch_confirmed' | 'absent';
+export interface MeUpdate {
+    phone?: string | null;
+    dob?: string | null;
+    gender?: 'M' | 'F' | null;
+    birthplace?: string | null;
+    /** ISO 3166-1 alpha-2. For a person born abroad a fiscal code encodes only the STATE: this is what it is compared with. */
+    birth_country?: string | null;
+    /** May be added later, or set to `null`. Validated and cross-checked when present (422 `codicefiscale_mismatch`). */
+    codicefiscale?: string | null;
+    /** Write-only: the person confirms a code that disagrees with their particulars (only after a `confirmable: true`). */
+    codicefiscale_confirmed?: boolean;
+    /** The person's language; `null` clears the choice. 422 `unsupported` for a language the platform does not speak. */
+    locale?: Locale | null;
+}
+export interface MembershipTypeRef {
+    uid: string;
+    cod: string;
+    name: string;
+}
+export interface MembershipStatuto {
+    current_version: number | null;
+    current_sha256: string | null;
+    accepted_version_id: string | null;
+    accepted_at: string | null;
+    /** A newer statuto was published since the member accepted one. */
+    pending: boolean;
+    /** … and the association's grace window for re-acceptance has elapsed. */
+    overdue: boolean;
+}
+export interface CardToken {
+    /** The `vmt_…` token: what a QR carries and what `/v1/verify/{card_token}` checks. */
+    token: string;
+    /** Validity window (unix seconds). */
+    nbf: number;
+    exp: number;
+}
+export interface Membership {
+    id: string;
+    status: MembershipStatus;
+    verdict: MembershipVerdict;
+    subdate: string | null;
+    issued_at: string | null;
+    expires_at: string | null;
+    membership_type: MembershipTypeRef | null;
+    statuto: MembershipStatuto;
+    /**
+     * Why a `pending` membership is still pending, IN ORDER: the association's approval of the request first (when it
+     * admits by decision of its board), then the quota of a paid type. Empty when active.
+     */
+    pending_reasons: PendingReason[];
+    /** May the quota be paid yet? `false` while the approval is still pending: approval opens payment. */
+    payment_open: boolean;
+    /** When the card starts to count at the door (the association's usability delay); `null` = since activation. */
+    valid_from: string | null;
+    /** Is the card usable right now? `status` may be `active` while this is still `false` (see `valid_from`). */
+    usable: boolean;
+    /** The quota of a paid membership type and whether it is paid for the current period; `null` for a free type. */
+    quota: {
+        amount: number;
+        currency: string;
+        paid: boolean;
+    } | null;
+    /** The association's instructions for paying the quota, only once the payment is open (`payment_open`). */
+    payment_instructions: string | null;
+    /** Days to expiry (negative once expired). */
+    expires_in_days: number | null;
+    /** Self-service renewal: open 60 days before expiry; `requested_at` once the member asked. */
+    renewal: {
+        window_open: boolean;
+        requested_at: string | null;
+    };
+    network_opt_in: boolean;
+    /** The signed card token. `null` unless `status` is `active` (a pending, suspended or revoked membership has no card) or when card signing is not configured. */
+    card: CardToken | null;
+}
+export type PendingReason = 'approval' | 'payment';
+/** How an association admits its members (`GET /v1/aps/{slug}` → `aps.admission.model`). */
+export type AdmissionModel = 'board' | 'provisional' | 'automatic';
+export interface MembershipRequest {
+    /** Membership type uid; optional when the association offers exactly one. */
+    membership_type?: string;
+    /** Must name the in-force statuto (see `Statuto.version`; `sha256` when published). */
+    accept_statuto: {
+        version: number;
+        sha256?: string;
+    };
+}
+/** A free type with no approval gate is issued `active` at once; otherwise `pending` with its reasons. */
+/** What every answer about a membership request says about its gates. */
+export interface MembershipGates {
+    /** In order: the association's approval first (board model), then the fee. Empty when active. */
+    pending_reasons: PendingReason[];
+    /** May the fee be paid yet? `false` while the approval is pending: approval opens payment. */
+    payment_open: boolean;
+    /** When the card becomes usable, for an active membership inside the usability delay; `null` otherwise. */
+    valid_from: string | null;
+}
+export type MembershipRequestResult = ({
+    created: true;
+    status: MembershipStatus;
+    id: string;
+} & MembershipGates) | ({
+    already_requested: true;
+    status: MembershipStatus;
+} & MembershipGates);
+export interface MembershipEvent {
+    from: MembershipStatus | null;
+    to: MembershipStatus;
+    reason: string | null;
+    changed_at: string;
+    channel: string;
+}
+export interface MembershipEvents {
+    items: MembershipEvent[];
+    next_cursor: string | null;
+}
+export interface StatutoInfo {
+    uid: string;
+    version: number;
+    approvaldate: string | null;
+    sha256: string | null;
+    content: string | null;
+    document_url: string | null;
+    accepted: boolean;
+    accepted_at: string | null;
+    overdue: boolean;
+}
+export interface StatutoAccept {
+    version: number;
+    sha256?: string;
+}
+export interface Card extends CardToken {
+    status: MembershipStatus;
+}
+export interface Connection {
+    client_id: string;
+    name: string;
+    kind: ClientInfo['kind'];
+    scopes: Scope[];
+    granted_at: string;
+}
+export interface Verification {
+    status: 'active' | 'inactive';
+    valid_until?: string;
+    /** With `reason: 'not_yet_valid'`: the card is genuine and active, and becomes usable at this moment. */
+    valid_from?: string;
+    reason?: 'expired' | 'invalid' | 'not_yet_valid';
+}
+export interface MembershipType {
+    uid: string;
+    cod: string;
+    name: string;
+    description: string | null;
+    quota_amount: number | null;
+    currency: string;
+    expiry_model: 'solar_year' | 'rolling_12' | 'rolling_24' | 'prorated_solar' | 'custom';
+    network_eligible: boolean;
+}
+export interface Statuto {
+    uid: string;
+    version: number;
+    approvaldate: string | null;
+    sha256: string | null;
+    content: string | null;
+    document_url: string | null;
+}
+export interface AssociationPublicConfig {
+    /** The language this answer is written in: the one you asked for when the association offers it, its own otherwise. */
+    locale: Locale;
+    /** The languages the association offers: its own, plus those it enabled. */
+    locales: Locale[];
+    aps: {
+        slug: string;
+        name: string;
+        brandcolor: string | null;
+        picture_url: string | null;
+        citta: string | null;
+        provincia: string | null;
+        enroll_enabled: boolean;
+        /** Enrolment is on AND the association can take one more member right now (plan caps are never disclosed). */
+        accepting_requests: boolean;
+        /**
+         * How the association admits its members — tell an applicant up front. `board`: the request waits for a decision
+         * of the association's board, and any fee is paid after it; `provisional`: admitted at once, ratified later;
+         * `automatic`: active as soon as the conditions are met. `delay_hours`: hours between admission and a USABLE card
+         * (0 = at once) — the membership is active from admission, the card counts at the door only afterwards.
+         */
+        admission: {
+            model: AdmissionModel;
+            delay_hours: number;
+        };
+        /** @deprecated Kept for compatibility: `true` when `admission.model` is `board`. Read `admission`. */
+        approval_required: boolean;
+        /**
+         * Whether the association collects its members' address — of every member or of nobody. `none`: do not ask (an
+         * `address` sent anyway is not stored); `optional`; `required`: enrolment answers 422 `required` on `address`
+         * without one.
+         */
+        member_address: MemberAddressPolicy;
+        /** How to pay the quota (IBAN, causale…), when the association published it. */
+        payment_instructions: string | null;
+        /**
+         * The activities of general interest the association carries out (Italian Third Sector Code, art. 5): `cod` is
+         * the letter of the article, `description` its Italian wording; one is marked as prevalent.
+         */
+        activity_sectors: Array<{
+            cod: string;
+            description: string;
+            prevalent: boolean;
+        }>;
+        /**
+         * Present when the association is registered in the RUNTS (the Italian national register of Third Sector
+         * entities), as checked by the platform against the official public lists; `null` otherwise. Never typed by
+         * the association.
+         */
+        registry: {
+            section: 'APS' | 'ODV' | 'EF' | 'IS' | 'RA' | 'SOMS' | 'ALTRI' | null;
+            /** Repertory number. */
+            number: string | null;
+            registered_on: string | null;
+            /** Date of the official list the check ran against. */
+            checked_on: string | null;
+        } | null;
+    };
+    membership_types: MembershipType[];
+    statuto: Statuto | null;
+}
+export interface FiscalCodeCheck {
+    /** Codice fiscale (16 characters). */
+    code: string;
+    first_name?: string;
+    last_name?: string;
+    gender?: 'M' | 'F';
+    /** Date of birth, YYYY-MM-DD. */
+    date?: string;
+    /** Birthplace: the comune, for a person born in Italy. */
+    place?: string;
+    /**
+     * Birth country, ISO 3166-1 alpha-2. A code encodes the comune for people born in Italy and only the STATE for
+     * everybody else: anything but `IT` is compared with that state, and `place` is ignored.
+     */
+    country?: string;
+}
+/** What may disagree with a fiscal code. `gender` only where it is sent: enrolment and the profile never cross-check it. */
+export type FiscalCodeMismatch = 'lastName' | 'firstName' | 'gender' | 'date' | 'place';
+/** `names_swapped`: the code matches once surname and given name are exchanged. */
+export type FiscalCodeHint = 'names_swapped';
+export interface FiscalCodeResult {
+    valid: boolean;
+    /** `invalid`: structure or check character; `mismatch`: a well-formed code that disagrees with the data sent. */
+    error: 'invalid' | 'mismatch' | null;
+    /** What disagrees with the code, when `error` is `mismatch`. */
+    mismatches: FiscalCodeMismatch[];
+    hints: FiscalCodeHint[];
+    /** The date of birth the code itself encodes (YYYY-MM-DD). */
+    birth_date: string | null;
+    /** The birth country the code itself encodes, ISO 3166-1 alpha-2 (`IT` for a comune). */
+    birth_country: string | null;
+}
+export interface CardKeys {
+    keys: Array<{
+        kty: string;
+        crv: string;
+        x: string;
+        kid: string;
+        use: string;
+        alg: string;
+    }>;
+}
+/** A person your system registers on Vimine (`POST /v1/signup`). */
+export interface SignupInput {
+    email: string;
+    first_name: string;
+    last_name: string;
+    phone?: string | null;
+    /** YYYY-MM-DD */
+    dob?: string | null;
+    /** Demographic only: it is not cross-checked. */
+    gender?: 'M' | 'F' | null;
+    /** Comune (born in Italy) or city, free text (born abroad). */
+    birthplace?: string | null;
+    /** ISO 3166-1 alpha-2. Send it for a person born abroad: their fiscal code encodes only the state. */
+    birth_country?: string | null;
+    /** Validated and cross-checked against the other fields when present. */
+    codicefiscale?: string | null;
+    /** The person confirms a code that disagrees with their particulars (422 `codicefiscale_mismatch` with `confirmable: true`). */
+    codicefiscale_confirmed?: boolean;
+    /** The account terms (`platform_terms`) the person accepted on your site — optional; when given it must name the in-force version (`GET /v1/legal/platform_terms`). */
+    accept_terms?: LegalRef;
+    /** The platform privacy notice (`platform_privacy`) the person read on your site — optional, same rule. */
+    acknowledge_privacy?: LegalRef;
+    /**
+     * The language of the page the person filled in. It decides the language of the mails that follow and becomes the
+     * preference of a NEW account; an existing account keeps its own.
+     */
+    locale?: Locale | string;
+}
+/** Whether an association collects its members' address (`GET /v1/aps/{slug}` → `aps.member_address`). */
+export type MemberAddressPolicy = 'none' | 'optional' | 'required';
+/** A member's address, as `POST /v1/enroll` takes it. */
+export interface MemberAddress {
+    /** `residence` (the default) or, where different, `domicile`. */
+    kind?: 'residence' | 'domicile';
+    /** Street and number. */
+    line: string;
+    postal_code?: string | null;
+    city: string;
+    /** Italian addresses only (two letters); dropped abroad. */
+    province?: string | null;
+    /** ISO 3166-1 alpha-2 (default `IT`). */
+    country?: string;
+}
+/**
+ * `POST /v1/enroll/confirm` after a 409 `identification_required`: what the account still lacks — a fiscal code, or
+ * date, place and country of birth. It completes the EMPTY fields of the profile, never over what is there.
+ */
+export interface EnrollIdentification {
+    /** YYYY-MM-DD */
+    dob?: string;
+    birthplace?: string;
+    /** ISO 3166-1 alpha-2 */
+    birth_country?: string;
+    codicefiscale?: string;
+    codicefiscale_confirmed?: boolean;
+}
+/** A published legal text named by version (and hash when published). */
+export interface LegalRef {
+    version: string;
+    sha256?: string;
+}
+/** A membership request your system submits for a person (`POST /v1/enroll`). */
+export interface EnrollInput extends SignupInput {
+    /**
+     * Optional. A person is identified by a fiscal code OR by `dob` + `birthplace` + `birth_country` — never neither
+     * (422 `required` on each missing particular). When present it is validated and cross-checked against the names,
+     * the date and the place (the state, for people born abroad).
+     */
+    codicefiscale?: string | null;
+    /**
+     * Residence or, where different, domicile. Asked of every member or of nobody: the public profile says what the
+     * association declared (`aps.member_address`).
+     */
+    address?: MemberAddress;
+    /** Membership type uid; optional when the association offers exactly one. */
+    membership_type?: string;
+    /** The in-force statuto the person accepted on your site (see `Statuto.version`; `sha256` when published). */
+    accept_statuto: {
+        version: number;
+        sha256?: string;
+    };
+    /**
+     * The association's privacy notice the person read on your site (`ApsPublicConfig.privacy_notice`). REQUIRED when the
+     * association publishes one; 422 `privacy_notice_outdated` when it is not the in-force version.
+     */
+    privacy_notice?: {
+        version: number;
+        sha256?: string;
+        locale?: Locale | string;
+    };
+}
+/** One acceptance, acknowledgement or consent the person recorded (`GET /v1/me/acceptances`). */
+export interface AcceptanceRecord {
+    at: string;
+    action: 'accepted' | 'acknowledged' | 'consented' | 'withdrawn' | 'declared';
+    channel: 'ui' | 'public' | 'api' | 'job' | 'paper';
+    kind: string;
+    title: string;
+    version: string;
+    sha256: string | null;
+    /** Hash of the text actually shown. */
+    rendered_sha256: string | null;
+    locale: string | null;
+    /** The association the act concerns, when any. */
+    association: string | null;
+}
+/** A document the person has not acted on at its in-force version. */
+export interface PendingDocument {
+    kind: string;
+    title: string;
+    locale: string;
+    version: string | number;
+    sha256: string | null;
+    effective_from: string | null;
+    /** What the person is asked to do. */
+    action: 'accepted' | 'acknowledged' | 'consented';
+    /** Never acted on any version of this kind (false: a new version requires it again). */
+    first: boolean;
+}
+export interface MyAcceptances {
+    items: AcceptanceRecord[];
+    pending: {
+        /** Account-layer documents still to accept / acknowledge. */
+        platform: PendingDocument[];
+        /** This association's notice to members, when not yet acknowledged. */
+        privacy_notice: PendingDocument | null;
+    };
+}
+/** `POST /v1/me/acceptances`: the in-force version your app showed. */
+export interface AcceptanceInput {
+    /** `platform_terms` | `platform_privacy` | `network_consent` | `privacy_notice` */
+    kind: string;
+    version: string | number;
+    sha256?: string;
+}
+export interface AcceptanceResult {
+    recorded: true;
+    kind: string;
+    action: string;
+    version: string;
+    at: string;
+}
+/** The uniform answer of the creating routes: whatever happened behind the address, it was accepted. */
+export interface Accepted {
+    status: 'accepted';
+}
+/** `POST /v1/enroll/confirm` — the outcome of the confirmation link an existing account's owner uses. */
+export interface EnrollConfirmResult {
+    status: MembershipStatus;
+    /** The person already had a membership request or membership here; nothing new was created. */
+    already: boolean;
+    /** In order: the association's approval first (board model), then the fee. */
+    pending_reasons: PendingReason[];
+    payment_open: boolean;
+    valid_from: string | null;
+    association: {
+        name: string;
+        slug: string;
+    };
+}
+/** `POST /v1/me/membership/renew` — renewed at once (free type, no approval gate) or turned into a request. */
+export interface RenewResult {
+    renewed: boolean;
+    requested: boolean;
+    status: MembershipStatus;
+    expires_at: string | null;
+    renewal_requested_at: string | null;
+}
+/** `PATCH /v1/me/membership/network-opt-in` */
+export interface NetworkOptIn {
+    network_opt_in: boolean;
+    network_opt_in_at: string | null;
+}
+/** `POST /v1/checkins` — a door check-in from a scanned card token. No personal data. */
+/** `POST /v1/checkins` for a CARD token. */
+export interface CardCheckinResult {
+    kind: 'card';
+    verdict: MembershipVerdict;
+    status: MembershipStatus;
+    membership_id: string;
+    valid_until: string | null;
+    /** With `verdict: 'not_yet_valid'`: when the card becomes usable. The scan is recorded all the same. */
+    valid_from: string | null;
+    /**
+     * A note for whoever staffs the gate, never part of `verdict`: it restricts nothing. `pending`: the member has no
+     * verifiable fiscal code and nobody of the association has looked at a document yet — show it. Cleared from the
+     * association's console. `null`: nothing to check. The public `verifyCard` never carries it.
+     */
+    identity_check: IdentityCheck | null;
+    checked_in_at: string;
+}
+/**
+ * The identity check at first presence (`CardCheckinResult.identity_check`). `pending`: a document is still to be
+ * looked at; `verified`: somebody of the association looked at one; `flagged`: somebody did, and it did not agree —
+ * a matter for the association's office, which revokes nothing by itself.
+ */
+export type IdentityCheck = 'pending' | 'verified' | 'flagged';
+export type RegistrationCheckinVerdict = 'valid' | 'already_checked_in' | 'not_confirmed' | 'cancelled' | 'event_cancelled' | 'membership_invalid';
+/** `POST /v1/checkins` for an event REGISTRATION token (`k:'reg'` in the payload). */
+export interface RegistrationCheckinResult {
+    kind: 'registration';
+    verdict: RegistrationCheckinVerdict;
+    status: RegistrationStatus;
+    registration_id: string;
+    event: {
+        slug: string;
+        title: string;
+        starts_at: string;
+    };
+    registration_type: string | null;
+    membership_id: string | null;
+    membership_verdict: MembershipVerdict | null;
+    /** True the first time this registration is checked in. */
+    first: boolean;
+    checked_in_at: string | null;
+}
+export type CheckinResult = CardCheckinResult | RegistrationCheckinResult;
+/** One row of `GET /v1/memberships` — ids and status only. */
+export interface MembershipListItem {
+    id: string;
+    status: MembershipStatus;
+    verdict: MembershipVerdict;
+    membership_type: {
+        cod: string;
+    } | null;
+    issued_at: string | null;
+    valid_until: string | null;
+    updated_at: string;
+}
+export interface MembershipList {
+    items: MembershipListItem[];
+    next_cursor: string | null;
+}
+export interface MembershipListParams {
+    status?: MembershipStatus;
+    /** RFC 3339: only rows changed after this instant (incremental sync). */
+    updated_since?: string;
+    limit?: number;
+    cursor?: string;
+}
+export interface MembershipStatusInfo {
+    id: string;
+    status: MembershipStatus;
+    verdict: MembershipVerdict;
+    valid_until: string | null;
+    membership_type: {
+        cod: string;
+    } | null;
+}
+export interface SandboxMember {
+    email: string;
+    name: string;
+    status: MembershipStatus;
+    expires_at: string | null;
+    statuto_accepted: boolean;
+}
+export interface SandboxMembers {
+    slug: string;
+    members: SandboxMember[];
+}
+export interface SandboxReset {
+    /** The synthetic members' shared password — shown only here. */
+    password: string;
+    members: Array<Pick<SandboxMember, 'email' | 'name' | 'status'>>;
+}
+export type EventStatus = 'published' | 'completed' | 'cancelled';
+export type EventVisibility = 'members_only' | 'public';
+export type RegistrationStatus = 'reserved' | 'confirmed' | 'cancelled' | 'refunded';
+/** Why a registration type is not open right now. */
+export type RegistrationTypeReason = 'sold_out' | 'registration_not_open' | 'registration_closed';
+/** Why the member may not register (`GET /v1/events/{slug}/eligibility`, `422 not_eligible`). */
+export type EligibilityReason = 'membership_required' | 'membership_not_active'
+/** The event starts before the member's card is usable (the association's usability delay). */
+ | 'membership_not_yet_valid' | 'membership_type_not_allowed' | 'sold_out' | 'event_full' | 'registration_not_open' | 'registration_closed' | 'max_per_user' | 'event_past' | 'event_cancelled' | 'event_not_published' | 'plan_limit' | 'invalid_type';
+export interface EventLocation {
+    name: string | null;
+    address: string | null;
+    lat: number | null;
+    lng: number | null;
+}
+/** An admission class of an event: free (`amount` 0) or a contribution; places and window are live. */
+export interface RegistrationType {
+    uid: string;
+    cod: string;
+    name: string;
+    description: string | null;
+    amount: number;
+    currency: string;
+    quantity: number | null;
+    /** Places left (never who holds them); null = unlimited. */
+    remaining: number | null;
+    max_per_user: number;
+    requires_active_membership: boolean;
+    open: boolean;
+    reason: RegistrationTypeReason | null;
+    opens_at: string | null;
+    closes_at: string | null;
+}
+/** An event as the API describes it: headless copy, dates, place, images, live availability per type. */
+export interface Event {
+    id: string;
+    slug: string;
+    /**
+     * The language the `title` was served in. When it is not the one you asked for, the association wrote no
+     * translation: you got its own text — never a machine translation. Each text falls back on its own.
+     */
+    locale: Locale;
+    /** The languages in which this event has a title. */
+    locales: Locale[];
+    title: string;
+    summary: string | null;
+    /** Markdown — render it yourself. */
+    description_md: string | null;
+    starts_at: string;
+    ends_at: string | null;
+    timezone: string;
+    status: EventStatus;
+    visibility: EventVisibility;
+    location: EventLocation | null;
+    cover_url: string | null;
+    gallery: {
+        url: string;
+        alt: string | null;
+        order: number;
+    }[];
+    links: {
+        label: string;
+        url: string;
+    }[];
+    registration: {
+        opens_at: string | null;
+        closes_at: string | null;
+        capacity: number | null;
+        remaining: number | null;
+        cancellation_hours: number;
+    };
+    registration_types: RegistrationType[];
+    published_at: string | null;
+    cancelled_at: string | null;
+    cancel_reason: string | null;
+}
+export interface EventList {
+    items: Event[];
+}
+export interface EventListParams extends LocaleParam {
+    /** `upcoming` (default) | `past` | `cancelled` | `all` */
+    filter?: 'upcoming' | 'past' | 'cancelled' | 'all';
+    /** RFC 3339 bounds on `starts_at`. */
+    from?: string;
+    to?: string;
+    limit?: number;
+}
+export interface Eligibility {
+    can_register: boolean;
+    membership_verdict: MembershipVerdict | null;
+    types: {
+        uid: string;
+        cod: string;
+        can_register: boolean;
+        reasons: EligibilityReason[];
+        pending_membership: boolean;
+    }[];
+}
+export interface RegistrationRequest {
+    registration_type: string;
+    note?: string | null;
+    quantity?: number;
+    /** The language the registration was made in: the fallback for a member who never chose one. */
+    locale?: Locale | string;
+}
+/** A person's registration (the member's own, or a guest's after the confirmation link). */
+export interface Registration {
+    id: string;
+    status: RegistrationStatus;
+    event: {
+        id: string;
+        slug: string;
+        title: string;
+        starts_at: string;
+        ends_at: string | null;
+        timezone: string;
+        status: EventStatus;
+        location: string | null;
+        cancel_reason: string | null;
+    } | null;
+    registration_type: {
+        uid: string;
+        cod: string;
+        name: string;
+        amount: number;
+        currency: string;
+    } | null;
+    quantity: number;
+    reserved_until: string | null;
+    checked_in_at: string | null;
+    cancelled_at: string | null;
+    cancel_reason: 'user' | 'staff' | 'expired' | 'event_cancelled' | null;
+    can_cancel: boolean;
+    payment: {
+        status: 'recorded' | 'refunded' | 'void';
+        amount: number;
+        currency: string;
+        method: string;
+        paid_at: string;
+    } | null;
+    /** How to pay the contribution while `reserved` (the association's own text). */
+    payment_instructions?: string | null;
+    note: string | null;
+    created_at: string;
+    /** The registration QR payload (`vmt_…`), confirmed registrations only — draw it as a QR code. */
+    token?: string | null;
+}
+export interface RegistrationList {
+    items: Registration[];
+}
+/** `POST /v1/events/{slug}/registrations/guest` (client scope `registrations:write`, public events only). */
+export interface GuestRegistrationRequest {
+    email: string;
+    first_name: string;
+    last_name: string;
+    registration_type: string;
+    note?: string | null;
+    /** The language the registration was made in — for a guest, the language of every mail they receive. */
+    locale?: Locale | string;
+}
+/** One row of `GET /v1/events/{slug}/registrations` — no personal data. */
+export interface RegistrationListItem {
+    id: string;
+    status: RegistrationStatus;
+    registration_type: string | null;
+    membership_id: string | null;
+    quantity: number;
+    checked_in_at: string | null;
+    created_at: string;
+}
+export interface EventRegistrationList {
+    items: RegistrationListItem[];
+    next_cursor: string | null;
+}
+export interface EventRegistrationListParams {
+    status?: RegistrationStatus;
+    limit?: number;
+    cursor?: string;
+}