pub(all) enum BatchError {
  TooManyInputs
  TotalOutputTooLong
  InvalidItem(Int, ExpandError)
}

pub(all) enum BindingIssue {
  Missing(String)
  Unused(String)
  Duplicate(String)
  CompositePrefix(String)
}

pub struct BindingReport {
  issues : Array[BindingIssue]
}

pub struct BoundTemplate {
  template : Template
  fixed : Array[(String, Value)]
  fixed_names : Map[String, Bool]
}

pub struct CatalogAudit {
  entries : Array[CatalogEntryAudit]
  total_findings : Int
}

pub(all) enum CatalogBatchError {
  TooManyRequests
  TotalOutputTooLong
  InvalidRequest(Int, CatalogExpandError)
}

pub struct CatalogDiff {
  added : Array[String]
  removed : Array[String]
  changed : Array[CatalogTemplateChange]
}

pub struct CatalogEntryAudit {
  name : String
  variable_count : Int
  expression_count : Int
  max_level : Int
  findings : Array[PolicyFinding]
}

pub(all) enum CatalogError {
  TooManyTemplates
  EmptyName
  DuplicateName(String)
  InvalidTemplate(String, ParseError)
}

pub(all) enum CatalogExpandError {
  UnknownTemplate(String)
  InvalidBinding(String, ExpandError)
}

pub(all) enum CatalogJsonError {
  RootMustBeObject
  TemplateMustBeString(String)
  Compilation(CatalogError)
}

pub(all) enum CatalogJsonRenderError {
  BindingConversion(JsonBridgeError)
  CatalogExpansion(CatalogExpandError)
}

pub(all) struct CatalogRequest {
  name : String
  bindings : Array[(String, Value)]
}

pub struct CatalogTemplateChange {
  name : String
  contract : TemplateDiff
}

pub(all) enum ExpandError {
  DuplicateVariable(String)
  MissingVariable(String)
  UnusedVariable(String)
  InvalidValue(String)
  TooManyBindings
  ValueTooLong(String)
  TooManyItems(String)
  InvalidLimit(String)
  OutputTooLong
}

pub(all) struct ExpressionInfo {
  start : Int
  end : Int
  operator : String
  level : Int
  variable_count : Int
  permits_reserved : Bool
}

pub(all) enum JsonBridgeError {
  RootMustBeObject
  UnsupportedValue(String)
}

pub(all) enum JsonRenderError {
  Conversion(JsonBridgeError)
  Expansion(ExpandError)
}

pub(all) enum JsonTemplateError {
  TemplateParse(ParseError)
  TemplateRender(JsonRenderError)
}

pub enum Operator {
  Simple
  Reserved
  Fragment
  Label
  Path
  PathParameter
  Query
  QueryContinuation
}

pub(all) struct OutputSpan {
  source_start : Int
  source_end : Int
  output_start : Int
  output_end : Int
  is_expression : Bool
}

pub(all) enum ParseError {
  InputTooLong
  InvalidUnicode(Int)
  InvalidLiteral(Int)
  UnclosedExpression(Int)
  NestedExpression(Int)
  EmptyExpression(Int)
  InvalidOperator(Int)
  InvalidVariable(Int)
  InvalidModifier(Int)
  TooManyExpressions
  TooManyVariables
}

pub(all) enum PolicyError {
  InvalidFeatureLevel
  InvalidReferenceLimit
}

pub(all) struct PolicyFinding {
  kind : PolicyFindingKind
  start : Int
  end : Int
}

pub(all) enum PolicyFindingKind {
  ReservedExpansion
  FragmentExpansion
  FeatureLevelExceeded(Int)
  ReferenceLimitExceeded
  RepeatedVariable(String)
}

pub struct RenderedUri {
  text : String
  spans : Array[OutputSpan]
}

pub struct RequestAudit {
  index : Int
  name : String
  unknown_template : Bool
  issues : Array[BindingIssue]
}

pub(all) enum RequestAuditError {
  RequestLimit
  BindingLimit
  FindingLimit
}

pub enum Segment {
  Literal(String)
  Expression(Operator, Array[VarSpec], Int, Int)
}

pub struct Template {
  source : String
  segments : Array[Segment]
  variables : Array[String]
}

pub struct TemplateAnalysis {
  expressions : Array[ExpressionInfo]
  uses : Array[VariableUse]
  max_level : Int
  has_reserved_expansion : Bool
}

pub struct TemplateCatalog {
  names : Array[String]
  templates : Map[String, Template]
}

pub struct TemplateDiff {
  added_variables : Array[String]
  removed_variables : Array[String]
  became_scalar_only : Array[String]
  new_repeated_variables : Array[String]
  old_level : Int
  new_level : Int
  reserved_added : Bool
  fragment_added : Bool
}

pub(all) enum TemplateError {
  Parse(ParseError)
  Expand(ExpandError)
}

pub(all) struct TemplatePolicy {
  allow_reserved : Bool
  allow_fragment : Bool
  max_level : Int
  max_references : Int
  forbid_repeated_variables : Bool
}

pub(all) enum Value {
  Scalar(String)
  List(Array[String])
  Assoc(Array[(String, String)])
  SparseList(Array[String?])
  SparseAssoc(Array[(String, String?)])
}

pub struct VarSpec {
  name : String
  prefix : Int?
  explode : Bool
  start : Int
  end : Int
}

pub(all) struct VariableProfile {
  name : String
  occurrences : Int
  first_start : Int
  last_end : Int
  scalar_only : Bool
  uses_explode : Bool
  uses_reserved : Bool
  uses_query : Bool
  maximum_prefix : Int?
}

pub(all) struct VariableUse {
  name : String
  start : Int
  end : Int
  expression_index : Int
  operator : String
  prefix : Int?
  explode : Bool
}

fn bindings_from_json(input : Json) -> Result[Array[(String, Value)], JsonBridgeError]

fn compile_catalog(entries : Array[(String, String)], max_templates? : Int, max_template_length? : Int) -> Result[TemplateCatalog, CatalogError]

fn compile_catalog_json(input : Json, max_templates? : Int, max_template_length? : Int) -> Result[TemplateCatalog, CatalogJsonError]

fn expand(source : String, bindings : Array[(String, Value)], max_output? : Int) -> Result[String, TemplateError]

fn expand_json(source : String, values : Json, max_output? : Int) -> Result[String, JsonTemplateError]

fn parse(input : String, max_length? : Int, max_expressions? : Int, max_variables? : Int, strict_literals? : Bool) -> Result[Template, ParseError]

fn permissive_policy() -> TemplatePolicy

fn value_from_json(input : Json, path? : String) -> Result[Value?, JsonBridgeError]

fn version() -> String