@overturo/js 0.0.0-stage → 1.5.2

package/dist/index.d.ts

@@ -0,0 +1,1366 @@
+interface ApiClientOptions {
+    baseUrl: string;
+    publishableKey: string;
+    apiKey?: string;
+    /** Request timeout in milliseconds. 0 disables timeout. */
+    timeout?: number;
+}
+/**
+ * Fetch-based HTTP client with automatic case conversion, timeout, and error handling.
+ */
+declare class ApiClient {
+    private baseUrl;
+    private publishableKey;
+    private apiKey?;
+    private timeout;
+    constructor(options: ApiClientOptions);
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: Record<string, unknown>): Promise<T>;
+    /**
+     * GET that returns the raw Response object without JSON parsing, case
+     * conversion or error throwing. Used where part of the body must stay
+     * verbatim (keys that are data, such as purpose names).
+     */
+    rawGet(path: string): Promise<Response>;
+    /**
+     * POST that returns the raw Response object without JSON parsing or error throwing.
+     * Used by exchange() to handle HTTP 202 (fulfillment pending) with retry logic.
+     */
+    rawPost(path: string, body: Record<string, unknown>): Promise<Response>;
+    private rawRequest;
+    private request;
+}
+
+/** Configuration options for the Overturo client. */
+interface OverturoOptions {
+    /** Publishable key for client-side authentication (pk_live_... or pk_test_...). */
+    publishableKey: string;
+    /** API key for server-side operations (sk_live_... or sk_test_...). */
+    apiKey?: string;
+    /** Base URL of the Overturo API. Defaults to https://overturo.com. */
+    baseUrl?: string;
+    /**
+     * Base URL of the host that serves consent flows + iframes (the
+     * "trust" host). Defaults to `baseUrl` — production runs API and
+     * flow on the same origin (`overturo.com`), so most integrations
+     * leave this unset. Set it when the flow is served from a separate
+     * host (e.g. `https://trust.overturo.com`, or `http://trust.lvh.me:5100`
+     * in dev).
+     *
+     * Affects: `embed()`, `popup()`, `redirect()`, and the `accordSetup*`
+     * variants. Does NOT affect API calls — those always go through
+     * `baseUrl`.
+     */
+    flowBaseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 30000 (30s). Set to 0 to disable. */
+    timeout?: number;
+    /**
+     * opt-in structured `console.debug` output prefixed with
+     * `[overturo:sdk]`. Never logs session tokens, publishable keys, or raw
+     * envelope payloads. Default false.
+     */
+    debug?: boolean;
+}
+/** Parameters for creating a new consent session. */
+interface CreateSessionParams {
+    /** The flow ID to initiate (flw_...). */
+    flowId: string;
+    /** Delivery mode for the consent flow. */
+    deliveryMode?: "embed" | "popup" | "redirect";
+    /** Origin of the embedding page (auto-detected in browser). */
+    embedOrigin?: string;
+    /** URI to redirect after consent (for redirect mode). */
+    redirectUri?: string;
+    /** CSRF protection token. */
+    state?: string;
+    /** ID token replay protection nonce. */
+    nonce?: string;
+    /** Requested OAuth scopes (space-separated). */
+    scope?: string;
+    /** Steps to skip in the flow. */
+    skipSteps?: string[];
+}
+/** A created consent session. */
+interface Session {
+    /** Session token for subsequent operations. */
+    sessionToken: string;
+    /** Delivery mode of the session. */
+    deliveryMode: string;
+    /** When the session expires. */
+    expiresAt: string;
+    /** URL for embedding the consent flow in an iframe. */
+    embedUrl: string;
+}
+/** Status of a consent session. */
+interface SessionStatus {
+    /** Session token. */
+    sessionToken: string;
+    /** Current status of the session. */
+    status: string;
+    /** Delivery mode. */
+    deliveryMode: string;
+    /** Current step key. */
+    currentStep: string | null;
+    /** All steps in the flow. */
+    steps: StepInfo[];
+    /** When the session expires. */
+    expiresAt: string;
+    /** When the session was completed, if applicable. */
+    completedAt: string | null;
+}
+/** Information about a single step in a flow. */
+interface StepInfo {
+    /** Step number (1-based). */
+    number: number;
+    /** Step key identifier. */
+    key: string;
+    /** Human-readable step title. */
+    title: string;
+}
+/**
+ * v2 callback signatures.
+ *
+ * The host's lifecycle callbacks now receive the kind discriminator and the
+ * full payload object so a single SDK can route consent-shaped vs.
+ * approval-shaped completions correctly.
+ */
+type DecisionKind = "consent" | "approval" | "signature_request";
+/** Payload object carried in v2 envelopes. Per-kind-per-type schemas live in `lib/sdk/overturo-js/schemas/postmessage-v2/`. */
+type DecisionPayload = Record<string, unknown>;
+/** Options for the high-level consent() method. */
+interface ConsentOptions {
+    /** The flow ID to initiate (flw_...). */
+    flowId: string;
+    /** Container element or CSS selector for the iframe. */
+    container: string | HTMLElement;
+    /** Requested OAuth scopes (space-separated). */
+    scope?: string;
+    /** CSRF protection token. */
+    state?: string;
+    /** ID token replay protection nonce. */
+    nonce?: string;
+    /** Steps to skip in the flow. */
+    skipSteps?: string[];
+    /** Style overrides for the iframe. */
+    style?: EmbedStyle;
+    /** Loading placeholder (HTML string or DOM element). */
+    loading?: string | HTMLElement;
+    /** Called when the flow completes. Receives kind and outcome payload. */
+    onComplete?: (kind: DecisionKind, payload: DecisionPayload) => void;
+    /** Called when the flow is cancelled. */
+    onCancel?: (payload: DecisionPayload) => void;
+    /** Called on error. Payload conforms to the per-kind error schema. */
+    onError?: (payload: DecisionPayload) => void;
+    /** Called when the flow's state transitions (replaces v1 `onStep`). */
+    onState?: (kind: DecisionKind, payload: DecisionPayload) => void;
+    /** Called on a DEADLINE tick (T-30s/T-15s/T-5s/T-0). */
+    onDeadline?: (payload: DecisionPayload) => void;
+    /** Called when the iframe content resizes. */
+    onResize?: (height: number) => void;
+    /** Called when the iframe is ready (carries branding + kind in payload). */
+    onReady?: (payload: DecisionPayload) => void;
+}
+/**
+ * @deprecated Use the v2 `onComplete(kind, payload)` callback signature.
+ * Retained as a type-only export for downstream type checkers.
+ */
+interface ConsentResult {
+    consentToken: string;
+}
+/** Options for embedding a consent or approval flow in an iframe. */
+interface EmbedOptions {
+    /** Session token from createSession(). */
+    sessionToken: string;
+    /** Container element or CSS selector for the iframe. */
+    container: string | HTMLElement;
+    /** Style overrides for the iframe. */
+    style?: EmbedStyle;
+    /** Loading placeholder (HTML string or DOM element). */
+    loading?: string | HTMLElement;
+    /** Called when the flow completes. Receives kind and outcome payload. */
+    onComplete?: (kind: DecisionKind, payload: DecisionPayload) => void;
+    /** Called when the flow is cancelled. */
+    onCancel?: (payload: DecisionPayload) => void;
+    /** Called on error. */
+    onError?: (payload: DecisionPayload) => void;
+    /** Called on each STATE transition. */
+    onState?: (kind: DecisionKind, payload: DecisionPayload) => void;
+    /** Called on a DEADLINE tick. */
+    onDeadline?: (payload: DecisionPayload) => void;
+    /** Called when the iframe content resizes. */
+    onResize?: (height: number) => void;
+    /** Called when the iframe is ready (READY payload carries branding + kind). */
+    onReady?: (payload: DecisionPayload) => void;
+}
+/** Style overrides for the embed iframe. Only whitelisted properties are applied. */
+interface EmbedStyle {
+    /** CSS width. Default: "100%". */
+    width?: string;
+    /** CSS min-height. Default: "400px". */
+    minHeight?: string;
+    /** CSS max-height. Default: "none". */
+    maxHeight?: string;
+    /** CSS border. Default: "none". */
+    border?: string;
+    /** CSS border-radius. Default: "0". */
+    borderRadius?: string;
+    /** CSS background. Default: "transparent". */
+    background?: string;
+}
+/** Handle returned from embed(), used to control or destroy the iframe. */
+interface EmbedHandle {
+    /** The iframe element. */
+    iframe: HTMLIFrameElement;
+    /** Removes the iframe and cleans up event listeners. */
+    destroy: () => void;
+}
+/** Options for opening a consent or approval flow in a popup window. */
+interface PopupOptions {
+    /** Session token from createSession(). */
+    sessionToken: string;
+    /** Called when the flow completes. Receives kind and outcome payload. */
+    onComplete?: (kind: DecisionKind, payload: DecisionPayload) => void;
+    /** Called when the flow is cancelled. */
+    onCancel?: (payload: DecisionPayload) => void;
+    /** Called on error. */
+    onError?: (payload: DecisionPayload) => void;
+    /** Popup window width in pixels. Default: 500. */
+    width?: number;
+    /** Popup window height in pixels. Default: 700. */
+    height?: number;
+}
+/** Handle returned from popup(), used to close the popup. */
+interface PopupHandle {
+    /** Closes the popup window and cleans up event listeners. */
+    close: () => void;
+}
+/** Options for redirect mode (full-page navigation). */
+interface RedirectOptions {
+    /** The flow ID to redirect to (flw_...). */
+    flowId: string;
+    /** URI to redirect back to after consent. */
+    redirectUri: string;
+    /** CSRF protection token. */
+    state?: string;
+    /** ID token replay protection nonce. */
+    nonce?: string;
+    /** Requested OAuth scopes (space-separated). */
+    scope?: string;
+}
+/** Parameters for exchanging a consent token. */
+interface ExchangeParams {
+    /** Session token from the consent session. */
+    sessionToken: string;
+    /** Single-use consent token received on completion. */
+    consentToken: string;
+}
+/** Result of a consent token exchange. */
+interface ExchangeResult {
+    /** Resolved claims from the consent flow. */
+    claims: Record<string, unknown>;
+    /** Attestation results from third-party connectors. */
+    attestations: Attestation[];
+    /** Issued verifiable credentials. */
+    credentials: Credential[];
+    /** Provenance metadata for claims. */
+    provenance: Record<string, unknown>;
+    /** OAuth access token (if OAuth application configured). */
+    accessToken?: string;
+    /** Token type (e.g., "Bearer"). */
+    tokenType?: string;
+    /** Token expiry in seconds. */
+    expiresIn?: number;
+    /** OIDC ID token. */
+    idToken?: string;
+    /** OAuth refresh token. */
+    refreshToken?: string;
+}
+/** An attestation from a third-party connector. */
+interface Attestation {
+    /** The claim type that was attested. */
+    claimType: string;
+    /** Name of the connector that provided the attestation. */
+    connector: string;
+    /** Attestation status. */
+    status: string;
+    /** Provider-specific identifier. */
+    providerId: string;
+}
+/** An issued verifiable credential. */
+interface Credential {
+    /** Credential ID. */
+    id: string;
+    /** Type of credential. */
+    credentialType: string;
+    /** Credential format (e.g., "jwt_vc", "sd_jwt"). */
+    format: string;
+    /** When the credential was issued. */
+    issuedAt: string;
+}
+/** Parameters for creating an accord setup session. */
+interface CreateSetupSessionParams {
+    /** Solution key (e.g., "meetings", "venues"). */
+    solution?: string;
+    /** Vertical key (e.g., "healthcare", "education"). */
+    vertical?: string;
+    /** Pre-selected archetype. */
+    archetype?: string;
+    /** Pre-selected template key. */
+    templateKey?: string;
+    /** Delivery mode. */
+    deliveryMode?: "embed" | "popup" | "redirect";
+    /** Origin of the embedding page (auto-detected in browser). */
+    embedOrigin?: string;
+    /** URI to redirect after setup (for redirect mode). */
+    redirectUri?: string;
+    /** CSRF protection token. */
+    state?: string;
+    /** Locale for the setup wizard (auto-detected from navigator.language if omitted). */
+    locale?: string;
+    /** Enterprise constraints. */
+    constraints?: SetupConstraints;
+    /** Load constraints from a saved preset (overrides inline constraints). */
+    presetId?: string;
+}
+/** Enterprise constraints for the setup wizard. */
+interface SetupConstraints {
+    /** Allowed archetype values. */
+    allowedArchetypes?: string[];
+    /** Allowed template keys. */
+    allowedTemplates?: string[];
+    /** Fields that are locked (user cannot change). */
+    locked?: Record<string, unknown>;
+    /** Default values for fields (user can override). */
+    defaults?: Record<string, unknown>;
+    /** Steps to hide from the wizard. */
+    hiddenSteps?: string[];
+}
+/** A created setup session. */
+interface SetupSession {
+    /** Session token for subsequent operations. */
+    sessionToken: string;
+    /** Delivery mode of the session. */
+    deliveryMode: string;
+    /** URL for embedding the setup wizard in an iframe. */
+    embedUrl: string;
+    /** When the session expires. */
+    expiresAt: string;
+}
+/** Options for the accordSetup() embed method. */
+interface AccordSetupOptions {
+    /** Solution key (e.g., "meetings", "venues"). */
+    solution?: string;
+    /** Vertical key (e.g., "healthcare", "education"). */
+    vertical?: string;
+    /** Surface key (e.g., "consent", "agree", "protect"). */
+    surface?: string;
+    /** Pre-selected archetype. */
+    archetype?: string;
+    /** Pre-selected template key. */
+    templateKey?: string;
+    /** Container element or CSS selector for the iframe. */
+    container: string | HTMLElement;
+    /** Enterprise constraints. */
+    constraints?: SetupConstraints;
+    /** Load constraints from a saved preset (overrides inline constraints). */
+    presetId?: string;
+    /** Style overrides for the iframe. */
+    style?: EmbedStyle;
+    /** Loading placeholder (HTML string or DOM element). */
+    loading?: string | HTMLElement;
+    /** Locale for the wizard. */
+    locale?: string;
+    /** Called when the iframe is ready. */
+    onReady?: () => void;
+    /** Called when the flow navigates to a new step. */
+    onStep?: (step: SetupStep) => void;
+    /** Called when the accord is created. */
+    onCreated?: (result: AccordSetupResult) => void;
+    /** Called when the user cancels. */
+    onCancel?: () => void;
+    /** Called on error. */
+    onError?: (error: string) => void;
+    /** Called when the iframe content resizes. */
+    onResize?: (height: number) => void;
+}
+/** Step progress information. */
+interface SetupStep {
+    /** Step key (e.g., "purposes_and_scopes"). */
+    key: string;
+    /** 0-based step index. */
+    index: number;
+    /** Total number of steps. */
+    total: number;
+}
+/** Result returned when accord setup completes. */
+interface AccordSetupResult {
+    /** The created accord ID. Always present. */
+    accordId: string;
+    /** Consent flow ID (for consent/protect archetypes). */
+    flowId?: string;
+}
+/** Options for opening setup in a popup window. */
+interface AccordSetupPopupOptions {
+    /** Solution key. */
+    solution?: string;
+    /** Pre-selected archetype. */
+    archetype?: string;
+    /** Pre-selected template key. */
+    templateKey?: string;
+    /** Enterprise constraints. */
+    constraints?: SetupConstraints;
+    /** Load constraints from a saved preset. */
+    presetId?: string;
+    /** Called when the accord is created. */
+    onCreated?: (result: AccordSetupResult) => void;
+    /** Called when the user cancels. */
+    onCancel?: () => void;
+    /** Called on error. */
+    onError?: (error: string) => void;
+    /** Popup window width in pixels. Default: 600. */
+    width?: number;
+    /** Popup window height in pixels. Default: 800. */
+    height?: number;
+}
+/** Options for redirect mode setup. */
+interface AccordSetupRedirectOptions {
+    /** Solution key. */
+    solution?: string;
+    /** Pre-selected archetype. */
+    archetype?: string;
+    /** Pre-selected template key. */
+    templateKey?: string;
+    /** URI to redirect back to after setup. */
+    redirectUri: string;
+    /** CSRF protection token. */
+    state?: string;
+    /** Enterprise constraints. */
+    constraints?: SetupConstraints;
+    /** Load constraints from a saved preset. */
+    presetId?: string;
+}
+/** Handle returned from accordSetup(), used to control or destroy the iframe. */
+interface SetupHandle {
+    /** The iframe element. */
+    iframe: HTMLIFrameElement;
+    /** Removes the iframe and cleans up event listeners. */
+    destroy: () => void;
+}
+/** Handle returned from accordSetupPopup(). */
+interface SetupPopupHandle {
+    /** Closes the popup window and cleans up event listeners. */
+    close: () => void;
+}
+/** Options for rendering a preview. */
+interface PreviewOptions {
+    /** Container element or CSS selector for the preview iframe. */
+    container: string | HTMLElement;
+    /** Device simulation. Default: "desktop". */
+    device?: "mobile" | "tablet" | "desktop";
+    /** Theme override. */
+    theme?: string;
+    /** Locale override. */
+    locale?: string;
+    /** Style overrides for the iframe. */
+    style?: EmbedStyle;
+    /** Loading placeholder. */
+    loading?: string | HTMLElement;
+}
+/** Options for previewing a template. */
+interface PreviewTemplateOptions extends PreviewOptions {
+    /** Template ID to preview. */
+    templateId: string;
+}
+/** Options for previewing a setup session. */
+interface PreviewSetupOptions extends PreviewOptions {
+    /** Setup session token. */
+    sessionToken: string;
+}
+/** Handle returned from preview methods, used to control or destroy the preview. */
+interface PreviewHandle {
+    /** The iframe element. */
+    iframe: HTMLIFrameElement;
+    /** Switch device viewport. */
+    setDevice: (device: "mobile" | "tablet" | "desktop") => void;
+    /** Switch theme. */
+    setTheme: (theme: string) => void;
+    /** Destroy the preview and remove the iframe. */
+    destroy: () => void;
+}
+/** Delivery mode for a decision. */
+/** `capture` (201) types a session the one-call form capture minted; it is never passed to createSession. */
+type DecisionMode = "embed" | "popup" | "redirect" | "capture";
+interface FormCaptureOptions {
+    /** The flow whose purposes the form answers. */
+    flowId: string;
+    /** The form element or a selector resolving to it. */
+    form: HTMLFormElement | string;
+    /** purpose key → CSS selector of the consent control (a checkbox or radio). Required unless `field` is given. */
+    map?: Record<string, string>;
+    /**
+     * 202 — the `<overturo-consent-field>` element (or a selector resolving to it) inside the form.
+     * The control is Overturo-rendered: presentation is observed by the platform and the receipt
+     * says so. Needs the field entry (`@overturo/js/field` / `overturo-field.js`) loaded first.
+     */
+    field?: HTMLElement | string;
+    /** CSS selector of the input that holds the person's email address. */
+    subjectField: string;
+    /** CSS selector of an input holding your own identifier for the person. */
+    externalIdField?: string;
+    /** purpose key → selector whose text is replaced by the published wording (the discovery read). */
+    wording?: Record<string, string>;
+    /**
+     * purpose key → selector of the label the person read. Its text is digested
+     * (the published algorithm, over the trimmed text) and attested with the capture, so the record
+     * says whether your wording matched the published wording. Defaults to `wording`.
+     */
+    labels?: Record<string, string>;
+    /** Browser commit — honoured only when the application enabled it and lists allowed origins. */
+    commit?: boolean;
+    /** Locale for the published wording. */
+    locale?: string;
+    /** Name of the hidden input that carries the capture token to your server (default overturo_capture_token). */
+    tokenFieldName?: string;
+    /** Set false to stop the form from submitting after the capture (you call requestSubmit yourself). */
+    submitAfterCapture?: boolean;
+    onCaptured?: (result: FormCaptureResult) => void;
+    onError?: (error: Error) => void;
+}
+interface FormCaptureResult {
+    /** The capture token — hand it to your server with the submission and commit it. */
+    token: DecisionToken;
+    attestationId: string;
+    /** True only for a browser commit. */
+    committed: boolean;
+    wordingVerdict: string | null;
+    recordId: string | null;
+}
+/**
+ * Nominal-typed decision token. Server-issued, opaque. The brand
+ * prevents bare strings from being passed where a token is expected.
+ */
+type DecisionToken = string & {
+    readonly __brand: "DecisionToken";
+};
+/** Per-kind outcome envelope returned by the COMPLETE postMessage. */
+type DecisionOutcome = {
+    kind: "consent";
+    result: "granted" | "declined";
+    consentToken?: string;
+    purposesGranted?: string[];
+    purposesDeclined?: string[];
+} | {
+    kind: "approval";
+    result: "approved" | "denied" | "countered";
+    escalationToken?: string;
+    counterProposal?: Record<string, unknown>;
+} | {
+    kind: "signature_request";
+    result: "signed" | "declined" | "countered";
+    assuranceLevel?: "integrity_proof" | "advanced" | "qualified" | null;
+    completedAt?: string;
+};
+/** Per-kind input to `decisions.createSession`. */
+type DecisionsCreateSessionInput = {
+    kind: "consent";
+    subjectRef: string;
+    mode?: DecisionMode;
+    embedOrigin?: string;
+    scope?: string;
+    state?: string;
+    nonce?: string;
+    redirectUri?: string;
+} | {
+    kind: "approval";
+    subjectRef: string;
+    mode?: DecisionMode;
+    embedOrigin?: string;
+    state?: string;
+    redirectUri?: string;
+} | {
+    kind: "signature_request";
+    subjectRef: string;
+    mode?: DecisionMode;
+    embedOrigin?: string;
+    state?: string;
+    redirectUri?: string;
+};
+/**
+ * typed view of a signing-kind STATE payload (`signature/state.json`).
+ * The base `DecisionPayload` stays an untyped Record; consumers that know the
+ * kind is `signature_request` can read state through this shape. Carries
+ * assurance + signing progress only — there is no home-country/region field.
+ */
+interface SignatureStatePayload {
+    from: string | null;
+    to: "pending" | "opened" | "in_progress" | "signed" | "declined" | "expired";
+    kind_payload: {
+        required_assurance_level: "integrity_proof" | "advanced" | "qualified";
+        participant_role?: string | null;
+    };
+}
+/** Per-kind output from `decisions.createSession`. */
+interface DecisionsSession {
+    token: DecisionToken;
+    kind: DecisionKind;
+    mode: DecisionMode;
+    expiresAt: string;
+    embedUrl: string;
+}
+/** Input to `decisions.exchange`. */
+interface DecisionsExchangeInput {
+    token: DecisionToken;
+    exchangeToken: string;
+}
+/** Per-kind exchange result. */
+type DecisionExchange = {
+    kind: "consent";
+    consentToken: string;
+    attestations?: Attestation[];
+    credentials?: Credential[];
+} | {
+    kind: "approval";
+    escalationToken: string;
+    receiptJti?: string;
+};
+/** Options for `decisions.embed` / `consent.open` / `approvals.open`. */
+interface DecisionsEmbedOptions {
+    token: DecisionToken;
+    container: string | HTMLElement;
+    style?: EmbedStyle;
+    loading?: string | HTMLElement;
+    embedOrigin?: string;
+    onReady?: (payload: DecisionPayload) => void;
+    onState?: (kind: DecisionKind, payload: DecisionPayload) => void;
+    onComplete?: (outcome: DecisionOutcome) => void;
+    onCancel?: (payload: DecisionPayload) => void;
+    onError?: (payload: DecisionPayload) => void;
+    onDeadline?: (payload: DecisionPayload) => void;
+    onResize?: (height: number) => void;
+    /** Counter-proposal from approval flows (three-outcome). */
+    onCounter?: (payload: DecisionPayload) => void;
+}
+/** Options for `decisions.popup`. */
+interface DecisionsPopupOptions {
+    token: DecisionToken;
+    width?: number;
+    height?: number;
+    onComplete?: (outcome: DecisionOutcome) => void;
+    onCancel?: (payload: DecisionPayload) => void;
+    onError?: (payload: DecisionPayload) => void;
+}
+/** Handle returned by `decisions.embed` / `decisions.popup`. */
+interface DecisionsHandle {
+    readonly token: DecisionToken;
+    readonly mode: DecisionMode;
+    destroy(): Promise<void>;
+}
+/** Public surface of the decisions primitive. */
+interface DecisionsNamespace {
+    embed(opts: DecisionsEmbedOptions): DecisionsHandle;
+    popup(opts: DecisionsPopupOptions): DecisionsHandle;
+    url(opts: {
+        token: DecisionToken;
+        mode?: DecisionMode;
+    }): string;
+    createSession(input: DecisionsCreateSessionInput): Promise<DecisionsSession>;
+    discover(opts: {
+        flowId: string;
+        locale?: string;
+    }): Promise<FlowDisclosures>;
+    exchange(input: DecisionsExchangeInput): Promise<DecisionExchange>;
+    cancel(token: DecisionToken): Promise<void>;
+}
+type FlowDisclosureMechanism = "explicit" | "informed" | "opt_out" | "documented" | "delegated";
+type FlowDisclosureLegalBasis = "consent" | "contract" | "legitimate_interest" | "legal_obligation" | "vital_interest" | "public_task";
+type FlowDisclosureButtonMode = "accept" | "acknowledge" | "authorize" | "connect" | "continue" | "share" | "sign_in" | "verify";
+interface FlowDisclosurePurpose {
+    name: string;
+    label: string;
+    description: string | null;
+    mechanism: FlowDisclosureMechanism;
+    legalBasis: FlowDisclosureLegalBasis;
+    required: boolean;
+    dataLabels: string[];
+}
+interface FlowDisclosureField {
+    name: string;
+    label: string;
+    fieldType: string;
+    required: boolean;
+    section: "input" | "obligation" | "proof";
+    completedBy: "principal" | "application" | "both";
+}
+interface FlowDisclosureStep {
+    key: string;
+    title: string;
+}
+interface FlowDisclosures {
+    schema: string;
+    flow: {
+        id: string;
+        name: string;
+        version: number;
+        kind: "consent";
+    };
+    application: {
+        name: string;
+        primaryColor: string | null;
+        logoUrl: string | null;
+    };
+    purposes: FlowDisclosurePurpose[];
+    fields: FlowDisclosureField[];
+    steps: FlowDisclosureStep[];
+    presentation: {
+        buttonMode: FlowDisclosureButtonMode;
+        displayLabel: string;
+    };
+    outcomes: Array<"granted" | "denied">;
+    expiry: {
+        consentDurationDays: number | null;
+    };
+    locale: {
+        requested: "params" | "header" | "default";
+        resolved: string;
+        fallback: "en";
+    };
+    revision: string;
+}
+/**
+ * A participant's own view of one meeting (camelCase after the ApiClient's
+ * toCamelCase pass). `purposes` maps purpose name → the recorded decision
+ * value; `meeting` names the meeting the decision is pinned to.
+ */
+interface MeetingParticipantStatus {
+    meetingConsentId: string;
+    status: "pending" | "fulfilled" | "expired" | "revoked" | string;
+    consentedAt: string | null;
+    revokedAt: string | null;
+    purposes: Record<string, string>;
+    meeting: {
+        id: string;
+        title: string | null;
+        scheduledAt: string | null;
+        endsAt: string | null;
+        platform: string | null;
+        cancelledAt: string | null;
+    } | null;
+}
+/** Options for `consent.open` (preserves v0 callback names). */
+interface ConsentOpenOptions {
+    flowId: string;
+    container: string | HTMLElement;
+    mode?: DecisionMode;
+    embedOrigin?: string;
+    scope?: string;
+    state?: string;
+    nonce?: string;
+    redirectUri?: string;
+    style?: EmbedStyle;
+    loading?: string | HTMLElement;
+    onComplete?: (outcome: DecisionOutcome & {
+        kind: "consent";
+    }) => void;
+    onCancel?: (payload: DecisionPayload) => void;
+    onError?: (payload: DecisionPayload) => void;
+    onStep?: (payload: DecisionPayload) => void;
+    onReady?: (payload: DecisionPayload) => void;
+}
+/** Options for `approvals.open` (three-outcome flow). */
+interface ApprovalsOpenOptions {
+    escalationId: string;
+    container: string | HTMLElement;
+    mode?: DecisionMode;
+    embedOrigin?: string;
+    state?: string;
+    redirectUri?: string;
+    style?: EmbedStyle;
+    loading?: string | HTMLElement;
+    onComplete?: (outcome: DecisionOutcome & {
+        kind: "approval";
+    }) => void;
+    onCancel?: (payload: DecisionPayload) => void;
+    onError?: (payload: DecisionPayload) => void;
+    onState?: (payload: DecisionPayload) => void;
+    onDeadline?: (payload: DecisionPayload) => void;
+    onCounter?: (payload: DecisionPayload) => void;
+    onReady?: (payload: DecisionPayload) => void;
+}
+/** Public surface of the consent facade. */
+interface ConsentNamespace {
+    open(opts: ConsentOpenOptions): Promise<DecisionsHandle>;
+    url(opts: {
+        flowId: string;
+        mode?: DecisionMode;
+    }): string;
+    /** 189 — pre-flight disclosure discovery for a consent flow (delegates to `decisions.discover`). */
+    discover(opts: {
+        flowId: string;
+        locale?: string;
+    }): Promise<FlowDisclosures>;
+}
+/** Public surface of the approvals facade. */
+interface ApprovalsNamespace {
+    open(opts: ApprovalsOpenOptions): Promise<DecisionsHandle>;
+    url(opts: {
+        escalationId: string;
+        mode?: DecisionMode;
+    }): string;
+    /** Returns remaining deadline for an approval session. */
+    deadline(token: DecisionToken): Promise<{
+        remainingMs: number;
+        deadlineAt: string;
+    }>;
+}
+/**
+ * Options for `signing.open` (cross-border signing, kind
+ * `signature_request`). Mirrors `ApprovalsOpenOptions`; `signatureRef` is the
+ * per-party signing slot the host resolves to a signing token. `onComplete`
+ * narrows to the signing outcome (`signed | declined | countered`). `onState`
+ * receives the signing STATE payload (assurance + progress; see
+ * {@link SignatureStatePayload}).
+ */
+interface SigningOpenOptions {
+    signatureRef: string;
+    container: string | HTMLElement;
+    mode?: DecisionMode;
+    embedOrigin?: string;
+    state?: string;
+    redirectUri?: string;
+    style?: EmbedStyle;
+    loading?: string | HTMLElement;
+    onComplete?: (outcome: DecisionOutcome & {
+        kind: "signature_request";
+    }) => void;
+    onCancel?: (payload: DecisionPayload) => void;
+    onError?: (payload: DecisionPayload) => void;
+    /** Signing STATE — typed assurance + progress (`signature/state.json`). */
+    onState?: (payload: SignatureStatePayload) => void;
+    onDeadline?: (payload: DecisionPayload) => void;
+    /** Fires on a `countered` outcome. Signing carries no proposal payload. */
+    onCounter?: (payload: DecisionPayload) => void;
+    onReady?: (payload: DecisionPayload) => void;
+}
+/** Public surface of the signing facade. */
+interface SigningNamespace {
+    open(opts: SigningOpenOptions): Promise<DecisionsHandle>;
+    url(opts: {
+        signatureRef: string;
+        mode?: DecisionMode;
+    }): string;
+    /** Returns remaining deadline for a signing session. */
+    deadline(token: DecisionToken): Promise<{
+        remainingMs: number;
+        deadlineAt: string;
+    }>;
+}
+
+interface DecisionsConfig {
+    api: ApiClient;
+    flowBaseUrl: string;
+    debug: boolean;
+}
+/**
+ * Implementation of the kind-agnostic decisions namespace. Exposed
+ * to consumers as `Overturo#decisions`.
+ *
+ * The class tracks every live `DecisionsHandle` it creates so
+ * `Overturo#destroy()` can tear them all down at once.
+ */
+declare class Decisions implements DecisionsNamespace {
+    #private;
+    constructor(config: DecisionsConfig);
+    /**
+     * Returns the canonical decisions URL for a token. `mode="embed"`
+     * gets the `/embed` suffix; `popup` and `redirect` use the bare
+     * path (the server-rendered page handles both).
+     */
+    url(opts: {
+        token: DecisionToken;
+        mode?: DecisionMode;
+    }): string;
+    /**
+     * Creates a new decisions session via `POST /api/v1/decisions`.
+     * Wraps the legacy v0 API client's snake-case helpers so existing
+     * tests around case conversion keep working.
+     */
+    createSession(input: DecisionsCreateSessionInput): Promise<DecisionsSession>;
+    /**
+     * pre-flight disclosure discovery. Fetches what the decision screen
+     * will present for a flow, BEFORE any session exists: purposes, fields,
+     * steps, the action label, expiry, and application branding, in public
+     * vocabulary and the requested locale. The recommended first call in the
+     * embed flow: discover -> createSession -> (SDK reads config).
+     *
+     * Publishable-key authenticated — the ApiClient already sends
+     * `X-Publishable-Key` (api.ts); the server ignores any bearer header on this
+     * endpoint. An unknown / foreign / non-consent flow answers a uniform 404
+     * (OverturoApiError, status 404).
+     */
+    discover(opts: {
+        flowId: string;
+        locale?: string;
+    }): Promise<FlowDisclosures>;
+    /**
+     * Mounts the decisions flow inside an iframe under `opts.container`.
+     * Validates inbound v2 envelopes; drops on origin mismatch /
+     * schema-invalid. Returns a handle whose `.destroy()` tears down
+     * the iframe + listener.
+     */
+    embed(opts: DecisionsEmbedOptions): DecisionsHandle;
+    /**
+     * Opens the decisions flow in a popup window. Caller MUST invoke this
+     * synchronously from a user-action handler or browsers will block.
+     */
+    popup(opts: DecisionsPopupOptions): DecisionsHandle;
+    /**
+     * Exchanges a completed decision's token for the per-kind receipt.
+     * Server returns a discriminated union; the SDK preserves the
+     * discriminator so consumers using strict TypeScript get narrowing.
+     */
+    exchange(input: DecisionsExchangeInput): Promise<DecisionExchange>;
+    /**
+     * Asks the server to mark a session as cancelled. Idempotent on
+     * already-terminal sessions.
+     */
+    cancel(token: DecisionToken): Promise<void>;
+    /**
+     * Tears down every live handle (embed or popup) this client created.
+     * Called by `Overturo#destroy()`. Errors during destroy are swallowed
+     * — we want best-effort cleanup, not a half-destroyed state.
+     */
+    destroyAll(): Promise<void>;
+}
+
+declare class ApprovalsFacade implements ApprovalsNamespace {
+    #private;
+    constructor(decisions: Decisions, api: ApiClient);
+    open(opts: ApprovalsOpenOptions): Promise<DecisionsHandle>;
+    url(opts: {
+        escalationId: string;
+        mode?: DecisionMode;
+    }): string;
+    /**
+     * Polls `${decisions_api}/:token` for deadline metadata. Returns the
+     * computed remainingMs alongside the absolute deadlineAt for clock-
+     * skew tolerance in consumers.
+     */
+    deadline(token: DecisionToken): Promise<{
+        remainingMs: number;
+        deadlineAt: string;
+    }>;
+}
+
+declare class ConsentFacade implements ConsentNamespace {
+    #private;
+    constructor(decisions: Decisions);
+    /**
+     * Creates a consent session and mounts the iframe in one call.
+     * Bridges v0's `onStep(payload)` to v1's `onState(kind, payload)`
+     * so existing call sites keep working with a single rename.
+     */
+    open(opts: ConsentOpenOptions): Promise<DecisionsHandle>;
+    url(opts: {
+        flowId: string;
+        mode?: DecisionMode;
+    }): string;
+    /**
+     * pre-flight disclosure discovery. Thin delegate to
+     * `decisions.discover` so the kind facades stay symmetric.
+     */
+    discover(opts: {
+        flowId: string;
+        locale?: string;
+    }): Promise<FlowDisclosures>;
+}
+
+/**
+ * 201 D4 Level B — Form Capture: the organisation keeps its form; Overturo
+ * keeps the record. `attach` intercepts the form's submit, reads the mapped
+ * consent controls (decision + presentation as shown), posts one capture
+ * with the publishable key, writes the capture token into a hidden input and
+ * lets the submission proceed. If Overturo is unreachable the form still
+ * submits and `onError` fires. Writes nothing to client storage.
+ *
+ * @example
+ * ```ts
+ * overturo.forms.attach({
+ *   flowId: "flw_...",
+ *   form: "#signup",
+ *   map: { marketing: "#marketing_opt_in", analytics: "#analytics" },
+ *   subjectField: "#email",
+ * })
+ * ```
+ */
+declare class FormsFacade {
+    private readonly api;
+    private readonly decisions;
+    private readonly flowBaseUrl;
+    private readonly publishableKey;
+    constructor(api: ApiClient, decisions: Decisions, flowBaseUrl: string, publishableKey: string);
+    /** Wires the capture onto the form; returns a detach function. */
+    attach(opts: FormCaptureOptions): () => void;
+    /**
+     * 202 D9 — the embedded consent field: the control is Overturo-rendered
+     * inside the form, so the element does the capture from its own frame. The
+     * field entry (`@overturo/js/field` / `overturo-field.js`) must be loaded;
+     * one field per flow per form.
+     */
+    private attachField;
+    /** Builds the capture body the way `attach` does — exposed for integrators who post themselves. */
+    buildCaptureBody(form: HTMLFormElement, opts: FormCaptureOptions, initiallyChecked?: Record<string, boolean>): Record<string, unknown>;
+    /**
+     * 201 D11 — the digest of each mapped label's text as the person saw it
+     * (a 256-bit digest of the trimmed text — the algorithm the forms
+     * documentation publishes), so the record can
+     * say whether the form's wording matched the wording published for the flow.
+     * Needs `labels` (purpose → label selector) and WebCrypto; otherwise nothing is attested.
+     */
+    labelDigests(form: HTMLFormElement, opts: FormCaptureOptions): Promise<Record<string, string> | undefined>;
+    /** 201 D11 — writes the published wording into the labels the integrator names. */
+    writeWording(form: HTMLFormElement, opts: FormCaptureOptions): Promise<void>;
+}
+
+declare class SigningFacade implements SigningNamespace {
+    #private;
+    constructor(decisions: Decisions, api: ApiClient);
+    open(opts: SigningOpenOptions): Promise<DecisionsHandle>;
+    url(opts: {
+        signatureRef: string;
+        mode?: DecisionMode;
+    }): string;
+    /**
+     * Polls `${decisions_api}/:token` for deadline metadata. Returns the
+     * computed remainingMs alongside the absolute deadlineAt for clock-
+     * skew tolerance in consumers.
+     */
+    deadline(token: DecisionToken): Promise<{
+        remainingMs: number;
+        deadlineAt: string;
+    }>;
+}
+
+/**
+ * The main Overturo client for initiating consent flows and exchanging tokens.
+ *
+ * @example
+ * ```ts
+ * const overturo = new Overturo({ publishableKey: "pk_live_..." });
+ *
+ * // High-level: create session + embed in one call
+ * const flow = await overturo.consent({
+ *   flowId: "flw_...",
+ *   container: "#consent",
+ *   onComplete: (result) => console.log(result.consentToken),
+ * });
+ *
+ * // Low-level: manual session + embed
+ * const session = await overturo.createSession({ flowId: "flw_..." });
+ * const widget = overturo.embed({ sessionToken: session.sessionToken, container: "#el" });
+ * ```
+ */
+declare class Overturo {
+    private api;
+    private baseUrl;
+    private flowBaseUrl;
+    private debugFlag;
+    readonly decisions: Decisions;
+    readonly consent: ConsentFacade;
+    readonly approvals: ApprovalsFacade;
+    readonly signing: SigningFacade;
+    /** 201 — Form Capture: the organisation keeps its form; Overturo keeps the record. */
+    readonly forms: FormsFacade;
+    constructor(options: OverturoOptions);
+    /**
+     * Tears down every live decisions handle (embed iframes + popups).
+     * Best-effort: errors during teardown are swallowed.
+     *
+     * @since 1.0.0
+     */
+    destroy(): Promise<void>;
+    /**
+     * Creates a new consent session.
+     * The flowId is sent as accord_id to the server (automatic parameter aliasing).
+     */
+    createSession(params: CreateSessionParams): Promise<Session>;
+    /**
+     * Retrieves the status of an existing consent session.
+     */
+    getSession(sessionToken: string): Promise<SessionStatus>;
+    /**
+     * This participant's consent status for ONE meeting (the meeting's own
+     * window and platform ride along). Identified by the participant's own
+     * session token — never lists other participants.
+     */
+    getMeetingParticipantStatus(meetingId: string, sessionToken: string): Promise<MeetingParticipantStatus>;
+    /**
+     * Withdraws this participant's consent for ONE meeting. The host is told;
+     * the record keeps the withdrawal.
+     */
+    withdrawMeetingConsent(meetingId: string, sessionToken: string): Promise<MeetingParticipantStatus>;
+    private decodeParticipantStatus;
+    /**
+     * Embeds a consent flow in an iframe.
+     * Requires a sessionToken from createSession().
+     */
+    embed(options: EmbedOptions): EmbedHandle;
+    /**
+     * Opens a consent flow in a popup window.
+     * Requires a sessionToken from createSession().
+     *
+     * @throws {OverturoError} If the browser blocks the popup.
+     */
+    popup(options: PopupOptions): PopupHandle;
+    /**
+     * Redirects to a consent flow (full-page navigation).
+     * No session token needed — the server creates one on arrival.
+     */
+    redirect(options: RedirectOptions): void;
+    /**
+     * Exchanges a consent token for claims, attestations, credentials, and tokens.
+     * Best used server-side with apiKey set.
+     *
+     * Handles HTTP 202 (fulfillment pending) transparently by retrying with
+     * the Retry-After interval until the server returns the full result.
+     */
+    exchange(params: ExchangeParams): Promise<ExchangeResult>;
+    /**
+     * Creates a new AccordSetup session via the API.
+     * Lower-level than accordSetup() — use when you need manual control.
+     */
+    createSetupSession(params: CreateSetupSessionParams): Promise<SetupSession>;
+    /**
+     * High-level: creates a setup session and embeds the wizard in an iframe.
+     *
+     * @example
+     * ```ts
+     * const handle = await overturo.accordSetup({
+     *   solution: "meetings",
+     *   container: "#setup",
+     *   onCreated: ({ flowId }) => console.log("Created:", flowId),
+     * });
+     * ```
+     */
+    accordSetup(options: AccordSetupOptions): Promise<SetupHandle>;
+    /**
+     * Creates a setup session and opens the wizard in a popup window.
+     */
+    accordSetupPopup(options: AccordSetupPopupOptions): Promise<SetupPopupHandle>;
+    /**
+     * Creates a setup session and redirects to the wizard (full-page navigation).
+     * On completion, the user is redirected back to `redirectUri` with query params.
+     */
+    accordSetupRedirect(options: AccordSetupRedirectOptions): Promise<void>;
+    /**
+     * Preview a template in an iframe.
+     *
+     * Creates a preview token via the API, then renders the preview in the
+     * specified container. Returns a handle for controlling the preview.
+     *
+     * @example
+     * ```ts
+     * const preview = await overturo.previewTemplate({
+     *   templateId: "tpl_abc123",
+     *   container: "#preview",
+     *   device: "mobile",
+     *   theme: "corporate",
+     * });
+     * preview.setDevice("desktop");
+     * preview.destroy();
+     * ```
+     */
+    previewTemplate(options: PreviewTemplateOptions): Promise<PreviewHandle>;
+    /**
+     * Preview a setup session in an iframe.
+     *
+     * Creates a preview token via the API for the specified setup session,
+     * then renders the preview in the specified container.
+     *
+     * @example
+     * ```ts
+     * const preview = await overturo.previewSetup({
+     *   sessionToken: "acs_abc123",
+     *   container: "#preview",
+     * });
+     * preview.setTheme("dark");
+     * preview.destroy();
+     * ```
+     */
+    previewSetup(options: PreviewSetupOptions): Promise<PreviewHandle>;
+    /**
+     * Builds common CreateSetupSessionParams from any setup options variant.
+     */
+    private buildSetupParams;
+}
+
+/**
+ * 201 D12 — the decision and the presentation of one mapped form control, as
+ * observed in the DOM at submit: ticked → granted, unticked → declined (never
+ * silence), with the default-ticked and required flags the server's matrix
+ * refuses for a consent purpose. Only checkable controls are read; anything
+ * else is declined (a text field is never a consent).
+ */
+interface AttestedDecision {
+    decision: "granted" | "declined";
+    default_checked: boolean;
+    mandatory: boolean;
+}
+
+/**
+ * Creates an AccordSetup wizard embedded in an iframe.
+ *
+ * @param baseUrl - The Overturo base URL
+ * @param options - Setup options including session token, container, and callbacks
+ * @returns Handle with iframe reference and destroy method
+ */
+declare function createSetupEmbed(baseUrl: string, options: AccordSetupOptions & {
+    sessionToken: string;
+}): SetupHandle;
+/**
+ * Opens the AccordSetup wizard in a popup window.
+ *
+ * @param baseUrl - The Overturo base URL
+ * @param options - Popup options including session token and callbacks
+ * @returns Handle with close method
+ */
+declare function createSetupPopup(baseUrl: string, options: AccordSetupPopupOptions & {
+    sessionToken: string;
+}): SetupPopupHandle;
+/**
+ * Redirects to the AccordSetup wizard (full-page navigation).
+ *
+ * @param baseUrl - The Overturo base URL
+ * @param options - Redirect options including session token
+ */
+declare function setupRedirect(baseUrl: string, options: AccordSetupRedirectOptions & {
+    sessionToken: string;
+}): void;
+
+/** Base error class for all Overturo SDK errors. */
+declare class OverturoError extends Error {
+    constructor(message: string);
+}
+/** Thrown when required parameters are missing or invalid. */
+declare class OverturoValidationError extends OverturoError {
+    constructor(message: string);
+}
+/** Thrown when the API returns a 4xx or 5xx response. */
+declare class OverturoApiError extends OverturoError {
+    /** HTTP status code. */
+    status: number;
+    /** Parsed response body, if available. */
+    body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+/** Thrown when a network error prevents the request from completing. */
+declare class OverturoNetworkError extends OverturoError {
+    /** The original error that caused the failure. */
+    cause: unknown;
+    constructor(message: string, cause: unknown);
+}
+/** Thrown when an operation times out. */
+declare class OverturoTimeoutError extends OverturoError {
+    constructor(message?: string);
+}
+/**
+ * OAP denial category vocabulary.
+ *
+ * Cascade-relevant errors returned by OAP endpoints carry one of these
+ * values. Non-cascade errors (validation, conflict, internal) omit the
+ * field.
+ */
+type OapDenialCategory = "authorization_denied" | "intent_denied" | "trajectory_denied";
+/**
+ * Shape of a single OAP error envelope as rendered by the server.
+ * Surfaced through {@link OapDenied} so callers can introspect the
+ * full envelope without re-parsing the response body.
+ */
+interface OapErrorEnvelope {
+    reason_code: string;
+    message: string;
+    detail?: Record<string, unknown>;
+    failed_bound?: string;
+    denial_category?: OapDenialCategory;
+    cascade_step?: number;
+    request_id?: string;
+    negotiable?: boolean;
+    negotiate_url?: string;
+    documentation_url?: string;
+}
+/**
+ * Thrown when an OAP-protocol endpoint returns a denial.
+ *
+ * Carries the structured fields from the OAP error envelope. The
+ * three subclasses below map 1:1 to {@link OapDenialCategory} so
+ * callers can `catch (e: OapIntentDenied)` directly.
+ */
+declare class OapDenied extends OverturoApiError {
+    reason_code: string;
+    failed_bound: string | undefined;
+    denial_category: OapDenialCategory | undefined;
+    cascade_step: number | undefined;
+    detail: Record<string, unknown> | undefined;
+    constructor(envelope: OapErrorEnvelope, status: number, body: unknown);
+    /**
+     * Build the most-specific subclass for the envelope. Reason-code
+     * dispatch takes precedence over category dispatch so the most
+     * specific subclass wins (sequence denials are
+     * trajectory_denied but get their own subclass).
+     */
+    static fromEnvelope(envelope: OapErrorEnvelope, status: number, body: unknown): OapDenied;
+}
+/** denial_category == "authorization_denied" — OAuth/DPoP layer rejected. */
+declare class OapAuthorizationDenied extends OapDenied {
+    constructor(envelope: OapErrorEnvelope, status: number, body: unknown);
+}
+/** denial_category == "intent_denied" — request fell outside grant bounds. */
+declare class OapIntentDenied extends OapDenied {
+    constructor(envelope: OapErrorEnvelope, status: number, body: unknown);
+}
+/** denial_category == "trajectory_denied" — execution history blocked. */
+declare class OapTrajectoryDenied extends OapDenied {
+    constructor(envelope: OapErrorEnvelope, status: number, body: unknown);
+}
+/**
+ * 2 — sequence_bounds violation
+ * (`sequence_prohibited` / `sequence_missing_predecessor`). A
+ * trajectory denial with a structural-ordering flavour.
+ */
+declare class OapSequenceDenied extends OapTrajectoryDenied {
+    constructor(envelope: OapErrorEnvelope, status: number, body: unknown);
+}
+
+declare const ElementBase: typeof HTMLElement;
+
+declare const ELEMENT_NAME = "overturo-decision";
+declare const ALREADY_DEFINED_CODE = "OVERTURO_ELEMENT_ALREADY_DEFINED";
+/**
+ * Reads `token` + `mode` + `theme` attributes; mounts the trust-host
+ * iframe under a Shadow DOM root; emits CustomEvents for every
+ * lifecycle transition. Consumers can subscribe with bare DOM APIs
+ * (no SDK initialisation required for the simple case).
+ *
+ * Events fired (all CustomEvent):
+ *   `decision:ready`     — `detail` is the READY payload
+ *   `decision:state`     — `detail = {kind, payload}`
+ *   `decision:complete`  — `detail = {kind, payload}`
+ *   `decision:cancel`    — `detail` is the CANCEL payload
+ *   `decision:error`     — `detail` is the ERROR payload
+ *   `decision:deadline`  — `detail` is the DEADLINE payload
+ */
+declare class DecisionElement extends ElementBase {
+    #private;
+    static observedAttributes: string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+}
+/**
+ * Default registration. Side-effect import from `src/elements/index.ts`
+ * triggers this on bundle load. Skipped (with a console warning) if
+ * the element is already registered.
+ */
+declare function registerDecisionElement(): void;
+
+export { ALREADY_DEFINED_CODE, type AccordSetupOptions, type AccordSetupPopupOptions, type AccordSetupRedirectOptions, type AccordSetupResult, type ApprovalsNamespace, type ApprovalsOpenOptions, type Attestation, type AttestedDecision, type ConsentNamespace, type ConsentOpenOptions, type ConsentOptions, type ConsentResult, type CreateSessionParams, type CreateSetupSessionParams, type Credential, DecisionElement, type DecisionExchange, type DecisionKind, type DecisionMode, type DecisionOutcome, type DecisionPayload, type DecisionToken, type DecisionsCreateSessionInput, type DecisionsEmbedOptions, type DecisionsExchangeInput, type DecisionsHandle, type DecisionsNamespace, type DecisionsPopupOptions, type DecisionsSession, ELEMENT_NAME, type EmbedHandle, type EmbedOptions, type EmbedStyle, type ExchangeParams, type ExchangeResult, type FlowDisclosureButtonMode, type FlowDisclosureField, type FlowDisclosureLegalBasis, type FlowDisclosureMechanism, type FlowDisclosurePurpose, type FlowDisclosureStep, type FlowDisclosures, type FormCaptureOptions, type FormCaptureResult, type MeetingParticipantStatus, OapAuthorizationDenied, type OapDenialCategory, OapDenied, type OapErrorEnvelope, OapIntentDenied, OapSequenceDenied, OapTrajectoryDenied, Overturo, OverturoApiError, OverturoError, OverturoNetworkError, type OverturoOptions, OverturoTimeoutError, OverturoValidationError, type PopupHandle, type PopupOptions, type RedirectOptions, type Session, type SessionStatus, type SetupConstraints, type SetupHandle, type SetupPopupHandle, type SetupSession, type SetupStep, type SignatureStatePayload, type SigningNamespace, type SigningOpenOptions, type StepInfo, createSetupEmbed, createSetupPopup, Overturo as default, registerDecisionElement, setupRedirect };