@plumile/backoffice-core 0.2.9 → 0.2.11

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 (13) hide show
  1. package/README.md +9 -0
  2. package/lib/esm/config/columns.d.ts +1 -1
  3. package/lib/esm/config/columns.d.ts.map +1 -1
  4. package/lib/esm/config/columns.js +3 -73
  5. package/lib/esm/types.d.ts +2 -2
  6. package/lib/esm/types.d.ts.map +1 -1
  7. package/lib/esm/types.js +1 -1
  8. package/lib/tsconfig.esm.tsbuildinfo +1 -1
  9. package/lib/types/config/columns.d.ts +1 -1
  10. package/lib/types/config/columns.d.ts.map +1 -1
  11. package/lib/types/types.d.ts +2 -2
  12. package/lib/types/types.d.ts.map +1 -1
  13. package/package.json +7 -7
package/lib/esm/types.js CHANGED
@@ -5,4 +5,4 @@ export class BackofficeToolValidationError extends Error {
5
5
  this.label = label;
6
6
  }
7
7
  }
8
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAm5EA,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 { InferFilters, Schema } from '@plumile/filter-query/types.js';\nimport type { BackofficeFilterSchema } from './filters/schema.js';\nimport type { BACKOFFICE_ENTITY_FACET_KINDS } from './constants.js';\nimport type { BackofficeErasedValue } from './runtimeErasure.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' | 'info' | 'success' | 'warning' | 'danger';\n\nexport type BackofficeNumberFormat = 'number' | 'currency' | 'percent';\n\nexport type BackofficeFieldSize =\n  'xs' | 's' | 'statusAction' | 'm' | 'l' | 'xl' | 'fluid';\n\nexport type BackofficeActionVariant =\n  'solid' | 'soft' | 'outline' | 'ghost' | 'plain';\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  tone?: BackofficeActionTone;\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  TOperation extends OperationType,\n> = BackofficeEntityActionBase<Node> & {\n  kind: 'mutation';\n  relayOperationBound: true;\n  mutation: GraphQLTaggedNode;\n  getVariables: BivariantCallback<(node: Node) => TOperation['variables']>;\n  updater?: BackofficeEntityActionUpdater<Node>;\n  mapErrorReason?: BivariantCallback<\n    (reason: string, node: Node) => BackofficeValueLabel\n  >;\n  onCompleted?: BivariantCallback<\n    (response: TOperation['response'], node: Node) => void\n  >;\n  onError?: BivariantCallback<(error: Error, node: Node) => void>;\n  toasts?: {\n    success?: BackofficeActionToastSpec<Node, TOperation['response']>;\n    error?: BackofficeActionToastSpec<Node, TOperation['response']>;\n  };\n};\n\nexport type BackofficeEntityFormMutationActionSpec<\n  Node,\n  TOperation extends OperationType,\n  FormValues extends object,\n  InitialValues extends object = Partial<FormValues>,\n> = BackofficeEntityActionBase<Node> & {\n  kind: 'formMutation';\n  relayOperationBound: true;\n  mutation: GraphQLTaggedNode;\n  fields: readonly BackofficeEntityActionFormFieldSpec[];\n  getVariables: BivariantCallback<\n    (node: Node, values: FormValues) => TOperation['variables']\n  >;\n  updater?: BackofficeEntityActionUpdater<Node>;\n  getInitialValues?: BivariantCallback<(node: Node) => InitialValues>;\n  mapErrorReason?: BivariantCallback<\n    (reason: string, node: Node) => BackofficeValueLabel\n  >;\n  onCompleted?: BivariantCallback<\n    (response: TOperation['response'], node: Node) => void\n  >;\n  onError?: BivariantCallback<(error: Error, node: Node) => void>;\n  toasts?: {\n    success?: BackofficeActionToastSpec<Node, TOperation['response']>;\n    error?: BackofficeActionToastSpec<Node, TOperation['response']>;\n  };\n  result?: BackofficeEntityActionResultSpec<Node, TOperation['response']>;\n};\n\nexport type BackofficeEntityRouteActionSpec<Node> =\n  BackofficeEntityActionBase<Node> & {\n    kind: 'route';\n    to: BivariantCallback<(node: Node) => string>;\n  };\n\nexport type BackofficeRuntimeEntityMutationActionSpec<Node> =\n  BackofficeEntityMutationActionSpec<Node, BackofficeErasedValue>;\n\nexport type BackofficeRuntimeEntityFormMutationActionSpec<Node> =\n  BackofficeEntityFormMutationActionSpec<\n    Node,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeEntityActionSpec<Node> =\n  | BackofficeRuntimeEntityMutationActionSpec<Node>\n  | BackofficeRuntimeEntityFormMutationActionSpec<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' | 'loading' | 'loaded' | 'error';\n\nexport type BackofficeEntityLoadMode = 'cache-first' | 'reload';\n\nexport type BackofficeConfigAccessKind =\n  'manifest-only' | 'loaded-config-required';\n\nexport type BackofficeListState<Where, Sort extends string> = {\n  where: Where | null;\n  sort: Sort | null;\n};\n\nexport type BackofficeListNavigationQuery<Sort extends string> = {\n  sort?: Sort;\n};\n\nexport type BackofficeListNavigationParams<\n  S extends Schema,\n  Sort extends string,\n> = {\n  filters?: InferFilters<S>;\n  query?: BackofficeListNavigationQuery<Sort>;\n};\n\nexport type BackofficeListNavigationStateInput<\n  Where,\n  Sort extends string,\n> = Partial<BackofficeListState<Where, Sort>>;\n\nexport type BackofficeListNavigationEncoded<\n  S extends Schema,\n  Sort extends string,\n> = {\n  filters: InferFilters<S>;\n  query: BackofficeListNavigationQuery<Sort>;\n};\n\nexport type BackofficeListNavigation<\n  Where extends Record<string, unknown>,\n  Sort extends string,\n  S extends Schema = Schema,\n> = {\n  readonly kind: 'list-navigation';\n  /** Destination route schema consumed by @plumile/router. */\n  querySchema: S;\n  /** State used for values omitted by encode() and decode(). */\n  defaults: BackofficeListState<Where, Sort>;\n  /** Sort values accepted when decoding untrusted route input. */\n  sortIds: readonly Sort[];\n  /** Converts GraphQL list state into structured router filters and query. */\n  // Method syntax intentionally keeps heterogeneous manifest collections\n  // assignable while concrete manifests retain their exact state type.\n  // eslint-disable-next-line @typescript-eslint/method-signature-style\n  encode(\n    state: BackofficeListNavigationStateInput<Where, Sort>,\n  ): BackofficeListNavigationEncoded<S, Sort>;\n  /** Converts structured router filters and query into GraphQL list state. */\n  // eslint-disable-next-line @typescript-eslint/method-signature-style\n  decode(\n    params: BackofficeListNavigationParams<S, Sort>,\n  ): BackofficeListState<Where, Sort>;\n};\n\nexport type BackofficeListNavigationOptions<\n  Where extends Record<string, unknown>,\n  Sort extends string,\n  S extends Schema,\n> = {\n  defaults: BackofficeListState<Where, Sort>;\n  filterSchema: BackofficeFilterSchema<Where, S>;\n  sortIds: readonly Sort[];\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<BackofficeRuntimeOperation, 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 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 BackofficeDetailPageManifest = readonly [\n  BackofficeDetailPageManifestItem,\n  ...BackofficeDetailPageManifestItem[],\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  windowPresets?: readonly BackofficeDashboardWindowPreset[];\n  defaultWindowPresetId?: string;\n  widgets: readonly BackofficeDashboardWidget[];\n};\n\nexport type BackofficeQuerySpec<TOperation extends OperationType> = {\n  readonly node: GraphQLTaggedNode;\n  readonly __operation?: TOperation;\n};\n\nexport type BackofficeFragmentSpec<TKey, TData> = {\n  readonly node: GraphQLTaggedNode;\n  readonly __key?: TKey;\n  readonly __data?: TData;\n};\n\nexport type BackofficePaginationFragmentSpec<\n  TQuery extends OperationType,\n  TKey,\n  TData,\n> = BackofficeFragmentSpec<TKey, TData> & {\n  readonly __paginationQuery?: TQuery;\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' | 'main' | 'aside' | 'secondary' | 'full';\n\nexport type BackofficeDashboardWidgetLayout = {\n  zone?: BackofficeDashboardWidgetZone;\n  span?: BackofficeDashboardWidgetSpan;\n  tabletSpan?: BackofficeDashboardWidgetTabletSpan;\n  order?: number;\n};\n\nexport type BackofficeDashboardWidgetPriority =\n  'critical' | 'high' | 'normal' | 'low' | 'primary' | 'secondary' | 'debug';\n\nexport type BackofficeDashboardWindowPreset = {\n  id: string;\n  label: I18nLabel;\n  durationMs: number;\n};\n\nexport type BackofficeDashboardWindowState = {\n  id: string;\n  label: I18nLabel;\n  from: string;\n  to: string;\n};\n\nexport type BackofficeDashboardContext = {\n  window: BackofficeDashboardWindowState;\n};\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 BackofficeDashboardWidgetResolver<TResult> = (\n  data: BackofficeErasedValue,\n  context: BackofficeDashboardContext,\n) => TResult;\n\nexport type BackofficeDashboardEntityCountResult = {\n  count: number | null;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n};\n\nexport type BackofficeDashboardTablePreviewResult = {\n  columns: readonly BackofficeColumnSpec[];\n  rows: readonly unknown[];\n};\n\nexport type BackofficeDashboardListTargetState<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n> = {\n  where?: Where | null;\n  sort?: Sort | null;\n};\n\nexport type BackofficeDashboardHrefTarget = {\n  kind: 'href';\n  href: string;\n};\n\nexport type BackofficeDashboardEntityListTarget<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n> = {\n  kind: 'entity-list';\n  entityId: string;\n  state?: BackofficeDashboardListTargetState<Where, Sort>;\n};\n\nexport type BackofficeDashboardLinkTarget<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n> =\n  | BackofficeDashboardHrefTarget\n  | BackofficeDashboardEntityListTarget<Where, Sort>;\n\nexport type BackofficeDashboardStatusSummaryResult = readonly {\n  id: string;\n  label: I18nLabel;\n  value: string | number | null;\n  tone?: BackofficeBadgeTone;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\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  target?: BackofficeDashboardLinkTarget;\n}[];\n\nexport type BackofficeDashboardMetricTone =\n  'neutral' | 'info' | 'success' | 'warning' | 'danger';\n\nexport type BackofficeDashboardTrendDirection = 'up' | 'down' | 'flat';\n\nexport type BackofficeDashboardSparklinePoint = {\n  x: string;\n  y: number;\n};\n\nexport type BackofficeDashboardTrendMetricResult = {\n  label: I18nLabel;\n  value: string | number | null;\n  unit?: string;\n  delta?: {\n    value: string | number;\n    direction: BackofficeDashboardTrendDirection;\n    tone?: BackofficeDashboardMetricTone;\n    label?: I18nLabel;\n  };\n  sparkline?: readonly BackofficeDashboardSparklinePoint[];\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n  tone?: BackofficeDashboardMetricTone;\n};\n\nexport type BackofficeDashboardSlaGaugeResult = {\n  label: I18nLabel;\n  value: number | null;\n  max: number;\n  threshold?: number;\n  unit?: string;\n  tone?: BackofficeDashboardMetricTone;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n};\n\nexport type BackofficeDashboardBreakdownListResult = readonly {\n  id: string;\n  label: I18nLabel;\n  value: string | number | null;\n  meta?: I18nLabel;\n  tone?: BackofficeDashboardMetricTone;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n}[];\n\nexport type BackofficeDashboardTimelineChartResult = {\n  series: readonly {\n    id: string;\n    label: I18nLabel;\n    color: string;\n    unit?: string;\n    data: readonly BackofficeDashboardSparklinePoint[];\n  }[];\n  emptyLabel?: I18nLabel;\n};\n\nexport type BackofficeDashboardRiskQueueResult = readonly {\n  id: string;\n  label: I18nLabel;\n  severity: BackofficeDashboardMetricTone;\n  value?: string | number | null;\n  meta?: I18nLabel;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n}[];\n\nexport type BackofficeDashboardEntitySpotlightResult = {\n  label: I18nLabel;\n  title: I18nLabel;\n  meta?: readonly {\n    id: string;\n    label: I18nLabel;\n    value: string | number | null;\n  }[];\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n  tone?: BackofficeDashboardMetricTone;\n} | null;\n\nexport type BackofficeDashboardHealthMatrixResult = readonly {\n  id: string;\n  label: I18nLabel;\n  cells: readonly {\n    id: string;\n    label: I18nLabel;\n    value: string | number | null;\n    tone?: BackofficeDashboardMetricTone;\n    href?: string;\n    target?: BackofficeDashboardLinkTarget;\n  }[];\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:\n    | TOperation['variables']\n    | ((context: BackofficeDashboardContext) => TOperation['variables']);\n  resolve: (\n    data: TOperation['response'],\n    context: BackofficeDashboardContext,\n  ) => TResult;\n};\n\nexport type BackofficeDashboardWidgetVariables<\n  TOperation extends OperationType = OperationType,\n> =\n  | TOperation['variables']\n  | ((context: BackofficeDashboardContext) => TOperation['variables']);\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: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<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: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardTablePreviewResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'statusSummary';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<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        target?: BackofficeDashboardLinkTarget;\n        description?: I18nLabel;\n        tone?: 'default' | 'primary' | 'danger';\n      }[];\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'metricGroup';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardMetricGroupResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'billingUsageChart';\n      title: I18nLabel;\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      categories: readonly {\n        id: string;\n        label: I18nLabel;\n        color: string;\n      }[];\n      emptyLabel: I18nLabel;\n      rangePrefix: I18nLabel;\n      ariaLabel: I18nLabel;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardBillingUsageChartResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'trendMetric';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardTrendMetricResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'slaGauge';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardSlaGaugeResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'breakdownList';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardBreakdownListResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'timelineChart';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      chart?: 'line' | 'bar';\n      ariaLabel: I18nLabel;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardTimelineChartResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'riskQueue';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardRiskQueueResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'entitySpotlight';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardEntitySpotlightResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'windowControl';\n      title: I18nLabel;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'healthMatrix';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardHealthMatrixResult>;\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' | 'important' | 'secondary' | 'debug';\n\nexport type BackofficeListMobileRole =\n  'title' | 'subtitle' | 'meta' | 'badge' | 'status' | 'action' | 'hidden';\n\nexport type BackofficeListColumnVisibility = {\n  priority?: BackofficeListColumnPriority;\n  align?: 'start' | 'center' | 'end';\n  mobile?: BackofficeListMobileRole;\n  tablet?: 'visible' | 'hidden';\n  desktop?: 'visible' | 'hidden';\n  minVisibleAt?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';\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: 'technicalIdentifier';\n        value: BivariantCallback<(row: Row) => string | number | null>;\n        abbreviation?: 'none' | 'middle' | 'fingerprint';\n        copyValue?: 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, EntityId extends string = string> =\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: EntityId;\n    })\n  | (BackofficeFilterBase<Where, readonly string[]> & {\n      kind: 'entityIdList';\n      entity: EntityId;\n    })\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'stringList';\n      placeholderLabel?: I18nLabel;\n      placeholderText?: I18nLabel;\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 = OperationType,\n  TEntityId extends string = string,\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, TEntityId>[];\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 = OperationType,\n  TEntityId extends string = string,\n> = BackofficeConnectionListConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere,\n  TSort,\n  TCountOperation,\n  TEntityId\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' | 'primary' | 'secondary' | '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' | 'info' | 'success' | 'warning' | 'danger';\n\nexport type BackofficeActionTone = 'brand' | 'neutral' | 'success' | 'danger';\n\nexport type BackofficeDensity = 'compact' | 'comfortable';\n\nexport type BackofficeSemanticDetailPlacement = 'main' | 'side' | 'fullWidth';\n\nexport type BackofficeSemanticDetailPriority =\n  'primary' | 'secondary' | 'diagnostic';\n\nexport type BackofficeRenderableValue =\n  string | number | boolean | null | 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 BackofficeRelationSummaryTileSpec<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 BackofficeRelationSummaryGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'relationSummary';\n    readonly items: readonly BackofficeRelationSummaryTileSpec<Node>[];\n  };\n\nexport type BackofficeRelationSummaryBlockSpec<Node> =\n  BackofficeRelationSummaryGroupBlockSpec<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' | 'slug' | 'path' | 'url' | 'hash' | 'external' | '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  | BackofficeRelationSummaryGroupBlockSpec<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: 'technicalIdentifier';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => string | number | null>;\n      abbreviation?: 'none' | 'middle' | 'fingerprint';\n      copyValue?: BivariantCallback<(node: Node) => string | null>;\n      fullWidth?: boolean;\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: '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 BackofficeEntityRelationSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly target: string;\n  readonly whereKey: string;\n  readonly value: BivariantCallback<(node: Node) => string | null>;\n  readonly path?: readonly string[];\n  readonly filterId?: string;\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, BackofficeErasedValue>\n  | BackofficeCustomBlockSpec<Node>;\n\nexport type BackofficeDetailContentSpec<Node> =\n  BackofficeFieldSetBlockSpec<Node> | 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 BackofficeRelayFragmentKey<TData = unknown> = Readonly<{\n  ' $data'?: TData;\n  ' $fragmentSpreads': unknown;\n}>;\n\nexport type BackofficeRelayFragmentData<\n  TKey extends BackofficeRelayFragmentKey,\n> = Required<TKey>[' $data'];\n\nexport type BackofficeDetailPageDataSpec<\n  DetailView,\n  DetailData = DetailView,\n  DetailQueryData = unknown,\n  DetailFragmentKey extends BackofficeRelayFragmentKey<DetailData> =\n    BackofficeRelayFragmentKey<DetailData>,\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<\n    (data: BackofficeRelayFragmentData<DetailFragmentKey>) => DetailView\n  >;\n  buildVariables?: (input: {\n    id: string;\n  }) => BackofficeDetailPageVariablesResult<DetailQueryVariables>;\n};\n\nexport type BackofficeDetailStandardTab =\n  'overview' | 'relations' | 'activity' | 'billing' | 'technical' | '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 extends BackofficeRelayFragmentKey<LayoutData> =\n    BackofficeRelayFragmentKey<LayoutData>,\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 extends BackofficeRelayFragmentKey<DetailData> =\n    BackofficeRelayFragmentKey<DetailData>,\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 = unknown,\n  LayoutView = unknown,\n  MainData = LayoutData,\n  MainView = LayoutView,\n  SubData = MainData,\n  SubView = MainView,\n  LayoutQueryData = unknown,\n  MainQueryData = unknown,\n  SubQueryData = MainQueryData,\n  LayoutFragmentKey extends BackofficeRelayFragmentKey<LayoutData> =\n    BackofficeRelayFragmentKey<LayoutData>,\n  MainFragmentKey extends BackofficeRelayFragmentKey<MainData> =\n    BackofficeRelayFragmentKey<MainData>,\n  SubFragmentKey extends BackofficeRelayFragmentKey<SubData> = MainFragmentKey &\n    BackofficeRelayFragmentKey<SubData>,\n  LayoutQueryVariables = Record<string, unknown>,\n  MainQueryVariables = Record<string, unknown>,\n  SubQueryVariables = MainQueryVariables,\n> = {\n  title: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  relations?: readonly BackofficeEntityRelationSpec<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 = OperationType,\n  TEntityId extends string = string,\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    TEntityId\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 = unknown,\n  LayoutView = unknown,\n  LayoutQueryData = unknown,\n  LayoutFragmentKey extends BackofficeRelayFragmentKey<LayoutData> =\n    BackofficeRelayFragmentKey<LayoutData>,\n  LayoutQueryVariables = Record<string, unknown>,\n> = {\n  kind: 'detail-layout';\n  id: string;\n  label: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  title: I18nLabel;\n  relations?: readonly BackofficeEntityRelationSpec<LayoutView>[];\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 = unknown,\n  DetailView = unknown,\n  DetailQueryData = unknown,\n  DetailFragmentKey extends BackofficeRelayFragmentKey<DetailData> =\n    BackofficeRelayFragmentKey<DetailData>,\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  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  Record<string, BackofficeErasedValue>,\n  BackofficeErasedValue\n>;\n\nexport type BackofficeRuntimePickerFacetConfig = BackofficePickerFacetConfig<\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  Record<string, BackofficeErasedValue>,\n  BackofficeErasedValue\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 BackofficeListDetailPickerFacetLoaderMap =\n  BackofficeListDetailFacetLoaderMap & {\n    picker: BackofficePickerFacetLoader;\n  };\n\nexport type BackofficeToolFacetLoaderMap = {\n  tool: BackofficeToolFacetLoader;\n};\n\nexport type BackofficeEntityFacetLoaderMap =\n  BackofficeListDetailFacetLoaderMap | BackofficeToolFacetLoaderMap;\n\ntype BackofficeEntityManifestBase = {\n  id: string;\n  routeSegment: string;\n  groupId?: string;\n  label: I18nLabel;\n  detailLabel?: I18nLabel;\n  routes: BackofficeEntityRouteManifest;\n};\n\nexport type BackofficeListDetailManifestItem<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n  S extends Schema = Schema,\n> = BackofficeEntityManifestBase & {\n  kind: 'list-detail';\n  detailPages: BackofficeDetailPageManifest;\n  defaultDetailPageId: string;\n} & (\n    | {\n        hasList: true;\n        listNavigation: BackofficeListNavigation<Where, Sort, S>;\n        facets: BackofficeListDetailFacetLoaderMap & {\n          list: BackofficeListFacetLoader;\n        };\n      }\n    | {\n        hasList: false;\n        listNavigation?: never;\n        facets: Omit<BackofficeListDetailFacetLoaderMap, 'list'> & {\n          list?: never;\n        };\n      }\n  );\n\nexport type BackofficeToolManifestItem = BackofficeEntityManifestBase & {\n  kind: 'tool';\n  hasList: false;\n  listNavigation?: never;\n  detailPages?: never;\n  defaultDetailPageId?: never;\n  facets: BackofficeToolFacetLoaderMap;\n};\n\nexport type BackofficeEntityManifestItem<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n  S extends Schema = Schema,\n> =\n  BackofficeListDetailManifestItem<Where, Sort, S> | BackofficeToolManifestItem;\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  string extends BackofficeManifestEntityId<TManifest>\n    ? string\n    : {\n        [\n          TEntityId in BackofficeManifestEntityId<TManifest>\n        ]: TManifest[TEntityId] extends {\n          kind: 'list-detail';\n          hasList: true;\n        }\n          ? TEntityId\n          : never;\n      }[BackofficeManifestEntityId<TManifest>];\n\nexport type BackofficeManifestListStateInput<\n  TManifest,\n  TEntityId extends BackofficeManifestListEntityId<TManifest>,\n> =\n  string extends BackofficeManifestEntityId<TManifest>\n    ? BackofficeListNavigationStateInput<Record<string, unknown>, string>\n    : TEntityId extends BackofficeManifestListEntityId<TManifest>\n      ? TManifest[TEntityId] extends {\n          listNavigation: {\n            defaults: BackofficeListState<\n              infer Where extends Record<string, unknown>,\n              infer Sort extends string\n            >;\n          };\n        }\n        ? BackofficeListNavigationStateInput<Where, Sort>\n        : never\n      : never;\n\nexport type BackofficeManifestDetailEntityId<TManifest> =\n  string extends BackofficeManifestEntityId<TManifest>\n    ? string\n    : {\n        [\n          TEntityId in BackofficeManifestEntityId<TManifest>\n        ]: TManifest[TEntityId] extends {\n          kind: 'list-detail';\n        }\n          ? TEntityId\n          : never;\n      }[BackofficeManifestEntityId<TManifest>];\n\nexport type BackofficeManifestToolId<TManifest> =\n  string extends BackofficeManifestEntityId<TManifest>\n    ? string\n    : {\n        [\n          TEntityId in BackofficeManifestEntityId<TManifest>\n        ]: TManifest[TEntityId] extends {\n          kind: 'tool';\n        }\n          ? TEntityId\n          : never;\n      }[BackofficeManifestEntityId<TManifest>];\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 = OperationType,\n> = BackofficeListFacetConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere,\n  TSort,\n  TCountOperation\n> & {\n  routes: BackofficeEntityRoutes;\n  listNavigation: BackofficeListNavigation<TWhere, TSort>;\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 = unknown,\n  LayoutView = unknown,\n  LayoutQueryData = unknown,\n  LayoutFragmentRef extends BackofficeRelayFragmentKey<LayoutRef> =\n    BackofficeRelayFragmentKey<LayoutRef>,\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 = unknown,\n  DetailView = unknown,\n  DetailQueryData = unknown,\n  DetailFragmentRef extends BackofficeRelayFragmentKey<DetailRef> =\n    BackofficeRelayFragmentKey<DetailRef>,\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<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeDetailPageFacetConfigBase =\n  BackofficeDetailPageFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeResolvedListFacetConfigBase =\n  BackofficeResolvedListFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    Record<string, BackofficeErasedValue>,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeResolvedPickerFacetConfigBase =\n  BackofficeResolvedPickerFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    Record<string, BackofficeErasedValue>\n  >;\n\nexport type BackofficeResolvedDetailLayoutFacetConfigBase =\n  BackofficeResolvedDetailLayoutFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeResolvedDetailPageFacetConfigBase =\n  BackofficeResolvedDetailPageFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeRuntimeResolvedListFacetConfig =\n  BackofficeResolvedListFacetConfigBase;\n\nexport type BackofficeRuntimeResolvedPickerFacetConfig =\n  BackofficeResolvedPickerFacetConfigBase;\n\nexport type BackofficeRuntimeConnectionListConfig =\n  BackofficeConnectionListConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    Record<string, BackofficeErasedValue>,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeRuntimeEntityListConfig = BackofficeEntityListConfig<\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  Record<string, BackofficeErasedValue>,\n  BackofficeErasedValue\n>;\n\nexport type BackofficeRuntimeEntityPickerConfig = BackofficeEntityPickerConfig<\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  Record<string, BackofficeErasedValue>\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 BackofficePreparedListShellRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n};\n\nexport type BackofficePreparedListLayoutRoute =\n  BackofficePreparedListShellRoute & {\n    entityConfig: BackofficeResolvedListFacetConfigBase;\n  };\n\nexport type BackofficePreparedListDataRoute =\n  BackofficePreparedListLayoutRoute & {\n    query: PreloadedQuery<OperationType>;\n  };\n\nexport type BackofficePreparedDetailFrameRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  id: string;\n};\n\nexport type BackofficePreparedDetailShellRoute =\n  BackofficePreparedDetailFrameRoute & {\n    pageId: string | null;\n    pagePath: string | null;\n  };\n\nexport type BackofficePreparedDetailLayoutDataRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  id: string;\n  layoutQuery: PreloadedQuery<OperationType>;\n};\n\nexport type BackofficePreparedDetailPageConfigRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  id: string;\n  pageId: string;\n  pagePath: string;\n  pageConfig: BackofficeResolvedDetailPageFacetConfigBase;\n  detailId?: string;\n};\n\nexport type BackofficePreparedDetailPageDataRoute = Omit<\n  BackofficePreparedDetailPageConfigRoute,\n  'entityConfig'\n> & {\n  pageQuery: PreloadedQuery<OperationType>;\n};\n\nexport type BackofficePreparedDetailUnknownPageRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  id: string;\n  pagePath: string;\n};\n\nexport type BackofficePreparedToolRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n};\n\nexport type BackofficePreparedToolConfigRoute = BackofficePreparedToolRoute & {\n  entityConfig: BackofficeResolvedToolFacetConfig;\n};\n"]}
8
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAm5EA,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 { InferFilters, Schema } from '@plumile/filter-query/types.js';\nimport type { BackofficeFilterSchema } from './filters/schema.js';\nimport type { BACKOFFICE_ENTITY_FACET_KINDS } from './constants.js';\nimport type { BackofficeErasedValue } from './runtimeErasure.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' | 'info' | 'success' | 'warning' | 'danger';\n\nexport type BackofficeNumberFormat = 'number' | 'currency' | 'percent';\n\nexport type BackofficeFieldSize =\n  'xs' | 's' | 'statusAction' | 'm' | 'l' | 'xl' | 'fluid';\n\nexport type BackofficeActionVariant =\n  'solid' | 'soft' | 'outline' | 'ghost' | 'plain';\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  tone?: BackofficeActionTone;\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  TOperation extends OperationType,\n> = BackofficeEntityActionBase<Node> & {\n  kind: 'mutation';\n  relayOperationBound: true;\n  mutation: GraphQLTaggedNode;\n  getVariables: BivariantCallback<(node: Node) => TOperation['variables']>;\n  updater?: BackofficeEntityActionUpdater<Node>;\n  mapErrorReason?: BivariantCallback<\n    (reason: string, node: Node) => BackofficeValueLabel\n  >;\n  onCompleted?: BivariantCallback<\n    (response: TOperation['response'], node: Node) => void\n  >;\n  onError?: BivariantCallback<(error: Error, node: Node) => void>;\n  toasts?: {\n    success?: BackofficeActionToastSpec<Node, TOperation['response']>;\n    error?: BackofficeActionToastSpec<Node, TOperation['response']>;\n  };\n};\n\nexport type BackofficeEntityFormMutationActionSpec<\n  Node,\n  TOperation extends OperationType,\n  FormValues extends object,\n  InitialValues extends object = Partial<FormValues>,\n> = BackofficeEntityActionBase<Node> & {\n  kind: 'formMutation';\n  relayOperationBound: true;\n  mutation: GraphQLTaggedNode;\n  fields: readonly BackofficeEntityActionFormFieldSpec[];\n  getVariables: BivariantCallback<\n    (node: Node, values: FormValues) => TOperation['variables']\n  >;\n  updater?: BackofficeEntityActionUpdater<Node>;\n  getInitialValues?: BivariantCallback<(node: Node) => InitialValues>;\n  mapErrorReason?: BivariantCallback<\n    (reason: string, node: Node) => BackofficeValueLabel\n  >;\n  onCompleted?: BivariantCallback<\n    (response: TOperation['response'], node: Node) => void\n  >;\n  onError?: BivariantCallback<(error: Error, node: Node) => void>;\n  toasts?: {\n    success?: BackofficeActionToastSpec<Node, TOperation['response']>;\n    error?: BackofficeActionToastSpec<Node, TOperation['response']>;\n  };\n  result?: BackofficeEntityActionResultSpec<Node, TOperation['response']>;\n};\n\nexport type BackofficeEntityRouteActionSpec<Node> =\n  BackofficeEntityActionBase<Node> & {\n    kind: 'route';\n    to: BivariantCallback<(node: Node) => string>;\n  };\n\nexport type BackofficeRuntimeEntityMutationActionSpec<Node> =\n  BackofficeEntityMutationActionSpec<Node, BackofficeErasedValue>;\n\nexport type BackofficeRuntimeEntityFormMutationActionSpec<Node> =\n  BackofficeEntityFormMutationActionSpec<\n    Node,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeEntityActionSpec<Node> =\n  | BackofficeRuntimeEntityMutationActionSpec<Node>\n  | BackofficeRuntimeEntityFormMutationActionSpec<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' | 'loading' | 'loaded' | 'error';\n\nexport type BackofficeEntityLoadMode = 'cache-first' | 'reload';\n\nexport type BackofficeConfigAccessKind =\n  'manifest-only' | 'loaded-config-required';\n\nexport type BackofficeListState<Where, Sort extends string> = {\n  where: Where | null;\n  sort: Sort | null;\n};\n\nexport type BackofficeListNavigationQuery<Sort extends string> = {\n  sort?: Sort;\n};\n\nexport type BackofficeListNavigationParams<\n  S extends Schema,\n  Sort extends string,\n> = {\n  filters?: InferFilters<S>;\n  query?: BackofficeListNavigationQuery<Sort>;\n};\n\nexport type BackofficeListNavigationStateInput<\n  Where,\n  Sort extends string,\n> = Partial<BackofficeListState<Where, Sort>>;\n\nexport type BackofficeListNavigationEncoded<\n  S extends Schema,\n  Sort extends string,\n> = {\n  filters: InferFilters<S>;\n  query: BackofficeListNavigationQuery<Sort>;\n};\n\nexport type BackofficeListNavigation<\n  Where extends Record<string, unknown>,\n  Sort extends string,\n  S extends Schema = Schema,\n> = {\n  readonly kind: 'list-navigation';\n  /** Destination route schema consumed by @plumile/router. */\n  querySchema: S;\n  /** State used for values omitted by encode() and decode(). */\n  defaults: BackofficeListState<Where, Sort>;\n  /** Sort values accepted when decoding untrusted route input. */\n  sortIds: readonly Sort[];\n  /** Converts GraphQL list state into structured router filters and query. */\n  // Method syntax intentionally keeps heterogeneous manifest collections\n  // assignable while concrete manifests retain their exact state type.\n  // eslint-disable-next-line @typescript-eslint/method-signature-style\n  encode(\n    state: BackofficeListNavigationStateInput<Where, Sort>,\n  ): BackofficeListNavigationEncoded<S, Sort>;\n  /** Converts structured router filters and query into GraphQL list state. */\n  // eslint-disable-next-line @typescript-eslint/method-signature-style\n  decode(\n    params: BackofficeListNavigationParams<S, Sort>,\n  ): BackofficeListState<Where, Sort>;\n};\n\nexport type BackofficeListNavigationOptions<\n  Where extends Record<string, unknown>,\n  Sort extends string,\n  S extends Schema,\n> = {\n  defaults: BackofficeListState<Where, Sort>;\n  filterSchema: BackofficeFilterSchema<Where, S>;\n  sortIds: readonly Sort[];\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<BackofficeRuntimeOperation, 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 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 BackofficeDetailPageManifest = readonly [\n  BackofficeDetailPageManifestItem,\n  ...BackofficeDetailPageManifestItem[],\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  windowPresets?: readonly BackofficeDashboardWindowPreset[];\n  defaultWindowPresetId?: string;\n  widgets: readonly BackofficeDashboardWidget[];\n};\n\nexport type BackofficeQuerySpec<TOperation extends OperationType> = {\n  readonly node: GraphQLTaggedNode;\n  readonly __operation?: TOperation;\n};\n\nexport type BackofficeFragmentSpec<TKey, TData> = {\n  readonly node: GraphQLTaggedNode;\n  readonly __key?: TKey;\n  readonly __data?: TData;\n};\n\nexport type BackofficePaginationFragmentSpec<\n  TQuery extends OperationType,\n  TKey,\n  TData,\n> = BackofficeFragmentSpec<TKey, TData> & {\n  readonly __paginationQuery?: TQuery;\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' | 'main' | 'aside' | 'secondary' | 'full';\n\nexport type BackofficeDashboardWidgetLayout = {\n  zone?: BackofficeDashboardWidgetZone;\n  span?: BackofficeDashboardWidgetSpan;\n  tabletSpan?: BackofficeDashboardWidgetTabletSpan;\n  order?: number;\n};\n\nexport type BackofficeDashboardWidgetPriority =\n  'critical' | 'high' | 'normal' | 'low' | 'primary' | 'secondary' | 'debug';\n\nexport type BackofficeDashboardWindowPreset = {\n  id: string;\n  label: I18nLabel;\n  durationMs: number;\n};\n\nexport type BackofficeDashboardWindowState = {\n  id: string;\n  label: I18nLabel;\n  from: string;\n  to: string;\n};\n\nexport type BackofficeDashboardContext = {\n  window: BackofficeDashboardWindowState;\n};\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 BackofficeDashboardWidgetResolver<TResult> = (\n  data: BackofficeErasedValue,\n  context: BackofficeDashboardContext,\n) => TResult;\n\nexport type BackofficeDashboardEntityCountResult = {\n  count: number | null;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n};\n\nexport type BackofficeDashboardTablePreviewResult = {\n  columns: readonly BackofficeColumnSpec[];\n  rows: readonly unknown[];\n};\n\nexport type BackofficeDashboardListTargetState<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n> = {\n  where?: Where | null;\n  sort?: Sort | null;\n};\n\nexport type BackofficeDashboardHrefTarget = {\n  kind: 'href';\n  href: string;\n};\n\nexport type BackofficeDashboardEntityListTarget<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n> = {\n  kind: 'entity-list';\n  entityId: string;\n  state?: BackofficeDashboardListTargetState<Where, Sort>;\n};\n\nexport type BackofficeDashboardLinkTarget<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n> =\n  | BackofficeDashboardHrefTarget\n  | BackofficeDashboardEntityListTarget<Where, Sort>;\n\nexport type BackofficeDashboardStatusSummaryResult = readonly {\n  id: string;\n  label: I18nLabel;\n  value: string | number | null;\n  tone?: BackofficeBadgeTone;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\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  target?: BackofficeDashboardLinkTarget;\n}[];\n\nexport type BackofficeDashboardMetricTone =\n  'neutral' | 'info' | 'success' | 'warning' | 'danger';\n\nexport type BackofficeDashboardTrendDirection = 'up' | 'down' | 'flat';\n\nexport type BackofficeDashboardSparklinePoint = {\n  x: string;\n  y: number;\n};\n\nexport type BackofficeDashboardTrendMetricResult = {\n  label: I18nLabel;\n  value: string | number | null;\n  unit?: string;\n  delta?: {\n    value: string | number;\n    direction: BackofficeDashboardTrendDirection;\n    tone?: BackofficeDashboardMetricTone;\n    label?: I18nLabel;\n  };\n  sparkline?: readonly BackofficeDashboardSparklinePoint[];\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n  tone?: BackofficeDashboardMetricTone;\n};\n\nexport type BackofficeDashboardSlaGaugeResult = {\n  label: I18nLabel;\n  value: number | null;\n  max: number;\n  threshold?: number;\n  unit?: string;\n  tone?: BackofficeDashboardMetricTone;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n};\n\nexport type BackofficeDashboardBreakdownListResult = readonly {\n  id: string;\n  label: I18nLabel;\n  value: string | number | null;\n  meta?: I18nLabel;\n  tone?: BackofficeDashboardMetricTone;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n}[];\n\nexport type BackofficeDashboardTimelineChartResult = {\n  series: readonly {\n    id: string;\n    label: I18nLabel;\n    color: string;\n    unit?: string;\n    data: readonly BackofficeDashboardSparklinePoint[];\n  }[];\n  emptyLabel?: I18nLabel;\n};\n\nexport type BackofficeDashboardRiskQueueResult = readonly {\n  id: string;\n  label: I18nLabel;\n  severity: BackofficeDashboardMetricTone;\n  value?: string | number | null;\n  meta?: I18nLabel;\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n}[];\n\nexport type BackofficeDashboardEntitySpotlightResult = {\n  label: I18nLabel;\n  title: I18nLabel;\n  meta?: readonly {\n    id: string;\n    label: I18nLabel;\n    value: string | number | null;\n  }[];\n  href?: string;\n  target?: BackofficeDashboardLinkTarget;\n  tone?: BackofficeDashboardMetricTone;\n} | null;\n\nexport type BackofficeDashboardHealthMatrixResult = readonly {\n  id: string;\n  label: I18nLabel;\n  cells: readonly {\n    id: string;\n    label: I18nLabel;\n    value: string | number | null;\n    tone?: BackofficeDashboardMetricTone;\n    href?: string;\n    target?: BackofficeDashboardLinkTarget;\n  }[];\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:\n    | TOperation['variables']\n    | ((context: BackofficeDashboardContext) => TOperation['variables']);\n  resolve: (\n    data: TOperation['response'],\n    context: BackofficeDashboardContext,\n  ) => TResult;\n};\n\nexport type BackofficeDashboardWidgetVariables<\n  TOperation extends OperationType = OperationType,\n> =\n  | TOperation['variables']\n  | ((context: BackofficeDashboardContext) => TOperation['variables']);\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: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<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: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardTablePreviewResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'statusSummary';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<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        target?: BackofficeDashboardLinkTarget;\n        description?: I18nLabel;\n        tone?: 'default' | 'primary' | 'danger';\n      }[];\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'metricGroup';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardMetricGroupResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'billingUsageChart';\n      title: I18nLabel;\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      categories: readonly {\n        id: string;\n        label: I18nLabel;\n        color: string;\n      }[];\n      emptyLabel: I18nLabel;\n      rangePrefix: I18nLabel;\n      ariaLabel: I18nLabel;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardBillingUsageChartResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'trendMetric';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardTrendMetricResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'slaGauge';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardSlaGaugeResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'breakdownList';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardBreakdownListResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'timelineChart';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      chart?: 'line' | 'bar';\n      ariaLabel: I18nLabel;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardTimelineChartResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'riskQueue';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardRiskQueueResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'entitySpotlight';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardEntitySpotlightResult>;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'static';\n      kind: 'windowControl';\n      title: I18nLabel;\n    })\n  | (BackofficeDashboardWidgetBase & {\n      dataSource: 'query';\n      kind: 'healthMatrix';\n      query: GraphQLTaggedNode;\n      variables: BackofficeDashboardWidgetVariables;\n      resolve: BackofficeDashboardWidgetResolver<BackofficeDashboardHealthMatrixResult>;\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' | 'important' | 'secondary' | 'debug';\n\nexport type BackofficeListMobileRole =\n  'title' | 'subtitle' | 'meta' | 'badge' | 'status' | 'action' | 'hidden';\n\nexport type BackofficeListColumnVisibility = {\n  priority?: BackofficeListColumnPriority;\n  align?: 'start' | 'center' | 'end';\n  mobile: BackofficeListMobileRole;\n  tablet?: 'visible' | 'hidden';\n  desktop?: 'visible' | 'hidden';\n  minVisibleAt?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';\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: 'technicalIdentifier';\n        value: BivariantCallback<(row: Row) => string | number | null>;\n        abbreviation?: 'none' | 'middle' | 'fingerprint';\n        copyValue?: 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, EntityId extends string = string> =\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: EntityId;\n    })\n  | (BackofficeFilterBase<Where, readonly string[]> & {\n      kind: 'entityIdList';\n      entity: EntityId;\n    })\n  | (BackofficeFilterBase<Where, string> & {\n      kind: 'stringList';\n      placeholderLabel?: I18nLabel;\n      placeholderText?: I18nLabel;\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 = OperationType,\n  TEntityId extends string = string,\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, TEntityId>[];\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 = OperationType,\n  TEntityId extends string = string,\n> = BackofficeConnectionListConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere,\n  TSort,\n  TCountOperation,\n  TEntityId\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' | 'primary' | 'secondary' | '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' | 'info' | 'success' | 'warning' | 'danger';\n\nexport type BackofficeActionTone = 'brand' | 'neutral' | 'success' | 'danger';\n\nexport type BackofficeDensity = 'compact' | 'comfortable';\n\nexport type BackofficeSemanticDetailPlacement = 'main' | 'side' | 'fullWidth';\n\nexport type BackofficeSemanticDetailPriority =\n  'primary' | 'secondary' | 'diagnostic';\n\nexport type BackofficeRenderableValue =\n  string | number | boolean | null | 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 BackofficeRelationSummaryTileSpec<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 BackofficeRelationSummaryGroupBlockSpec<Node> =\n  BackofficeSemanticBlockBase & {\n    readonly kind: 'relationSummary';\n    readonly items: readonly BackofficeRelationSummaryTileSpec<Node>[];\n  };\n\nexport type BackofficeRelationSummaryBlockSpec<Node> =\n  BackofficeRelationSummaryGroupBlockSpec<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' | 'slug' | 'path' | 'url' | 'hash' | 'external' | '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  | BackofficeRelationSummaryGroupBlockSpec<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: 'technicalIdentifier';\n      label: I18nLabel;\n      size: BackofficeFieldSize;\n      value: BivariantCallback<(node: Node) => string | number | null>;\n      abbreviation?: 'none' | 'middle' | 'fingerprint';\n      copyValue?: BivariantCallback<(node: Node) => string | null>;\n      fullWidth?: boolean;\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: '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 BackofficeEntityRelationSpec<Node> = {\n  readonly id: string;\n  readonly label: I18nLabel;\n  readonly target: string;\n  readonly whereKey: string;\n  readonly value: BivariantCallback<(node: Node) => string | null>;\n  readonly path?: readonly string[];\n  readonly filterId?: string;\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, BackofficeErasedValue>\n  | BackofficeCustomBlockSpec<Node>;\n\nexport type BackofficeDetailContentSpec<Node> =\n  BackofficeFieldSetBlockSpec<Node> | 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 BackofficeRelayFragmentKey<TData = unknown> = Readonly<{\n  ' $data'?: TData;\n  ' $fragmentSpreads': unknown;\n}>;\n\nexport type BackofficeRelayFragmentData<\n  TKey extends BackofficeRelayFragmentKey,\n> = Required<TKey>[' $data'];\n\nexport type BackofficeDetailPageDataSpec<\n  DetailView,\n  DetailData = DetailView,\n  DetailQueryData = unknown,\n  DetailFragmentKey extends BackofficeRelayFragmentKey<DetailData> =\n    BackofficeRelayFragmentKey<DetailData>,\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<\n    (data: BackofficeRelayFragmentData<DetailFragmentKey>) => DetailView\n  >;\n  buildVariables?: (input: {\n    id: string;\n  }) => BackofficeDetailPageVariablesResult<DetailQueryVariables>;\n};\n\nexport type BackofficeDetailStandardTab =\n  'overview' | 'relations' | 'activity' | 'billing' | 'technical' | '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 extends BackofficeRelayFragmentKey<LayoutData> =\n    BackofficeRelayFragmentKey<LayoutData>,\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 extends BackofficeRelayFragmentKey<DetailData> =\n    BackofficeRelayFragmentKey<DetailData>,\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 = unknown,\n  LayoutView = unknown,\n  MainData = LayoutData,\n  MainView = LayoutView,\n  SubData = MainData,\n  SubView = MainView,\n  LayoutQueryData = unknown,\n  MainQueryData = unknown,\n  SubQueryData = MainQueryData,\n  LayoutFragmentKey extends BackofficeRelayFragmentKey<LayoutData> =\n    BackofficeRelayFragmentKey<LayoutData>,\n  MainFragmentKey extends BackofficeRelayFragmentKey<MainData> =\n    BackofficeRelayFragmentKey<MainData>,\n  SubFragmentKey extends BackofficeRelayFragmentKey<SubData> = MainFragmentKey &\n    BackofficeRelayFragmentKey<SubData>,\n  LayoutQueryVariables = Record<string, unknown>,\n  MainQueryVariables = Record<string, unknown>,\n  SubQueryVariables = MainQueryVariables,\n> = {\n  title: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  relations?: readonly BackofficeEntityRelationSpec<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 = OperationType,\n  TEntityId extends string = string,\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    TEntityId\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 = unknown,\n  LayoutView = unknown,\n  LayoutQueryData = unknown,\n  LayoutFragmentKey extends BackofficeRelayFragmentKey<LayoutData> =\n    BackofficeRelayFragmentKey<LayoutData>,\n  LayoutQueryVariables = Record<string, unknown>,\n> = {\n  kind: 'detail-layout';\n  id: string;\n  label: I18nLabel;\n  header: BackofficeDetailHeaderConfig<LayoutView>;\n  title: I18nLabel;\n  relations?: readonly BackofficeEntityRelationSpec<LayoutView>[];\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 = unknown,\n  DetailView = unknown,\n  DetailQueryData = unknown,\n  DetailFragmentKey extends BackofficeRelayFragmentKey<DetailData> =\n    BackofficeRelayFragmentKey<DetailData>,\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  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  Record<string, BackofficeErasedValue>,\n  BackofficeErasedValue\n>;\n\nexport type BackofficeRuntimePickerFacetConfig = BackofficePickerFacetConfig<\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  Record<string, BackofficeErasedValue>,\n  BackofficeErasedValue\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 BackofficeListDetailPickerFacetLoaderMap =\n  BackofficeListDetailFacetLoaderMap & {\n    picker: BackofficePickerFacetLoader;\n  };\n\nexport type BackofficeToolFacetLoaderMap = {\n  tool: BackofficeToolFacetLoader;\n};\n\nexport type BackofficeEntityFacetLoaderMap =\n  BackofficeListDetailFacetLoaderMap | BackofficeToolFacetLoaderMap;\n\ntype BackofficeEntityManifestBase = {\n  id: string;\n  routeSegment: string;\n  groupId?: string;\n  label: I18nLabel;\n  detailLabel?: I18nLabel;\n  routes: BackofficeEntityRouteManifest;\n};\n\nexport type BackofficeListDetailManifestItem<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n  S extends Schema = Schema,\n> = BackofficeEntityManifestBase & {\n  kind: 'list-detail';\n  detailPages: BackofficeDetailPageManifest;\n  defaultDetailPageId: string;\n} & (\n    | {\n        hasList: true;\n        listNavigation: BackofficeListNavigation<Where, Sort, S>;\n        facets: BackofficeListDetailFacetLoaderMap & {\n          list: BackofficeListFacetLoader;\n        };\n      }\n    | {\n        hasList: false;\n        listNavigation?: never;\n        facets: Omit<BackofficeListDetailFacetLoaderMap, 'list'> & {\n          list?: never;\n        };\n      }\n  );\n\nexport type BackofficeToolManifestItem = BackofficeEntityManifestBase & {\n  kind: 'tool';\n  hasList: false;\n  listNavigation?: never;\n  detailPages?: never;\n  defaultDetailPageId?: never;\n  facets: BackofficeToolFacetLoaderMap;\n};\n\nexport type BackofficeEntityManifestItem<\n  Where extends Record<string, unknown> = Record<string, unknown>,\n  Sort extends string = string,\n  S extends Schema = Schema,\n> =\n  BackofficeListDetailManifestItem<Where, Sort, S> | BackofficeToolManifestItem;\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  string extends BackofficeManifestEntityId<TManifest>\n    ? string\n    : {\n        [\n          TEntityId in BackofficeManifestEntityId<TManifest>\n        ]: TManifest[TEntityId] extends {\n          kind: 'list-detail';\n          hasList: true;\n        }\n          ? TEntityId\n          : never;\n      }[BackofficeManifestEntityId<TManifest>];\n\nexport type BackofficeManifestListStateInput<\n  TManifest,\n  TEntityId extends BackofficeManifestListEntityId<TManifest>,\n> =\n  string extends BackofficeManifestEntityId<TManifest>\n    ? BackofficeListNavigationStateInput<Record<string, unknown>, string>\n    : TEntityId extends BackofficeManifestListEntityId<TManifest>\n      ? TManifest[TEntityId] extends {\n          listNavigation: {\n            defaults: BackofficeListState<\n              infer Where extends Record<string, unknown>,\n              infer Sort extends string\n            >;\n          };\n        }\n        ? BackofficeListNavigationStateInput<Where, Sort>\n        : never\n      : never;\n\nexport type BackofficeManifestDetailEntityId<TManifest> =\n  string extends BackofficeManifestEntityId<TManifest>\n    ? string\n    : {\n        [\n          TEntityId in BackofficeManifestEntityId<TManifest>\n        ]: TManifest[TEntityId] extends {\n          kind: 'list-detail';\n        }\n          ? TEntityId\n          : never;\n      }[BackofficeManifestEntityId<TManifest>];\n\nexport type BackofficeManifestToolId<TManifest> =\n  string extends BackofficeManifestEntityId<TManifest>\n    ? string\n    : {\n        [\n          TEntityId in BackofficeManifestEntityId<TManifest>\n        ]: TManifest[TEntityId] extends {\n          kind: 'tool';\n        }\n          ? TEntityId\n          : never;\n      }[BackofficeManifestEntityId<TManifest>];\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 = OperationType,\n> = BackofficeListFacetConfig<\n  TOperation,\n  RowRef,\n  RowView,\n  ListFragmentData,\n  TWhere,\n  TSort,\n  TCountOperation\n> & {\n  routes: BackofficeEntityRoutes;\n  listNavigation: BackofficeListNavigation<TWhere, TSort>;\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 = unknown,\n  LayoutView = unknown,\n  LayoutQueryData = unknown,\n  LayoutFragmentRef extends BackofficeRelayFragmentKey<LayoutRef> =\n    BackofficeRelayFragmentKey<LayoutRef>,\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 = unknown,\n  DetailView = unknown,\n  DetailQueryData = unknown,\n  DetailFragmentRef extends BackofficeRelayFragmentKey<DetailRef> =\n    BackofficeRelayFragmentKey<DetailRef>,\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<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeDetailPageFacetConfigBase =\n  BackofficeDetailPageFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeResolvedListFacetConfigBase =\n  BackofficeResolvedListFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    Record<string, BackofficeErasedValue>,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeResolvedPickerFacetConfigBase =\n  BackofficeResolvedPickerFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    Record<string, BackofficeErasedValue>\n  >;\n\nexport type BackofficeResolvedDetailLayoutFacetConfigBase =\n  BackofficeResolvedDetailLayoutFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeResolvedDetailPageFacetConfigBase =\n  BackofficeResolvedDetailPageFacetConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeRuntimeResolvedListFacetConfig =\n  BackofficeResolvedListFacetConfigBase;\n\nexport type BackofficeRuntimeResolvedPickerFacetConfig =\n  BackofficeResolvedPickerFacetConfigBase;\n\nexport type BackofficeRuntimeConnectionListConfig =\n  BackofficeConnectionListConfig<\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    BackofficeErasedValue,\n    Record<string, BackofficeErasedValue>,\n    BackofficeErasedValue\n  >;\n\nexport type BackofficeRuntimeEntityListConfig = BackofficeEntityListConfig<\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  Record<string, BackofficeErasedValue>,\n  BackofficeErasedValue\n>;\n\nexport type BackofficeRuntimeEntityPickerConfig = BackofficeEntityPickerConfig<\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  BackofficeErasedValue,\n  Record<string, BackofficeErasedValue>\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 BackofficePreparedListShellRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n};\n\nexport type BackofficePreparedListLayoutRoute =\n  BackofficePreparedListShellRoute & {\n    entityConfig: BackofficeResolvedListFacetConfigBase;\n  };\n\nexport type BackofficePreparedListDataRoute =\n  BackofficePreparedListLayoutRoute & {\n    query: PreloadedQuery<OperationType>;\n  };\n\nexport type BackofficePreparedDetailFrameRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  id: string;\n};\n\nexport type BackofficePreparedDetailShellRoute =\n  BackofficePreparedDetailFrameRoute & {\n    pageId: string | null;\n    pagePath: string | null;\n  };\n\nexport type BackofficePreparedDetailLayoutDataRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  id: string;\n  layoutQuery: PreloadedQuery<OperationType>;\n};\n\nexport type BackofficePreparedDetailPageConfigRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  id: string;\n  pageId: string;\n  pagePath: string;\n  pageConfig: BackofficeResolvedDetailPageFacetConfigBase;\n  detailId?: string;\n};\n\nexport type BackofficePreparedDetailPageDataRoute = Omit<\n  BackofficePreparedDetailPageConfigRoute,\n  'entityConfig'\n> & {\n  pageQuery: PreloadedQuery<OperationType>;\n};\n\nexport type BackofficePreparedDetailUnknownPageRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n  entityConfig: BackofficeResolvedDetailLayoutFacetConfigBase;\n  id: string;\n  pagePath: string;\n};\n\nexport type BackofficePreparedToolRoute = {\n  entityId: string;\n  entityManifest: BackofficeEntityManifestItem;\n};\n\nexport type BackofficePreparedToolConfigRoute = BackofficePreparedToolRoute & {\n  entityConfig: BackofficeResolvedToolFacetConfig;\n};\n"]}