# types/grammar.types.ts

> 121 lines of code and 16 definitions.

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

Listed in [types](https://banes-lab.com/api/source/context/types.md), after [types/grammar.document.types.ts](https://banes-lab.com/source/context/types/grammar.document.types.ts.md) and before [types/layer.types.ts](https://banes-lab.com/source/context/types/layer.types.ts.md).

## Definitions

- `KeywordRole` (interface_declaration, line 6, exported)
- `KeywordRecord` (interface_declaration, line 13, exported)
- `DocumentTypeRecord` (interface_declaration, line 20, exported)
- `ProductionRecord` (interface_declaration, line 31, exported)
- `TemplateSlot` (interface_declaration, line 39, exported)
- `TemplateRecord` (interface_declaration, line 47, exported)
- `PagData` (interface_declaration, line 56, exported)
- `ContractResolver` (interface_declaration, line 64, exported)
- `PagGrammarOptions` (interface_declaration, line 68, exported)
- `ContextForResult` (interface_declaration, line 73, exported)
- `GrammarIssues` (interface_declaration, line 83, exported)
- `PagGrammar` (interface_declaration, line 94, exported)
- `GrammarIndexes` (interface_declaration, line 114, exported)
- `GrammarContext` (interface_declaration, line 121, exported)
- `GrammarFile` (interface_declaration, line 127, exported)
- `TemplateRef` (interface_declaration, line 133, exported)

## Contained in

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

## Source

```typescript
import type { PagDocument, TemplateResolveResult, ValidateResult } from "#types/grammar.document.types";
import type { CheckFacet } from "#types/check.types";
import type { DistinctDeclaration } from "#types/field.types";
import type { UnreadKey } from "#types/record.types";

export interface KeywordRole {
    category: string;
    meaning: string;
    example: string;
    grounds?: string[];
}

export interface KeywordRecord {
    keyword: string;
    roles: [KeywordRole, ...KeywordRole[]];
    aliases?: string[];
    distinctFrom?: DistinctDeclaration[];
}

export interface DocumentTypeRecord {
    type: string;
    defaultVerb: string;
    purpose: string;
    verbs: string[];
    aliases?: string[];
    grounds?: string[];
    model?: string;
    axis?: string;
}

export interface ProductionRecord {
    lhs: string;
    rhs: string;
    group: string;
    aliases?: string[];
    grounds?: string[];
}

export interface TemplateSlot {
    name: string;
    description: string;
    required: boolean;
    kind: string;
    enum?: string[];
}

export interface TemplateRecord {
    type: string;
    title: string;
    slots: TemplateSlot[];
    constraints: string[];
    body: string;
    aliases?: string[];
}

export interface PagData {
    keywords: KeywordRecord[];
    documentTypes: DocumentTypeRecord[];
    productions: ProductionRecord[];
    terminals: string[];
    templates: TemplateRecord[];
}

export interface ContractResolver {
    contractsForType?: (type: string) => string[];
}

export interface PagGrammarOptions {
    data?: PagData;
    resolver?: ContractResolver;
}

export interface ContextForResult {
    documentType: DocumentTypeRecord | null;
    applicable: boolean;
    palette: { verbs: string[]; constructs: string[] };
    grounding: { model: string | null; axis: string | null; constructGrounds: Record<string, string[]> };
    template: TemplateRecord | null;
    requiredSections: string[];
    contracts: string[];
}

export interface GrammarIssues {
    duplicateKeywordIds: string[];
    danglingTemplateSlots: { type: string; slot: string }[];
    docTypesWithoutVerb: string[];
    unknownTemplateTypes: string[];
    unrecognizedDocumentTypes: string[];
    unrecognizedDocumentVerbs: { type: string; verb: string }[];
    danglingNonterminals: { production: string; ref: string }[];
    unusedTerminals: string[];
}

export interface PagGrammar {
    attributions: () => string[];
    checkOf: (kind: string, id: string) => CheckFacet | null;
    keyword: (id: string) => KeywordRecord | null;
    keywords: (category?: string) => KeywordRecord[];
    categories: () => string[];
    documentType: (type: string) => DocumentTypeRecord | null;
    documentTypes: () => DocumentTypeRecord[];
    production: (lhs: string) => ProductionRecord | null;
    productions: () => ProductionRecord[];
    template: (type: string) => TemplateRecord | null;
    templates: () => TemplateRecord[];
    resolvePagTemplate: (type: string, slots: Record<string, string>) => TemplateResolveResult;
    parse: (text: string) => PagDocument;
    validate: (text: string) => ValidateResult;
    contextFor: (type: string) => ContextForResult;
    unreadKeys: () => UnreadKey[];
    validateOntology: () => GrammarIssues;
}

export interface GrammarIndexes {
    keywordById: Map<string, KeywordRecord>;
    typeByName: Map<string, DocumentTypeRecord>;
    productionByLhs: Map<string, ProductionRecord>;
    templateByType: Map<string, TemplateRecord>;
}

export interface GrammarContext {
    data: PagData;
    indexes: GrammarIndexes;
    resolver: ContractResolver;
}

export interface GrammarFile {
    object: Record<string, unknown>;
    source: string;
    kind: string;
}

export interface TemplateRef {
    readonly id: string;
    readonly kind: string;
    readonly line: number;
}
```