# types/readme.types.ts

> 170 lines of code and 28 definitions.

Tree: GovLab Docs
Language: typescript
Layer: infrastructure
Canonical: https://banes-lab.com/anatomy/docs#file-docs-types-readme-types-ts
Source text: https://banes-lab.com/source/docs/types/readme.types.ts.txt

Listed in [types](https://banes-lab.com/api/source/docs/types.md), after [types/metadata.types.ts](https://banes-lab.com/source/docs/types/metadata.types.ts.md) and before [types/reference.types.ts](https://banes-lab.com/source/docs/types/reference.types.ts.md).

## Definitions

- `FlatRecord` (type_alias_declaration, line 4, exported)
- `Renderable` (type_alias_declaration, line 5, exported)
- `PublicMember` (interface_declaration, line 7, exported)
- `SurfaceResult` (interface_declaration, line 14, exported)
- `ResolvedMember` (interface_declaration, line 18, exported)
- `PrincipleRecord` (interface_declaration, line 23, exported)
- `ConceptRecord` (interface_declaration, line 33, exported)
- `ApiNote` (interface_declaration, line 38, exported)
- `RepoMetrics` (interface_declaration, line 43, exported)
- `DocsBlock` (interface_declaration, line 54, exported)
- `Governance` (interface_declaration, line 68, exported)
- `Domain` (interface_declaration, line 72, exported)
- `Manifest` (interface_declaration, line 77, exported)
- `PackageJson` (interface_declaration, line 88, exported)
- `RenderContext` (interface_declaration, line 96, exported)
- `ReadmeLayer` (interface_declaration, line 112, exported)
- `ManifestFinding` (interface_declaration, line 117, exported)
- `DeclaredDocFinding` (interface_declaration, line 123, exported)
- `ProseFinding` (interface_declaration, line 130, exported)
- `DeclaredGovernContext` (interface_declaration, line 135, exported)
- `OntologyFinding` (interface_declaration, line 142, exported)
- `DiscoveredModule` (interface_declaration, line 147, exported)
- `ArchEdges` (interface_declaration, line 154, exported)
- `ArchResolveResult` (interface_declaration, line 158, exported)
- `ArchPort` (interface_declaration, line 163, exported)
- `ContextDeps` (interface_declaration, line 169, exported)
- `ModuleDocsOptions` (interface_declaration, line 176, exported)
- `ModuleDocs` (interface_declaration, line 188, exported)

## Contained in

- [types](https://banes-lab.com/anatomy/docs/folder-docs-types.md)

## Source

```typescript
import type { DocForm, DocRegistries, LocationOptions } from "#types/location.types";
import type { DocumentDecl } from "#types/document.types";

export type FlatRecord = Record<string, string>;
export type Renderable = FlatRecord[] | string[] | string;

export interface PublicMember {
    name: string;
    kind: string;
    signature: string;
    axis: string;
}

export interface SurfaceResult {
    surface: PublicMember[];
}

export interface ResolvedMember {
    kind: string;
    signature: string;
}

export interface PrincipleRecord {
    name: string;
    category: string;
    severity: string;
    reinforces?: string[];
    enables?: string[];
    tensions_with?: string[];
    conflicts_with?: string[];
}

export interface ConceptRecord {
    id: string;
    dimension: string;
}

export interface ApiNote {
    name: string;
    note: string;
}

export interface RepoMetrics {
    branch?: string;
    commits?: number;
    contributors?: number;
    created?: string;
    lastCommit?: string;
    latestTag?: string;
    files?: number;
    languages?: FlatRecord;
}

export interface DocsBlock {
    [field: string]: unknown;
    overview?: Renderable;
    whenToUse?: Renderable;
    whenNotToUse?: Renderable;
    quickStart?: Renderable;
    configuration?: Renderable;
    disposal?: Renderable;
    aiContext?: Renderable;
    apiNotes?: ApiNote[];
    api?: Renderable;
    install?: Renderable;
}

export interface Governance {
    principles?: string[];
}

export interface Domain {
    meta: string;
    sub: string;
}

export interface Manifest {
    [key: string]: unknown;
    label?: string;
    summary?: string;
    docs?: DocsBlock;
    documents?: DocumentDecl[];
    governance?: Governance;
    governedBy?: string[];
    domains?: Domain[];
}

export interface PackageJson {
    name?: string;
    exports?: unknown;
    types?: string;
    main?: string;
    dependencies?: Record<string, string>;
}

export interface RenderContext {
    name: string;
    scoped: string;
    summary: string;
    maturity: string;
    docs: DocsBlock;
    surface: PublicMember[];
    principles: PrincipleRecord[];
    concepts: ConceptRecord[];
    domains: Domain[];
    pkg: PackageJson;
    moduleDir: string;
    repo: RepoMetrics | null;
    hasCharts: boolean;
}

export interface ReadmeLayer {
    id: string;
    render: (context: RenderContext) => string | null;
}

export interface ManifestFinding {
    field: string;
    axis: string;
    detail: string;
}

export interface DeclaredDocFinding {
    doc: string;
    heading: string;
    axis: string;
    detail: string;
}

export interface ProseFinding {
    axis: string;
    detail: string;
}

export interface DeclaredGovernContext {
    consumerRoot: string;
    registries: DocRegistries;
    options: LocationOptions;
    hostTokens: readonly string[];
}

export interface OntologyFinding {
    axis: string;
    detail: string;
}

export interface DiscoveredModule {
    manifest: Manifest;
    dir: string;
    axis: string;
    slug: string;
}

export interface ArchEdges {
    conflictsWith: (string | { id: string })[];
}

export interface ArchResolveResult {
    principles: PrincipleRecord[];
    edges: ArchEdges;
}

export interface ArchPort {
    get: (id: string) => unknown;
    resolve: (ids: readonly string[]) => ArchResolveResult;
    validateOntology: () => { duplicateIds: string[] };
}

export interface ContextDeps {
    archRelations: ArchPort;
    conceptMap: ReadonlyMap<string, ConceptRecord>;
    deriveGovernedBy: (slug: string) => string[] | null;
    deriveRepoMetrics?: ((dir: string) => RepoMetrics | null) | undefined;
}

export interface ModuleDocsOptions {
    docConcerns: readonly string[];
    docForms?: Readonly<Record<string, DocForm>>;
    docMembers?: readonly string[];
    consumerRoot: string;
    hostTokens: readonly string[];
    archRelations: ArchPort;
    conceptMap: ReadonlyMap<string, ConceptRecord>;
    deriveGovernedBy: (slug: string) => string[] | null;
    deriveRepoMetrics?: (dir: string) => RepoMetrics | null;
}

export interface ModuleDocs {
    generateReadme: (moduleDir: string, hasCharts?: boolean) => string;
    renderDeclaredDoc: (doc: DocumentDecl) => string;
    declaredDocLocation: (doc: DocumentDecl) => string;
    governManifest: (module: DiscoveredModule) => ManifestFinding[];
    governDeclaredDocs: (module: DiscoveredModule) => DeclaredDocFinding[];
    governPrinciples: (manifest: Manifest) => OntologyFinding[];
    governConcepts: (manifest: Manifest) => OntologyFinding[];
    ontologyDuplicates: () => string[];
}
```