@elevasis/core 0.1.0

package/src/organization-model/graph/build.ts

@@ -0,0 +1,432 @@
+import { BuildOrganizationGraphInputSchema, OrganizationGraphSchema } from './schema'
+import type { CommandViewData } from '../../platform/registry/command-view'
+import type {
+  BuildOrganizationGraphInput,
+  OrganizationGraph,
+  OrganizationGraphEdge,
+  OrganizationGraphNode,
+  OrganizationGraphNodeKind
+} from './types'
+
+function nodeId(kind: OrganizationGraphNodeKind, sourceId?: string): string {
+  return kind === 'organization' ? 'organization-model' : `${kind}:${sourceId ?? ''}`
+}
+
+function edgeId(kind: string, sourceId: string, targetId: string, variant?: string): string {
+  return variant ? `edge:${kind}:${variant}:${sourceId}:${targetId}` : `edge:${kind}:${sourceId}:${targetId}`
+}
+
+function pushUniqueNode(nodes: OrganizationGraphNode[], seen: Set<string>, node: OrganizationGraphNode): void {
+  if (seen.has(node.id)) return
+  seen.add(node.id)
+  nodes.push(node)
+}
+
+function pushUniqueEdge(edges: OrganizationGraphEdge[], seen: Set<string>, edge: OrganizationGraphEdge): void {
+  if (seen.has(edge.id)) return
+  seen.add(edge.id)
+  edges.push(edge)
+}
+
+function upsertResourceNode(
+  nodes: OrganizationGraphNode[],
+  seen: Set<string>,
+  resourceNodesById: Map<string, OrganizationGraphNode>,
+  node: OrganizationGraphNode
+): OrganizationGraphNode {
+  const existing = resourceNodesById.get(node.id)
+  if (existing) {
+    if (!existing.label || existing.label === existing.sourceId) {
+      existing.label = node.label
+    }
+    if (!existing.description && node.description) {
+      existing.description = node.description
+    }
+    if (!existing.sourceId && node.sourceId) {
+      existing.sourceId = node.sourceId
+    }
+    if (!existing.resourceType && node.resourceType) {
+      existing.resourceType = node.resourceType
+    }
+    return existing
+  }
+
+  resourceNodesById.set(node.id, node)
+  pushUniqueNode(nodes, seen, node)
+  return node
+}
+
+function ensureResourceNode(
+  nodes: OrganizationGraphNode[],
+  seen: Set<string>,
+  resourceNodesById: Map<string, OrganizationGraphNode>,
+  resourceId: string
+): OrganizationGraphNode {
+  const existing = resourceNodesById.get(nodeId('resource', resourceId))
+  if (existing) return existing
+
+  return upsertResourceNode(nodes, seen, resourceNodesById, {
+    id: nodeId('resource', resourceId),
+    kind: 'resource',
+    label: resourceId,
+    sourceId: resourceId
+  })
+}
+
+function titleCase(value: string): string {
+  return value
+    .replace(/[-_.]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .split(' ')
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ')
+}
+
+type CommandViewResource =
+  | CommandViewData['workflows'][number]
+  | CommandViewData['agents'][number]
+  | CommandViewData['triggers'][number]
+  | CommandViewData['integrations'][number]
+  | CommandViewData['externalResources'][number]
+  | CommandViewData['humanCheckpoints'][number]
+
+function normalizeCommandViewResourceType(
+  resourceType: CommandViewResource['type']
+): OrganizationGraphNode['resourceType'] {
+  return resourceType === 'human' ? 'human_checkpoint' : resourceType
+}
+
+function collectCommandViewResources(commandViewData: CommandViewData): CommandViewResource[] {
+  return [
+    ...commandViewData.workflows,
+    ...commandViewData.agents,
+    ...commandViewData.triggers,
+    ...commandViewData.integrations,
+    ...commandViewData.externalResources,
+    ...commandViewData.humanCheckpoints
+  ]
+}
+
+export function buildOrganizationGraph(input: BuildOrganizationGraphInput): OrganizationGraph {
+  const parsed = BuildOrganizationGraphInputSchema.parse(input)
+  const organizationModel = parsed.organizationModel
+  const commandViewData = parsed.commandViewData as CommandViewData | undefined
+
+  const nodes: OrganizationGraphNode[] = []
+  const edges: OrganizationGraphEdge[] = []
+  const nodeIds = new Set<string>()
+  const edgeIds = new Set<string>()
+  const resourceNodesById = new Map<string, OrganizationGraphNode>()
+
+  const organizationNode: OrganizationGraphNode = {
+    id: nodeId('organization'),
+    kind: 'organization',
+    label: 'Organization Model'
+  }
+  pushUniqueNode(nodes, nodeIds, organizationNode)
+
+  const featureEntries = Object.entries(organizationModel.features.enabled)
+    .map(([featureKey, enabled]) => {
+      const key = featureKey as keyof typeof organizationModel.features.enabled
+      return {
+        key: featureKey,
+        enabled,
+        label: organizationModel.features.labels[key] ?? titleCase(featureKey)
+      }
+    })
+    .sort((a, b) => a.key.localeCompare(b.key))
+
+  for (const feature of featureEntries) {
+    const id = nodeId('feature', feature.key)
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: 'feature',
+      label: feature.label,
+      sourceId: feature.key,
+      enabled: feature.enabled,
+      featureKey: feature.key as OrganizationGraphNode['featureKey']
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+  }
+
+  const domainMap = new Map<string, (typeof organizationModel.domains)[number]>()
+  for (const domain of organizationModel.domains) {
+    domainMap.set(domain.id, domain)
+  }
+
+  const surfaceMap = new Map<string, (typeof organizationModel.navigation.surfaces)[number]>()
+  for (const surface of organizationModel.navigation.surfaces) {
+    surfaceMap.set(surface.id, surface)
+  }
+
+  const entityIds = new Set<string>()
+  const capabilityIds = new Set<string>()
+  const resourceMappings = [...organizationModel.resourceMappings].sort((a, b) => a.resourceId.localeCompare(b.resourceId))
+  for (const resourceMapping of resourceMappings) {
+    for (const entityId of resourceMapping.entityIds) {
+      entityIds.add(entityId)
+    }
+    for (const capabilityId of resourceMapping.capabilityIds) {
+      capabilityIds.add(capabilityId)
+    }
+  }
+
+  for (const domain of [...organizationModel.domains].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId('domain', domain.id)
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: 'domain',
+      label: domain.label,
+      sourceId: domain.id,
+      description: domain.description
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+
+    for (const entityId of domain.entityIds) {
+      entityIds.add(entityId)
+    }
+    for (const capabilityId of domain.capabilityIds) {
+      capabilityIds.add(capabilityId)
+    }
+    for (const surfaceId of domain.surfaceIds) {
+      const surface = surfaceMap.get(surfaceId)
+      if (surface) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId('references', id, nodeId('surface', surface.id)),
+          kind: 'references',
+          sourceId: id,
+          targetId: nodeId('surface', surface.id)
+        })
+      }
+    }
+  }
+
+  for (const surface of [...organizationModel.navigation.surfaces].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId('surface', surface.id)
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: 'surface',
+      label: surface.label,
+      sourceId: surface.id,
+      description: surface.description,
+      surfaceType: surface.surfaceType
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+
+    if (surface.featureKey) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('exposes', nodeId('feature', surface.featureKey), id),
+        kind: 'exposes',
+        sourceId: nodeId('feature', surface.featureKey),
+        targetId: id
+      })
+    }
+
+    for (const domainId of surface.domainIds) {
+      if (domainMap.has(domainId)) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId('references', id, nodeId('domain', domainId)),
+          kind: 'references',
+          sourceId: id,
+          targetId: nodeId('domain', domainId)
+        })
+      }
+    }
+
+    for (const entityId of surface.entityIds) {
+      entityIds.add(entityId)
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('references', id, nodeId('entity', entityId)),
+        kind: 'references',
+        sourceId: id,
+        targetId: nodeId('entity', entityId)
+      })
+    }
+
+    for (const capabilityId of surface.capabilityIds) {
+      capabilityIds.add(capabilityId)
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('references', id, nodeId('capability', capabilityId)),
+        kind: 'references',
+        sourceId: id,
+        targetId: nodeId('capability', capabilityId)
+      })
+    }
+  }
+
+  for (const entityId of [...entityIds].sort()) {
+    pushUniqueNode(nodes, nodeIds, {
+      id: nodeId('entity', entityId),
+      kind: 'entity',
+      label: entityId,
+      sourceId: entityId
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, nodeId('entity', entityId)),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: nodeId('entity', entityId)
+    })
+  }
+
+  for (const capabilityId of [...capabilityIds].sort()) {
+    pushUniqueNode(nodes, nodeIds, {
+      id: nodeId('capability', capabilityId),
+      kind: 'capability',
+      label: capabilityId,
+      sourceId: capabilityId
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, nodeId('capability', capabilityId)),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: nodeId('capability', capabilityId)
+    })
+  }
+
+  for (const resourceMapping of resourceMappings) {
+    const id = nodeId('resource', resourceMapping.resourceId)
+    upsertResourceNode(nodes, nodeIds, resourceNodesById, {
+      id,
+      kind: 'resource',
+      label: resourceMapping.label,
+      sourceId: resourceMapping.resourceId,
+      description: resourceMapping.description,
+      resourceType: resourceMapping.resourceType
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+
+    for (const domainId of resourceMapping.domainIds) {
+      if (domainMap.has(domainId)) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId('maps_to', id, nodeId('domain', domainId)),
+          kind: 'maps_to',
+          sourceId: id,
+          targetId: nodeId('domain', domainId)
+        })
+      }
+    }
+
+    for (const entityId of resourceMapping.entityIds) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('maps_to', id, nodeId('entity', entityId)),
+        kind: 'maps_to',
+        sourceId: id,
+        targetId: nodeId('entity', entityId)
+      })
+    }
+
+    for (const surfaceId of resourceMapping.surfaceIds) {
+      if (surfaceMap.has(surfaceId)) {
+        pushUniqueEdge(edges, edgeIds, {
+          id: edgeId('maps_to', id, nodeId('surface', surfaceId)),
+          kind: 'maps_to',
+          sourceId: id,
+          targetId: nodeId('surface', surfaceId)
+        })
+      }
+    }
+
+    for (const capabilityId of resourceMapping.capabilityIds) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('maps_to', id, nodeId('capability', capabilityId)),
+        kind: 'maps_to',
+        sourceId: id,
+        targetId: nodeId('capability', capabilityId)
+      })
+    }
+  }
+
+  if (commandViewData) {
+    const commandViewResources = collectCommandViewResources(commandViewData).sort((a, b) =>
+      a.resourceId.localeCompare(b.resourceId)
+    )
+
+    for (const resource of commandViewResources) {
+      const id = nodeId('resource', resource.resourceId)
+      const resourceNode = upsertResourceNode(nodes, nodeIds, resourceNodesById, {
+        id,
+        kind: 'resource',
+        label: resource.name,
+        sourceId: resource.resourceId,
+        description: resource.description,
+        resourceType: normalizeCommandViewResourceType(resource.type)
+      })
+
+      for (const domainId of resource.domains ?? []) {
+        if (domainMap.has(domainId)) {
+          pushUniqueEdge(edges, edgeIds, {
+            id: edgeId('references', resourceNode.id, nodeId('domain', domainId), 'domain'),
+            kind: 'references',
+            sourceId: resourceNode.id,
+            targetId: nodeId('domain', domainId)
+          })
+        }
+      }
+
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('contains', organizationNode.id, resourceNode.id),
+        kind: 'contains',
+        sourceId: organizationNode.id,
+        targetId: resourceNode.id
+      })
+    }
+
+    for (const relationship of [...commandViewData.edges].sort((a, b) => a.id.localeCompare(b.id))) {
+      const sourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.source)
+      const targetNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.target)
+
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('contains', organizationNode.id, sourceNode.id),
+        kind: 'contains',
+        sourceId: organizationNode.id,
+        targetId: sourceNode.id
+      })
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('contains', organizationNode.id, targetNode.id),
+        kind: 'contains',
+        sourceId: organizationNode.id,
+        targetId: targetNode.id
+      })
+
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('references', sourceNode.id, targetNode.id, relationship.relationship),
+        kind: 'references',
+        sourceId: sourceNode.id,
+        targetId: targetNode.id,
+        label: relationship.relationship,
+        relationshipType: relationship.relationship
+      })
+    }
+  }
+
+  const graph: OrganizationGraph = {
+    version: 1,
+    organizationModelVersion: organizationModel.version,
+    nodes,
+    edges
+  }
+
+  return OrganizationGraphSchema.parse(graph)
+}

package/src/organization-model/graph/index.ts

@@ -0,0 +1,4 @@
+export * from './types'
+export * from './schema'
+export * from './build'
+

package/src/organization-model/graph/schema.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod'
+import { DescriptionSchema, LabelSchema } from '../domains/shared'
+import { FeatureKeySchema } from '../domains/features'
+import { SurfaceTypeSchema } from '../domains/navigation'
+import { OrganizationModelSchema } from '../schema'
+
+export const OrganizationGraphNodeKindSchema = z.enum([
+  'organization',
+  'feature',
+  'domain',
+  'surface',
+  'entity',
+  'capability',
+  'resource'
+])
+
+export const OrganizationGraphEdgeKindSchema = z.enum(['contains', 'references', 'exposes', 'maps_to'])
+
+export const OrganizationGraphNodeSchema = z.object({
+  id: z.string().trim().min(1).max(200),
+  kind: OrganizationGraphNodeKindSchema,
+  label: LabelSchema,
+  sourceId: z.string().trim().min(1).max(255).optional(),
+  description: DescriptionSchema.optional(),
+  enabled: z.boolean().optional(),
+  featureKey: FeatureKeySchema.optional(),
+  surfaceType: SurfaceTypeSchema.optional(),
+  resourceType: z.enum(['workflow', 'agent', 'trigger', 'integration', 'external', 'human_checkpoint']).optional()
+})
+
+export const OrganizationGraphEdgeSchema = z.object({
+  id: z.string().trim().min(1).max(250),
+  kind: OrganizationGraphEdgeKindSchema,
+  sourceId: z.string().trim().min(1).max(200),
+  targetId: z.string().trim().min(1).max(200),
+  label: z.string().trim().min(1).max(120).optional(),
+  relationshipType: z.enum(['triggers', 'uses', 'approval']).optional()
+})
+
+export const OrganizationGraphSchema = z.object({
+  version: z.literal(1),
+  organizationModelVersion: OrganizationModelSchema.shape.version,
+  nodes: z.array(OrganizationGraphNodeSchema),
+  edges: z.array(OrganizationGraphEdgeSchema)
+})
+
+export const BuildOrganizationGraphInputSchema = z.object({
+  organizationModel: OrganizationModelSchema,
+  commandViewData: z.unknown().optional()
+})

package/src/organization-model/graph/types.ts

@@ -0,0 +1,52 @@
+import type { CommandViewData } from '../../platform/registry/command-view'
+import type {
+  OrganizationModel,
+  OrganizationModelFeatureKey,
+  OrganizationModelResourceMapping,
+  OrganizationModelSurface
+} from '../types'
+import type { RelationshipType } from '../../platform/registry/command-view'
+
+export type OrganizationGraphNodeKind =
+  | 'organization'
+  | 'feature'
+  | 'domain'
+  | 'surface'
+  | 'entity'
+  | 'capability'
+  | 'resource'
+
+export type OrganizationGraphEdgeKind = 'contains' | 'references' | 'exposes' | 'maps_to'
+
+export interface OrganizationGraphNode {
+  id: string
+  kind: OrganizationGraphNodeKind
+  label: string
+  sourceId?: string
+  description?: string
+  enabled?: boolean
+  featureKey?: OrganizationModelFeatureKey
+  surfaceType?: OrganizationModelSurface['surfaceType']
+  resourceType?: OrganizationModelResourceMapping['resourceType']
+}
+
+export interface OrganizationGraphEdge {
+  id: string
+  kind: OrganizationGraphEdgeKind
+  sourceId: string
+  targetId: string
+  label?: string
+  relationshipType?: RelationshipType
+}
+
+export interface OrganizationGraph {
+  version: 1
+  organizationModelVersion: OrganizationModel['version']
+  nodes: OrganizationGraphNode[]
+  edges: OrganizationGraphEdge[]
+}
+
+export interface BuildOrganizationGraphInput {
+  organizationModel: OrganizationModel
+  commandViewData?: CommandViewData
+}

package/src/organization-model/index.ts

@@ -0,0 +1,11 @@
+export * from './schema'
+export * from './types'
+export * from './defaults'
+export * from './resolve'
+export * from './graph'
+export * from './domains/branding'
+export * from './domains/crm'
+export * from './domains/delivery'
+export * from './domains/features'
+export * from './domains/lead-gen'
+export * from './domains/navigation'

package/src/organization-model/published.ts

@@ -0,0 +1,18 @@
+export { OrganizationModelSchema } from './schema'
+export { DEFAULT_ORGANIZATION_MODEL } from './defaults'
+export { defineOrganizationModel, resolveOrganizationModel } from './resolve'
+
+export type {
+  DeepPartial,
+  OrganizationModel,
+  OrganizationModelBranding,
+  OrganizationModelCrm,
+  OrganizationModelDelivery,
+  OrganizationModelFeatureKey,
+  OrganizationModelFeatures,
+  OrganizationModelLeadGen,
+  OrganizationModelNavigation,
+  OrganizationModelResourceMapping,
+  OrganizationModelSemanticDomain,
+  OrganizationModelSurface
+} from './types'

package/src/organization-model/resolve.ts

@@ -0,0 +1,42 @@
+import { DEFAULT_ORGANIZATION_MODEL } from './defaults'
+import { OrganizationModelSchema } from './schema'
+import type { DeepPartial, OrganizationModel } from './types'
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function deepMerge<T>(base: T, override: DeepPartial<T> | undefined): T {
+  if (override === undefined) {
+    return base
+  }
+
+  if (Array.isArray(base)) {
+    return (override as T) ?? base
+  }
+
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return (override as T) ?? base
+  }
+
+  const result: Record<string, unknown> = { ...base }
+
+  for (const [key, value] of Object.entries(override)) {
+    if (value === undefined) continue
+
+    const existing = result[key]
+    result[key] = isPlainObject(existing) && isPlainObject(value) ? deepMerge(existing, value) : value
+  }
+
+  return result as T
+}
+
+export function defineOrganizationModel<T extends DeepPartial<OrganizationModel>>(model: T): T {
+  return model
+}
+
+export function resolveOrganizationModel(override?: DeepPartial<OrganizationModel>): OrganizationModel {
+  const merged = deepMerge(DEFAULT_ORGANIZATION_MODEL, override)
+  return OrganizationModelSchema.parse(merged)
+}
+

package/src/organization-model/schema.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+import { OrganizationModelBrandingSchema } from './domains/branding'
+import { OrganizationModelCrmSchema } from './domains/crm'
+import { OrganizationModelDeliverySchema } from './domains/delivery'
+import { OrganizationModelFeaturesSchema } from './domains/features'
+import { OrganizationModelLeadGenSchema } from './domains/lead-gen'
+import { OrganizationModelNavigationSchema } from './domains/navigation'
+import { ResourceMappingSchema, SemanticDomainSchema } from './domains/shared'
+
+export const OrganizationModelSchema = z.object({
+  version: z.literal(1).default(1),
+  domains: z.array(SemanticDomainSchema).default([]),
+  branding: OrganizationModelBrandingSchema,
+  features: OrganizationModelFeaturesSchema,
+  navigation: OrganizationModelNavigationSchema,
+  crm: OrganizationModelCrmSchema,
+  leadGen: OrganizationModelLeadGenSchema,
+  delivery: OrganizationModelDeliverySchema,
+  resourceMappings: z.array(ResourceMappingSchema).default([])
+})
+

package/src/organization-model/types.ts

@@ -0,0 +1,27 @@
+import type { z } from 'zod'
+import { OrganizationModelBrandingSchema } from './domains/branding'
+import { OrganizationModelCrmSchema } from './domains/crm'
+import { OrganizationModelDeliverySchema } from './domains/delivery'
+import { OrganizationModelFeaturesSchema, FeatureKeySchema } from './domains/features'
+import { OrganizationModelLeadGenSchema } from './domains/lead-gen'
+import { OrganizationModelNavigationSchema, SurfaceDefinitionSchema } from './domains/navigation'
+import { ResourceMappingSchema, SemanticDomainSchema } from './domains/shared'
+import { OrganizationModelSchema } from './schema'
+
+export type OrganizationModel = z.infer<typeof OrganizationModelSchema>
+export type OrganizationModelBranding = z.infer<typeof OrganizationModelBrandingSchema>
+export type OrganizationModelCrm = z.infer<typeof OrganizationModelCrmSchema>
+export type OrganizationModelLeadGen = z.infer<typeof OrganizationModelLeadGenSchema>
+export type OrganizationModelDelivery = z.infer<typeof OrganizationModelDeliverySchema>
+export type OrganizationModelFeatures = z.infer<typeof OrganizationModelFeaturesSchema>
+export type OrganizationModelFeatureKey = z.infer<typeof FeatureKeySchema>
+export type OrganizationModelNavigation = z.infer<typeof OrganizationModelNavigationSchema>
+export type OrganizationModelSurface = z.infer<typeof SurfaceDefinitionSchema>
+export type OrganizationModelSemanticDomain = z.infer<typeof SemanticDomainSchema>
+export type OrganizationModelResourceMapping = z.infer<typeof ResourceMappingSchema>
+
+export type DeepPartial<T> = T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends object
+    ? { [K in keyof T]?: DeepPartial<T[K]> }
+    : T

package/src/platform/api/index.ts

@@ -0,0 +1 @@
+export type { APIErrorResponse, APIErrorCode } from './types'