@likec4/leanix-bridge 1.53.0

package/src/leanix-api-client.ts

@@ -0,0 +1,138 @@
+/**
+ * Low-level LeanIX GraphQL API client.
+ * Handles authentication (Bearer token), request throttling, and errors.
+ */
+
+/** Configuration for LeanixApiClient (apiToken, baseUrl, requestDelayMs). */
+export interface LeanixApiClientConfig {
+  /** LeanIX API token (required for auth). */
+  apiToken: string
+  /**
+   * Base URL for the LeanIX API (e.g. https://app.leanix.net or https://<workspace>.leanix.net).
+   * Default: https://app.leanix.net
+   */
+  baseUrl?: string
+  /**
+   * Delay in ms between consecutive GraphQL requests (rate limiting).
+   * Default: 200
+   */
+  requestDelayMs?: number
+}
+
+const DEFAULT_BASE_URL = 'https://app.leanix.net'
+const DEFAULT_DELAY_MS = 200
+
+/** Result of a GraphQL request (data or errors). */
+export interface GraphQLResponse<T = unknown> {
+  data?: T
+  errors?: Array<{ message: string; path?: string[]; extensions?: Record<string, unknown> }>
+}
+
+/** Thrown when the LeanIX API returns errors or non-OK HTTP. */
+export class LeanixApiError extends Error {
+  constructor(
+    message: string,
+    public readonly statusCode?: number,
+    public readonly graphqlErrors?: GraphQLResponse['errors'],
+  ) {
+    super(message)
+    this.name = 'LeanixApiError'
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * LeanIX GraphQL API client with Bearer auth and optional rate limiting.
+ * Throttle state is per instance so multiple clients do not share delay.
+ */
+export class LeanixApiClient {
+  private readonly baseUrl: string
+  private readonly apiToken: string
+  private readonly requestDelayMs: number
+  /** Last request timestamp for throttling (per instance). */
+  private lastRequestTime = 0
+  /** Serializes rate-limit and request so only one caller runs at a time. */
+  private rateLimitLock: Promise<void> = Promise.resolve()
+
+  constructor(config: LeanixApiClientConfig) {
+    this.apiToken = config.apiToken
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, '')
+    this.requestDelayMs = config.requestDelayMs ?? DEFAULT_DELAY_MS
+  }
+
+  /**
+   * Execute a GraphQL operation (query or mutation).
+   * Throttles requests by requestDelayMs. Throws LeanixApiError on HTTP or GraphQL errors.
+   */
+  async graphql<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T> {
+    const run = async (): Promise<T> => {
+      const now = Date.now()
+      const elapsed = now - this.lastRequestTime
+      if (elapsed < this.requestDelayMs) {
+        await sleep(this.requestDelayMs - elapsed)
+      }
+      this.lastRequestTime = Date.now()
+
+      const url = `${this.baseUrl}/services/pathfinder/v1/graphql`
+      let res: Response
+      try {
+        res = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiToken}`,
+          },
+          body: JSON.stringify({ query, variables }),
+        })
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        throw new LeanixApiError(`GraphQL request failed: ${url} POST - ${msg}`)
+      }
+
+      let body: GraphQLResponse<T>
+      try {
+        body = (await res.json()) as GraphQLResponse<T>
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        throw new LeanixApiError(
+          `Invalid JSON response: ${url} ${res.status} ${res.statusText} - ${msg}`,
+          res.status,
+        )
+      }
+
+      if (!res.ok) {
+        throw new LeanixApiError(
+          body.errors?.[0]?.message ?? `HTTP ${res.status} ${res.statusText}`,
+          res.status,
+          body.errors,
+        )
+      }
+
+      if (body.errors && body.errors.length > 0) {
+        const msg = body.errors.map(e => e.message).join('; ')
+        throw new LeanixApiError(msg, res.status, body.errors)
+      }
+
+      if (body.data === undefined) {
+        throw new LeanixApiError('GraphQL response had no data and no errors')
+      }
+
+      return body.data as T
+    }
+
+    const prev = this.rateLimitLock
+    let resolve: () => void
+    this.rateLimitLock = new Promise<void>(r => {
+      resolve = r
+    })
+    await prev
+    try {
+      return await run()
+    } finally {
+      resolve!()
+    }
+  }
+}

package/src/leanix-graphql-operations.ts

@@ -0,0 +1,160 @@
+/**
+ * LeanIX GraphQL operations used by sync (find, create, patch fact sheets; create relations).
+ * Extracted for SRP; sync-to-leanix orchestrates, this module performs API calls.
+ */
+
+import type { LeanixApiClient } from './leanix-api-client'
+import type { LeanixFactSheetDryRun } from './to-leanix-inventory-dry-run'
+
+/** Search fact sheets by name and type (for idempotency). Returns null when not found; throws on API/network error. */
+export async function findFactSheetByNameAndType(
+  client: LeanixApiClient,
+  name: string,
+  type: string,
+): Promise<string | null> {
+  type AllFactSheetsResult = {
+    allFactSheets?: {
+      edges?: Array<{
+        node?: { id?: string; name?: string; type?: string }
+      }>
+    }
+  }
+  const query = `
+    query FindFactSheet($name: String!, $type: String!) {
+      allFactSheets(filter: { name: $name, factSheetType: $type }) {
+        edges { node { id name type } }
+      }
+    }
+  `
+  const data = await client.graphql<AllFactSheetsResult>(query, { name, type })
+  const edges = data.allFactSheets?.edges ?? []
+  if (edges.length > 1) {
+    throw new Error(
+      `Multiple fact sheets found for name="${name}" type="${type}". Ensure unique name+type in LeanIX or use likec4Id attribute for lookup.`,
+    )
+  }
+  const first = edges[0]?.node
+  return first?.id ?? null
+}
+
+/**
+ * Search fact sheets by custom attribute (e.g. likec4Id) for idempotent lookup.
+ * Returns null when not found; throws on API/network error.
+ */
+export async function findFactSheetByLikec4IdAttribute(
+  client: LeanixApiClient,
+  attributeKey: string,
+  likec4Id: string,
+): Promise<string | null> {
+  type AllFactSheetsResult = {
+    allFactSheets?: {
+      edges?: Array<{
+        node?: { id?: string }
+      }>
+    }
+  }
+  type FilterInput = {
+    facetFilters?: Array<{ facetKey: string; operator: string; keys: string[] }>
+  }
+  const query = `
+    query FindFactSheetByAttribute($filter: FilterInput!) {
+      allFactSheets(filter: $filter) {
+        edges { node { id } }
+      }
+    }
+  `
+  const filter: FilterInput = {
+    facetFilters: [{ facetKey: attributeKey, operator: 'OR', keys: [likec4Id] }],
+  }
+  const data = await client.graphql<AllFactSheetsResult>(query, { filter })
+  const edges = data.allFactSheets?.edges ?? []
+  if (edges.length > 1) {
+    throw new Error(
+      `Multiple fact sheets found for attribute ${attributeKey}=${likec4Id}. Ensure unique likec4Id in LeanIX.`,
+    )
+  }
+  const first = edges[0]?.node
+  return first?.id ?? null
+}
+
+/** Patch an existing fact sheet to set a custom attribute (e.g. likec4Id). Throws on API error. */
+export async function patchFactSheetAttribute(
+  client: LeanixApiClient,
+  factSheetId: string,
+  attributeKey: string,
+  value: string,
+): Promise<void> {
+  type UpdateResult = { updateFactSheet?: { factSheet?: { id: string } } }
+  const patches = [{ op: 'replace', path: `/factSheetAttributes/${attributeKey}`, value }]
+  const mutation = `
+    mutation UpdateFactSheet($id: ID!, $patches: [Patch]) {
+      updateFactSheet(id: $id, patches: $patches) {
+        factSheet { id }
+      }
+    }
+  `
+  const data = await client.graphql<UpdateResult>(mutation, { id: factSheetId, patches })
+  if (!data.updateFactSheet?.factSheet?.id) {
+    throw new Error(`updateFactSheet did not return fact sheet (id=${factSheetId}, attribute=${attributeKey})`)
+  }
+}
+
+/** Create fact sheet (name, type, optional description and likec4Id attribute). Returns new id; throws on API error. */
+export async function createFactSheet(
+  client: LeanixApiClient,
+  fs: LeanixFactSheetDryRun,
+  likec4IdAttribute: string | undefined,
+): Promise<string> {
+  type CreateResult = { createFactSheet?: { factSheet?: { id: string } } }
+  const patches: Array<{ op: string; path: string; value: string }> = []
+  if (fs.description) {
+    patches.push({ op: 'replace', path: '/description', value: fs.description })
+  }
+  if (likec4IdAttribute && fs.likec4Id) {
+    patches.push({ op: 'replace', path: `/factSheetAttributes/${likec4IdAttribute}`, value: fs.likec4Id })
+  }
+  const mutation = `
+    mutation CreateFactSheet($input: CreateFactSheetInput!, $patches: [Patch]) {
+      createFactSheet(input: $input, patches: $patches) {
+        factSheet { id name type rev }
+      }
+    }
+  `
+  const input = { name: fs.name, type: fs.type }
+  const variables = { input, patches }
+  const data = await client.graphql<CreateResult>(mutation, variables)
+  const id = data.createFactSheet?.factSheet?.id
+  if (!id) throw new Error(`createFactSheet did not return id for ${String(fs.name)}`)
+  return id
+}
+
+/** Create a relation between two fact sheets. Returns relation id; throws when mutation returns no id. */
+export async function createRelation(
+  client: LeanixApiClient,
+  sourceFactSheetId: string,
+  targetFactSheetId: string,
+  relationType: string,
+  _title?: string,
+): Promise<string> {
+  type CreateResult = { createRelation?: { relation?: { id: string } } }
+  const mutation = `
+    mutation CreateRelation($source: ID!, $target: ID!, $type: String!) {
+      createRelation(source: $source, target: $target, type: $type) {
+        relation { id }
+      }
+    }
+  `
+  const data = await client.graphql<CreateResult>(mutation, {
+    source: sourceFactSheetId,
+    target: targetFactSheetId,
+    type: relationType,
+  })
+  const id = data.createRelation?.relation?.id
+  if (!id) {
+    const payload = JSON.stringify(data, null, 2)
+    throw new Error(
+      `createRelation did not return relation id (sourceFactSheetId=${sourceFactSheetId}, targetFactSheetId=${targetFactSheetId}, relationType=${relationType}). Response: ${payload}`,
+    )
+  }
+  return id
+}

package/src/leanix-inventory-snapshot.ts

@@ -0,0 +1,263 @@
+/**
+ * Inbound LeanIX: read-only snapshot of LeanIX inventory (fact sheets + relations).
+ * Used for reconciliation with the LikeC4 manifest; no DSL generation.
+ */
+
+import type { LeanixApiClient } from './leanix-api-client'
+
+/** Single fact sheet as returned from LeanIX API (read-only snapshot). */
+export interface LeanixFactSheetSnapshotItem {
+  id: string
+  name: string
+  type: string
+  /** Set when fetched with likec4IdAttribute and the fact sheet has that custom attribute. */
+  likec4Id?: string
+}
+
+/** Single relation as returned from LeanIX API (read-only snapshot). */
+export interface LeanixRelationSnapshotItem {
+  id?: string
+  sourceFactSheetId: string
+  targetFactSheetId: string
+  type: string
+}
+
+/** Read-only snapshot of LeanIX inventory for reconciliation. */
+export interface LeanixInventorySnapshot {
+  generatedAt: string
+  /** Workspace or project identifier if available from API. */
+  workspaceId?: string
+  factSheets: LeanixFactSheetSnapshotItem[]
+  relations: LeanixRelationSnapshotItem[]
+}
+
+/** Options for fetchLeanixInventorySnapshot (likec4Id attribute, maxFactSheets, generatedAt). */
+export interface FetchLeanixInventorySnapshotOptions {
+  /** Custom attribute key to read likec4Id from fact sheets (e.g. "likec4Id"). When set, snapshot items get likec4Id when present. */
+  likec4IdAttribute?: string
+  /** Max fact sheets to fetch (pagination). Default 1000. */
+  maxFactSheets?: number
+  /** ISO timestamp for snapshot. Default: new Date().toISOString() */
+  generatedAt?: string
+}
+
+const DEFAULT_PAGE_SIZE = 100
+const DEFAULT_MAX_FACT_SHEETS = 1000
+const MAX_GRAPHQL_RETRIES = 3
+
+async function withGraphQLRetry<T>(fn: () => Promise<T>): Promise<T> {
+  let lastErr: unknown
+  for (let attempt = 0; attempt < MAX_GRAPHQL_RETRIES; attempt++) {
+    try {
+      return await fn()
+    } catch (err) {
+      lastErr = err
+      if (attempt < MAX_GRAPHQL_RETRIES - 1) {
+        await new Promise(r => setTimeout(r, 500 * (attempt + 1)))
+      }
+    }
+  }
+  throw lastErr
+}
+
+/**
+ * Fetches a read-only snapshot of the LeanIX inventory (fact sheets, then relations).
+ * Uses cursor-based pagination. Does not modify LeanIX.
+ */
+export async function fetchLeanixInventorySnapshot(
+  client: LeanixApiClient,
+  options: FetchLeanixInventorySnapshotOptions = {},
+): Promise<LeanixInventorySnapshot> {
+  const generatedAt = options.generatedAt ?? new Date().toISOString()
+  const maxFactSheets = options.maxFactSheets ?? DEFAULT_MAX_FACT_SHEETS
+  if (!Number.isInteger(maxFactSheets) || maxFactSheets < 0) {
+    throw new Error('maxFactSheets must be a non-negative integer')
+  }
+  const likec4IdAttribute = options.likec4IdAttribute
+
+  const factSheets = await fetchAllFactSheets(client, {
+    ...(likec4IdAttribute != null ? { likec4IdAttribute } : {}),
+    maxFactSheets,
+  })
+  const relations = await fetchAllRelations(client, factSheets.map(f => f.id))
+
+  return {
+    generatedAt,
+    factSheets,
+    relations,
+  }
+}
+
+type FactSheetNode = {
+  id?: string
+  name?: string
+  type?: string
+  factSheetAttributes?: Array<{ key?: string; value?: string }>
+}
+
+/** Maps a GraphQL node to LeanixFactSheetSnapshotItem; returns null when node has no id. */
+function mapNodeToFactSheetItem(
+  node: FactSheetNode | undefined,
+  likec4IdAttribute: string | undefined,
+): LeanixFactSheetSnapshotItem | null {
+  if (!node?.id) return null
+  const likec4Id = likec4IdAttribute != null && Array.isArray(node.factSheetAttributes)
+    ? node.factSheetAttributes.find((a: { key?: string; value?: string }) => a.key === likec4IdAttribute)?.value
+    : undefined
+  return {
+    id: node.id,
+    name: node.name ?? '',
+    type: node.type ?? '',
+    ...(likec4Id ? { likec4Id } : {}),
+  }
+}
+
+async function fetchAllFactSheets(
+  client: LeanixApiClient,
+  opts: { likec4IdAttribute?: string; maxFactSheets: number },
+): Promise<LeanixInventorySnapshot['factSheets']> {
+  const likec4IdAttribute = opts.likec4IdAttribute
+  const pageSize = Math.min(DEFAULT_PAGE_SIZE, opts.maxFactSheets)
+  const result: LeanixInventorySnapshot['factSheets'] = []
+  let after: string | null = null
+  let hasNextPage = true
+
+  const attributeSelection = likec4IdAttribute != null
+    ? `factSheetAttributes { key value }`
+    : ''
+
+  const query = `
+    query AllFactSheets($first: Int!, $after: String, $filter: FilterInput) {
+      allFactSheets(first: $first, after: $after, filter: $filter) {
+        edges {
+          node {
+            id
+            name
+            type
+            ${attributeSelection}
+          }
+          cursor
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  `
+
+  type PageRes = {
+    allFactSheets?: {
+      edges?: Array<{ node?: FactSheetNode; cursor?: string }>
+      pageInfo?: { hasNextPage?: boolean; endCursor?: string | null }
+    }
+  }
+
+  const fetchPage = async (cursor: string | null): Promise<PageRes> =>
+    withGraphQLRetry(() =>
+      client.graphql<PageRes>(query, {
+        first: pageSize,
+        after: cursor,
+        filter: {},
+      })
+    )
+
+  while (hasNextPage && result.length < opts.maxFactSheets) {
+    const data: PageRes = await fetchPage(after)
+    const edges = data.allFactSheets?.edges ?? []
+    const pageInfo = data.allFactSheets?.pageInfo
+
+    for (const edge of edges) {
+      if (result.length >= opts.maxFactSheets) break
+      const item = mapNodeToFactSheetItem(edge.node, likec4IdAttribute)
+      if (item) result.push(item)
+    }
+
+    hasNextPage = pageInfo?.hasNextPage === true && result.length < opts.maxFactSheets
+    after = pageInfo?.endCursor ?? null
+  }
+
+  return result
+}
+
+const RELATIONS_FETCH_CONCURRENCY = 10
+const RELATIONS_PAGE_SIZE = 100
+
+async function fetchAllRelations(
+  client: LeanixApiClient,
+  factSheetIds: string[],
+): Promise<LeanixInventorySnapshot['relations']> {
+  if (factSheetIds.length === 0) return []
+
+  const relations: LeanixRelationSnapshotItem[] = []
+  const idSet = new Set(factSheetIds)
+
+  type RelationsResult = {
+    factSheet?: {
+      id?: string
+      relations?: {
+        edges?: Array<{
+          node?: {
+            id?: string
+            type?: string
+            targetFactSheet?: { id?: string }
+          }
+        }>
+        pageInfo?: { hasNextPage?: boolean; endCursor?: string | null }
+      }
+    }
+  }
+
+  const query = `
+    query FactSheetRelations($id: ID!, $first: Int, $after: String) {
+      factSheet(id: $id) {
+        id
+        relations(first: $first, after: $after) {
+          edges {
+            node {
+              id
+              type
+              targetFactSheet { id }
+            }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  `
+
+  async function fetchRelationsForFactSheet(sourceId: string): Promise<LeanixRelationSnapshotItem[]> {
+    const out: LeanixRelationSnapshotItem[] = []
+    let after: string | null = null
+    let hasNextPage = true
+    while (hasNextPage) {
+      const data = await withGraphQLRetry(() =>
+        client.graphql<RelationsResult>(query, { id: sourceId, first: RELATIONS_PAGE_SIZE, after })
+      )
+      const edges = data?.factSheet?.relations?.edges ?? []
+      const pageInfo = data?.factSheet?.relations?.pageInfo
+      for (const edge of edges) {
+        const node = edge.node
+        const targetId = node?.targetFactSheet?.id
+        if (!targetId || !idSet.has(targetId)) continue
+        out.push({
+          ...(node?.id ? { id: node.id } : {}),
+          sourceFactSheetId: sourceId,
+          targetFactSheetId: targetId,
+          type: node?.type ?? 'RELATES_TO',
+        })
+      }
+      hasNextPage = pageInfo?.hasNextPage === true
+      after = pageInfo?.endCursor ?? null
+    }
+    return out
+  }
+
+  for (let i = 0; i < factSheetIds.length; i += RELATIONS_FETCH_CONCURRENCY) {
+    const batch = factSheetIds.slice(i, i + RELATIONS_FETCH_CONCURRENCY)
+    const results = await Promise.all(batch.map(sourceId => fetchRelationsForFactSheet(sourceId)))
+    for (const items of results) relations.push(...items)
+  }
+
+  return relations
+}

package/src/mapping.ts

@@ -0,0 +1,88 @@
+/**
+ * Configurable LeanIX mapping: LikeC4 kinds/relations/tags → LeanIX fact sheet types and fields.
+ * No universal taxonomy; safe defaults. Actor kind maps to 'Provider' unless overridden.
+ */
+
+/** Configurable mapping from LikeC4 kinds/relations/tags to LeanIX fact sheet and relation types. */
+export interface LeanixMappingConfig {
+  /** LikeC4 element kind → LeanIX fact sheet type */
+  factSheetTypes?: Record<string, string>
+  /** LikeC4 relationship kind → LeanIX relation type name */
+  relationTypes?: Record<string, string>
+  /** LikeC4 tags / metadata keys → LeanIX field names (optional) */
+  metadataToFields?: Record<string, string>
+}
+
+/** Fallback when element kind is unknown (G25: named constant). */
+export const FALLBACK_FACT_SHEET_TYPE = 'Application'
+
+/** Fallback when relation kind is unknown (G25: named constant). */
+export const FALLBACK_RELATION_TYPE = 'depends on'
+
+/** Default mapping: actor → Provider; override factSheetTypes/relationTypes as needed */
+export const DEFAULT_LEANIX_MAPPING: Required<LeanixMappingConfig> = {
+  factSheetTypes: {
+    system: 'Application',
+    container: 'ITComponent',
+    component: 'ITComponent',
+    actor: 'Provider',
+  },
+  relationTypes: {
+    default: FALLBACK_RELATION_TYPE,
+  },
+  metadataToFields: {
+    title: 'name',
+    description: 'description',
+    technology: 'technology',
+  },
+}
+
+/**
+ * Merges partial mapping config with DEFAULT_LEANIX_MAPPING; returns a full Required<LeanixMappingConfig>.
+ */
+export function mergeWithDefault(partial?: LeanixMappingConfig | null): Required<LeanixMappingConfig> {
+  const base = {
+    factSheetTypes: { ...DEFAULT_LEANIX_MAPPING.factSheetTypes },
+    relationTypes: { ...DEFAULT_LEANIX_MAPPING.relationTypes },
+    metadataToFields: { ...DEFAULT_LEANIX_MAPPING.metadataToFields },
+  }
+  if (!partial) {
+    return base
+  }
+  return {
+    factSheetTypes: { ...base.factSheetTypes, ...partial.factSheetTypes },
+    relationTypes: { ...base.relationTypes, ...partial.relationTypes },
+    metadataToFields: { ...base.metadataToFields, ...partial.metadataToFields },
+  }
+}
+
+/**
+ * Returns LeanIX fact sheet type for a LikeC4 element kind.
+ * Uses mapping.factSheetTypes[kind], then 'default', then FALLBACK_FACT_SHEET_TYPE.
+ */
+export function getFactSheetType(
+  likec4Kind: string,
+  mapping: Required<LeanixMappingConfig>,
+): string {
+  return (
+    mapping.factSheetTypes[likec4Kind] ??
+      mapping.factSheetTypes['default'] ??
+      FALLBACK_FACT_SHEET_TYPE
+  )
+}
+
+/**
+ * Returns LeanIX relation type for a LikeC4 relationship kind.
+ * Uses mapping.relationTypes[kind], then 'default', then FALLBACK_RELATION_TYPE.
+ */
+export function getRelationType(
+  likec4Kind: string | null,
+  mapping: Required<LeanixMappingConfig>,
+): string {
+  const kind = likec4Kind ?? 'default'
+  return (
+    mapping.relationTypes[kind] ??
+      mapping.relationTypes['default'] ??
+      FALLBACK_RELATION_TYPE
+  )
+}

package/src/model-input.ts

@@ -0,0 +1,36 @@
+/**
+ * Minimal model shape required by the bridge. Satisfied by LikeC4Model (layouted).
+ * Keeps the bridge decoupled from concrete model class.
+ */
+
+/** Element shape required by the bridge (id, kind, title, tags, getMetadata). */
+export interface BridgeElementLike {
+  id: string
+  kind: string
+  title: string
+  tags: readonly string[]
+  technology?: string | null
+  getMetadata(): Record<string, unknown>
+}
+
+/** Relation shape required by the bridge (id, source, target, kind, title). */
+export interface BridgeRelationLike {
+  id: string
+  source: { id: string }
+  target: { id: string }
+  kind: string | null
+  title?: string | null
+}
+
+/** View shape required by the bridge (id only). */
+export interface BridgeViewLike {
+  id: string
+}
+
+/** Model input for toBridgeManifest / toLeanixInventoryDryRun */
+export interface BridgeModelInput {
+  projectId: string
+  elements(): Iterable<BridgeElementLike>
+  relationships(): Iterable<BridgeRelationLike>
+  views(): Iterable<BridgeViewLike>
+}