@burojs/test-helpers 0.3.0 → 0.5.0

package/dist/index.d.cts

@@ -1,42 +1,89 @@
-import { ErasedQueryDescriptor, ErasedMutationDescriptor, BatchedQueryOperation, DataProvider } from '@burojs/core';
-
+//#region src/types.d.ts
 /**
- * Subset of Playwright's Page API that we depend on.
- * Real consumers pass a real Page; tests pass a mock.
+ * The page surface the page objects compose testids on.
+ *
+ * **The locator type is a parameter, not a fixed shape.** Every factory in
+ * this package is written as `createX<L>(page: PlaywrightPage<L>, …): X<L>`,
+ * so `L` is INFERRED from whatever page is handed in: a real
+ * `@playwright/test` `Page` yields real `Locator`s — which is what makes
+ * `expect(view.row(id).cell('status')).toHaveText('paid')` type-check — while
+ * a hand-written double (see `tests/_mock-page.ts`) yields the double's own
+ * locator type and still exercises the string composition without a browser.
+ *
+ * It did not always work that way, and the reason is worth keeping.
+ * `PlaywrightPage` used to be a fixed structural subset whose members
+ * returned a fixed structural `PlaywrightLocator`. Under `strictFunctionTypes`
+ * a real `Page` was NOT assignable to it — its `getByRole` takes Playwright's
+ * `AriaRole` union, the subset declared the wider `string`, and a parameter
+ * may not widen — so `createBuroPage(realPage)` was a type error. Even had it
+ * been assignable, every locator came back as the structural type, which
+ * `expect()` does not accept, leaving a consumer with `isVisible()`-style
+ * boolean reads and no web-first (auto-waiting) assertion at all. Both defects
+ * were invisible for as long as the only caller was this package's own mock:
+ * the first real consumer (`examples/marketplace-ops/e2e`) hit them on its
+ * first line. Keep the parameter.
+ *
+ * Only the members the factories actually CALL are required. `getByRole`,
+ * `click`, `fill`, `textContent` and `isVisible` were declared here and used
+ * by nothing — the factories return locators and let the caller drive them —
+ * and `getByRole` in particular was the member that broke assignability, so
+ * requiring it bought nothing and cost everything.
  */
-interface PlaywrightLocator {
-    click: () => Promise<void>;
-    fill: (value: string) => Promise<void>;
-    textContent: () => Promise<string | null>;
-    getByTestId: (id: string) => PlaywrightLocator;
-    getByRole: (role: string, opts?: {
-        name?: string | RegExp;
-    }) => PlaywrightLocator;
-    isVisible: () => Promise<boolean>;
+interface PlaywrightPage<TLocator = unknown> {
+  goto: (url: string) => Promise<unknown>;
+  getByTestId: (id: string) => TLocator;
+  /**
+   * Attribute/CSS selection. Needed for the SET-shaped accessors — "every
+   * rendered row", "this column across every row" — which `getByTestId`
+   * cannot express: those testids embed a record id, so they can only be
+   * addressed by prefix.
+   */
+  locator: (selector: string) => TLocator;
+  url: () => string;
 }
-interface PlaywrightPage {
-    goto: (url: string) => Promise<unknown>;
-    getByTestId: (id: string) => PlaywrightLocator;
-    getByRole: (role: string, opts?: {
-        name?: string | RegExp;
-    }) => PlaywrightLocator;
-    url: () => string;
+/**
+ * The one capability the page objects need from a locator THEMSELVES rather
+ * than handing it to the caller: {@link RowObject.open} clicks the row it
+ * addresses. Everything else in this package returns a locator and stops, so
+ * this is the whole constraint the locator parameter carries.
+ */
+interface ClickableLocator {
+  click: () => Promise<unknown>;
 }
-
-interface FormFieldObject {
-    input: () => PlaywrightLocator;
-    error: () => PlaywrightLocator;
-    help: () => PlaywrightLocator;
+/**
+ * A convenience shape for writing a page DOUBLE (`PlaywrightPage<PlaywrightLocator>`).
+ * Nothing in this package requires it — a real consumer passes a real `Page`
+ * and gets real `Locator`s back.
+ */
+interface PlaywrightLocator {
+  click: () => Promise<void>;
+  fill: (value: string) => Promise<void>;
+  textContent: () => Promise<string | null>;
+  getByTestId: (id: string) => PlaywrightLocator;
+  isVisible: () => Promise<boolean>;
+}
+//#endregion
+//#region src/form-view.d.ts
+interface FormFieldObject<L> {
+  input: () => L;
+  error: () => L;
+  help: () => L;
 }
-interface FormView {
-    field: (fieldName: string) => FormFieldObject;
-    section: (sectionKey: string) => PlaywrightLocator;
-    submit: () => PlaywrightLocator;
-    cancel: () => PlaywrightLocator;
-    action: (actionName: string) => PlaywrightLocator;
+interface FormView<L extends ClickableLocator> {
+  field: (fieldName: string) => FormFieldObject<L>;
+  submit: () => L;
+  cancel: () => L;
+  action: (actionName: string) => L;
+  /**
+   * A keyed node of the record screen (a panel, tabs, a step) by its key,
+   * inside `[data-buro-region="<region>"]` (default the body). Nodes carry no
+   * test id of their own: the key and the region locate them.
+   */
+  node: (key: string, region?: 'record-header' | 'record-body') => L;
 }
-declare function createFormView(page: PlaywrightPage, resource: string, view: 'create' | 'edit' | 'show'): FormView;
-
+declare function createFormView<L extends ClickableLocator>(page: PlaywrightPage<L>, resource: string, view: 'create' | 'edit' | 'show'): FormView<L>;
+//#endregion
+//#region src/list-view.d.ts
 /**
  * A row's address inside the filter-builder draft: `[]` is the root group,
  * `[0]` is its first row, `[1, 0]` is the first row of the group nested at
@@ -47,155 +94,348 @@ declare function createFormView(page: PlaywrightPage, resource: string, view: 'c
  * `list-filter:<r>:group::add-row`).
  */
 type FilterRowPath = readonly number[];
-interface ListView {
-    goto: () => Promise<void>;
-    row: (recordId: string) => RowObject;
-    search: () => PlaywrightLocator;
-    /** The filter region container — `list-filters:<resource>`. */
-    filtersContainer: () => PlaywrightLocator;
-    /** Opens/closes the filter-builder popover. */
-    filterButton: () => PlaywrightLocator;
-    /** The popover body once open. */
-    filterPanel: () => PlaywrightLocator;
-    /** "+ Filter" — appends a new predicate row to the group at `groupPath` (root: `[]`). */
-    filterAddRow: (groupPath?: FilterRowPath) => PlaywrightLocator;
-    /** Field-select trigger for the row at `path`. */
-    filterRowField: (path: FilterRowPath) => PlaywrightLocator;
-    /** One field option inside an open field-select. */
-    filterRowFieldOption: (path: FilterRowPath, field: string) => PlaywrightLocator;
-    /** Operator-select trigger for the row at `path`. */
-    filterRowOp: (path: FilterRowPath) => PlaywrightLocator;
-    /** One operator option inside an open operator-select. */
-    filterRowOpOption: (path: FilterRowPath, op: string) => PlaywrightLocator;
-    /** Value control trigger/input for the row at `path` — shape depends on the field kind (text box, enum/relation/boolean popover). */
-    filterRowValue: (path: FilterRowPath) => PlaywrightLocator;
-    /** Removes the row at `path` from the draft (inside the panel, before Apply). */
-    filterRowRemove: (path: FilterRowPath) => PlaywrightLocator;
-    /** Commits the draft — applies it and closes the panel. */
-    filterApply: () => PlaywrightLocator;
-    /** Clears the draft back to empty (still requires Apply to take effect). */
-    filterReset: () => PlaywrightLocator;
-    /** One applied-filter badge outside the panel, by its top-level index. */
-    filterBadge: (index: number) => PlaywrightLocator;
-    /** A badge's × — removes that row immediately, no Apply needed. */
-    filterBadgeRemove: (index: number) => PlaywrightLocator;
-    /** "Clear all" — empties both the pinned slot and the builder group. */
-    filterClearAll: () => PlaywrightLocator;
-    /** An always-visible pinned control (`views.list.filters.pinned`) for `field`, rendered outside the panel. */
-    filterPinned: (field: string) => PlaywrightLocator;
-    paginationPrev: () => PlaywrightLocator;
-    paginationNext: () => PlaywrightLocator;
-    empty: () => PlaywrightLocator;
-    toolbar: () => PlaywrightLocator;
-    table: () => PlaywrightLocator;
+interface ListView<L extends ClickableLocator> {
+  goto: () => Promise<void>;
+  row: (recordId: string) => RowObject<L>;
+  /**
+   * EVERY rendered row of this resource, as one locator — the set, not a
+   * named member of it. `row(recordId)` cannot express it: a row's testid
+   * embeds its record id, so the set is only addressable by prefix.
+   *
+   * This is the accessor a list assertion is actually built on
+   * (`await expect(list.rows()).toHaveCount(n)`), and it was missing for as
+   * long as the only consumer of this package was a mock that never counted
+   * anything.
+   */
+  rows: () => L;
+  /**
+   * One column across every rendered row, in row order — again a set, again
+   * prefix-addressed. Reading a whole column through ONE locator matters for
+   * more than convenience: a per-row loop awaits between reads and can meet a
+   * detached node mid-re-render, which turns a polling wait into a thrown
+   * error instead of another attempt.
+   */
+  column: (fieldName: string) => L;
+  /** The column header's menu trigger (sort / pin / hide / move). */
+  columnMenu: (fieldName: string) => L;
+  /** The sort item inside an OPEN column header menu. */
+  columnSort: (fieldName: string, direction: 'asc' | 'desc') => L;
+  /**
+   * The reorder item inside an OPEN column header menu — moves the column one
+   * position left or right.
+   *
+   * ⚠️ What it moves is **column layout**, which is a different persistence
+   * mechanism from everything else on this object: order, width and pinning
+   * live in raw `localStorage` under `buro:table-layout:<resource>:{order,
+   * sizing,pinning}` and are carried by neither the URL nor a saved view. See
+   * {@link ListView.savedViews}.
+   */
+  columnMove: (fieldName: string, direction: 'left' | 'right') => L;
+  /** The Columns menu trigger — show/hide columns, reset widths, restore defaults. */
+  columnsToggle: () => L;
+  /**
+   * One column's row inside the OPEN Columns menu. A column the resource
+   * declares in `views.list.columns` is REQUIRED unless
+   * `views.list.requiredColumns` says otherwise, and renders `disabled` with
+   * `data-required="true"` — only `optionalColumns` are actually clickable.
+   */
+  columnsOption: (columnId: string) => L;
+  /** The rows-per-page select trigger; its text is the active page size. */
+  pageSize: () => L;
+  search: () => L;
+  /** The filter region container — `list-filters:<resource>`. */
+  filtersContainer: () => L;
+  /** Opens/closes the filter-builder popover. */
+  filterButton: () => L;
+  /** The popover body once open. */
+  filterPanel: () => L;
+  /** "+ Filter" — appends a new predicate row to the group at `groupPath` (root: `[]`). */
+  filterAddRow: (groupPath?: FilterRowPath) => L;
+  /** Field-select trigger for the row at `path`. */
+  filterRowField: (path: FilterRowPath) => L;
+  /** One field option inside an open field-select. */
+  filterRowFieldOption: (path: FilterRowPath, field: string) => L;
+  /** Operator-select trigger for the row at `path`. */
+  filterRowOp: (path: FilterRowPath) => L;
+  /** One operator option inside an open operator-select. */
+  filterRowOpOption: (path: FilterRowPath, op: string) => L;
+  /** Value control trigger/input for the row at `path` — shape depends on the field kind (text box, enum/relation/boolean popover). */
+  filterRowValue: (path: FilterRowPath) => L;
+  /** Removes the row at `path` from the draft (inside the panel, before Apply). */
+  filterRowRemove: (path: FilterRowPath) => L;
+  /** Commits the draft — applies it and closes the panel. */
+  filterApply: () => L;
+  /** Clears the draft back to empty (still requires Apply to take effect). */
+  filterReset: () => L;
+  /** One applied-filter badge outside the panel, by its top-level index. */
+  filterBadge: (index: number) => L;
+  /** A badge's × — removes that row immediately, no Apply needed. */
+  filterBadgeRemove: (index: number) => L;
+  /** "Clear all" — empties both the pinned slot and the builder group. */
+  filterClearAll: () => L;
+  /** An always-visible pinned control (`views.list.filters.pinned`) for `field`, rendered outside the panel. */
+  filterPinned: (field: string) => L;
+  /**
+   * The floating bulk bar, which appears as soon as ANY row is selected —
+   * even for a resource that declares no bulk action, because it also carries
+   * the built-in Export entry and the selection count.
+   */
+  bulkBar: () => L;
+  /** One declared bulk action's button inside the bar (`actions.bulk`). */
+  bulkAction: (actionName: string) => L;
+  paginationPrev: () => L;
+  paginationNext: () => L;
+  /**
+   * The load-more button a CURSOR-paginated list renders instead of the
+   * numbered pager (`views.list.pagination: 'cursor'` → `<CursorLoadMore>`).
+   *
+   * ⚠️ NOT resource-scoped, because the control itself is not: `CursorLoadMore`
+   * carries a bare `data-testid="cursor-load-more"` with no resource segment,
+   * unlike every other id above. A page rendering two cursor lists at once
+   * would need `.first()`/`.nth()` to tell them apart. Recorded rather than
+   * papered over — inventing a scoped id here would only make this object
+   * disagree with the component.
+   *
+   * ⚠️ `<CursorLoadMore>` renders NOTHING when there is no next page, so the
+   * end of a cursor list is "this locator resolves to no element", not a
+   * disabled button. That is what makes it usable as an end-of-list assertion.
+   *
+   * Like `columnMenu`/`columnSort`, this id has no `useTestIds` factory behind
+   * it, so `page-object-vocabulary` tests have nothing to check it against
+   * (the pre-existing F6 gap — see the saved-views block below for what that
+   * costs, measured).
+   */
+  loadMore: () => L;
+  empty: () => L;
+  toolbar: () => L;
+  table: () => L;
+  /** The Views dropdown trigger in the list toolbar. */
+  savedViews: () => L;
+  /** The dropdown body once open. */
+  savedViewsMenu: () => L;
+  /**
+   * EVERY view entry in the open dropdown (adopter presets and user-saved
+   * alike), as one locator — the set, not a named member of it, because a
+   * user view's id is a uuid minted at save time and no test can know it in
+   * advance. Prefix-addressed for the same reason {@link ListView.rows} is.
+   */
+  savedViewEntries: () => L;
+  /** One view entry by id — for an adopter preset declared in `views.list.savedViews`, whose id IS known. */
+  savedView: (viewId: string) => L;
+  /** "Save current view…" — opens the save dialog. */
+  savedViewSave: () => L;
+  /** The label input inside the open save dialog. */
+  savedViewSaveInput: () => L;
+  /** The save dialog's confirm button; disabled while the label is empty. */
+  savedViewSaveConfirm: () => L;
+  /**
+   * "Manage views…" — opens the manage dialog. Rendered only when at least
+   * one entry exists, so `toHaveCount(0)` is a usable "this browser has no
+   * saved views" assertion.
+   */
+  savedViewManage: () => L;
+  /** One entry's Delete button inside the open manage dialog. */
+  savedViewManageDelete: (viewId: string) => L;
 }
-interface RowObject {
-    cell: (fieldName: string) => PlaywrightLocator;
-    action: (actionName: string) => PlaywrightLocator;
-    checkbox: () => PlaywrightLocator;
-    open: () => Promise<void>;
+interface RowObject<L extends ClickableLocator> {
+  /**
+   * The row element itself. Without it a caller cannot say "this row is on
+   * screen" or "this row is gone" — the two assertions a list test needs
+   * most, and the ones `cell()`/`action()` cannot stand in for (a row can be
+   * present while a given cell or action is not).
+   */
+  root: () => L;
+  cell: (fieldName: string) => L;
+  action: (actionName: string) => L;
+  checkbox: () => L;
+  open: () => Promise<void>;
 }
 interface ListViewOptions {
-    basePath?: string;
+  /**
+   * What {@link ListView.goto} navigates to. Defaults to `/<resource>`, which
+   * assumes the route is named after the resource — often false (a `order`
+   * resource routed at `/orders`), and it carries no query string, so an app
+   * whose test isolation travels on the URL has to pass its whole launch URL
+   * here.
+   */
+  basePath?: string;
 }
-declare function createListView(page: PlaywrightPage, resource: string, options?: ListViewOptions): ListView;
-
-interface PickerObject {
-    dialog: () => PlaywrightLocator;
-    popover: () => PlaywrightLocator;
-    option: (value: string) => PlaywrightLocator;
-    search: () => PlaywrightLocator;
-    clear: () => PlaywrightLocator;
-    quickCreate: () => PlaywrightLocator;
+declare function createListView<L extends ClickableLocator>(page: PlaywrightPage<L>, resource: string, options?: ListViewOptions): ListView<L>;
+//#endregion
+//#region src/picker-object.d.ts
+/**
+ * The relation picker's addresses, as a test drives them.
+ *
+ * ⚠️ **Every id here was wrong until SP9 task 5, and nothing could see it.**
+ * This object used to ask for `picker-dialog:` / `picker-popover:` /
+ * `picker-search:` / `picker-option:` / `picker-clear:` /
+ * `picker-quickcreate:`, and `@burojs/react`'s `useTestIds()` composed exactly
+ * the same six — while `@burojs/ui-shadcn`'s `<RelationPicker>` has always
+ * emitted `relation-picker:<target>:…`. Neither vocabulary had a single
+ * producer. The cross-check that exists to prevent this
+ * (`examples/marketplace-ops/tests/page-object-vocabulary.test.tsx`) was green
+ * throughout, because it compared these two copies with each other and neither
+ * of them with the component. The producer side is pinned now, in
+ * `packages/ui-shadcn/tests/relation-picker-testids.test.tsx`.
+ *
+ * `quickCreate` is not re-spelled but REMOVED: quick-create inside the picker
+ * is deferred to the picker's v2 and there is no element to address. `popover`
+ * is likewise gone — the popover content carries no id; {@link PickerObject.list}
+ * is the element inside it that does.
+ *
+ * **`trigger()` is the standalone spelling.** Inside a record form the
+ * form overrides the trigger's testid with its own
+ * `form-field-input:<resource>:<view>:<field>`, so a form field's picker is
+ * opened through `resource(r).create().field(f).input()` and only its popover
+ * children are addressed through this object.
+ */
+interface PickerObject<L> {
+  /** The standalone trigger button. In a form, use the form field's `input()`. */
+  trigger: () => L;
+  /** The popover's search box. */
+  search: () => L;
+  /** The popover's result list. */
+  list: () => L;
+  /** One result row, by the target record's id. */
+  option: (value: string) => L;
+  /** The "No results." row. */
+  empty: () => L;
+  /** The Clear link — present only when the picker is clearable and set. */
+  clear: () => L;
+  /** The "Advanced search" link that escalates to {@link PickerObject.dialog}. */
+  advanced: () => L;
+  /** The "Open list" link to the target's own list page. */
+  viewAll: () => L;
+  /** The escalation modal. */
+  dialog: () => L;
+  /** The escalation modal's own search box. */
+  dialogSearch: () => L;
+  /** The disabled trigger shown when the target resource is unregistered. */
+  unregistered: () => L;
 }
-declare function createPickerObject(page: PlaywrightPage, targetResource: string): PickerObject;
-
-type ShowView = FormView;
-declare function createShowView(page: PlaywrightPage, resource: string): ShowView;
-
-interface ResourceObject {
-    name: string;
-    list: (options?: ListViewOptions) => ListView;
-    edit: (recordId: string) => FormView;
-    show: (recordId: string) => ShowView;
-    create: () => FormView;
-    picker: () => PickerObject;
+declare function createPickerObject<L>(page: PlaywrightPage<L>, targetResource: string): PickerObject<L>;
+//#endregion
+//#region src/show-view.d.ts
+interface ShowView<L extends ClickableLocator> extends FormView<L> {
+  /**
+   * The show page root — `useTestIds`' `pageShow(resource, recordId)`.
+   *
+   * The ONE show accessor that uses the record id. Every other locator on this
+   * view comes from `createFormView`, whose testids carry no record id at all
+   * (see {@link import('./resource-object.js').ResourceObject.show}), so this
+   * is what lets a test assert it is looking at the show page OF A GIVEN
+   * RECORD rather than at whatever detail page happens to be mounted.
+   */
+  root: () => L;
 }
-declare function createResourceObject(page: PlaywrightPage, name: string): ResourceObject;
-
-interface BuroPage {
-    resource: (name: string) => ResourceObject;
-    contextPicker: (sliceName: string) => PlaywrightLocator;
-    notification: (type: 'success' | 'error' | 'progress' | 'info') => PlaywrightLocator;
-    actionConfirm: (resource: string, scope: string, actionName: string) => PlaywrightLocator;
-    page: PlaywrightPage;
+declare function createShowView<L extends ClickableLocator>(page: PlaywrightPage<L>, resource: string, recordId: string): ShowView<L>;
+//#endregion
+//#region src/resource-object.d.ts
+interface ResourceObject<L extends ClickableLocator> {
+  name: string;
+  list: (options?: ListViewOptions) => ListView<L>;
+  /**
+   * ⚠️ `recordId` is accepted and IGNORED: the form testids
+   * (`form-field:<resource>:edit:<field>`) carry no record id, so an edit view
+   * addressed for record A and one addressed for record B are the same
+   * locators. Only one edit form is ever mounted at a time, so this is
+   * harmless in practice — but the parameter reads like a scope and is not
+   * one.
+   */
+  edit: (recordId: string) => FormView<L>;
+  /**
+   * ⚠️ `recordId` reaches {@link ShowView.root} and NOTHING ELSE. The show
+   * view's field/section/action locators all come from `createFormView`, whose
+   * testids carry no record id, so they are the same locators for record A and
+   * record B. `root()` is the one accessor that is genuinely scoped to the
+   * record — assert on it first if a test needs to know WHICH record's page is
+   * mounted.
+   */
+  show: (recordId: string) => ShowView<L>;
+  create: () => FormView<L>;
+  picker: () => PickerObject<L>;
 }
-declare function createBuroPage(page: PlaywrightPage): BuroPage;
-
-interface ConfirmDialogObject {
-    dialog: () => PlaywrightLocator;
-    yes: () => PlaywrightLocator;
-    no: () => PlaywrightLocator;
+declare function createResourceObject<L extends ClickableLocator>(page: PlaywrightPage<L>, name: string): ResourceObject<L>;
+//#endregion
+//#region src/buro-page.d.ts
+interface BuroPage<L extends ClickableLocator> {
+  resource: (name: string) => ResourceObject<L>;
+  /**
+   * The sidebar entry for a registered resource — `<NavMain>`'s
+   * `tid.navMenuItem(resource)`. The whole navigation half of a suite used to
+   * spell this string by hand even though the factory existed (SP3 stage C
+   * final review, Important 2).
+   */
+  navMenuItem: (resource: string) => L;
+  /** The sidebar entry for an adopter-declared custom page, keyed by page key
+   * rather than resource name (`tid.sidebarCustomPage`). */
+  sidebarCustomPage: (pageKey: string) => L;
+  contextPicker: (sliceName: string) => L;
+  /** One option inside an open context picker — the half that actually
+   * performs a switch. Without it a caller can open the picker and not choose. */
+  contextPickerOption: (sliceName: string, value: string) => L;
+  /**
+   * The header language switcher (`<LanguageSwitch>`) and one locale button
+   * inside it. The trigger carries `data-language-state="<code>"`, which is
+   * how a test reads the ACTIVE locale without opening anything.
+   */
+  languageSwitch: () => L;
+  languageSwitchOption: (localeCode: string) => L;
+  /** `<LoginForm>`'s three controls, in the order a sign-in uses them. */
+  login: () => LoginFormObject<L>;
+  /**
+   * `<TaskRunPanel>`'s three addressable parts, keyed by the RUN's name — a
+   * task run has no resource to key on (a long server-side operation has no
+   * record, a bulk run spans a selection).
+   *
+   * `root()` carries `data-state`, which is how a spec reads the outcome
+   * without matching translated text.
+   */
+  taskRun: (name: string) => TaskRunObject<L>;
+  notification: (type: 'success' | 'error' | 'progress' | 'info') => L;
+  /**
+   * A flow's confirm dialog on a toolbar surface (`form-action:<resource>:<scope>:<action>`): the
+   * dialog a flow with `confirm` (or a fired warning) asks through before it writes (P4). Its
+   * buttons are the same id with `:proceed` / `:cancel` in place of `:dialog`. A row's flow asks
+   * through `list-row-action:<resource>:<id>:<action>:confirm:dialog`.
+   */
+  actionConfirm: (resource: string, scope: string, actionName: string) => L;
+  page: PlaywrightPage<L>;
 }
-declare function createConfirmDialog(page: PlaywrightPage, resource: string, scope: string, actionName: string): ConfirmDialogObject;
-
-type QueryKind = ErasedQueryDescriptor['kind'];
-type MutationKind = ErasedMutationDescriptor['kind'];
-interface ProviderObservedCall {
-    readonly lifecycle: 'query' | 'mutation' | 'batch' | 'live-open' | 'live-subscribe';
-    readonly kind?: QueryKind | MutationKind;
-    readonly descriptor?: ErasedQueryDescriptor | ErasedMutationDescriptor;
-    readonly descriptors?: readonly ErasedQueryDescriptor[];
-    readonly signal?: AbortSignal;
+interface TaskRunObject<L> {
+  root: () => L;
+  /** The bar; its `aria-valuenow`/`aria-valuemax` are the counts. */
+  progress: () => L;
+  /** One named unit that did not succeed — a refused row, or the step a run stopped at. */
+  failure: (subject: string) => L;
 }
-/** Specimens supplied by an adapter author; unsupported optional methods are omitted. */
-interface ProviderContractDescriptors {
-    readonly queries?: Partial<Record<QueryKind, ErasedQueryDescriptor>>;
-    readonly mutations?: Partial<Record<MutationKind, ErasedMutationDescriptor>>;
-    readonly batch?: readonly BatchedQueryOperation[];
-    /** Independent batch groups prove that grouping is explicit, never merged by the helper. */
-    readonly batchGroups?: readonly (readonly BatchedQueryOperation[])[];
-    /** List specimens for both pagination protocols, including expected totals/pageInfo. */
-    readonly pagination?: {
-        readonly offset?: ErasedQueryDescriptor;
-        readonly cursor?: ErasedQueryDescriptor;
-    };
-    readonly live?: ErasedQueryDescriptor;
-    /** Error specimens must make the selected handler reject with a DataError. */
-    readonly errors?: readonly ProviderContractErrorSpecimen[];
-    /** Hand-authored mapped results; assertions never derive expectations from an adapter. */
-    readonly expected?: {
-        readonly queries?: Partial<Record<QueryKind, unknown>>;
-        readonly mutations?: Partial<Record<MutationKind, unknown>>;
-        readonly batch?: unknown;
-        readonly pagination?: {
-            readonly offset?: unknown;
-            readonly cursor?: unknown;
-        };
-    };
+interface LoginFormObject<L> {
+  email: () => L;
+  password: () => L;
+  submit: () => L;
 }
-type ProviderContractErrorSpecimen = {
-    readonly lifecycle: 'query';
-    readonly kind: QueryKind;
-    readonly descriptor: ErasedQueryDescriptor;
-} | {
-    readonly lifecycle: 'mutation';
-    readonly kind: MutationKind;
-    readonly descriptor: ErasedMutationDescriptor;
-};
-interface ProviderContractFixture {
-    create(): DataProvider | Promise<DataProvider>;
-    descriptors: ProviderContractDescriptors;
-    observeCalls(): readonly ProviderObservedCall[];
+declare function createBuroPage<L extends ClickableLocator>(page: PlaywrightPage<L>): BuroPage<L>;
+//#endregion
+//#region src/confirm-dialog.d.ts
+interface ConfirmDialogObject<L> {
+  dialog: () => L;
+  yes: () => L;
+  no: () => L;
 }
+declare function createConfirmDialog<L>(page: PlaywrightPage<L>, resource: string, scope: string, actionName: string): ConfirmDialogObject<L>;
+//#endregion
+//#region src/index.d.ts
 /**
- * Registers transport-agnostic provider conformance tests. It intentionally
- * imports only core contracts: adapters supply their own deterministic client
- * and expose provider-boundary observations through the fixture.
+ * `@burojs/test-helpers` — the Playwright entry point.
+ *
+ * Everything exported here is loadable inside a `@playwright/test` process:
+ * page objects over the testid convention `useTestIds()` (`@burojs/react`)
+ * emits, and nothing else. The vitest-based provider contract moved to
+ * `@burojs/test-helpers/provider-contract` — see that module for the measured
+ * reason it can no longer share an entry point with these.
  */
-declare function dataProviderContract(name: string, fixture: ProviderContractFixture): void;
-
 declare const PACKAGE_NAME: "@burojs/test-helpers";
 declare const PACKAGE_VERSION: "0.0.0";
-
-export { type BuroPage, type ConfirmDialogObject, type FormFieldObject, type FormView, type ListView, type ListViewOptions, PACKAGE_NAME, PACKAGE_VERSION, type PickerObject, type PlaywrightLocator, type PlaywrightPage, type ProviderContractDescriptors, type ProviderContractFixture, type ProviderObservedCall, type ResourceObject, type RowObject, type ShowView, createBuroPage, createConfirmDialog, createFormView, createListView, createPickerObject, createResourceObject, createShowView, dataProviderContract };
+//#endregion
+export { type BuroPage, type ClickableLocator, type ConfirmDialogObject, type FilterRowPath, type FormFieldObject, type FormView, type ListView, type ListViewOptions, type LoginFormObject, PACKAGE_NAME, PACKAGE_VERSION, type PickerObject, type PlaywrightLocator, type PlaywrightPage, type ResourceObject, type RowObject, type ShowView, type TaskRunObject, createBuroPage, createConfirmDialog, createFormView, createListView, createPickerObject, createResourceObject, createShowView };
+//# sourceMappingURL=index.d.cts.map