@payabli/component-contracts 0.1.0

package/dist/payin/definition.d.ts

@@ -0,0 +1,81 @@
+import type { Infer, InferEvents } from '../protocol/envelope.js';
+import { payinEvents, payinOptionsSchema } from './schema.js';
+import type { PayInSuccessPayload } from './schema.js';
+export * from './schema.js';
+/**
+ * The partner-facing options type IS the wire schema's type: one definition
+ * serves the SDK surface and payhub's validator.
+ */
+export type PayInOptions = Infer<typeof payinOptionsSchema>;
+/**
+ * Event payload types are INFERRED from the shared wire schemas, so the
+ * partner-facing surface and the wire validators are one definition.
+ * `success` is the one exception: it comes from SUBMIT_RESULT.data, which the
+ * base protocol types openly and PayIn narrows. Partners consume the full map
+ * as `PayInEvents` (see `aliases.ts`).
+ */
+declare module '../registry.js' {
+    interface ComponentDefinitions {
+        payin: ComponentDefinition<PayInOptions, InferEvents<typeof payinEvents> & {
+            success: PayInSuccessPayload;
+        }>;
+    }
+}
+/**
+ * Wire type → emitter event, with the shared schema from `./schema.js` as the
+ * only validator.
+ */
+export declare const payInEventSchemas: {
+    METHOD_CHANGE: {
+        event: "methodChange";
+        schema: import("zod/v4/mini").ZodMiniObject<{
+            method: import("zod/v4/mini").ZodMiniEnum<{
+                card: "card";
+                ach: "ach";
+                check: "check";
+                applepay: "applepay";
+                googlepay: "googlepay";
+            }>;
+        }, import("zod/v4/core").$strip>;
+    };
+    WALLET_AVAILABLE: {
+        event: "walletAvailable";
+        schema: import("zod/v4/mini").ZodMiniObject<{
+            applepay: import("zod/v4/mini").ZodMiniBoolean<boolean>;
+            googlepay: import("zod/v4/mini").ZodMiniBoolean<boolean>;
+        }, import("zod/v4/core").$strip>;
+    };
+    CARD_BRAND_CHANGE: {
+        event: "cardBrandChange";
+        schema: import("zod/v4/mini").ZodMiniObject<{
+            brand: import("zod/v4/mini").ZodMiniEnum<{
+                unknown: "unknown";
+                Visa: "Visa";
+                Mastercard: "Mastercard";
+                Amex: "Amex";
+                Discover: "Discover";
+                Jcb: "Jcb";
+                Diners: "Diners";
+            }>;
+        }, import("zod/v4/core").$strip>;
+    };
+    VALIDATION_STATUS: {
+        event: "validationStatus";
+        schema: import("zod/v4/mini").ZodMiniObject<{
+            status: import("zod/v4/mini").ZodMiniEnum<{
+                verified: "verified";
+                pending: "pending";
+                failed: "failed";
+                warning: "warning";
+            }>;
+            message: import("zod/v4/mini").ZodMiniOptional<import("zod/v4/mini").ZodMiniString<string>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    VENDOR_CREATED: {
+        event: "vendorCreated";
+        schema: import("zod/v4/mini").ZodMiniObject<{
+            vendorId: import("zod/v4/mini").ZodMiniString<string>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+export declare const payInDescriptor: import("../registry.js").ComponentDescriptor<"payin">;

package/dist/payin/schema.d.ts

@@ -0,0 +1,72 @@
+import * as z from 'zod/v4/mini';
+/**
+ * PayIn's wire contract: its event schemas, options schema, and vocabulary.
+ * PayIn-specific on purpose — a payout component defines its own methods in
+ * its own folder.
+ */
+export declare const PAYMENT_METHODS: readonly ["card", "ach", "check", "applepay", "googlepay"];
+export type PaymentMethodName = (typeof PAYMENT_METHODS)[number];
+/**
+ * A card network. Not a payment method. Accepted brands are session config
+ * (`Session/init` acceptedCardBrands), not a client option: the API owns them
+ * and payhub reads them from bootstrap.
+ */
+export declare const CARD_BRANDS: readonly ["Visa", "Mastercard", "Amex", "Discover", "Jcb", "Diners"];
+export type CardBrand = (typeof CARD_BRANDS)[number];
+/**
+ * Client-side UI behavior only. Business configuration — operation, methods,
+ * amount, required fields, billing address — belongs to `Session/init` on the
+ * partner's server, and its types belong to the API's generated SDK.
+ *
+ * The SDK sends this in CONFIG_SET.options and payhub parses with this same
+ * object (via the descriptor's `optionsSchema`).
+ */
+export declare const payinOptionsSchema: z.ZodMiniObject<{
+    showSubmitButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>;
+/** PayIn's own inbound events, beyond the base set every component shares. */
+export declare const payinEvents: {
+    readonly METHOD_CHANGE: z.ZodMiniObject<{
+        method: z.ZodMiniEnum<{
+            card: "card";
+            ach: "ach";
+            check: "check";
+            applepay: "applepay";
+            googlepay: "googlepay";
+        }>;
+    }, z.core.$strip>;
+    readonly WALLET_AVAILABLE: z.ZodMiniObject<{
+        applepay: z.ZodMiniBoolean<boolean>;
+        googlepay: z.ZodMiniBoolean<boolean>;
+    }, z.core.$strip>;
+    readonly CARD_BRAND_CHANGE: z.ZodMiniObject<{
+        brand: z.ZodMiniEnum<{
+            unknown: "unknown";
+            Visa: "Visa";
+            Mastercard: "Mastercard";
+            Amex: "Amex";
+            Discover: "Discover";
+            Jcb: "Jcb";
+            Diners: "Diners";
+        }>;
+    }, z.core.$strip>;
+    readonly VALIDATION_STATUS: z.ZodMiniObject<{
+        status: z.ZodMiniEnum<{
+            verified: "verified";
+            pending: "pending";
+            failed: "failed";
+            warning: "warning";
+        }>;
+        message: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>;
+    readonly VENDOR_CREATED: z.ZodMiniObject<{
+        vendorId: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+};
+/**
+ * SUBMIT_RESULT.data for PayIn. Open on purpose: the transaction result grows
+ * fields the SDK does not interpret, and it forwards all of them.
+ */
+export type PayInSuccessPayload = {
+    transactionId?: string;
+} & Record<string, unknown>;

package/dist/protocol/base.d.ts

@@ -0,0 +1,164 @@
+import * as z from 'zod/v4/mini';
+import type { ProtocolMessageEvent } from './envelope.js';
+export declare const componentErrorSchema: z.ZodMiniObject<{
+    code: z.ZodMiniString<string>;
+    message: z.ZodMiniString<string>;
+    recoverable: z.ZodMiniBoolean<boolean>;
+    details: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
+}, z.core.$strip>;
+export type ComponentError = z.infer<typeof componentErrorSchema>;
+/**
+ * Client-side appearance, shared by every component. The SDK sends it in
+ * CONFIG_SET and payhub parses it with this same object, so the layout
+ * vocabulary exists in exactly one place.
+ */
+export declare const appearanceSchema: z.ZodMiniObject<{
+    layout: z.ZodMiniOptional<z.ZodMiniEnum<{
+        tabs: "tabs";
+        accordion: "accordion";
+        stacked: "stacked";
+        minimal: "minimal";
+    }>>;
+    layoutVariant: z.ZodMiniOptional<z.ZodMiniEnum<{
+        compact: "compact";
+        standard: "standard";
+        wide: "wide";
+    }>>;
+    labelStyle: z.ZodMiniOptional<z.ZodMiniEnum<{
+        above: "above";
+        floating: "floating";
+        outlined: "outlined";
+    }>>;
+    mode: z.ZodMiniOptional<z.ZodMiniEnum<{
+        light: "light";
+        dark: "dark";
+        system: "system";
+    }>>;
+    tokens: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    labels: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+}, z.core.$strip>;
+export type AppearanceOptions = z.infer<typeof appearanceSchema>;
+/**
+ * Inbound wire messages: iframe → parent SDK. One schema per wire type, and
+ * this map is the only definition. Payhub emits through these objects and the
+ * SDK validates with the same objects, so agreement between the two sides is
+ * shared, not tested.
+ */
+export declare const baseInboundEvents: {
+    readonly READY: z.ZodMiniObject<{
+        fields: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+        methods: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    }, z.core.$strip>;
+    readonly RENDERED: z.ZodMiniObject<{}, z.core.$strip>;
+    readonly CONFIG_REQUEST: z.ZodMiniObject<{}, z.core.$strip>;
+    readonly PREFILL_REQUEST: z.ZodMiniObject<{}, z.core.$strip>;
+    readonly RESIZE: z.ZodMiniObject<{
+        height: z.ZodMiniNumber<number>;
+    }, z.core.$strip>;
+    readonly STATE_CHANGE: z.ZodMiniObject<{
+        isValid: z.ZodMiniBoolean<boolean>;
+        completeness: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        fields: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+            valid: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+            touched: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    readonly SUBMIT_RESULT: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+        success: z.ZodMiniLiteral<true>;
+        data: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
+    }, z.core.$strip>, z.ZodMiniObject<{
+        success: z.ZodMiniLiteral<false>;
+        error: z.ZodMiniObject<{
+            code: z.ZodMiniString<string>;
+            message: z.ZodMiniString<string>;
+            recoverable: z.ZodMiniBoolean<boolean>;
+            details: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "success">;
+    readonly ERROR: z.ZodMiniObject<{
+        code: z.ZodMiniString<string>;
+        message: z.ZodMiniString<string>;
+        recoverable: z.ZodMiniBoolean<boolean>;
+        details: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
+    }, z.core.$strip>;
+    readonly LOADING: z.ZodMiniObject<{
+        state: z.ZodMiniEnum<{
+            bootstrapping: "bootstrapping";
+            submitting: "submitting";
+            validating: "validating";
+        }>;
+    }, z.core.$strip>;
+};
+export type BaseInboundType = keyof typeof baseInboundEvents;
+/**
+ * Outbound wire messages: parent SDK → iframe. `options` is a plain record
+ * here because its shape is per-component: payhub validates it with the
+ * `optionsSchema` on the component's descriptor.
+ */
+export declare const outboundMessages: {
+    readonly CONFIG_SET: z.ZodMiniObject<{
+        sessionToken: z.ZodMiniString<string>;
+        options: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
+        appearance: z.ZodMiniOptional<z.ZodMiniObject<{
+            layout: z.ZodMiniOptional<z.ZodMiniEnum<{
+                tabs: "tabs";
+                accordion: "accordion";
+                stacked: "stacked";
+                minimal: "minimal";
+            }>>;
+            layoutVariant: z.ZodMiniOptional<z.ZodMiniEnum<{
+                compact: "compact";
+                standard: "standard";
+                wide: "wide";
+            }>>;
+            labelStyle: z.ZodMiniOptional<z.ZodMiniEnum<{
+                above: "above";
+                floating: "floating";
+                outlined: "outlined";
+            }>>;
+            mode: z.ZodMiniOptional<z.ZodMiniEnum<{
+                light: "light";
+                dark: "dark";
+                system: "system";
+            }>>;
+            tokens: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+            labels: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly PREFILL_SET: z.ZodMiniObject<{
+        prefill: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+    }, z.core.$strip>;
+    readonly FOCUS_REQUEST: z.ZodMiniObject<{
+        field: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>;
+    readonly BLUR_REQUEST: z.ZodMiniObject<{}, z.core.$strip>;
+    readonly SUBMIT_REQUEST: z.ZodMiniObject<{}, z.core.$strip>;
+    readonly SESSION_UPDATE: z.ZodMiniObject<{
+        sessionToken: z.ZodMiniString<string>;
+        replace: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    }, z.core.$strip>;
+    readonly DESTROY: z.ZodMiniObject<{}, z.core.$strip>;
+    readonly PROTOCOL_ERROR: z.ZodMiniObject<{
+        originalType: z.ZodMiniString<string>;
+        reason: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+};
+export type OutboundType = keyof typeof outboundMessages;
+export type OutboundPayloads = {
+    [K in OutboundType]: z.infer<(typeof outboundMessages)[K]>;
+};
+/**
+ * The emitter events every component shares, keyed by the names partners
+ * subscribe to. Payload types come from the wire schemas above, so the partner
+ * surface cannot drift from what the wire actually carries.
+ */
+export type BaseComponentEventMap = {
+    ready: z.infer<(typeof baseInboundEvents)['READY']>;
+    rendered: Record<string, never>;
+    message: ProtocolMessageEvent;
+    success: Record<string, unknown>;
+    change: z.infer<(typeof baseInboundEvents)['STATE_CHANGE']>;
+    error: ComponentError;
+    loading: z.infer<(typeof baseInboundEvents)['LOADING']>;
+    resize: z.infer<(typeof baseInboundEvents)['RESIZE']>;
+};

package/dist/protocol/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const MESSAGE_SOURCE: "payabli";
+export declare const MESSAGE_VERSION: 1;

package/dist/protocol/envelope.d.ts

@@ -0,0 +1,65 @@
+import * as z from 'zod/v4/mini';
+/**
+ * Any zod schema whose output is `T`. The alias keeps consumers off zod
+ * internals: descriptors and schema maps are typed against this.
+ */
+export type WireSchema<T = unknown> = z.core.$ZodType<T>;
+export type Infer<S extends WireSchema> = z.infer<S>;
+export type ParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare const eventEnvelopeSchema: z.ZodMiniObject<{
+    source: z.ZodMiniLiteral<"payabli">;
+    version: z.ZodMiniLiteral<1>;
+    type: z.ZodMiniString<string>;
+    instanceId: z.ZodMiniString<string>;
+    payload: z.ZodMiniOptional<z.ZodMiniUnknown>;
+}, z.core.$strip>;
+export type EventEnvelope = z.infer<typeof eventEnvelopeSchema>;
+/**
+ * Reads a raw postMessage payload as a protocol envelope. Anything that is not
+ * an envelope of this protocol version returns null: the `message` event is a
+ * channel shared with the whole page, so foreign traffic is dropped, not
+ * reported.
+ */
+export declare function parseEnvelope(data: unknown): EventEnvelope | null;
+/**
+ * Validates one payload against its wire schema and reports failures in the
+ * `ParseResult` shape the SDK turns into PROTOCOL_ERROR messages.
+ */
+export declare function parsePayload<S extends WireSchema>(schema: S, value: unknown, path: string): ParseResult<z.infer<S>>;
+export type SchemaMap = Record<string, WireSchema>;
+type SnakeToCamel<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Lowercase<Head>}${Capitalize<SnakeToCamel<Tail>>}` : Lowercase<S>;
+/**
+ * The partner-facing event map a wire schema map defines: wire types become
+ * camelCase event names (`METHOD_CHANGE` → `methodChange`) and payload types
+ * are inferred from the schemas. One definition serves both the wire and the
+ * partner surface, so they cannot drift.
+ */
+export type InferEvents<Events extends SchemaMap> = {
+    [K in keyof Events & string as SnakeToCamel<K>]: Infer<Events[K]>;
+};
+/** The discriminated union of `{ type, payload }` pairs a schema map defines. */
+export type MessageOf<Events extends SchemaMap> = {
+    [K in keyof Events & string]: {
+        type: K;
+        payload: z.infer<Events[K]>;
+    };
+}[keyof Events & string];
+/**
+ * Validates one envelope against a schema map and returns the typed message.
+ * Own-property lookup only: a wire type like "constructor" must resolve to
+ * "unknown type", never to Object.prototype.
+ */
+export declare function parseMessage<Events extends SchemaMap>(envelope: EventEnvelope, events: Events): ParseResult<MessageOf<Events>>;
+/** The SDK's `message` debug event: every message it received or sent. */
+export type ProtocolMessageEvent = {
+    direction: 'inbound' | 'outbound';
+    type: string;
+    payload: Record<string, unknown>;
+};
+export {};

package/dist/registry.d.ts

@@ -0,0 +1,43 @@
+import type { WireSchema } from './protocol/envelope.js';
+import type { EventMap } from './shared.js';
+export interface ComponentDefinition<Options, Events> {
+    options: Options;
+    events: Events;
+}
+/** Component folders add entries through declaration merging. */
+export interface ComponentDefinitions {
+}
+export type ComponentType = Extract<keyof ComponentDefinitions, string>;
+type DefinitionOptions<T extends ComponentType> = ComponentDefinitions[T] extends ComponentDefinition<infer Options, unknown> ? Options : never;
+type DefinitionEvents<T extends ComponentType> = ComponentDefinitions[T] extends ComponentDefinition<unknown, infer Events> ? Events : never;
+export type ComponentOptions<T extends ComponentType> = T extends ComponentType ? DefinitionOptions<T> : never;
+export type ComponentEventMap<T extends ComponentType> = T extends ComponentType ? EventMap & DefinitionEvents<T> : never;
+export type ComponentEventKey<T extends ComponentType> = keyof ComponentEventMap<T>;
+export type ComponentEventName<T extends ComponentType> = T extends ComponentType ? Extract<ComponentEventKey<T>, string> : never;
+/**
+ * Routes one wire type to the emitter event it becomes. The schema is the
+ * shared wire contract from the component's own `schema.ts` — the same object
+ * payhub emits through, so the two sides cannot drift.
+ */
+export type EventSchemaDescriptor<EventName extends string = string> = {
+    event: EventName;
+    schema: WireSchema<Record<string, unknown>>;
+};
+export type ComponentDescriptor<T extends ComponentType = ComponentType> = {
+    type: T;
+    displayName: string;
+    embedPath: `/embed/${string}`;
+    /**
+     * Wire schema for CONFIG_SET.options. Payhub parses the options payload
+     * with this same object, so the partner-facing options type and the
+     * validator cannot drift.
+     */
+    optionsSchema: WireSchema<ComponentOptions<T>>;
+    eventSchemas: Readonly<Record<string, EventSchemaDescriptor<ComponentEventName<T>>>>;
+};
+export declare const componentDescriptors: ReadonlyMap<ComponentType, ComponentDescriptor>;
+/** Kept in registration order to preserve the former COMPONENT_TYPES value. */
+export declare const componentTypes: ComponentType[];
+export declare function register<T extends ComponentType>(descriptor: ComponentDescriptor<T>): ComponentDescriptor<T>;
+export declare function getComponentDescriptor<T extends ComponentType>(type: T): ComponentDescriptor<T> | undefined;
+export {};

package/dist/sdk.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The partner-facing SDK surface, defined once.
+ *
+ * The CDN script implements these types (`ComponentInstance implements
+ * ComponentHandle`, `PayabliFactory implements PayabliInstance`) and the npm
+ * wrapper re-exports them, so the surface the wrapper advertises is the one
+ * the script is compiled against.
+ */
+import type { ComponentEventKey, ComponentEventMap, ComponentOptions, ComponentType } from './registry.js';
+import type { AppearanceOptions } from './protocol/base.js';
+export interface Session {
+    /** Session JWT returned by `POST /v2/{entryName}/Session/init`. */
+    sessionToken: string;
+    /**
+     * Signed render token from the same response. The SDK puts it in the iframe URL as the
+     * `rt` parameter, where it identifies the entrypoint and carries the origin allowlist.
+     * It authenticates no API call. Every refresh returns a fresh one.
+     */
+    renderToken: string;
+    /** Organization or paypoint slug the session belongs to. Used to build the refresh URL. */
+    entryName: string;
+    environment: string;
+    /** ISO 8601 expiry of `sessionToken`. The SDK refreshes at ~80% of the remaining time. */
+    expiresAt: string;
+}
+export interface PayabliConfig {
+    session: Session;
+}
+export interface CreateOptions<T extends ComponentType = ComponentType> {
+    appearance?: AppearanceOptions;
+    options?: ComponentOptions<T>;
+    prefill?: Record<string, string>;
+    locale?: string;
+    timeout?: number;
+}
+export type MountOptions = {
+    height?: number;
+    maxHeight?: number;
+};
+export type SessionEventPayload = {
+    code: string;
+    message: string;
+    recoverable: boolean;
+    details?: Record<string, unknown>;
+};
+export type SessionEventMap = {
+    sessionExpired: SessionEventPayload;
+    sessionError: SessionEventPayload;
+};
+export type SessionEventKey = keyof SessionEventMap;
+export type ComponentHandle<T extends ComponentType = ComponentType> = {
+    mount: (target: string | HTMLElement, options?: MountOptions) => void;
+    unmount: () => void;
+    submit: () => Promise<Record<string, unknown>>;
+    focus: (field?: string) => void;
+    blur: () => void;
+    update: (options: CreateOptions<T>) => void;
+    destroy: () => void;
+    on: <K extends ComponentEventKey<T>>(event: K, handler: (payload: ComponentEventMap<T>[K]) => void, options?: {
+        signal?: AbortSignal;
+    }) => () => void;
+    off: <K extends ComponentEventKey<T>>(event: K, handler: (payload: ComponentEventMap<T>[K]) => void) => void;
+    addEventListener: <K extends ComponentEventKey<T>>(event: K, handler: (payload: ComponentEventMap<T>[K]) => void, options?: {
+        signal?: AbortSignal;
+    }) => void;
+    removeEventListener: <K extends ComponentEventKey<T>>(event: K, handler: (payload: ComponentEventMap<T>[K]) => void) => void;
+};
+export type PayabliInstance = {
+    create: <T extends ComponentType>(type: T, options?: CreateOptions<T>) => ComponentHandle<T>;
+    on: <K extends SessionEventKey>(event: K, handler: (payload: SessionEventMap[K]) => void, options?: {
+        signal?: AbortSignal;
+    }) => () => void;
+    updateSession: (session: Session) => void;
+    destroy: () => void;
+};
+export type PayabliConstructor = (config: PayabliConfig) => PayabliInstance;

package/dist/shared.d.ts

@@ -0,0 +1,9 @@
+import type { BaseComponentEventMap } from './protocol/base.js';
+export declare const BASE_COMPONENT_EVENT_NAMES: readonly ["ready", "rendered", "message", "success", "change", "error", "loading", "resize"];
+/**
+ * The events every component shares. A component definition adds its own on
+ * top through `ComponentDefinitions` (see `registry.ts`).
+ */
+export type EventMap = BaseComponentEventMap;
+export type EventKey = keyof EventMap;
+export type Listener<T> = (payload: T) => void;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@payabli/component-contracts",
+  "version": "0.1.0",
+  "description": "Wire schemas, component registry, and partner-facing types shared by the Payabli embedded components SDK and payhub.",
+  "private": false,
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/payabli/components-web.git",
+    "directory": "packages/component-contracts"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/__tests__"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "tslib": "^2.8.1"
+  },
+  "scripts": {
+    "generate": "node scripts/generate-registry.mjs",
+    "build": "pnpm generate && rm -rf dist && rollup -c && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "lint": "pnpm generate && eslint src",
+    "typecheck": "pnpm generate && tsc -p tsconfig.json --noEmit",
+    "test": "pnpm generate && vitest run && pnpm build && node scripts/test-published-esm.mjs",
+    "pack:check": "publint && attw --pack . --profile esm-only"
+  }
+}