npm - @plumile/backoffice-core - Versions diffs - 0.1.156 → 0.1.158 - Mend

@plumile/backoffice-core 0.1.156 → 0.1.158

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/lib/esm/builders.d.ts +13 -17
package/lib/esm/builders.d.ts.map +1 -1
package/lib/esm/builders.js +2 -15
package/lib/esm/config/listRuntime.d.ts +1 -1
package/lib/esm/config/listRuntime.d.ts.map +1 -1
package/lib/esm/config/listRuntime.js +3 -3
package/lib/esm/resolve.d.ts +1 -1
package/lib/esm/resolve.d.ts.map +1 -1
package/lib/esm/resolve.js +1 -1
package/lib/esm/type-tests/operation-bound-config.test-d.d.ts.map +1 -1
package/lib/esm/type-tests/operation-bound-config.test-d.js +19 -1
package/lib/esm/types.d.ts +15 -34
package/lib/esm/types.d.ts.map +1 -1
package/lib/esm/types.js +1 -1
package/lib/tsconfig.esm.tsbuildinfo +1 -1
package/lib/types/builders.d.ts +13 -17
package/lib/types/builders.d.ts.map +1 -1
package/lib/types/config/listRuntime.d.ts +1 -1
package/lib/types/config/listRuntime.d.ts.map +1 -1
package/lib/types/resolve.d.ts +1 -1
package/lib/types/resolve.d.ts.map +1 -1
package/lib/types/type-tests/operation-bound-config.test-d.d.ts.map +1 -1
package/lib/types/types.d.ts +15 -34
package/lib/types/types.d.ts.map +1 -1
package/package.json +6 -6

package/lib/esm/types.js CHANGED Viewed

@@ -5,4 +5,4 @@ export class BackofficeToolValidationError extends Error {
         this.label = label;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AA8iEA,MAAM,OAAO,6BAA8B,SAAQ,KAAK;IAC/C,KAAK,CAAY;IAExB,YAAmB,KAAgB;QACjC,KAAK,CAAC,kCAAkC,CAAC,CAAC;QAC1C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF","sourcesContent":["import type { ReactNode } from 'react';\nimport type { TFunction } from 'i18next';\nimport type { PreloadedQuery } from 'react-relay';\nimport type {\n  GraphQLTaggedNode,\n  OperationType,\n  RecordSourceSelectorProxy,\n} from 'relay-runtime';\nimport type { BACKOFFICE_ENTITY_FACET_KINDS } from './constants.js';\n\nexport type I18nLabel = (t: TFunction) => string;\n\ntype BivariantCallback<Fn> = Fn extends (...args: infer A) => infer R\n  ? { bivarianceHack: (...args: A) => R }['bivarianceHack']\n  : never;\n\nexport type BackofficeActionRenderNode = Exclude<ReactNode, Promise<unknown>>;\n\nexport type BackofficeValueLabel = string | number | null | I18nLabel;\n\nexport type BackofficeBadgeTone =\n  | 'neutral'\n  | 'info'\n  | 'success'\n  | 'warning'\n  | 'danger';\n\nexport type BackofficeNumberFormat = 'number' | 'currency' | 'percent';\n\nexport type BackofficeFieldSize =\n  | 'xs'\n  | 's'\n  | 'statusAction'\n  | 'm'\n  | 'l'\n  | 'xl'\n  | 'fluid';\n\nexport type BackofficeActionVariant =\n  | 'primary'\n  | 'secondary'\n  | 'text'\n  | 'success'\n  | 'danger'\n  | 'brand'\n  | 'brandGhost'\n  | 'tab'\n  | 'icon';\n\nexport type BackofficeActionSize = 'small' | 'medium' | 'large';\n\nexport type BackofficeActionToastViewSpec<\n  Node = unknown,\n  Response = unknown,\n> = {\n  entityId: string;\n  getTargetId: BivariantCallback<\n    (response: Response, node: Node) => string | null\n  >;\n  label?: I18nLabel;\n};\n\nexport type BackofficeActionToastSpec<Node = unknown, Response = unknown> = {\n  title: I18nLabel;\n  message?: I18nLabel;\n  view?: BackofficeActionToastViewSpec<Node, Response>;\n};\n\nexport type BackofficeEntityActionBase<Node> = {\n  id: string;\n  label: I18nLabel;\n  ariaLabel?: I18nLabel;\n  variant?: BackofficeActionVariant;\n  size?: BackofficeActionSize;\n  isVisible?: BivariantCallback<(node: Node) => boolean>;\n  isDisabled?: BivariantCallback<(node: Node) => boolean>;\n};\n\ntype BackofficeEntityActionFormFieldBase = {\n  id: string;\n  label: I18nLabel;\n  description?: I18nLabel;\n};\n\nexport type BackofficeEntityActionFormFieldSpec =\n  | (BackofficeEntityActionFormFieldBase & {\n      id: string;\n      kind: 'text';\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n      required?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      id: string;\n      kind: 'textarea';\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n      required?: boolean;\n      rows?: number;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'number';\n      placeholder?: I18nLabel;\n      defaultValue?: number;\n      required?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'json';\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n      required?: boolean;\n      jsonType?: 'object' | 'array' | 'any';\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'enum';\n      options: readonly { value: string; label: I18nLabel }[];\n      defaultValue?: string;\n      required?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'boolean';\n      defaultValue?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'entityId';\n      entity: string;\n      defaultValue?: string;\n      required?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'multiEnum';\n      options: readonly { value: string; label: I18nLabel }[];\n      defaultValue?: readonly string[];\n      required?: boolean;\n    });\n\nexport type BackofficeEntityActionResultSpec<Node, Response = unknown> = {\n  label: I18nLabel;\n  getValue: BivariantCallback<\n    (response: Response, node: Node) => string | null\n  >;\n  render?: BivariantCallback<\n    (response: Response, node: Node) => BackofficeActionRenderNode | null\n  >;\n};\n\nexport type BackofficeEntityActionUpdater<Node> = BivariantCallback<\n  (store: RecordSourceSelectorProxy, node: Node) => void\n>;\n\nexport type BackofficeEntityMutationActionSpec<\n  Node,\n  Variables = Record<string, unknown>,\n  Response = unknown,\n> = BackofficeEntityActionBase<Node> & {\n  kind: 'mutation';\n  mutation: GraphQLTaggedNode;\n  getVariables: BivariantCallback<(node: Node) => Variables>;\n  updater?: BackofficeEntityActionUpdater<Node>;\n  mapErrorReason?: BivariantCallback<\n    (reason: string, node: Node) => BackofficeValueLabel\n  >;\n  onCompleted?: BivariantCallback<(response: Response, node: Node) => void>;\n  onError?: BivariantCallback<(error: Error, node: Node) => void>;\n  toasts?: {\n    success?: BackofficeActionToastSpec<Node, Response>;\n    error?: BackofficeActionToastSpec<Node, Response>;\n  };\n};\n\nexport type BackofficeEntityFormMutationActionSpec<\n  Node,\n  Variables = Record<string, unknown>,\n  Response = unknown,\n> = BackofficeEntityActionBase<Node> & {\n  kind: 'formMutation';\n  mutation: GraphQLTaggedNode;\n  fields: readonly BackofficeEntityActionFormFieldSpec[];\n  getVariables: BivariantCallback<\n    (node: Node, values: Record<string, unknown>) => Variables\n  >;\n  updater?: BackofficeEntityActionUpdater<Node>;\n  getInitialValues?: BivariantCallback<(node: Node) => Record<string, unknown>>;\n  mapErrorReason?: BivariantCallback<\n    (reason: string, node: Node) => BackofficeValueLabel\n  >;\n  onCompleted?: BivariantCallback<(response: Response, node: Node) => void>;\n  onError?: BivariantCallback<(error: Error, node: Node) => void>;\n  toasts?: {\n    success?: BackofficeActionToastSpec<Node, Response>;\n    error?: BackofficeActionToastSpec<Node, Response>;\n  };\n  result?: BackofficeEntityActionResultSpec<Node, Response>;\n};\n\nexport type BackofficeEntityRouteActionSpec<Node> =\n  BackofficeEntityActionBase<Node> & {\n    kind: 'route';\n    to: BivariantCallback<(node: Node) => string>;\n  };\n\nexport type BackofficeEntityActionSpec<Node> =\n  | BackofficeEntityMutationActionSpec<Node>\n  | BackofficeEntityFormMutationActionSpec<Node>\n  | BackofficeEntityRouteActionSpec<Node>;\n\nexport type BackofficeListActionSpec = BackofficeEntityActionSpec<null>;\n\nexport type BackofficeEntityKind = 'list-detail' | 'tool';\n\nexport type BackofficeEntityManifestKind = 'list-detail' | 'tool';\n\nexport type BackofficeEntityFacetKind =\n  (typeof BACKOFFICE_ENTITY_FACET_KINDS)[number];\n\nexport type BackofficeEntityModuleStatus =\n  | 'idle'\n  | 'loading'\n  | 'loaded'\n  | 'error';\n\nexport type BackofficeEntityLoadMode = 'cache-first' | 'reload';\n\nexport type BackofficeConfigAccessKind =\n  | 'manifest-only'\n  | 'loaded-config-required';\n\nexport type BackofficeListState<Where, Sort extends string> = {\n  where: Where | null;\n  sort: Sort | null;\n};\n\nexport type BackofficeListVariables<Where, Sort extends string> = {\n  where: Where | null;\n  sort: Sort | null;\n  count: number;\n  cursor: string | null;\n};\n\nexport type BackofficeOperationVariables<TOperation extends OperationType> =\n  TOperation['variables'];\n\nexport type BackofficeOperationResponse<TOperation extends OperationType> =\n  TOperation['response'];\n\nexport type BackofficeOperationWhere<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown> = TOperation['variables'] extends {\n    where?: infer Where | null | undefined;\n  }\n    ? Extract<NonNullable<Where>, Record<string, unknown>>\n    : never,\n> = TWhere;\n\nexport type BackofficeOperationSort<\n  TOperation extends OperationType,\n  TSort = TOperation['variables'] extends {\n    sort?: infer Sort | null | undefined;\n  }\n    ? Extract<NonNullable<Sort>, string>\n    : never,\n> = Extract<TSort, string>;\n\nexport type BackofficeDerivedOperationWhere<TOperation extends OperationType> =\n  TOperation['variables'] extends {\n    where?: infer Where | null | undefined;\n  }\n    ? Extract<NonNullable<Where>, Record<string, unknown>>\n    : never;\n\nexport type BackofficeDerivedOperationSort<TOperation extends OperationType> =\n  TOperation['variables'] extends {\n    sort?: infer Sort | null | undefined;\n  }\n    ? Extract<NonNullable<Sort>, string>\n    : never;\n\nexport type BackofficeListQueryInput<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n> = {\n  where: TWhere | null;\n  sort: TSort | null;\n  count: number;\n  cursor: string | null;\n};\n\nexport type BackofficePickerScope<Where> = Partial<{\n  [Key in keyof Where]: Extract<NonNullable<Where[Key]>, string>;\n}>;\n\nexport type BackofficePickerQueryInput<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n> = {\n  search: string;\n  scope?: BackofficePickerScope<TWhere>;\n};\n\nexport type BackofficeRelationFilterSpec<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n> = {\n  target: string;\n  filterId?: string;\n  whereKey: Extract<keyof TWhere, string>;\n  path?: readonly string[];\n};\n\nexport type BackofficeRuntimeRelationFilterSpec = {\n  target: string;\n  filterId?: string;\n  whereKey: string;\n  path?: readonly string[];\n};\n\nexport type BackofficeRelationCountSpec<\n  Node,\n  TOperation extends OperationType = BackofficeRelationCountRuntimeOperation,\n> = {\n  query: GraphQLTaggedNode;\n  getVariables: BivariantCallback<\n    (node: Node, relationValue: string) => TOperation['variables']\n  >;\n  getCount: BivariantCallback<(data: TOperation['response']) => number | null>;\n};\n\nexport type BackofficeEntityRoutes = {\n  list: string;\n  detail: (id: string) => string;\n  detailPage: (id: string, pageId: string) => string;\n};\n\nexport type BackofficeEntityRouteManifest = {\n  list: string;\n  detail: (id: string) => string;\n  detailPage: (id: string, pageId: string) => string;\n};\n\nexport type BackofficeDetailPageManifestItem = {\n  id: string;\n  pathSegment: string;\n  label: I18nLabel;\n  isDefault?: boolean;\n};\n\nexport type BackofficeDetailPageRouteSpec<LayoutView = unknown> = {\n  id: string;\n  path: string;\n  label: I18nLabel;\n  isVisible?: BivariantCallback<(layoutPage: LayoutView) => boolean>;\n};\n\nexport type BackofficeDashboardConfig = {\n  title: I18nLabel;\n  subtitle?: I18nLabel;\n  widgets: readonly BackofficeDashboardWidget[];\n};\n\nexport type BackofficeDashboardWidgetSize = 's' | 'm' | 'l' | 'xl' | 'full';\n\nexport type BackofficeDashboardWidgetSpan = 3 | 4 | 6 | 8 | 12;\n\nexport type BackofficeDashboardWidgetTabletSpan = 3 | 6;\n\nexport type BackofficeDashboardWidgetZone =\n  | 'summary'\n  | 'main'\n  | 'aside'\n  | 'secondary'\n  | 'full';\n\nexport type BackofficeDashboardWidgetLayout = {\n  zone?: BackofficeDashboardWidgetZone;\n  span?: BackofficeDashboardWidgetSpan;\n  tabletSpan?: BackofficeDashboardWidgetTabletSpan;\n  order?: number;\n};\n\nexport type BackofficeDashboardWidgetPriority =\n  | 'critical'\n  | 'high'\n  | 'normal'\n  | 'low'\n  | 'primary'\n  | 'secondary'\n  | 'debug';\n\nexport type BackofficeDashboardWidgetBase = {\n  id: string;\n  title?: I18nLabel;\n  description?: I18nLabel;\n  size?: BackofficeDashboardWidgetSize;\n  layout?: BackofficeDashboardWidgetLayout;\n  priority?: BackofficeDashboardWidgetPriority;\n  minHeight?: 'sm' | 'md' | 'lg';\n};\n\nexport type BackofficeDashboardEntityCountResult = {\n  count: number | null;\n};\n\nexport type BackofficeDashboardTablePreviewResult = {\n  columns: readonly BackofficeColumnSpec[];\n  rows: readonly unknown[];\n};\n\nexport type BackofficeDashboardStatusSummaryResult = readonly {\n  id: string;\n  label: I18nLabel;\n  value: string | number | null;\n  tone?: BackofficeBadgeTone;\n  href?: string;\n}[];\n\nexport type BackofficeDashboardMetricGroupResult = readonly {\n  id: string;\n  label: I18nLabel;\n  value: string | number | null;\n  meta?: I18nLabel;\n  tone?: 'neutral' | 'info' | 'success' | 'warning' | 'danger';\n  href?: string;\n}[];\n\nexport type BackofficeDashboardBillingUsageChartResult = {\n  currency: string;\n  totalAmount: number;\n  from: string | null;\n  to: string | null;\n  buckets: readonly {\n    day: string;\n    category: string;\n    value: number;\n  }[];\n} | null;\n\nexport type BackofficeDashboardWidgetQuerySource<\n  TOperation extends OperationType,\n  TResult,\n> = {\n  dataSource: 'query';\n  query: GraphQLTaggedNode;\n  variables: TOperation['variables'];\n  resolve: (data: TOperation['response']) => TResult;\n};\n\nexport type BackofficeDashboardWidgetStaticSource = {\n  dataSource: 'static';\n};\n\nexport type BackofficeDashboardWidget =\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'entityCount';\n      label: I18nLabel;\n      entityId: string;\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardEntityCountResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'shortcut';\n      label: I18nLabel;\n      entityId: string;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'tablePreview';\n      title: I18nLabel;\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardTablePreviewResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'statusSummary';\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardStatusSummaryResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'recentItems';\n      maxItems?: number;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'quickActions';\n      actions: readonly {\n        id: string;\n        label: I18nLabel;\n        href: string;\n        description?: I18nLabel;\n        tone?: 'default' | 'primary' | 'danger';\n      }[];\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'metricGroup';\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardMetricGroupResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'billingUsageChart';\n      title: I18nLabel;\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      categories: readonly {\n        id: string;\n        label: I18nLabel;\n        color: string;\n      }[];\n      emptyLabel: I18nLabel;\n      rangePrefix: I18nLabel;\n      ariaLabel: I18nLabel;\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardBillingUsageChartResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'textBlock';\n      title: I18nLabel;\n      body: I18nLabel;\n    });\n\nexport type BackofficeListUrlCodec<Where, Sort extends string> = {\n  parse: (search: URLSearchParams) => BackofficeListState<Where, Sort>;\n  serialize: (state: BackofficeListState<Where, Sort>) => URLSearchParams;\n};\n\nexport type BackofficeSortSpec<Sort extends string = string> = {\n  id: Sort;\n  label: I18nLabel;\n};\n\nexport type BackofficeRowFlagSpec<Row = unknown> = {\n  id: string;\n  label: BivariantCallback<(row: Row) => I18nLabel>;\n  render: BivariantCallback<(row: Row) => unknown>;\n};\n\nexport type BackofficeListColumnPriority =\n  | 'primary'\n  | 'important'\n  | 'secondary'\n  | 'debug';\n\nexport type BackofficeListMobileRole =\n  | 'title'\n  | 'subtitle'\n  | 'meta'\n  | 'badge'\n  | 'status'\n  | 'action'\n  | 'hidden';\n\nexport type BackofficeListColumnVisibility = {\n  priority?: BackofficeListColumnPriority;\n  align?: 'left' | 'center' | 'right';\n  mobile?: BackofficeListMobileRole;\n  tablet?: 'visible' | 'hidden';\n  desktop?: 'visible' | 'hidden';\n  minVisibleAt?: 'sm' | 'md' | 'lg' | 'xl';\n  debugOnly?: boolean;\n};\n\nexport type BackofficeListColumnCopy = {\n  shortLabel?: I18nLabel;\n  description?: I18nLabel;\n  emptyLabel?: I18nLabel;\n};\n\nexport type BackofficeColumnSpec<Row = unknown> = {\n  key: string;\n  header: I18nLabel;\n  size: BackofficeFieldSize;\n  visibility?: BackofficeListColumnVisibility;\n  copy?: BackofficeListColumnCopy;\n  cell:\n    | {\n        size?: BackofficeFieldSize;\n        type: 'text';\n        value: BivariantCallback<(row: Row) => string | number | null>;\n        copyValue?: BivariantCallback<(row: Row) => string | null>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'link';\n        value: BivariantCallback<(row: Row) => string | number | null>;\n        to: BivariantCallback<(row: Row) => string>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'badge';\n        value: BivariantCallback<(row: Row) => string | null>;\n        tone?:\n          | BackofficeBadgeTone\n          | BivariantCallback<(row: Row) => BackofficeBadgeTone>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'dateTime';\n        value: BivariantCallback<(row: Row) => string | number | null>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'entityRef';\n        entity: string;\n        value: BivariantCallback<(row: Row) => string>;\n        label?: BivariantCallback<(row: Row) => string | null>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'custom';\n        render: BivariantCallback<(row: Row) => unknown>;\n        textValue?: BivariantCallback<(row: Row) => string | null>;\n      };\n};\n\nexport type BackofficeListDensity = 'compact' | 'default' | 'comfortable';\n\nexport type BackofficeListDisplayMode = 'table' | 'cards' | 'auto';\n\nexport type BackofficeListVirtualizationMode = 'auto' | 'always' | 'never';\n\nexport type BackofficeListVirtualizationConfig = {\n  mode?: BackofficeListVirtualizationMode;\n  rowHeightPx?: number;\n  overscan?: number;\n};\n\nexport type BackofficeInfiniteScrollConfig = {\n  enabled?: true;\n  rootMargin?: string;\n  threshold?: number;\n  thresholdPx?: number;\n  autoLoad?: boolean;\n  status?: {\n    showLoadedCount?: boolean;\n    showTotalCount?: boolean;\n    showEndState?: boolean;\n    showInconsistentPageInfo?: boolean;\n  };\n};\n\nexport type BackofficeListToolbarProfile = {\n  density?: BackofficeListDensity;\n  displayMode?: BackofficeListDisplayMode;\n  maxPromotedFilters?: number;\n  showRefresh?: boolean;\n  showSort?: boolean;\n  showFilterChips?: 'auto' | 'always' | 'never';\n};\n\nexport type BackofficeListUiConfig = {\n  density?: BackofficeListDensity;\n  displayMode?: BackofficeListDisplayMode;\n  infiniteScroll?: BackofficeInfiniteScrollConfig;\n  virtualization?: BackofficeListVirtualizationConfig;\n  toolbar?: BackofficeListToolbarProfile;\n};\n\nexport type BackofficeListResponsiveMetaItem = {\n  id: string;\n  label?: I18nLabel;\n  value: string;\n  tone?: BackofficeBadgeTone;\n};\n\nexport type BackofficeListResponsiveProfile<Row = unknown> = {\n  mode?: BackofficeListDisplayMode;\n  density?: BackofficeListDensity;\n  mobileBreakpoint?: 'sm' | 'md' | 'lg';\n  primaryColumn?: string;\n  defaultVisibleColumns?: readonly string[];\n  debugColumns?: readonly string[];\n  rowTitle?: BivariantCallback<(row: Row) => string | null>;\n  rowSubtitle?: BivariantCallback<(row: Row) => string | null>;\n  rowMeta?: BivariantCallback<\n    (row: Row) => readonly BackofficeListResponsiveMetaItem[]\n  >;\n};\n\nexport type BackofficeRelationCountRuntimeOperation = OperationType & {\n  // Relation config stores an existential Relay operation; each spec remains\n  // strongly typed at definition time through BackofficeRelationCountSpec<TNode, TOperation>.\n  response: any;\n  variables: any;\n};\n\nexport type BackofficeFilterPlacement = 'quick' | 'drawer' | 'both';\n\ntype BackofficeFilterBase<Where, Value> = {\n  id: string;\n  label: I18nLabel;\n  placement?: BackofficeFilterPlacement;\n  toGraphQL: (value: Value) => Partial<Where>;\n  fromGraphQL?: (where: Where) => Value | null;\n  whereKey?: keyof Where;\n  path?: readonly string[];\n  pickerScope?:\n    | BackofficePickerScope<Where>\n    | ((where: Where | null) => BackofficePickerScope<Where>);\n};\n\nexport type BackofficeFilterSpec<Where> =\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'text';\n      placeholderLabel?: I18nLabel;\n      placeholderText?: I18nLabel;\n    })\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'datetime';\n      mode?: 'from' | 'to' | 'exact';\n      placeholderLabel?: I18nLabel;\n      placeholderText?: I18nLabel;\n    })\n  | (BackofficeFilterBase<Where, number> & {\n      kind: 'number';\n      placeholderLabel?: I18nLabel;\n      placeholderText?: I18nLabel;\n      inputMode?: 'numeric' | 'decimal';\n    })\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'enum';\n      options: readonly {\n        value: string;\n        label: I18nLabel;\n      }[];\n    })\n  | (BackofficeFilterBase<Where, boolean> & {\n      kind: 'boolean';\n      trueLabel?: I18nLabel;\n      falseLabel?: I18nLabel;\n    })\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'entityId';\n      entity: string;\n    });\n\nexport type BackofficeConnectionListConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData = unknown,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n> = {\n  kind: 'connection';\n  title: I18nLabel;\n  query: GraphQLTaggedNode;\n  fragment: GraphQLTaggedNode;\n  buildQueryVariables: (\n    input: BackofficeListQueryInput<TOperation, TWhere, TSort>,\n  ) => TOperation['variables'];\n  getConnection: BivariantCallback<\n    (data: ListFragmentData) => BackofficeConnection<RowRef>\n  >;\n  toRow: BivariantCallback<(rowRef: RowRef) => RowView>;\n  getRowId: BivariantCallback<(row: RowView) => string>;\n  columns: readonly BackofficeColumnSpec<RowView>[];\n  rowFlags?: readonly BackofficeRowFlagSpec<RowView>[];\n  sorts: readonly BackofficeSortSpec<TSort>[];\n  filters: readonly BackofficeFilterSpec<TWhere>[];\n  responsive?: BackofficeListResponsiveProfile<RowView>;\n  ui?: BackofficeListUiConfig;\n  defaultState?: BackofficeListState<TWhere, TSort>;\n};\n\nexport type BackofficeRecordListConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData = unknown,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n> = {\n  kind: 'records';\n  title: I18nLabel;\n  query: GraphQLTaggedNode;\n  fragment: GraphQLTaggedNode;\n  buildQueryVariables: (\n    input: BackofficeListQueryInput<TOperation, TWhere, TSort>,\n  ) => TOperation['variables'];\n  getRows: BivariantCallback<(data: ListFragmentData) => readonly RowRef[]>;\n  toRow: BivariantCallback<(rowRef: RowRef) => RowView>;\n  getNextCursor?: BivariantCallback<\n    (data: BackofficeOperationResponse<TOperation>) => string | null\n  >;\n  getRowId: BivariantCallback<(row: RowView) => string>;\n  columns: readonly BackofficeColumnSpec<RowView>[];\n  rowFlags?: readonly BackofficeRowFlagSpec<RowView>[];\n  sorts: readonly BackofficeSortSpec<TSort>[];\n  filters: readonly BackofficeFilterSpec<TWhere>[];\n  responsive?: BackofficeListResponsiveProfile<RowView>;\n  ui?: BackofficeListUiConfig;\n  defaultState?: BackofficeListState<TWhere, TSort>;\n};\n\nexport type BackofficeEntityListConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData = unknown,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n> =\n  | BackofficeConnectionListConfig<\n      TOperation,\n      RowRef,\n      RowView,\n      ListFragmentData,\n      TWhere,\n      TSort\n    >\n  | BackofficeRecordListConfig<\n      TOperation,\n      RowRef,\n      RowView,\n      ListFragmentData,\n      TWhere,\n      TSort\n    >;\n\nexport type BackofficeBadgeItem = {\n  id: string;\n  label: string | I18nLabel;\n  title?: string | I18nLabel;\n  tone?: BackofficeBadgeTone;\n};\n\nexport type BackofficeInlineValueSpec =\n  | {\n      type: 'text';\n      value: BackofficeValueLabel;\n    }\n  | {\n      type: 'entityRef';\n      entity: string;\n      id: string | null;\n      label?: BackofficeValueLabel;\n    }\n  | {\n      type: 'link';\n      href: string | null;\n      label: BackofficeValueLabel;\n    };\n\nexport type BackofficeDetailHeaderSubtitleItem<Node> = {\n  id: string;\n  value: BivariantCallback<(node: Node) => BackofficeInlineValueSpec>;\n};\n\nexport type BackofficeDetailHeaderMetaSpec<Node> =\n  | {\n      type?: 'text';\n      label: I18nLabel;\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n    }\n  | {\n      type: 'dateTime';\n      label: I18nLabel;\n      value: BivariantCallback<(node: Node) => string | number | null>;\n    }\n  | {\n      type: 'entityRef';\n      label: I18nLabel;\n      entity: string;\n      id: BivariantCallback<(node: Node) => string | null>;\n      value?: BivariantCallback<(node: Node) => string | null>;\n    }\n  | {\n      type: 'link';\n      label: I18nLabel;\n      href: BivariantCallback<(node: Node) => string | null>;\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n    };\n\nexport type BackofficeDetailHeaderStatusSpec<Node> =\n  | {\n      type: 'badge';\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n      tone?:\n        | BackofficeBadgeTone\n        | BivariantCallback<(node: Node) => BackofficeBadgeTone>;\n    }\n  | {\n      type: 'badgeRow';\n      items: BivariantCallback<(node: Node) => readonly BackofficeBadgeItem[]>;\n    };\n\nexport type BackofficeDetailPlacement = 'primary' | 'secondary';\n\nexport type BackofficeDetailContentGroup =\n  | 'summary'\n  | 'identity'\n  | 'scope'\n  | 'status'\n  | 'relations'\n  | 'activity'\n  | 'billing'\n  | 'technical'\n  | 'raw';\n\nexport type BackofficeDetailImportance =\n  | 'hero'\n  | 'primary'\n  | 'secondary'\n  | 'debug';\n\nexport type BackofficeDetailCollapseBehavior = {\n  collapsible?: boolean;\n  defaultCollapsed?: boolean;\n  persistKey?: string;\n};\n\nexport type BackofficeDetailPresentation = {\n  group?: BackofficeDetailContentGroup;\n  importance?: BackofficeDetailImportance;\n  collapse?: BackofficeDetailCollapseBehavior;\n  mobile?: 'visible' | 'collapsed' | 'hidden';\n  desktop?: 'primary' | 'secondary' | 'fullWidth';\n};\n\nexport type BackofficeTone =\n  | 'neutral'\n  | 'info'\n  | 'success'\n  | 'warning'\n  | 'danger';\n\nexport type BackofficeActionTone = 'neutral' | 'primary' | 'danger';\n\nexport type BackofficeDensity = 'compact' | 'comfortable';\n\nexport type BackofficeSemanticDetailPlacement = 'main' | 'side' | 'fullWidth';\n\nexport type BackofficeSemanticDetailPriority =\n  | 'primary'\n  | 'secondary'\n  | 'diagnostic';\n\nexport type BackofficeRenderableValue =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined;\n\nexport type BackofficeStatusValue = {\n  readonly label: string | I18nLabel;\n  readonly tone: BackofficeTone;\n};\n\nexport type BackofficeSemanticBlockBase = {\n  readonly id?: string;\n  readonly title: I18nLabel;\n  readonly description?: I18nLabel;\n  readonly placement?: BackofficeSemanticDetailPlacement;\n  readonly priority?: BackofficeSemanticDetailPriority;\n  readonly presentation?: BackofficeDetailPresentation;\n};\n\nexport type BackofficeValueSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly tone?: BivariantCallback<(node: Node) => BackofficeTone | undefined>;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n  readonly copyValue?: BivariantCallback<\n    (node: Node) => string | null | undefined\n  >;\n};\n\nexport type BackofficeSummaryItemSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly tone?: BivariantCallback<(node: Node) => BackofficeTone | undefined>;\n  readonly description?: BivariantCallback<\n    (node: Node) => BackofficeValueLabel\n  >;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n};\n\nexport type BackofficeSummaryBlockSpec<Node> = BackofficeSemanticBlockBase & {\n  readonly kind: 'summary';\n  readonly items: readonly BackofficeSummaryItemSpec<Node>[];\n};\n\nexport type BackofficeHeroSummaryBlockSpec<Node> =\n  BackofficeSummaryBlockSpec<Node>;\n\nexport type BackofficeMetricSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly formattedValue?: BivariantCallback<\n    (node: Node) => string | null | undefined\n  >;\n  readonly hint?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly tone?: BivariantCallback<(node: Node) => BackofficeTone | undefined>;\n  readonly copyValue?: BivariantCallback<\n    (node: Node) => string | null | undefined\n  >;\n};\n\nexport type BackofficeMetricGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'metrics';\n    readonly density?: BackofficeDensity;\n    readonly items: readonly BackofficeMetricSpec<Node>[];\n  };\n\nexport type BackofficeMetricBlockSpec<Node> =\n  BackofficeMetricGroupBlockSpec<Node>;\n\nexport type BackofficeStateSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeRenderableValue>;\n  readonly getDisplay: BivariantCallback<\n    (\n      value: BackofficeRenderableValue,\n      node: Node,\n    ) => {\n      readonly label: string | I18nLabel;\n      readonly tone: BackofficeTone;\n    }\n  >;\n};\n\nexport type BackofficeStateGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'states';\n    readonly states: readonly BackofficeStateSpec<Node>[];\n  };\n\nexport type BackofficeStateBlockSpec<Node> =\n  BackofficeStateGroupBlockSpec<Node>;\n\nexport type BackofficeContextItemSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n  readonly emptyLabel?: I18nLabel;\n};\n\nexport type BackofficeContextStackBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'context';\n    readonly items: readonly BackofficeContextItemSpec<Node>[];\n  };\n\nexport type BackofficeContextBlockSpec<Node> =\n  BackofficeContextStackBlockSpec<Node>;\n\nexport type BackofficeRelationTileSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly count?: BivariantCallback<(node: Node) => number | null | undefined>;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n  readonly description?: BivariantCallback<\n    (node: Node) => BackofficeValueLabel\n  >;\n  readonly tone?: BivariantCallback<(node: Node) => BackofficeTone | undefined>;\n};\n\nexport type BackofficeRelationGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'relations';\n    readonly items: readonly BackofficeRelationTileSpec<Node>[];\n  };\n\nexport type BackofficeRelationBlockSpec<Node> =\n  BackofficeRelationGroupBlockSpec<Node>;\n\nexport type BackofficeTimelineEventSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly timestamp?: BivariantCallback<\n    (node: Node) => string | number | Date | null | undefined\n  >;\n  readonly state?: BivariantCallback<\n    (node: Node) => BackofficeStatusValue | null | undefined\n  >;\n  readonly description?: BivariantCallback<\n    (node: Node) => BackofficeValueLabel\n  >;\n  readonly actor?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly payload?: BivariantCallback<(node: Node) => unknown>;\n};\n\nexport type BackofficeTimelineBlockSpec<Node> = BackofficeSemanticBlockBase & {\n  readonly kind: 'timeline';\n  readonly events: readonly BackofficeTimelineEventSpec<Node>[];\n};\n\nexport type BackofficeAuditItemSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly timestamp?: BivariantCallback<\n    (node: Node) => string | number | Date | null | undefined\n  >;\n  readonly actor?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly source?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n};\n\nexport type BackofficeAuditBlockSpec<Node> = BackofficeSemanticBlockBase & {\n  readonly kind: 'audit';\n  readonly items: readonly BackofficeAuditItemSpec<Node>[];\n};\n\nexport type BackofficeReferenceSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n  readonly copyValue?: BivariantCallback<\n    (node: Node) => string | null | undefined\n  >;\n  readonly refKind?:\n    | 'id'\n    | 'slug'\n    | 'path'\n    | 'url'\n    | 'hash'\n    | 'external'\n    | 'text';\n};\n\nexport type BackofficeReferenceGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'references';\n    readonly references: readonly BackofficeReferenceSpec<Node>[];\n  };\n\nexport type BackofficePayloadFormat = 'json' | 'markdown' | 'text' | 'code';\n\nexport type BackofficePayloadBlockSpec<Node> = BackofficeSemanticBlockBase & {\n  readonly kind: 'payload';\n  readonly format?: BackofficePayloadFormat;\n  readonly summary?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly value: BivariantCallback<(node: Node) => unknown>;\n  readonly defaultCollapsed?: boolean;\n  readonly emptyLabel?: I18nLabel;\n};\n\nexport type BackofficeActionResultBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'actionResult';\n    readonly status?: BivariantCallback<\n      (node: Node) => BackofficeStatusValue | null | undefined\n    >;\n    readonly message?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n    readonly references?: readonly BackofficeReferenceSpec<Node>[];\n    readonly payload?: BivariantCallback<(node: Node) => unknown>;\n  };\n\nexport type BackofficeTechnicalFactsBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'technicalFacts';\n    readonly facts: readonly BackofficeValueSpec<Node>[];\n  };\n\nexport type BackofficeSemanticDetailBlockSpec<Node> =\n  | BackofficeSummaryBlockSpec<Node>\n  | BackofficeMetricGroupBlockSpec<Node>\n  | BackofficeStateGroupBlockSpec<Node>\n  | BackofficeContextStackBlockSpec<Node>\n  | BackofficeRelationGroupBlockSpec<Node>\n  | BackofficeTimelineBlockSpec<Node>\n  | BackofficeAuditBlockSpec<Node>\n  | BackofficeReferenceGroupBlockSpec<Node>\n  | BackofficePayloadBlockSpec<Node>\n  | BackofficeActionResultBlockSpec<Node>\n  | BackofficeTechnicalFactsBlockSpec<Node>;\n\nexport type BackofficeFlagVariant =\n  | 'yesNo'\n  | 'capability'\n  | 'enabled'\n  | 'failure'\n  | 'encrypted'\n  | 'locked'\n  | 'default'\n  | 'agentManaged'\n  | 'deployedProduction'\n  | 'forced';\n\nexport type BackofficeDetailFieldSpec<Node> =\n  | {\n      type: 'text';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n      copyValue?: BivariantCallback<(node: Node) => string | null>;\n      fullWidth?: boolean;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'badge';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n      tone?:\n        | BackofficeBadgeTone\n        | BivariantCallback<(node: Node) => BackofficeBadgeTone>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'badgeRow';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      items: BivariantCallback<(node: Node) => readonly BackofficeBadgeItem[]>;\n      fullWidth?: boolean;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'dateTime';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => string | number | null>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'number';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => number | null>;\n      format?: BackofficeNumberFormat;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'flag';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => boolean | null>;\n      variant: BackofficeFlagVariant;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'entityRef';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      entity: string;\n      id: BivariantCallback<(node: Node) => string | null>;\n      value?: BivariantCallback<(node: Node) => string | null>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'link';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      href: BivariantCallback<(node: Node) => string | null>;\n      value: BivariantCallback<(node: Node) => string | number | null>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'taggedValue';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      tag: BivariantCallback<\n        (node: Node) => {\n          label: string | I18nLabel;\n          tone?: BackofficeBadgeTone;\n        } | null\n      >;\n      value: BivariantCallback<(node: Node) => BackofficeInlineValueSpec>;\n      fullWidth?: boolean;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'relation';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      relation: BackofficeRuntimeRelationFilterSpec;\n      value: BivariantCallback<(node: Node) => string>;\n      count?: BackofficeRelationCountSpec<Node>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'custom';\n      label?: I18nLabel;\n      size: BackofficeFieldSize;\n      render: BivariantCallback<(node: Node) => unknown>;\n      fullWidth?: boolean;\n      presentation?: BackofficeDetailPresentation;\n    };\n\nexport type BackofficeDetailHeaderConfig<Node> = {\n  title: I18nLabel;\n  titleValue?: BivariantCallback<(node: Node, t: TFunction) => string | null>;\n  subtitle?: I18nLabel;\n  subtitleValue?: BivariantCallback<\n    (node: Node, t: TFunction) => string | null\n  >;\n  subtitleItems?: readonly BackofficeDetailHeaderSubtitleItem<Node>[];\n  subtitleSeparator?: string;\n  id?: BivariantCallback<(node: Node) => string | null>;\n  badges?: readonly {\n    label: I18nLabel;\n    value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n    tone?:\n      | BackofficeBadgeTone\n      | BivariantCallback<(node: Node) => BackofficeBadgeTone>;\n  }[];\n  status?: BackofficeDetailHeaderStatusSpec<Node>;\n  meta?: readonly BackofficeDetailHeaderMetaSpec<Node>[];\n};\n\nexport type BackofficeDetailSectionConfig<Node> = {\n  id?: string;\n  title: I18nLabel;\n  description?: I18nLabel;\n  fields: readonly BackofficeDetailFieldSpec<Node>[];\n  placement?: BackofficeDetailPlacement;\n  presentation?: BackofficeDetailPresentation;\n};\n\nexport type BackofficeFieldSetBlockSpec<Node> =\n  BackofficeDetailSectionConfig<Node> & {\n    kind: 'fieldSet';\n  };\n\nexport type BackofficeDetailTableBlockSpec<Node, Row> = {\n  kind: 'table';\n  label: I18nLabel;\n  description?: I18nLabel;\n  columns: readonly BackofficeColumnSpec<Row>[];\n  rows: BivariantCallback<(node: Node) => readonly Row[]>;\n  placement?: BackofficeDetailPlacement;\n  presentation?: BackofficeDetailPresentation;\n};\n\nexport type BackofficeTableBlockSpec<\n  Node,\n  Row = unknown,\n> = BackofficeDetailTableBlockSpec<Node, Row>;\n\nexport type BackofficeCustomBlockSpec<Node> = {\n  kind: 'custom';\n  label?: I18nLabel;\n  render: BivariantCallback<(node: Node) => unknown>;\n  placement?: BackofficeDetailPlacement;\n  presentation?: BackofficeDetailPresentation;\n};\n\nexport type BackofficeDetailBlockSpec<Node> =\n  | BackofficeSemanticDetailBlockSpec<Node>\n  | BackofficeDetailTableBlockSpec<Node, any>\n  | BackofficeCustomBlockSpec<Node>;\n\nexport type BackofficeDetailContentSpec<Node> =\n  | BackofficeFieldSetBlockSpec<Node>\n  | BackofficeDetailBlockSpec<Node>;\n\nexport type BackofficeDetailViewLayoutSpec = {\n  readonly density?: BackofficeDensity;\n  readonly columns?: 'auto' | 'single' | 'mainSide';\n  readonly technicalDefaultCollapsed?: boolean;\n  readonly sideColumn?: {\n    readonly width?: 'narrow' | 'medium' | 'wide';\n    readonly sticky?: boolean;\n  };\n};\n\nexport type BackofficeDetailPageViewSpec<Node> = {\n  readonly title: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly subtitle?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly eyebrow?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly status?: BackofficeDetailHeaderStatusSpec<Node>;\n  readonly references?: readonly BackofficeReferenceSpec<Node>[];\n  readonly actions?: readonly BackofficeEntityActionSpec<Node>[];\n  readonly layout?: BackofficeDetailViewLayoutSpec;\n  readonly blocks: readonly BackofficeDetailContentSpec<Node>[];\n};\n\nexport type BackofficeDetailPageDataContext = {\n  id: string;\n  detailId?: string;\n};\n\nexport type BackofficeDetailPageVariablesResult<DetailQueryVariables> = {\n  variables: DetailQueryVariables;\n  detailId?: string;\n};\n\nexport type BackofficeDetailVariables<DetailQueryVariables> =\n  BackofficeDetailPageVariablesResult<DetailQueryVariables>;\n\nexport type BackofficeNodeQueryResponse<NodeRef> = {\n  readonly node?: NodeRef | null;\n};\n\nexport type BackofficeAliasedNodeQueryResponse<\n  Alias extends string,\n  NodeRef,\n> = {\n  readonly node?:\n    | (Readonly<Partial<Record<Alias, NodeRef | null>>> & {\n        readonly __typename?: string;\n      })\n    | null;\n};\n\nexport type BackofficeAliasedPickerValueResponse<\n  Alias extends string,\n  RowRef,\n> = BackofficeAliasedNodeQueryResponse<Alias, RowRef>;\n\nexport type BackofficeDetailPageDataSpec<\n  DetailView,\n  DetailData = DetailView,\n  DetailQueryData = unknown,\n  DetailFragmentKey = unknown,\n  DetailQueryVariables = Record<string, unknown>,\n> = {\n  query: GraphQLTaggedNode;\n  fragment: GraphQLTaggedNode;\n  resolveNode: (\n    data: DetailQueryData,\n    context: BackofficeDetailPageDataContext,\n  ) => DetailFragmentKey | null;\n  toView: BivariantCallback<(data: DetailData) => DetailView>;\n  buildVariables?: (input: {\n    id: string;\n  }) => BackofficeDetailPageVariablesResult<DetailQueryVariables>;\n};\n\nexport type BackofficeDetailStandardTab =\n  | 'overview'\n  | 'relations'\n  | 'activity'\n  | 'billing'\n  | 'technical'\n  | 'raw';\n\nexport type BackofficeDetailTitleMetaItem = {\n  id: string;\n  label?: I18nLabel;\n  value: string;\n  tone?: BackofficeBadgeTone;\n};\n\nexport type BackofficeDetailLayoutProfile<DetailView = unknown> = {\n  standardTabs?: readonly BackofficeDetailStandardTab[];\n  summaryFields?: readonly string[];\n  scopeFields?: readonly string[];\n  statusFields?: readonly string[];\n  technicalGroupsCollapsed?: boolean;\n  rawGroupsHiddenFromOverview?: boolean;\n  sideRail?: {\n    groups: readonly BackofficeDetailContentGroup[];\n    sticky?: boolean;\n  };\n  titleMeta?: BivariantCallback<\n    (node: DetailView) => readonly BackofficeDetailTitleMetaItem[]\n  >;\n};\n\nexport type BackofficeDetailLayoutSpec<\n  LayoutView,\n  LayoutData = LayoutView,\n  LayoutQueryData = unknown,\n  LayoutFragmentKey = unknown,\n  LayoutQueryVariables = Record<string, unknown>,\n> = BackofficeDetailPageDataSpec<\n  LayoutView,\n  LayoutData,\n  LayoutQueryData,\n  LayoutFragmentKey,\n  LayoutQueryVariables\n>;\n\nexport type BackofficeDetailPageSpec<\n  DetailView,\n  LayoutView = DetailView,\n  DetailData = DetailView,\n  DetailQueryData = unknown,\n  DetailFragmentKey = unknown,\n  DetailQueryVariables = Record<string, unknown>,\n> = BackofficeDetailPageDataSpec<\n  DetailView,\n  DetailData,\n  DetailQueryData,\n  DetailFragmentKey,\n  DetailQueryVariables\n> & {\n  id: string;\n  path: string;\n  label: I18nLabel;\n  content: readonly BackofficeDetailContentSpec<DetailView>[];\n  actions?: readonly BackofficeEntityActionSpec<DetailView>[];\n  isVisible?: BivariantCallback<(layoutPage: LayoutView) => boolean>;\n  profile?: BackofficeDetailLayoutProfile<DetailView>;\n};\n\nexport type BackofficePickerValueConfig<\n  RowRef,\n  RowView,\n  ValueQueryData = unknown,\n> = {\n  query: GraphQLTaggedNode;\n  resolveRow: (data: ValueQueryData) => RowRef | null;\n  toRow: BivariantCallback<(rowRef: RowRef) => RowView>;\n};\n\nexport type BackofficeEntityDetailConfig<\n  LayoutData = any,\n  LayoutView = any,\n  MainData = LayoutData,\n  MainView = LayoutView,\n  SubData = MainData,\n  SubView = MainView,\n  LayoutQueryData = unknown,\n  MainQueryData = unknown,\n  SubQueryData = MainQueryData,\n  LayoutFragmentKey = unknown,\n  MainFragmentKey = unknown,\n  SubFragmentKey = MainFragmentKey,\n  LayoutQueryVariables = Record<string, unknown>,\n  MainQueryVariables = Record<string, unknown>,\n  SubQueryVariables = MainQueryVariables,\n> = {\n  title: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  profile?: BackofficeDetailLayoutProfile<LayoutView>;\n  layoutPage: BackofficeDetailLayoutSpec<\n    LayoutView,\n    LayoutData,\n    LayoutQueryData,\n    LayoutFragmentKey,\n    LayoutQueryVariables\n  >;\n  mainPage: BackofficeDetailPageSpec<\n    MainView,\n    LayoutView,\n    MainData,\n    MainQueryData,\n    MainFragmentKey,\n    MainQueryVariables\n  >;\n  subPages?: readonly BackofficeDetailPageSpec<\n    SubView,\n    LayoutView,\n    SubData,\n    SubQueryData,\n    SubFragmentKey,\n    SubQueryVariables\n  >[];\n};\n\nexport type BackofficeEntityPickerConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  PickerFragmentData = unknown,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  ValueQueryData = BackofficeAliasedPickerValueResponse<string, RowRef>,\n> = {\n  query: GraphQLTaggedNode;\n  fragment: GraphQLTaggedNode;\n  buildQueryVariables: (\n    input: BackofficePickerQueryInput<TOperation, TWhere>,\n  ) => TOperation['variables'];\n  value?: BackofficePickerValueConfig<RowRef, RowView, ValueQueryData>;\n  getConnection: BivariantCallback<\n    (data: PickerFragmentData) => BackofficeConnection<RowRef>\n  >;\n  toRow: BivariantCallback<(rowRef: RowRef) => RowView>;\n  getRowId: BivariantCallback<(row: RowView) => string>;\n  searchEnabled?: boolean;\n  searchRequired?: boolean;\n  searchPlaceholder?: I18nLabel;\n};\n\nexport type BackofficeToolEntityConfig = {\n  kind: 'tool';\n  id: string;\n  label?: I18nLabel;\n  route?: string;\n  operation: BackofficeToolOperation;\n  list?: never;\n  detail?: never;\n  picker?: never;\n  routes?: never;\n};\n\nexport type BackofficeListFacetConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n> = {\n  kind: 'list';\n  id: string;\n  label: I18nLabel;\n  list: BackofficeEntityListConfig<\n    TOperation,\n    RowRef,\n    RowView,\n    ListFragmentData,\n    TWhere,\n    TSort\n  >;\n  listActions?: readonly BackofficeListActionSpec[];\n};\n\nexport type BackofficePickerFacetConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  PickerFragmentData,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  ValueQueryData = BackofficeAliasedPickerValueResponse<string, RowRef>,\n> = {\n  kind: 'picker';\n  id: string;\n  label: I18nLabel;\n  picker: BackofficeEntityPickerConfig<\n    TOperation,\n    RowRef,\n    RowView,\n    PickerFragmentData,\n    TWhere,\n    ValueQueryData\n  >;\n};\n\nexport type BackofficeDetailPagesSpec<\n  LayoutView = unknown,\n  Page extends BackofficeDetailPageRouteSpec<LayoutView> =\n    BackofficeDetailPageRouteSpec<LayoutView>,\n> = {\n  title: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  mainPage: Page;\n  subPages?: readonly Page[];\n  defaultPageId: string;\n};\n\nexport type BackofficeDetailLayoutFacetConfig<\n  LayoutData = any,\n  LayoutView = any,\n  LayoutQueryData = unknown,\n  LayoutFragmentKey = unknown,\n  LayoutQueryVariables = Record<string, unknown>,\n> = {\n  kind: 'detail-layout';\n  id: string;\n  label: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  title: I18nLabel;\n  layoutPage: BackofficeDetailLayoutSpec<\n    LayoutView,\n    LayoutData,\n    LayoutQueryData,\n    LayoutFragmentKey,\n    LayoutQueryVariables\n  >;\n  pages: BackofficeDetailPagesSpec<LayoutView>;\n};\n\nexport type BackofficeDetailPageFacetConfig<\n  LayoutView = unknown,\n  DetailData = any,\n  DetailView = any,\n  DetailQueryData = unknown,\n  DetailFragmentKey = unknown,\n  DetailQueryVariables = Record<string, unknown>,\n> = {\n  kind: 'detail-page';\n  id: string;\n  label: I18nLabel;\n  title: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  page: BackofficeDetailPageSpec<\n    DetailView,\n    LayoutView,\n    DetailData,\n    DetailQueryData,\n    DetailFragmentKey,\n    DetailQueryVariables\n  >;\n  pages: BackofficeDetailPagesSpec<LayoutView>;\n};\n\nexport type BackofficeToolFacetConfig = {\n  kind: 'tool';\n  id: string;\n  label: I18nLabel;\n  tool: BackofficeToolEntityConfig;\n};\n\nexport type BackofficeEntityFacetConfigBase =\n  | BackofficeListFacetConfigBase\n  | BackofficePickerFacetConfigBase\n  | BackofficeDetailLayoutFacetConfigBase\n  | BackofficeDetailPageFacetConfigBase\n  | BackofficeToolFacetConfig;\n\nexport type BackofficeLoadedListFacetModule = {\n  kind: 'list';\n  id: string;\n  config: BackofficeListFacetConfigBase;\n};\n\nexport type BackofficeLoadedPickerFacetModule = {\n  kind: 'picker';\n  id: string;\n  config: BackofficePickerFacetConfigBase;\n};\n\nexport type BackofficeLoadedDetailLayoutFacetModule = {\n  kind: 'detail-layout';\n  id: string;\n  config: BackofficeDetailLayoutFacetConfigBase;\n};\n\nexport type BackofficeLoadedDetailPageFacetModule = {\n  kind: 'detail-page';\n  id: string;\n  pageId: string;\n  config: BackofficeDetailPageFacetConfigBase;\n};\n\nexport type BackofficeLoadedToolFacetModule = {\n  kind: 'tool';\n  id: string;\n  config: BackofficeToolFacetConfig;\n};\n\nexport type BackofficeRuntimeOperation = OperationType & {\n  variables: {\n    [key: string]: unknown;\n    where?: Record<string, unknown> | null | undefined;\n    sort?: string | null | undefined;\n    count?: number;\n    cursor?: string | null | undefined;\n  };\n  response: unknown;\n};\n\nexport type BackofficeRuntimeListFacetConfig = BackofficeListFacetConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>,\n  any\n>;\n\nexport type BackofficeRuntimePickerFacetConfig = BackofficePickerFacetConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>\n>;\n\nexport type BackofficeLoadedEntityFacetModule =\n  | BackofficeLoadedListFacetModule\n  | BackofficeLoadedPickerFacetModule\n  | BackofficeLoadedDetailLayoutFacetModule\n  | BackofficeLoadedDetailPageFacetModule\n  | BackofficeLoadedToolFacetModule;\n\nexport type BackofficeListFacetLoader =\n  () => Promise<BackofficeLoadedListFacetModule>;\n\nexport type BackofficePickerFacetLoader =\n  () => Promise<BackofficeLoadedPickerFacetModule>;\n\nexport type BackofficeDetailLayoutFacetLoader =\n  () => Promise<BackofficeLoadedDetailLayoutFacetModule>;\n\nexport type BackofficeDetailPageFacetLoader = (\n  pageId: string,\n) => Promise<BackofficeLoadedDetailPageFacetModule>;\n\nexport type BackofficeToolFacetLoader =\n  () => Promise<BackofficeLoadedToolFacetModule>;\n\nexport type BackofficeListDetailFacetLoaderMap = {\n  list?: BackofficeListFacetLoader;\n  picker?: BackofficePickerFacetLoader;\n  detailLayout: BackofficeDetailLayoutFacetLoader;\n  detailPage: BackofficeDetailPageFacetLoader;\n};\n\nexport type BackofficeToolFacetLoaderMap = {\n  tool: BackofficeToolFacetLoader;\n};\n\nexport type BackofficeEntityFacetLoaderMap =\n  | BackofficeListDetailFacetLoaderMap\n  | BackofficeToolFacetLoaderMap;\n\nexport type BackofficeEntityManifestItem = {\n  id: string;\n  kind: BackofficeEntityManifestKind;\n  routeSegment: string;\n  groupId?: string;\n  label: I18nLabel;\n  routes: BackofficeEntityRouteManifest;\n  hasList: boolean;\n  detailPages?: readonly BackofficeDetailPageManifestItem[];\n  defaultDetailPageId?: string;\n  facets: BackofficeEntityFacetLoaderMap;\n};\n\nexport type BackofficeEntityManifestMap = Record<\n  string,\n  BackofficeEntityManifestItem\n>;\n\nexport type BackofficeManifestEntityId<TManifest> = Extract<\n  keyof TManifest,\n  string\n>;\n\nexport type BackofficeManifestListEntityId<TManifest> = {\n  [TEntityId in BackofficeManifestEntityId<TManifest>]: TManifest[TEntityId] extends {\n    kind: 'list-detail';\n    hasList: true;\n  }\n    ? TEntityId\n    : never;\n}[BackofficeManifestEntityId<TManifest>] extends infer TEntityId\n  ? [TEntityId] extends [never]\n    ? string extends BackofficeManifestEntityId<TManifest>\n      ? string\n      : never\n    : Extract<TEntityId, string>\n  : never;\n\nexport type BackofficeManifestDetailEntityId<TManifest> = {\n  [TEntityId in BackofficeManifestEntityId<TManifest>]: TManifest[TEntityId] extends {\n    kind: 'list-detail';\n  }\n    ? TEntityId\n    : never;\n}[BackofficeManifestEntityId<TManifest>] extends infer TEntityId\n  ? [TEntityId] extends [never]\n    ? string extends BackofficeManifestEntityId<TManifest>\n      ? string\n      : never\n    : Extract<TEntityId, string>\n  : never;\n\nexport type BackofficeManifestToolId<TManifest> = {\n  [TEntityId in BackofficeManifestEntityId<TManifest>]: TManifest[TEntityId] extends {\n    kind: 'tool';\n  }\n    ? TEntityId\n    : never;\n}[BackofficeManifestEntityId<TManifest>] extends infer TEntityId\n  ? [TEntityId] extends [never]\n    ? string extends BackofficeManifestEntityId<TManifest>\n      ? string\n      : never\n    : Extract<TEntityId, string>\n  : never;\n\nexport type BackofficeManifestDetailPageId<\n  TManifest,\n  TEntityId extends BackofficeManifestDetailEntityId<TManifest>,\n> = TManifest[TEntityId] extends {\n  detailPages: readonly (infer TPage)[];\n}\n  ? TPage extends { id: infer TPageId }\n    ? Extract<TPageId, string>\n    : string\n  : string;\n\nexport type BackofficeResolvedListFacetConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n> = BackofficeListFacetConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere,\n  TSort\n> & {\n  routes: BackofficeEntityRoutes;\n  listUrlCodec?: BackofficeListUrlCodec<TWhere, TSort>;\n  listDefaults?: BackofficeListState<TWhere, TSort>;\n};\n\nexport type BackofficeResolvedPickerFacetConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  PickerFragmentData,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n> = BackofficePickerFacetConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  PickerFragmentData,\n  TWhere\n> & {\n  routes: BackofficeEntityRoutes;\n};\n\nexport type BackofficeResolvedDetailLayoutFacetConfig<\n  LayoutRef = any,\n  LayoutView = any,\n  LayoutQueryData = unknown,\n  LayoutFragmentRef = unknown,\n  LayoutQueryVariables = Record<string, unknown>,\n> = BackofficeDetailLayoutFacetConfig<\n  LayoutRef,\n  LayoutView,\n  LayoutQueryData,\n  LayoutFragmentRef,\n  LayoutQueryVariables\n> & {\n  routes: BackofficeEntityRoutes;\n};\n\nexport type BackofficeResolvedDetailPageFacetConfig<\n  LayoutView = unknown,\n  DetailRef = any,\n  DetailView = any,\n  DetailQueryData = unknown,\n  DetailFragmentRef = unknown,\n  DetailQueryVariables = Record<string, unknown>,\n> = BackofficeDetailPageFacetConfig<\n  LayoutView,\n  DetailRef,\n  DetailView,\n  DetailQueryData,\n  DetailFragmentRef,\n  DetailQueryVariables\n> & {\n  routes: BackofficeEntityRoutes;\n};\n\nexport type BackofficeResolvedToolFacetConfig = BackofficeToolFacetConfig & {\n  route: string;\n  routes: BackofficeEntityRoutes;\n};\n\nexport type BackofficeResolvedEntityFacetConfigBase =\n  | BackofficeResolvedListFacetConfigBase\n  | BackofficeResolvedPickerFacetConfigBase\n  | BackofficeResolvedDetailLayoutFacetConfigBase\n  | BackofficeResolvedDetailPageFacetConfigBase\n  | BackofficeResolvedToolFacetConfig;\n\nexport type BackofficeResolvedListFacetModule = {\n  kind: 'list';\n  id: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedListFacetConfigBase;\n};\n\nexport type BackofficeResolvedPickerFacetModule = {\n  kind: 'picker';\n  id: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedPickerFacetConfigBase;\n};\n\nexport type BackofficeResolvedDetailLayoutFacetModule = {\n  kind: 'detail-layout';\n  id: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedDetailLayoutFacetConfigBase;\n};\n\nexport type BackofficeResolvedDetailPageFacetModule = {\n  kind: 'detail-page';\n  id: string;\n  pageId: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedDetailPageFacetConfigBase;\n};\n\nexport type BackofficeResolvedToolFacetModule = {\n  kind: 'tool';\n  id: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedToolFacetConfig;\n};\n\nexport type BackofficeResolvedEntityFacetModule =\n  | BackofficeResolvedListFacetModule\n  | BackofficeResolvedPickerFacetModule\n  | BackofficeResolvedDetailLayoutFacetModule\n  | BackofficeResolvedDetailPageFacetModule\n  | BackofficeResolvedToolFacetModule;\n\nexport type BackofficeListFacetConfigBase = BackofficeRuntimeListFacetConfig;\n\nexport type BackofficePickerFacetConfigBase =\n  BackofficeRuntimePickerFacetConfig;\n\nexport type BackofficeDetailLayoutFacetConfigBase =\n  BackofficeDetailLayoutFacetConfig<any, any, any, any, any>;\n\nexport type BackofficeDetailPageFacetConfigBase =\n  BackofficeDetailPageFacetConfig<any, any, any, any, any, any>;\n\nexport type BackofficeResolvedListFacetConfigBase =\n  BackofficeResolvedListFacetConfig<\n    any,\n    any,\n    any,\n    any,\n    Record<string, any>,\n    any\n  >;\n\nexport type BackofficeResolvedPickerFacetConfigBase =\n  BackofficeResolvedPickerFacetConfig<any, any, any, any, Record<string, any>>;\n\nexport type BackofficeResolvedDetailLayoutFacetConfigBase =\n  BackofficeResolvedDetailLayoutFacetConfig<any, any, any, any, any>;\n\nexport type BackofficeResolvedDetailPageFacetConfigBase =\n  BackofficeResolvedDetailPageFacetConfig<any, any, any, any, any, any>;\n\nexport type BackofficeRuntimeResolvedListFacetConfig =\n  BackofficeResolvedListFacetConfigBase;\n\nexport type BackofficeRuntimeResolvedPickerFacetConfig =\n  BackofficeResolvedPickerFacetConfigBase;\n\nexport type BackofficeRuntimeConnectionListConfig =\n  BackofficeConnectionListConfig<any, any, any, any, Record<string, any>, any>;\n\nexport type BackofficeRuntimeRecordListConfig = BackofficeRecordListConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>,\n  any\n>;\n\nexport type BackofficeRuntimeEntityListConfig = BackofficeEntityListConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>,\n  any\n>;\n\nexport type BackofficeRuntimeEntityPickerConfig = BackofficeEntityPickerConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>\n>;\n\nexport type BackofficeEntityFacetModuleCacheEntry = {\n  status: BackofficeEntityModuleStatus;\n  promise?: Promise<BackofficeResolvedEntityFacetModule>;\n  module?: BackofficeResolvedEntityFacetModule;\n  error?: Error;\n};\n\nexport type BackofficeToolVariablesContext = {\n  scope: Record<string, unknown>;\n  run: boolean;\n};\n\nexport class BackofficeToolValidationError extends Error {\n  public label: I18nLabel;\n\n  public constructor(label: I18nLabel) {\n    super('Backoffice tool validation error');\n    this.label = label;\n  }\n}\n\nexport type BackofficeToolOperation = {\n  title: I18nLabel;\n  subtitle?: I18nLabel;\n  inputTypeSDL?: string;\n  query: GraphQLTaggedNode;\n  inputs?: readonly BackofficeToolInputSpec[];\n  outputs?: readonly BackofficeToolOutputSpec[];\n  render?: (data: unknown) => unknown;\n  showProjectPicker?: boolean;\n  buildVariables?: (\n    input: Record<string, unknown>,\n    context: BackofficeToolVariablesContext,\n  ) => Record<string, unknown>;\n};\n\nexport type BackofficeToolInputSpec =\n  | {\n      id: string;\n      kind: 'text';\n      label: I18nLabel;\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n    }\n  | {\n      id: string;\n      kind: 'json';\n      label: I18nLabel;\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n    }\n  | {\n      id: string;\n      kind: 'enum';\n      label: I18nLabel;\n      options: readonly { value: string; label: I18nLabel }[];\n      defaultValue?: string;\n    }\n  | {\n      id: string;\n      kind: 'boolean';\n      label: I18nLabel;\n      defaultValue?: boolean;\n    }\n  | {\n      id: string;\n      kind: 'entityId';\n      label: I18nLabel;\n      entity: string;\n      defaultValue?: string;\n    };\n\nexport type BackofficeToolOutputSpec =\n  | {\n      kind: 'table';\n      label?: I18nLabel;\n      description?: I18nLabel;\n      columns: readonly BackofficeColumnSpec[];\n      rows: (data: unknown) => readonly unknown[];\n    }\n  | {\n      kind: 'code';\n      label?: I18nLabel;\n      description?: I18nLabel;\n      value: (data: unknown) => string;\n    }\n  | {\n      kind: 'json';\n      label?: I18nLabel;\n      description?: I18nLabel;\n      value: (data: unknown) => unknown;\n    }\n  | {\n      kind: 'keyValue';\n      label?: I18nLabel;\n      description?: I18nLabel;\n      items: readonly {\n        label: I18nLabel;\n        value: (data: unknown) => BackofficeValueLabel;\n      }[];\n    }\n  | {\n      kind: 'payload';\n      label: I18nLabel;\n      description?: I18nLabel;\n      value: (data: unknown) => unknown;\n      format?: 'markdown' | 'json' | 'text';\n    }\n  | {\n      kind: 'custom';\n      label?: I18nLabel;\n      render: (data: unknown) => unknown;\n    };\n\nexport type BackofficeConnection<Row> = {\n  edges: readonly { node: Row }[];\n  totalCount?: number | null;\n};\n\nexport type BackofficeListDefaults<Where, Sort extends string> = {\n  where: Where | null;\n  sort: Sort | null;\n};\n\nexport type BackofficePreparedListRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedListFacetConfigBase;\n  query: PreloadedQuery<OperationType>;\n};\n\nexport type BackofficePreparedDetailLayoutRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  layoutQuery: PreloadedQuery<OperationType>;\n  id: string;\n};\n\nexport type BackofficePreparedDetailPageRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  id: string;\n  pageId: string;\n  pagePath: string;\n  pageConfig: BackofficeResolvedDetailPageFacetConfigBase;\n  pageQuery: PreloadedQuery<OperationType>;\n  detailId?: string;\n};\n\nexport type BackofficePreparedToolRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedToolFacetConfig;\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAugEA,MAAM,OAAO,6BAA8B,SAAQ,KAAK;IAC/C,KAAK,CAAY;IAExB,YAAmB,KAAgB;QACjC,KAAK,CAAC,kCAAkC,CAAC,CAAC;QAC1C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF","sourcesContent":["import type { ReactNode } from 'react';\nimport type { TFunction } from 'i18next';\nimport type { PreloadedQuery } from 'react-relay';\nimport type {\n  GraphQLTaggedNode,\n  OperationType,\n  RecordSourceSelectorProxy,\n} from 'relay-runtime';\nimport type { BACKOFFICE_ENTITY_FACET_KINDS } from './constants.js';\n\nexport type I18nLabel = (t: TFunction) => string;\n\ntype BivariantCallback<Fn> = Fn extends (...args: infer A) => infer R\n  ? { bivarianceHack: (...args: A) => R }['bivarianceHack']\n  : never;\n\nexport type BackofficeActionRenderNode = Exclude<ReactNode, Promise<unknown>>;\n\nexport type BackofficeValueLabel = string | number | null | I18nLabel;\n\nexport type BackofficeBadgeTone =\n  | 'neutral'\n  | 'info'\n  | 'success'\n  | 'warning'\n  | 'danger';\n\nexport type BackofficeNumberFormat = 'number' | 'currency' | 'percent';\n\nexport type BackofficeFieldSize =\n  | 'xs'\n  | 's'\n  | 'statusAction'\n  | 'm'\n  | 'l'\n  | 'xl'\n  | 'fluid';\n\nexport type BackofficeActionVariant =\n  | 'primary'\n  | 'secondary'\n  | 'text'\n  | 'success'\n  | 'danger'\n  | 'brand'\n  | 'brandGhost'\n  | 'tab'\n  | 'icon';\n\nexport type BackofficeActionSize = 'small' | 'medium' | 'large';\n\nexport type BackofficeActionToastViewSpec<\n  Node = unknown,\n  Response = unknown,\n> = {\n  entityId: string;\n  getTargetId: BivariantCallback<\n    (response: Response, node: Node) => string | null\n  >;\n  label?: I18nLabel;\n};\n\nexport type BackofficeActionToastSpec<Node = unknown, Response = unknown> = {\n  title: I18nLabel;\n  message?: I18nLabel;\n  view?: BackofficeActionToastViewSpec<Node, Response>;\n};\n\nexport type BackofficeEntityActionBase<Node> = {\n  id: string;\n  label: I18nLabel;\n  ariaLabel?: I18nLabel;\n  variant?: BackofficeActionVariant;\n  size?: BackofficeActionSize;\n  isVisible?: BivariantCallback<(node: Node) => boolean>;\n  isDisabled?: BivariantCallback<(node: Node) => boolean>;\n};\n\ntype BackofficeEntityActionFormFieldBase = {\n  id: string;\n  label: I18nLabel;\n  description?: I18nLabel;\n};\n\nexport type BackofficeEntityActionFormFieldSpec =\n  | (BackofficeEntityActionFormFieldBase & {\n      id: string;\n      kind: 'text';\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n      required?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      id: string;\n      kind: 'textarea';\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n      required?: boolean;\n      rows?: number;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'number';\n      placeholder?: I18nLabel;\n      defaultValue?: number;\n      required?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'json';\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n      required?: boolean;\n      jsonType?: 'object' | 'array' | 'any';\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'enum';\n      options: readonly { value: string; label: I18nLabel }[];\n      defaultValue?: string;\n      required?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'boolean';\n      defaultValue?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'entityId';\n      entity: string;\n      defaultValue?: string;\n      required?: boolean;\n    })\n  | (BackofficeEntityActionFormFieldBase & {\n      kind: 'multiEnum';\n      options: readonly { value: string; label: I18nLabel }[];\n      defaultValue?: readonly string[];\n      required?: boolean;\n    });\n\nexport type BackofficeEntityActionResultSpec<Node, Response = unknown> = {\n  label: I18nLabel;\n  getValue: BivariantCallback<\n    (response: Response, node: Node) => string | null\n  >;\n  render?: BivariantCallback<\n    (response: Response, node: Node) => BackofficeActionRenderNode | null\n  >;\n};\n\nexport type BackofficeEntityActionUpdater<Node> = BivariantCallback<\n  (store: RecordSourceSelectorProxy, node: Node) => void\n>;\n\nexport type BackofficeEntityMutationActionSpec<\n  Node,\n  Variables = Record<string, unknown>,\n  Response = unknown,\n> = BackofficeEntityActionBase<Node> & {\n  kind: 'mutation';\n  mutation: GraphQLTaggedNode;\n  getVariables: BivariantCallback<(node: Node) => Variables>;\n  updater?: BackofficeEntityActionUpdater<Node>;\n  mapErrorReason?: BivariantCallback<\n    (reason: string, node: Node) => BackofficeValueLabel\n  >;\n  onCompleted?: BivariantCallback<(response: Response, node: Node) => void>;\n  onError?: BivariantCallback<(error: Error, node: Node) => void>;\n  toasts?: {\n    success?: BackofficeActionToastSpec<Node, Response>;\n    error?: BackofficeActionToastSpec<Node, Response>;\n  };\n};\n\nexport type BackofficeEntityFormMutationActionSpec<\n  Node,\n  Variables = Record<string, unknown>,\n  Response = unknown,\n> = BackofficeEntityActionBase<Node> & {\n  kind: 'formMutation';\n  mutation: GraphQLTaggedNode;\n  fields: readonly BackofficeEntityActionFormFieldSpec[];\n  getVariables: BivariantCallback<\n    (node: Node, values: Record<string, unknown>) => Variables\n  >;\n  updater?: BackofficeEntityActionUpdater<Node>;\n  getInitialValues?: BivariantCallback<(node: Node) => Record<string, unknown>>;\n  mapErrorReason?: BivariantCallback<\n    (reason: string, node: Node) => BackofficeValueLabel\n  >;\n  onCompleted?: BivariantCallback<(response: Response, node: Node) => void>;\n  onError?: BivariantCallback<(error: Error, node: Node) => void>;\n  toasts?: {\n    success?: BackofficeActionToastSpec<Node, Response>;\n    error?: BackofficeActionToastSpec<Node, Response>;\n  };\n  result?: BackofficeEntityActionResultSpec<Node, Response>;\n};\n\nexport type BackofficeEntityRouteActionSpec<Node> =\n  BackofficeEntityActionBase<Node> & {\n    kind: 'route';\n    to: BivariantCallback<(node: Node) => string>;\n  };\n\nexport type BackofficeEntityActionSpec<Node> =\n  | BackofficeEntityMutationActionSpec<Node>\n  | BackofficeEntityFormMutationActionSpec<Node>\n  | BackofficeEntityRouteActionSpec<Node>;\n\nexport type BackofficeListActionSpec = BackofficeEntityActionSpec<null>;\n\nexport type BackofficeEntityKind = 'list-detail' | 'tool';\n\nexport type BackofficeEntityManifestKind = 'list-detail' | 'tool';\n\nexport type BackofficeEntityFacetKind =\n  (typeof BACKOFFICE_ENTITY_FACET_KINDS)[number];\n\nexport type BackofficeEntityModuleStatus =\n  | 'idle'\n  | 'loading'\n  | 'loaded'\n  | 'error';\n\nexport type BackofficeEntityLoadMode = 'cache-first' | 'reload';\n\nexport type BackofficeConfigAccessKind =\n  | 'manifest-only'\n  | 'loaded-config-required';\n\nexport type BackofficeListState<Where, Sort extends string> = {\n  where: Where | null;\n  sort: Sort | null;\n};\n\nexport type BackofficeListVariables<Where, Sort extends string> = {\n  where: Where | null;\n  sort: Sort | null;\n  count: number;\n  cursor: string | null;\n};\n\nexport type BackofficeOperationVariables<TOperation extends OperationType> =\n  TOperation['variables'];\n\nexport type BackofficeOperationResponse<TOperation extends OperationType> =\n  TOperation['response'];\n\nexport type BackofficeOperationWhere<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown> = TOperation['variables'] extends {\n    where?: infer Where | null | undefined;\n  }\n    ? Extract<NonNullable<Where>, Record<string, unknown>>\n    : never,\n> = TWhere;\n\nexport type BackofficeOperationSort<\n  TOperation extends OperationType,\n  TSort = TOperation['variables'] extends {\n    sort?: infer Sort | null | undefined;\n  }\n    ? Extract<NonNullable<Sort>, string>\n    : never,\n> = Extract<TSort, string>;\n\nexport type BackofficeDerivedOperationWhere<TOperation extends OperationType> =\n  TOperation['variables'] extends {\n    where?: infer Where | null | undefined;\n  }\n    ? Extract<NonNullable<Where>, Record<string, unknown>>\n    : never;\n\nexport type BackofficeDerivedOperationSort<TOperation extends OperationType> =\n  TOperation['variables'] extends {\n    sort?: infer Sort | null | undefined;\n  }\n    ? Extract<NonNullable<Sort>, string>\n    : never;\n\nexport type BackofficeListQueryInput<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n> = {\n  where: TWhere | null;\n  sort: TSort | null;\n  count: number;\n  cursor: string | null;\n};\n\nexport type BackofficeCountQueryInput<TWhere extends Record<string, unknown>> =\n  {\n    where: TWhere | null;\n  };\n\nexport type BackofficeEntityCountConfig<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown>,\n> = {\n  query: GraphQLTaggedNode;\n  buildVariables: (\n    input: BackofficeCountQueryInput<TWhere>,\n  ) => TOperation['variables'];\n  getCount: BivariantCallback<(data: unknown) => number | null>;\n};\n\nexport type BackofficeRuntimeEntityCountConfig<\n  TWhere extends Record<string, unknown>,\n> = BackofficeEntityCountConfig<any, TWhere>;\n\nexport type BackofficePickerScope<Where> = Partial<{\n  [Key in keyof Where]: Extract<NonNullable<Where[Key]>, string>;\n}>;\n\nexport type BackofficePickerQueryInput<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n> = {\n  search: string;\n  scope?: BackofficePickerScope<TWhere>;\n};\n\nexport type BackofficeRelationFilterSpec<\n  TOperation extends OperationType,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n> = {\n  target: string;\n  filterId?: string;\n  whereKey: Extract<keyof TWhere, string>;\n  path?: readonly string[];\n};\n\nexport type BackofficeRuntimeRelationFilterSpec = {\n  target: string;\n  filterId?: string;\n  whereKey: string;\n  path?: readonly string[];\n};\n\nexport type BackofficeEntityRoutes = {\n  list: string;\n  detail: (id: string) => string;\n  detailPage: (id: string, pageId: string) => string;\n};\n\nexport type BackofficeEntityRouteManifest = {\n  list: string;\n  detail: (id: string) => string;\n  detailPage: (id: string, pageId: string) => string;\n};\n\nexport type BackofficeDetailPageManifestItem = {\n  id: string;\n  pathSegment: string;\n  label: I18nLabel;\n  isDefault?: boolean;\n};\n\nexport type BackofficeDetailPageRouteSpec<LayoutView = unknown> = {\n  id: string;\n  path: string;\n  label: I18nLabel;\n  isVisible?: BivariantCallback<(layoutPage: LayoutView) => boolean>;\n};\n\nexport type BackofficeDashboardConfig = {\n  title: I18nLabel;\n  subtitle?: I18nLabel;\n  widgets: readonly BackofficeDashboardWidget[];\n};\n\nexport type BackofficeDashboardWidgetSize = 's' | 'm' | 'l' | 'xl' | 'full';\n\nexport type BackofficeDashboardWidgetSpan = 3 | 4 | 6 | 8 | 12;\n\nexport type BackofficeDashboardWidgetTabletSpan = 3 | 6;\n\nexport type BackofficeDashboardWidgetZone =\n  | 'summary'\n  | 'main'\n  | 'aside'\n  | 'secondary'\n  | 'full';\n\nexport type BackofficeDashboardWidgetLayout = {\n  zone?: BackofficeDashboardWidgetZone;\n  span?: BackofficeDashboardWidgetSpan;\n  tabletSpan?: BackofficeDashboardWidgetTabletSpan;\n  order?: number;\n};\n\nexport type BackofficeDashboardWidgetPriority =\n  | 'critical'\n  | 'high'\n  | 'normal'\n  | 'low'\n  | 'primary'\n  | 'secondary'\n  | 'debug';\n\nexport type BackofficeDashboardWidgetBase = {\n  id: string;\n  title?: I18nLabel;\n  description?: I18nLabel;\n  size?: BackofficeDashboardWidgetSize;\n  layout?: BackofficeDashboardWidgetLayout;\n  priority?: BackofficeDashboardWidgetPriority;\n  minHeight?: 'sm' | 'md' | 'lg';\n};\n\nexport type BackofficeDashboardEntityCountResult = {\n  count: number | null;\n};\n\nexport type BackofficeDashboardTablePreviewResult = {\n  columns: readonly BackofficeColumnSpec[];\n  rows: readonly unknown[];\n};\n\nexport type BackofficeDashboardStatusSummaryResult = readonly {\n  id: string;\n  label: I18nLabel;\n  value: string | number | null;\n  tone?: BackofficeBadgeTone;\n  href?: string;\n}[];\n\nexport type BackofficeDashboardMetricGroupResult = readonly {\n  id: string;\n  label: I18nLabel;\n  value: string | number | null;\n  meta?: I18nLabel;\n  tone?: 'neutral' | 'info' | 'success' | 'warning' | 'danger';\n  href?: string;\n}[];\n\nexport type BackofficeDashboardBillingUsageChartResult = {\n  currency: string;\n  totalAmount: number;\n  from: string | null;\n  to: string | null;\n  buckets: readonly {\n    day: string;\n    category: string;\n    value: number;\n  }[];\n} | null;\n\nexport type BackofficeDashboardWidgetQuerySource<\n  TOperation extends OperationType,\n  TResult,\n> = {\n  dataSource: 'query';\n  query: GraphQLTaggedNode;\n  variables: TOperation['variables'];\n  resolve: (data: TOperation['response']) => TResult;\n};\n\nexport type BackofficeDashboardWidgetStaticSource = {\n  dataSource: 'static';\n};\n\nexport type BackofficeDashboardWidget =\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'entityCount';\n      label: I18nLabel;\n      entityId: string;\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardEntityCountResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'shortcut';\n      label: I18nLabel;\n      entityId: string;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'tablePreview';\n      title: I18nLabel;\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardTablePreviewResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'statusSummary';\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardStatusSummaryResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'recentItems';\n      maxItems?: number;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'quickActions';\n      actions: readonly {\n        id: string;\n        label: I18nLabel;\n        href: string;\n        description?: I18nLabel;\n        tone?: 'default' | 'primary' | 'danger';\n      }[];\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'metricGroup';\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardMetricGroupResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'billingUsageChart';\n      title: I18nLabel;\n      query: GraphQLTaggedNode;\n      variables: OperationType['variables'];\n      categories: readonly {\n        id: string;\n        label: I18nLabel;\n        color: string;\n      }[];\n      emptyLabel: I18nLabel;\n      rangePrefix: I18nLabel;\n      ariaLabel: I18nLabel;\n      resolve: (\n        data: OperationType['response'],\n      ) => BackofficeDashboardBillingUsageChartResult;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'textBlock';\n      title: I18nLabel;\n      body: I18nLabel;\n    });\n\nexport type BackofficeListUrlCodec<Where, Sort extends string> = {\n  parse: (search: URLSearchParams) => BackofficeListState<Where, Sort>;\n  serialize: (state: BackofficeListState<Where, Sort>) => URLSearchParams;\n};\n\nexport type BackofficeSortSpec<Sort extends string = string> = {\n  id: Sort;\n  label: I18nLabel;\n};\n\nexport type BackofficeRowFlagSpec<Row = unknown> = {\n  id: string;\n  label: BivariantCallback<(row: Row) => I18nLabel>;\n  render: BivariantCallback<(row: Row) => unknown>;\n};\n\nexport type BackofficeListColumnPriority =\n  | 'primary'\n  | 'important'\n  | 'secondary'\n  | 'debug';\n\nexport type BackofficeListMobileRole =\n  | 'title'\n  | 'subtitle'\n  | 'meta'\n  | 'badge'\n  | 'status'\n  | 'action'\n  | 'hidden';\n\nexport type BackofficeListColumnVisibility = {\n  priority?: BackofficeListColumnPriority;\n  align?: 'left' | 'center' | 'right';\n  mobile?: BackofficeListMobileRole;\n  tablet?: 'visible' | 'hidden';\n  desktop?: 'visible' | 'hidden';\n  minVisibleAt?: 'sm' | 'md' | 'lg' | 'xl';\n  debugOnly?: boolean;\n};\n\nexport type BackofficeListColumnCopy = {\n  shortLabel?: I18nLabel;\n  description?: I18nLabel;\n  emptyLabel?: I18nLabel;\n};\n\nexport type BackofficeColumnSpec<Row = unknown> = {\n  key: string;\n  header: I18nLabel;\n  size: BackofficeFieldSize;\n  visibility?: BackofficeListColumnVisibility;\n  copy?: BackofficeListColumnCopy;\n  cell:\n    | {\n        size?: BackofficeFieldSize;\n        type: 'text';\n        value: BivariantCallback<(row: Row) => string | number | null>;\n        copyValue?: BivariantCallback<(row: Row) => string | null>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'link';\n        value: BivariantCallback<(row: Row) => string | number | null>;\n        to: BivariantCallback<(row: Row) => string>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'badge';\n        value: BivariantCallback<(row: Row) => string | null>;\n        tone?:\n          | BackofficeBadgeTone\n          | BivariantCallback<(row: Row) => BackofficeBadgeTone>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'dateTime';\n        value: BivariantCallback<(row: Row) => string | number | null>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'entityRef';\n        entity: string;\n        value: BivariantCallback<(row: Row) => string>;\n        label?: BivariantCallback<(row: Row) => string | null>;\n      }\n    | {\n        size?: BackofficeFieldSize;\n        type: 'custom';\n        render: BivariantCallback<(row: Row) => unknown>;\n        textValue?: BivariantCallback<(row: Row) => string | null>;\n      };\n};\n\nexport type BackofficeListDensity = 'compact' | 'default' | 'comfortable';\n\nexport type BackofficeListDisplayMode = 'table' | 'cards' | 'auto';\n\nexport type BackofficeListVirtualizationMode = 'auto' | 'always' | 'never';\n\nexport type BackofficeListVirtualizationConfig = {\n  mode?: BackofficeListVirtualizationMode;\n  rowHeightPx?: number;\n  overscan?: number;\n};\n\nexport type BackofficeInfiniteScrollConfig = {\n  enabled?: true;\n  rootMargin?: string;\n  threshold?: number;\n  thresholdPx?: number;\n  autoLoad?: boolean;\n  status?: {\n    showLoadedCount?: boolean;\n    showTotalCount?: boolean;\n    showEndState?: boolean;\n    showInconsistentPageInfo?: boolean;\n  };\n};\n\nexport type BackofficeListToolbarProfile = {\n  density?: BackofficeListDensity;\n  displayMode?: BackofficeListDisplayMode;\n  maxPromotedFilters?: number;\n  showRefresh?: boolean;\n  showSort?: boolean;\n  showFilterChips?: 'auto' | 'always' | 'never';\n};\n\nexport type BackofficeListUiConfig = {\n  density?: BackofficeListDensity;\n  displayMode?: BackofficeListDisplayMode;\n  infiniteScroll?: BackofficeInfiniteScrollConfig;\n  virtualization?: BackofficeListVirtualizationConfig;\n  toolbar?: BackofficeListToolbarProfile;\n};\n\nexport type BackofficeListResponsiveMetaItem = {\n  id: string;\n  label?: I18nLabel;\n  value: string;\n  tone?: BackofficeBadgeTone;\n};\n\nexport type BackofficeListResponsiveProfile<Row = unknown> = {\n  mode?: BackofficeListDisplayMode;\n  density?: BackofficeListDensity;\n  mobileBreakpoint?: 'sm' | 'md' | 'lg';\n  primaryColumn?: string;\n  defaultVisibleColumns?: readonly string[];\n  debugColumns?: readonly string[];\n  rowTitle?: BivariantCallback<(row: Row) => string | null>;\n  rowSubtitle?: BivariantCallback<(row: Row) => string | null>;\n  rowMeta?: BivariantCallback<\n    (row: Row) => readonly BackofficeListResponsiveMetaItem[]\n  >;\n};\n\nexport type BackofficeFilterPlacement = 'quick' | 'drawer' | 'both';\n\ntype BackofficeFilterBase<Where, Value> = {\n  id: string;\n  label: I18nLabel;\n  placement?: BackofficeFilterPlacement;\n  toGraphQL: (value: Value) => Partial<Where>;\n  fromGraphQL?: (where: Where) => Value | null;\n  whereKey?: keyof Where;\n  path?: readonly string[];\n  pickerScope?:\n    | BackofficePickerScope<Where>\n    | ((where: Where | null) => BackofficePickerScope<Where>);\n};\n\nexport type BackofficeFilterSpec<Where> =\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'text';\n      placeholderLabel?: I18nLabel;\n      placeholderText?: I18nLabel;\n    })\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'datetime';\n      mode?: 'from' | 'to' | 'exact';\n      placeholderLabel?: I18nLabel;\n      placeholderText?: I18nLabel;\n    })\n  | (BackofficeFilterBase<Where, number> & {\n      kind: 'number';\n      placeholderLabel?: I18nLabel;\n      placeholderText?: I18nLabel;\n      inputMode?: 'numeric' | 'decimal';\n    })\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'enum';\n      options: readonly {\n        value: string;\n        label: I18nLabel;\n      }[];\n    })\n  | (BackofficeFilterBase<Where, boolean> & {\n      kind: 'boolean';\n      trueLabel?: I18nLabel;\n      falseLabel?: I18nLabel;\n    })\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'entityId';\n      entity: string;\n    });\n\nexport type BackofficeConnectionListConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData = unknown,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n  TCountOperation extends OperationType = any,\n> = {\n  kind: 'connection';\n  title: I18nLabel;\n  query: GraphQLTaggedNode;\n  fragment: GraphQLTaggedNode;\n  buildQueryVariables: (\n    input: BackofficeListQueryInput<TOperation, TWhere, TSort>,\n  ) => TOperation['variables'];\n  getConnection: BivariantCallback<\n    (data: ListFragmentData) => BackofficeConnection<RowRef>\n  >;\n  count: BackofficeEntityCountConfig<TCountOperation, TWhere>;\n  toRow: BivariantCallback<(rowRef: RowRef) => RowView>;\n  getRowId: BivariantCallback<(row: RowView) => string>;\n  columns: readonly BackofficeColumnSpec<RowView>[];\n  rowFlags?: readonly BackofficeRowFlagSpec<RowView>[];\n  sorts: readonly BackofficeSortSpec<TSort>[];\n  filters: readonly BackofficeFilterSpec<TWhere>[];\n  responsive?: BackofficeListResponsiveProfile<RowView>;\n  ui?: BackofficeListUiConfig;\n  defaultState?: BackofficeListState<TWhere, TSort>;\n};\n\nexport type BackofficeEntityListConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData = unknown,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n  TCountOperation extends OperationType = any,\n> = BackofficeConnectionListConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere,\n  TSort,\n  TCountOperation\n>;\n\nexport type BackofficeBadgeItem = {\n  id: string;\n  label: string | I18nLabel;\n  title?: string | I18nLabel;\n  tone?: BackofficeBadgeTone;\n};\n\nexport type BackofficeInlineValueSpec =\n  | {\n      type: 'text';\n      value: BackofficeValueLabel;\n    }\n  | {\n      type: 'entityRef';\n      entity: string;\n      id: string | null;\n      label?: BackofficeValueLabel;\n    }\n  | {\n      type: 'link';\n      href: string | null;\n      label: BackofficeValueLabel;\n    };\n\nexport type BackofficeDetailHeaderSubtitleItem<Node> = {\n  id: string;\n  value: BivariantCallback<(node: Node) => BackofficeInlineValueSpec>;\n};\n\nexport type BackofficeDetailHeaderMetaSpec<Node> =\n  | {\n      type?: 'text';\n      label: I18nLabel;\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n    }\n  | {\n      type: 'dateTime';\n      label: I18nLabel;\n      value: BivariantCallback<(node: Node) => string | number | null>;\n    }\n  | {\n      type: 'entityRef';\n      label: I18nLabel;\n      entity: string;\n      id: BivariantCallback<(node: Node) => string | null>;\n      value?: BivariantCallback<(node: Node) => string | null>;\n    }\n  | {\n      type: 'link';\n      label: I18nLabel;\n      href: BivariantCallback<(node: Node) => string | null>;\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n    };\n\nexport type BackofficeDetailHeaderStatusSpec<Node> =\n  | {\n      type: 'badge';\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n      tone?:\n        | BackofficeBadgeTone\n        | BivariantCallback<(node: Node) => BackofficeBadgeTone>;\n    }\n  | {\n      type: 'badgeRow';\n      items: BivariantCallback<(node: Node) => readonly BackofficeBadgeItem[]>;\n    };\n\nexport type BackofficeDetailPlacement = 'primary' | 'secondary';\n\nexport type BackofficeDetailContentGroup =\n  | 'summary'\n  | 'identity'\n  | 'scope'\n  | 'status'\n  | 'relations'\n  | 'activity'\n  | 'billing'\n  | 'technical'\n  | 'raw';\n\nexport type BackofficeDetailImportance =\n  | 'hero'\n  | 'primary'\n  | 'secondary'\n  | 'debug';\n\nexport type BackofficeDetailCollapseBehavior = {\n  collapsible?: boolean;\n  defaultCollapsed?: boolean;\n  persistKey?: string;\n};\n\nexport type BackofficeDetailPresentation = {\n  group?: BackofficeDetailContentGroup;\n  importance?: BackofficeDetailImportance;\n  collapse?: BackofficeDetailCollapseBehavior;\n  mobile?: 'visible' | 'collapsed' | 'hidden';\n  desktop?: 'primary' | 'secondary' | 'fullWidth';\n};\n\nexport type BackofficeTone =\n  | 'neutral'\n  | 'info'\n  | 'success'\n  | 'warning'\n  | 'danger';\n\nexport type BackofficeActionTone = 'neutral' | 'primary' | 'danger';\n\nexport type BackofficeDensity = 'compact' | 'comfortable';\n\nexport type BackofficeSemanticDetailPlacement = 'main' | 'side' | 'fullWidth';\n\nexport type BackofficeSemanticDetailPriority =\n  | 'primary'\n  | 'secondary'\n  | 'diagnostic';\n\nexport type BackofficeRenderableValue =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined;\n\nexport type BackofficeStatusValue = {\n  readonly label: string | I18nLabel;\n  readonly tone: BackofficeTone;\n};\n\nexport type BackofficeSemanticBlockBase = {\n  readonly id?: string;\n  readonly title: I18nLabel;\n  readonly description?: I18nLabel;\n  readonly placement?: BackofficeSemanticDetailPlacement;\n  readonly priority?: BackofficeSemanticDetailPriority;\n  readonly presentation?: BackofficeDetailPresentation;\n};\n\nexport type BackofficeValueSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly tone?: BivariantCallback<(node: Node) => BackofficeTone | undefined>;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n  readonly copyValue?: BivariantCallback<\n    (node: Node) => string | null | undefined\n  >;\n};\n\nexport type BackofficeSummaryItemSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly tone?: BivariantCallback<(node: Node) => BackofficeTone | undefined>;\n  readonly description?: BivariantCallback<\n    (node: Node) => BackofficeValueLabel\n  >;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n};\n\nexport type BackofficeSummaryBlockSpec<Node> = BackofficeSemanticBlockBase & {\n  readonly kind: 'summary';\n  readonly items: readonly BackofficeSummaryItemSpec<Node>[];\n};\n\nexport type BackofficeHeroSummaryBlockSpec<Node> =\n  BackofficeSummaryBlockSpec<Node>;\n\nexport type BackofficeMetricSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly formattedValue?: BivariantCallback<\n    (node: Node) => string | null | undefined\n  >;\n  readonly hint?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly tone?: BivariantCallback<(node: Node) => BackofficeTone | undefined>;\n  readonly copyValue?: BivariantCallback<\n    (node: Node) => string | null | undefined\n  >;\n};\n\nexport type BackofficeMetricGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'metrics';\n    readonly density?: BackofficeDensity;\n    readonly items: readonly BackofficeMetricSpec<Node>[];\n  };\n\nexport type BackofficeMetricBlockSpec<Node> =\n  BackofficeMetricGroupBlockSpec<Node>;\n\nexport type BackofficeStateSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeRenderableValue>;\n  readonly getDisplay: BivariantCallback<\n    (\n      value: BackofficeRenderableValue,\n      node: Node,\n    ) => {\n      readonly label: string | I18nLabel;\n      readonly tone: BackofficeTone;\n    }\n  >;\n};\n\nexport type BackofficeStateGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'states';\n    readonly states: readonly BackofficeStateSpec<Node>[];\n  };\n\nexport type BackofficeStateBlockSpec<Node> =\n  BackofficeStateGroupBlockSpec<Node>;\n\nexport type BackofficeContextItemSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n  readonly emptyLabel?: I18nLabel;\n};\n\nexport type BackofficeContextStackBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'context';\n    readonly items: readonly BackofficeContextItemSpec<Node>[];\n  };\n\nexport type BackofficeContextBlockSpec<Node> =\n  BackofficeContextStackBlockSpec<Node>;\n\nexport type BackofficeRelationTileSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly count?: BivariantCallback<(node: Node) => number | null | undefined>;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n  readonly description?: BivariantCallback<\n    (node: Node) => BackofficeValueLabel\n  >;\n  readonly tone?: BivariantCallback<(node: Node) => BackofficeTone | undefined>;\n};\n\nexport type BackofficeRelationGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'relations';\n    readonly items: readonly BackofficeRelationTileSpec<Node>[];\n  };\n\nexport type BackofficeRelationBlockSpec<Node> =\n  BackofficeRelationGroupBlockSpec<Node>;\n\nexport type BackofficeTimelineEventSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly timestamp?: BivariantCallback<\n    (node: Node) => string | number | Date | null | undefined\n  >;\n  readonly state?: BivariantCallback<\n    (node: Node) => BackofficeStatusValue | null | undefined\n  >;\n  readonly description?: BivariantCallback<\n    (node: Node) => BackofficeValueLabel\n  >;\n  readonly actor?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly payload?: BivariantCallback<(node: Node) => unknown>;\n};\n\nexport type BackofficeTimelineBlockSpec<Node> = BackofficeSemanticBlockBase & {\n  readonly kind: 'timeline';\n  readonly events: readonly BackofficeTimelineEventSpec<Node>[];\n};\n\nexport type BackofficeAuditItemSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly timestamp?: BivariantCallback<\n    (node: Node) => string | number | Date | null | undefined\n  >;\n  readonly actor?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly source?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n};\n\nexport type BackofficeAuditBlockSpec<Node> = BackofficeSemanticBlockBase & {\n  readonly kind: 'audit';\n  readonly items: readonly BackofficeAuditItemSpec<Node>[];\n};\n\nexport type BackofficeReferenceSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly href?: BivariantCallback<(node: Node) => string | null | undefined>;\n  readonly copyValue?: BivariantCallback<\n    (node: Node) => string | null | undefined\n  >;\n  readonly refKind?:\n    | 'id'\n    | 'slug'\n    | 'path'\n    | 'url'\n    | 'hash'\n    | 'external'\n    | 'text';\n};\n\nexport type BackofficeReferenceGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'references';\n    readonly references: readonly BackofficeReferenceSpec<Node>[];\n  };\n\nexport type BackofficePayloadFormat = 'json' | 'markdown' | 'text' | 'code';\n\nexport type BackofficePayloadBlockSpec<Node> = BackofficeSemanticBlockBase & {\n  readonly kind: 'payload';\n  readonly format?: BackofficePayloadFormat;\n  readonly summary?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly value: BivariantCallback<(node: Node) => unknown>;\n  readonly defaultCollapsed?: boolean;\n  readonly emptyLabel?: I18nLabel;\n};\n\nexport type BackofficeActionResultBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'actionResult';\n    readonly status?: BivariantCallback<\n      (node: Node) => BackofficeStatusValue | null | undefined\n    >;\n    readonly message?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n    readonly references?: readonly BackofficeReferenceSpec<Node>[];\n    readonly payload?: BivariantCallback<(node: Node) => unknown>;\n  };\n\nexport type BackofficeTechnicalFactsBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'technicalFacts';\n    readonly facts: readonly BackofficeValueSpec<Node>[];\n  };\n\nexport type BackofficeSemanticDetailBlockSpec<Node> =\n  | BackofficeSummaryBlockSpec<Node>\n  | BackofficeMetricGroupBlockSpec<Node>\n  | BackofficeStateGroupBlockSpec<Node>\n  | BackofficeContextStackBlockSpec<Node>\n  | BackofficeRelationGroupBlockSpec<Node>\n  | BackofficeTimelineBlockSpec<Node>\n  | BackofficeAuditBlockSpec<Node>\n  | BackofficeReferenceGroupBlockSpec<Node>\n  | BackofficePayloadBlockSpec<Node>\n  | BackofficeActionResultBlockSpec<Node>\n  | BackofficeTechnicalFactsBlockSpec<Node>;\n\nexport type BackofficeFlagVariant =\n  | 'yesNo'\n  | 'capability'\n  | 'enabled'\n  | 'failure'\n  | 'encrypted'\n  | 'locked'\n  | 'default'\n  | 'agentManaged'\n  | 'deployedProduction'\n  | 'forced';\n\nexport type BackofficeDetailFieldSpec<Node> =\n  | {\n      type: 'text';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n      copyValue?: BivariantCallback<(node: Node) => string | null>;\n      fullWidth?: boolean;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'badge';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n      tone?:\n        | BackofficeBadgeTone\n        | BivariantCallback<(node: Node) => BackofficeBadgeTone>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'badgeRow';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      items: BivariantCallback<(node: Node) => readonly BackofficeBadgeItem[]>;\n      fullWidth?: boolean;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'dateTime';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => string | number | null>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'number';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => number | null>;\n      format?: BackofficeNumberFormat;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'flag';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => boolean | null>;\n      variant: BackofficeFlagVariant;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'entityRef';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      entity: string;\n      id: BivariantCallback<(node: Node) => string | null>;\n      value?: BivariantCallback<(node: Node) => string | null>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'link';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      href: BivariantCallback<(node: Node) => string | null>;\n      value: BivariantCallback<(node: Node) => string | number | null>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'taggedValue';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      tag: BivariantCallback<\n        (node: Node) => {\n          label: string | I18nLabel;\n          tone?: BackofficeBadgeTone;\n        } | null\n      >;\n      value: BivariantCallback<(node: Node) => BackofficeInlineValueSpec>;\n      fullWidth?: boolean;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'relation';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      relation: BackofficeRuntimeRelationFilterSpec;\n      value: BivariantCallback<(node: Node) => string>;\n      presentation?: BackofficeDetailPresentation;\n    }\n  | {\n      type: 'custom';\n      label?: I18nLabel;\n      size: BackofficeFieldSize;\n      render: BivariantCallback<(node: Node) => unknown>;\n      fullWidth?: boolean;\n      presentation?: BackofficeDetailPresentation;\n    };\n\nexport type BackofficeDetailHeaderConfig<Node> = {\n  title: I18nLabel;\n  titleValue?: BivariantCallback<(node: Node, t: TFunction) => string | null>;\n  subtitle?: I18nLabel;\n  subtitleValue?: BivariantCallback<\n    (node: Node, t: TFunction) => string | null\n  >;\n  subtitleItems?: readonly BackofficeDetailHeaderSubtitleItem<Node>[];\n  subtitleSeparator?: string;\n  id?: BivariantCallback<(node: Node) => string | null>;\n  badges?: readonly {\n    label: I18nLabel;\n    value: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n    tone?:\n      | BackofficeBadgeTone\n      | BivariantCallback<(node: Node) => BackofficeBadgeTone>;\n  }[];\n  status?: BackofficeDetailHeaderStatusSpec<Node>;\n  meta?: readonly BackofficeDetailHeaderMetaSpec<Node>[];\n};\n\nexport type BackofficeDetailSectionConfig<Node> = {\n  id?: string;\n  title: I18nLabel;\n  description?: I18nLabel;\n  fields: readonly BackofficeDetailFieldSpec<Node>[];\n  placement?: BackofficeDetailPlacement;\n  presentation?: BackofficeDetailPresentation;\n};\n\nexport type BackofficeFieldSetBlockSpec<Node> =\n  BackofficeDetailSectionConfig<Node> & {\n    kind: 'fieldSet';\n  };\n\nexport type BackofficeDetailTableBlockSpec<Node, Row> = {\n  kind: 'table';\n  label: I18nLabel;\n  description?: I18nLabel;\n  columns: readonly BackofficeColumnSpec<Row>[];\n  rows: BivariantCallback<(node: Node) => readonly Row[]>;\n  placement?: BackofficeDetailPlacement;\n  presentation?: BackofficeDetailPresentation;\n};\n\nexport type BackofficeTableBlockSpec<\n  Node,\n  Row = unknown,\n> = BackofficeDetailTableBlockSpec<Node, Row>;\n\nexport type BackofficeCustomBlockSpec<Node> = {\n  kind: 'custom';\n  label?: I18nLabel;\n  render: BivariantCallback<(node: Node) => unknown>;\n  placement?: BackofficeDetailPlacement;\n  presentation?: BackofficeDetailPresentation;\n};\n\nexport type BackofficeDetailBlockSpec<Node> =\n  | BackofficeSemanticDetailBlockSpec<Node>\n  | BackofficeDetailTableBlockSpec<Node, any>\n  | BackofficeCustomBlockSpec<Node>;\n\nexport type BackofficeDetailContentSpec<Node> =\n  | BackofficeFieldSetBlockSpec<Node>\n  | BackofficeDetailBlockSpec<Node>;\n\nexport type BackofficeDetailViewLayoutSpec = {\n  readonly density?: BackofficeDensity;\n  readonly columns?: 'auto' | 'single' | 'mainSide';\n  readonly technicalDefaultCollapsed?: boolean;\n  readonly sideColumn?: {\n    readonly width?: 'narrow' | 'medium' | 'wide';\n    readonly sticky?: boolean;\n  };\n};\n\nexport type BackofficeDetailPageViewSpec<Node> = {\n  readonly title: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly subtitle?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly eyebrow?: BivariantCallback<(node: Node) => BackofficeValueLabel>;\n  readonly status?: BackofficeDetailHeaderStatusSpec<Node>;\n  readonly references?: readonly BackofficeReferenceSpec<Node>[];\n  readonly actions?: readonly BackofficeEntityActionSpec<Node>[];\n  readonly layout?: BackofficeDetailViewLayoutSpec;\n  readonly blocks: readonly BackofficeDetailContentSpec<Node>[];\n};\n\nexport type BackofficeDetailPageDataContext = {\n  id: string;\n  detailId?: string;\n};\n\nexport type BackofficeDetailPageVariablesResult<DetailQueryVariables> = {\n  variables: DetailQueryVariables;\n  detailId?: string;\n};\n\nexport type BackofficeDetailVariables<DetailQueryVariables> =\n  BackofficeDetailPageVariablesResult<DetailQueryVariables>;\n\nexport type BackofficeNodeQueryResponse<NodeRef> = {\n  readonly node?: NodeRef | null;\n};\n\nexport type BackofficeAliasedNodeQueryResponse<\n  Alias extends string,\n  NodeRef,\n> = {\n  readonly node?:\n    | (Readonly<Partial<Record<Alias, NodeRef | null>>> & {\n        readonly __typename?: string;\n      })\n    | null;\n};\n\nexport type BackofficeAliasedPickerValueResponse<\n  Alias extends string,\n  RowRef,\n> = BackofficeAliasedNodeQueryResponse<Alias, RowRef>;\n\nexport type BackofficeDetailPageDataSpec<\n  DetailView,\n  DetailData = DetailView,\n  DetailQueryData = unknown,\n  DetailFragmentKey = unknown,\n  DetailQueryVariables = Record<string, unknown>,\n> = {\n  query: GraphQLTaggedNode;\n  fragment: GraphQLTaggedNode;\n  resolveNode: (\n    data: DetailQueryData,\n    context: BackofficeDetailPageDataContext,\n  ) => DetailFragmentKey | null;\n  toView: BivariantCallback<(data: DetailData) => DetailView>;\n  buildVariables?: (input: {\n    id: string;\n  }) => BackofficeDetailPageVariablesResult<DetailQueryVariables>;\n};\n\nexport type BackofficeDetailStandardTab =\n  | 'overview'\n  | 'relations'\n  | 'activity'\n  | 'billing'\n  | 'technical'\n  | 'raw';\n\nexport type BackofficeDetailTitleMetaItem = {\n  id: string;\n  label?: I18nLabel;\n  value: string;\n  tone?: BackofficeBadgeTone;\n};\n\nexport type BackofficeDetailLayoutProfile<DetailView = unknown> = {\n  standardTabs?: readonly BackofficeDetailStandardTab[];\n  summaryFields?: readonly string[];\n  scopeFields?: readonly string[];\n  statusFields?: readonly string[];\n  technicalGroupsCollapsed?: boolean;\n  rawGroupsHiddenFromOverview?: boolean;\n  sideRail?: {\n    groups: readonly BackofficeDetailContentGroup[];\n    sticky?: boolean;\n  };\n  titleMeta?: BivariantCallback<\n    (node: DetailView) => readonly BackofficeDetailTitleMetaItem[]\n  >;\n};\n\nexport type BackofficeDetailLayoutSpec<\n  LayoutView,\n  LayoutData = LayoutView,\n  LayoutQueryData = unknown,\n  LayoutFragmentKey = unknown,\n  LayoutQueryVariables = Record<string, unknown>,\n> = BackofficeDetailPageDataSpec<\n  LayoutView,\n  LayoutData,\n  LayoutQueryData,\n  LayoutFragmentKey,\n  LayoutQueryVariables\n>;\n\nexport type BackofficeDetailPageSpec<\n  DetailView,\n  LayoutView = DetailView,\n  DetailData = DetailView,\n  DetailQueryData = unknown,\n  DetailFragmentKey = unknown,\n  DetailQueryVariables = Record<string, unknown>,\n> = BackofficeDetailPageDataSpec<\n  DetailView,\n  DetailData,\n  DetailQueryData,\n  DetailFragmentKey,\n  DetailQueryVariables\n> & {\n  id: string;\n  path: string;\n  label: I18nLabel;\n  content: readonly BackofficeDetailContentSpec<DetailView>[];\n  actions?: readonly BackofficeEntityActionSpec<DetailView>[];\n  isVisible?: BivariantCallback<(layoutPage: LayoutView) => boolean>;\n  profile?: BackofficeDetailLayoutProfile<DetailView>;\n};\n\nexport type BackofficePickerValueConfig<\n  RowRef,\n  RowView,\n  ValueQueryData = unknown,\n> = {\n  query: GraphQLTaggedNode;\n  resolveRow: (data: ValueQueryData) => RowRef | null;\n  toRow: BivariantCallback<(rowRef: RowRef) => RowView>;\n};\n\nexport type BackofficeEntityDetailConfig<\n  LayoutData = any,\n  LayoutView = any,\n  MainData = LayoutData,\n  MainView = LayoutView,\n  SubData = MainData,\n  SubView = MainView,\n  LayoutQueryData = unknown,\n  MainQueryData = unknown,\n  SubQueryData = MainQueryData,\n  LayoutFragmentKey = unknown,\n  MainFragmentKey = unknown,\n  SubFragmentKey = MainFragmentKey,\n  LayoutQueryVariables = Record<string, unknown>,\n  MainQueryVariables = Record<string, unknown>,\n  SubQueryVariables = MainQueryVariables,\n> = {\n  title: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  profile?: BackofficeDetailLayoutProfile<LayoutView>;\n  layoutPage: BackofficeDetailLayoutSpec<\n    LayoutView,\n    LayoutData,\n    LayoutQueryData,\n    LayoutFragmentKey,\n    LayoutQueryVariables\n  >;\n  mainPage: BackofficeDetailPageSpec<\n    MainView,\n    LayoutView,\n    MainData,\n    MainQueryData,\n    MainFragmentKey,\n    MainQueryVariables\n  >;\n  subPages?: readonly BackofficeDetailPageSpec<\n    SubView,\n    LayoutView,\n    SubData,\n    SubQueryData,\n    SubFragmentKey,\n    SubQueryVariables\n  >[];\n};\n\nexport type BackofficeEntityPickerConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  PickerFragmentData = unknown,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  ValueQueryData = BackofficeAliasedPickerValueResponse<string, RowRef>,\n> = {\n  query: GraphQLTaggedNode;\n  fragment: GraphQLTaggedNode;\n  buildQueryVariables: (\n    input: BackofficePickerQueryInput<TOperation, TWhere>,\n  ) => TOperation['variables'];\n  value?: BackofficePickerValueConfig<RowRef, RowView, ValueQueryData>;\n  getConnection: BivariantCallback<\n    (data: PickerFragmentData) => BackofficeConnection<RowRef>\n  >;\n  toRow: BivariantCallback<(rowRef: RowRef) => RowView>;\n  getRowId: BivariantCallback<(row: RowView) => string>;\n  searchEnabled?: boolean;\n  searchRequired?: boolean;\n  searchPlaceholder?: I18nLabel;\n};\n\nexport type BackofficeToolEntityConfig = {\n  kind: 'tool';\n  id: string;\n  label?: I18nLabel;\n  route?: string;\n  operation: BackofficeToolOperation;\n  list?: never;\n  detail?: never;\n  picker?: never;\n  routes?: never;\n};\n\nexport type BackofficeListFacetConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n  TCountOperation extends OperationType = any,\n> = {\n  kind: 'list';\n  id: string;\n  label: I18nLabel;\n  list: BackofficeEntityListConfig<\n    TOperation,\n    RowRef,\n    RowView,\n    ListFragmentData,\n    TWhere,\n    TSort,\n    TCountOperation\n  >;\n  listActions?: readonly BackofficeListActionSpec[];\n};\n\nexport type BackofficePickerFacetConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  PickerFragmentData,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  ValueQueryData = BackofficeAliasedPickerValueResponse<string, RowRef>,\n> = {\n  kind: 'picker';\n  id: string;\n  label: I18nLabel;\n  picker: BackofficeEntityPickerConfig<\n    TOperation,\n    RowRef,\n    RowView,\n    PickerFragmentData,\n    TWhere,\n    ValueQueryData\n  >;\n};\n\nexport type BackofficeDetailPagesSpec<\n  LayoutView = unknown,\n  Page extends BackofficeDetailPageRouteSpec<LayoutView> =\n    BackofficeDetailPageRouteSpec<LayoutView>,\n> = {\n  title: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  mainPage: Page;\n  subPages?: readonly Page[];\n  defaultPageId: string;\n};\n\nexport type BackofficeDetailLayoutFacetConfig<\n  LayoutData = any,\n  LayoutView = any,\n  LayoutQueryData = unknown,\n  LayoutFragmentKey = unknown,\n  LayoutQueryVariables = Record<string, unknown>,\n> = {\n  kind: 'detail-layout';\n  id: string;\n  label: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  title: I18nLabel;\n  layoutPage: BackofficeDetailLayoutSpec<\n    LayoutView,\n    LayoutData,\n    LayoutQueryData,\n    LayoutFragmentKey,\n    LayoutQueryVariables\n  >;\n  pages: BackofficeDetailPagesSpec<LayoutView>;\n};\n\nexport type BackofficeDetailPageFacetConfig<\n  LayoutView = unknown,\n  DetailData = any,\n  DetailView = any,\n  DetailQueryData = unknown,\n  DetailFragmentKey = unknown,\n  DetailQueryVariables = Record<string, unknown>,\n> = {\n  kind: 'detail-page';\n  id: string;\n  label: I18nLabel;\n  title: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  page: BackofficeDetailPageSpec<\n    DetailView,\n    LayoutView,\n    DetailData,\n    DetailQueryData,\n    DetailFragmentKey,\n    DetailQueryVariables\n  >;\n  pages: BackofficeDetailPagesSpec<LayoutView>;\n};\n\nexport type BackofficeToolFacetConfig = {\n  kind: 'tool';\n  id: string;\n  label: I18nLabel;\n  tool: BackofficeToolEntityConfig;\n};\n\nexport type BackofficeEntityFacetConfigBase =\n  | BackofficeListFacetConfigBase\n  | BackofficePickerFacetConfigBase\n  | BackofficeDetailLayoutFacetConfigBase\n  | BackofficeDetailPageFacetConfigBase\n  | BackofficeToolFacetConfig;\n\nexport type BackofficeLoadedListFacetModule = {\n  kind: 'list';\n  id: string;\n  config: BackofficeListFacetConfigBase;\n};\n\nexport type BackofficeLoadedPickerFacetModule = {\n  kind: 'picker';\n  id: string;\n  config: BackofficePickerFacetConfigBase;\n};\n\nexport type BackofficeLoadedDetailLayoutFacetModule = {\n  kind: 'detail-layout';\n  id: string;\n  config: BackofficeDetailLayoutFacetConfigBase;\n};\n\nexport type BackofficeLoadedDetailPageFacetModule = {\n  kind: 'detail-page';\n  id: string;\n  pageId: string;\n  config: BackofficeDetailPageFacetConfigBase;\n};\n\nexport type BackofficeLoadedToolFacetModule = {\n  kind: 'tool';\n  id: string;\n  config: BackofficeToolFacetConfig;\n};\n\nexport type BackofficeRuntimeOperation = OperationType & {\n  variables: {\n    [key: string]: unknown;\n    where?: Record<string, unknown> | null | undefined;\n    sort?: string | null | undefined;\n    count?: number;\n    cursor?: string | null | undefined;\n  };\n  response: unknown;\n};\n\nexport type BackofficeRuntimeListFacetConfig = BackofficeListFacetConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>,\n  any\n>;\n\nexport type BackofficeRuntimePickerFacetConfig = BackofficePickerFacetConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>\n>;\n\nexport type BackofficeLoadedEntityFacetModule =\n  | BackofficeLoadedListFacetModule\n  | BackofficeLoadedPickerFacetModule\n  | BackofficeLoadedDetailLayoutFacetModule\n  | BackofficeLoadedDetailPageFacetModule\n  | BackofficeLoadedToolFacetModule;\n\nexport type BackofficeListFacetLoader =\n  () => Promise<BackofficeLoadedListFacetModule>;\n\nexport type BackofficePickerFacetLoader =\n  () => Promise<BackofficeLoadedPickerFacetModule>;\n\nexport type BackofficeDetailLayoutFacetLoader =\n  () => Promise<BackofficeLoadedDetailLayoutFacetModule>;\n\nexport type BackofficeDetailPageFacetLoader = (\n  pageId: string,\n) => Promise<BackofficeLoadedDetailPageFacetModule>;\n\nexport type BackofficeToolFacetLoader =\n  () => Promise<BackofficeLoadedToolFacetModule>;\n\nexport type BackofficeListDetailFacetLoaderMap = {\n  list?: BackofficeListFacetLoader;\n  picker?: BackofficePickerFacetLoader;\n  detailLayout: BackofficeDetailLayoutFacetLoader;\n  detailPage: BackofficeDetailPageFacetLoader;\n};\n\nexport type BackofficeToolFacetLoaderMap = {\n  tool: BackofficeToolFacetLoader;\n};\n\nexport type BackofficeEntityFacetLoaderMap =\n  | BackofficeListDetailFacetLoaderMap\n  | BackofficeToolFacetLoaderMap;\n\nexport type BackofficeEntityManifestItem = {\n  id: string;\n  kind: BackofficeEntityManifestKind;\n  routeSegment: string;\n  groupId?: string;\n  label: I18nLabel;\n  routes: BackofficeEntityRouteManifest;\n  hasList: boolean;\n  detailPages?: readonly BackofficeDetailPageManifestItem[];\n  defaultDetailPageId?: string;\n  facets: BackofficeEntityFacetLoaderMap;\n};\n\nexport type BackofficeEntityManifestMap = Record<\n  string,\n  BackofficeEntityManifestItem\n>;\n\nexport type BackofficeManifestEntityId<TManifest> = Extract<\n  keyof TManifest,\n  string\n>;\n\nexport type BackofficeManifestListEntityId<TManifest> = {\n  [TEntityId in BackofficeManifestEntityId<TManifest>]: TManifest[TEntityId] extends {\n    kind: 'list-detail';\n    hasList: true;\n  }\n    ? TEntityId\n    : never;\n}[BackofficeManifestEntityId<TManifest>] extends infer TEntityId\n  ? [TEntityId] extends [never]\n    ? string extends BackofficeManifestEntityId<TManifest>\n      ? string\n      : never\n    : Extract<TEntityId, string>\n  : never;\n\nexport type BackofficeManifestDetailEntityId<TManifest> = {\n  [TEntityId in BackofficeManifestEntityId<TManifest>]: TManifest[TEntityId] extends {\n    kind: 'list-detail';\n  }\n    ? TEntityId\n    : never;\n}[BackofficeManifestEntityId<TManifest>] extends infer TEntityId\n  ? [TEntityId] extends [never]\n    ? string extends BackofficeManifestEntityId<TManifest>\n      ? string\n      : never\n    : Extract<TEntityId, string>\n  : never;\n\nexport type BackofficeManifestToolId<TManifest> = {\n  [TEntityId in BackofficeManifestEntityId<TManifest>]: TManifest[TEntityId] extends {\n    kind: 'tool';\n  }\n    ? TEntityId\n    : never;\n}[BackofficeManifestEntityId<TManifest>] extends infer TEntityId\n  ? [TEntityId] extends [never]\n    ? string extends BackofficeManifestEntityId<TManifest>\n      ? string\n      : never\n    : Extract<TEntityId, string>\n  : never;\n\nexport type BackofficeManifestDetailPageId<\n  TManifest,\n  TEntityId extends BackofficeManifestDetailEntityId<TManifest>,\n> = TManifest[TEntityId] extends {\n  detailPages: readonly (infer TPage)[];\n}\n  ? TPage extends { id: infer TPageId }\n    ? Extract<TPageId, string>\n    : string\n  : string;\n\nexport type BackofficeResolvedListFacetConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n  TSort extends string = BackofficeOperationSort<TOperation>,\n  TCountOperation extends OperationType = any,\n> = BackofficeListFacetConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere,\n  TSort,\n  TCountOperation\n> & {\n  routes: BackofficeEntityRoutes;\n  listUrlCodec?: BackofficeListUrlCodec<TWhere, TSort>;\n  listDefaults?: BackofficeListState<TWhere, TSort>;\n};\n\nexport type BackofficeResolvedPickerFacetConfig<\n  TOperation extends OperationType,\n  RowRef,\n  RowView,\n  PickerFragmentData,\n  TWhere extends Record<string, unknown> = BackofficeOperationWhere<TOperation>,\n> = BackofficePickerFacetConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  PickerFragmentData,\n  TWhere\n> & {\n  routes: BackofficeEntityRoutes;\n};\n\nexport type BackofficeResolvedDetailLayoutFacetConfig<\n  LayoutRef = any,\n  LayoutView = any,\n  LayoutQueryData = unknown,\n  LayoutFragmentRef = unknown,\n  LayoutQueryVariables = Record<string, unknown>,\n> = BackofficeDetailLayoutFacetConfig<\n  LayoutRef,\n  LayoutView,\n  LayoutQueryData,\n  LayoutFragmentRef,\n  LayoutQueryVariables\n> & {\n  routes: BackofficeEntityRoutes;\n};\n\nexport type BackofficeResolvedDetailPageFacetConfig<\n  LayoutView = unknown,\n  DetailRef = any,\n  DetailView = any,\n  DetailQueryData = unknown,\n  DetailFragmentRef = unknown,\n  DetailQueryVariables = Record<string, unknown>,\n> = BackofficeDetailPageFacetConfig<\n  LayoutView,\n  DetailRef,\n  DetailView,\n  DetailQueryData,\n  DetailFragmentRef,\n  DetailQueryVariables\n> & {\n  routes: BackofficeEntityRoutes;\n};\n\nexport type BackofficeResolvedToolFacetConfig = BackofficeToolFacetConfig & {\n  route: string;\n  routes: BackofficeEntityRoutes;\n};\n\nexport type BackofficeResolvedEntityFacetConfigBase =\n  | BackofficeResolvedListFacetConfigBase\n  | BackofficeResolvedPickerFacetConfigBase\n  | BackofficeResolvedDetailLayoutFacetConfigBase\n  | BackofficeResolvedDetailPageFacetConfigBase\n  | BackofficeResolvedToolFacetConfig;\n\nexport type BackofficeResolvedListFacetModule = {\n  kind: 'list';\n  id: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedListFacetConfigBase;\n};\n\nexport type BackofficeResolvedPickerFacetModule = {\n  kind: 'picker';\n  id: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedPickerFacetConfigBase;\n};\n\nexport type BackofficeResolvedDetailLayoutFacetModule = {\n  kind: 'detail-layout';\n  id: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedDetailLayoutFacetConfigBase;\n};\n\nexport type BackofficeResolvedDetailPageFacetModule = {\n  kind: 'detail-page';\n  id: string;\n  pageId: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedDetailPageFacetConfigBase;\n};\n\nexport type BackofficeResolvedToolFacetModule = {\n  kind: 'tool';\n  id: string;\n  manifest: BackofficeEntityManifestItem;\n  config: BackofficeResolvedToolFacetConfig;\n};\n\nexport type BackofficeResolvedEntityFacetModule =\n  | BackofficeResolvedListFacetModule\n  | BackofficeResolvedPickerFacetModule\n  | BackofficeResolvedDetailLayoutFacetModule\n  | BackofficeResolvedDetailPageFacetModule\n  | BackofficeResolvedToolFacetModule;\n\nexport type BackofficeListFacetConfigBase = BackofficeRuntimeListFacetConfig;\n\nexport type BackofficePickerFacetConfigBase =\n  BackofficeRuntimePickerFacetConfig;\n\nexport type BackofficeDetailLayoutFacetConfigBase =\n  BackofficeDetailLayoutFacetConfig<any, any, any, any, any>;\n\nexport type BackofficeDetailPageFacetConfigBase =\n  BackofficeDetailPageFacetConfig<any, any, any, any, any, any>;\n\nexport type BackofficeResolvedListFacetConfigBase =\n  BackofficeResolvedListFacetConfig<\n    any,\n    any,\n    any,\n    any,\n    Record<string, any>,\n    any\n  >;\n\nexport type BackofficeResolvedPickerFacetConfigBase =\n  BackofficeResolvedPickerFacetConfig<any, any, any, any, Record<string, any>>;\n\nexport type BackofficeResolvedDetailLayoutFacetConfigBase =\n  BackofficeResolvedDetailLayoutFacetConfig<any, any, any, any, any>;\n\nexport type BackofficeResolvedDetailPageFacetConfigBase =\n  BackofficeResolvedDetailPageFacetConfig<any, any, any, any, any, any>;\n\nexport type BackofficeRuntimeResolvedListFacetConfig =\n  BackofficeResolvedListFacetConfigBase;\n\nexport type BackofficeRuntimeResolvedPickerFacetConfig =\n  BackofficeResolvedPickerFacetConfigBase;\n\nexport type BackofficeRuntimeConnectionListConfig =\n  BackofficeConnectionListConfig<any, any, any, any, Record<string, any>, any>;\n\nexport type BackofficeRuntimeEntityListConfig = BackofficeEntityListConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>,\n  any\n>;\n\nexport type BackofficeRuntimeEntityPickerConfig = BackofficeEntityPickerConfig<\n  any,\n  any,\n  any,\n  any,\n  Record<string, any>\n>;\n\nexport type BackofficeEntityFacetModuleCacheEntry = {\n  status: BackofficeEntityModuleStatus;\n  promise?: Promise<BackofficeResolvedEntityFacetModule>;\n  module?: BackofficeResolvedEntityFacetModule;\n  error?: Error;\n};\n\nexport type BackofficeToolVariablesContext = {\n  scope: Record<string, unknown>;\n  run: boolean;\n};\n\nexport class BackofficeToolValidationError extends Error {\n  public label: I18nLabel;\n\n  public constructor(label: I18nLabel) {\n    super('Backoffice tool validation error');\n    this.label = label;\n  }\n}\n\nexport type BackofficeToolOperation = {\n  title: I18nLabel;\n  subtitle?: I18nLabel;\n  inputTypeSDL?: string;\n  query: GraphQLTaggedNode;\n  inputs?: readonly BackofficeToolInputSpec[];\n  outputs?: readonly BackofficeToolOutputSpec[];\n  render?: (data: unknown) => unknown;\n  showProjectPicker?: boolean;\n  buildVariables?: (\n    input: Record<string, unknown>,\n    context: BackofficeToolVariablesContext,\n  ) => Record<string, unknown>;\n};\n\nexport type BackofficeToolInputSpec =\n  | {\n      id: string;\n      kind: 'text';\n      label: I18nLabel;\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n    }\n  | {\n      id: string;\n      kind: 'json';\n      label: I18nLabel;\n      placeholder?: I18nLabel;\n      defaultValue?: string;\n    }\n  | {\n      id: string;\n      kind: 'enum';\n      label: I18nLabel;\n      options: readonly { value: string; label: I18nLabel }[];\n      defaultValue?: string;\n    }\n  | {\n      id: string;\n      kind: 'boolean';\n      label: I18nLabel;\n      defaultValue?: boolean;\n    }\n  | {\n      id: string;\n      kind: 'entityId';\n      label: I18nLabel;\n      entity: string;\n      defaultValue?: string;\n    };\n\nexport type BackofficeToolOutputSpec =\n  | {\n      kind: 'table';\n      label?: I18nLabel;\n      description?: I18nLabel;\n      columns: readonly BackofficeColumnSpec[];\n      rows: (data: unknown) => readonly unknown[];\n    }\n  | {\n      kind: 'code';\n      label?: I18nLabel;\n      description?: I18nLabel;\n      value: (data: unknown) => string;\n    }\n  | {\n      kind: 'json';\n      label?: I18nLabel;\n      description?: I18nLabel;\n      value: (data: unknown) => unknown;\n    }\n  | {\n      kind: 'keyValue';\n      label?: I18nLabel;\n      description?: I18nLabel;\n      items: readonly {\n        label: I18nLabel;\n        value: (data: unknown) => BackofficeValueLabel;\n      }[];\n    }\n  | {\n      kind: 'payload';\n      label: I18nLabel;\n      description?: I18nLabel;\n      value: (data: unknown) => unknown;\n      format?: 'markdown' | 'json' | 'text';\n    }\n  | {\n      kind: 'custom';\n      label?: I18nLabel;\n      render: (data: unknown) => unknown;\n    };\n\nexport type BackofficeConnection<Row> = {\n  edges: readonly { node: Row }[];\n  totalCount?: number | null;\n};\n\nexport type BackofficeListDefaults<Where, Sort extends string> = {\n  where: Where | null;\n  sort: Sort | null;\n};\n\nexport type BackofficePreparedListRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedListFacetConfigBase;\n  query: PreloadedQuery<OperationType>;\n};\n\nexport type BackofficePreparedDetailLayoutRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  layoutQuery: PreloadedQuery<OperationType>;\n  id: string;\n};\n\nexport type BackofficePreparedDetailPageRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  id: string;\n  pageId: string;\n  pagePath: string;\n  pageConfig: BackofficeResolvedDetailPageFacetConfigBase;\n  pageQuery: PreloadedQuery<OperationType>;\n  detailId?: string;\n};\n\nexport type BackofficePreparedToolRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedToolFacetConfig;\n};\n"]}