public addModel(kilnModel: IKilnModelInput): IKiln {
    modelAssertions.typeof(kilnModel.name, 'string', 'name')
    modelAssertions.ok(kilnModel.model.isKlayModel, 'model must be a klay model')
    modelAssertions.ok(!this._models.has(kilnModel.name), 'model with same name already exists')

    const meta = {plural: `${kilnModel.name}s`, ...kilnModel.meta}
    this._models.set(kilnModel.name, {...kilnModel, meta, extensions: new Map()})
    return this
  }

export function findModel(model: IModel, pathToModel: string[]): IModel {
  let target = model

  const parts = pathToModel.slice()
  while (parts.length) {
    modelAssertions.typeof(target.spec.children, 'array', 'children')
    const nextPath = parts.shift()
    const found = (target.spec.children as IModelChild[]).find(child => child.path === nextPath)
    modelAssertions.ok(found, `could not find model child ${nextPath}`)
    target = found!.model
  }

  return target
}

  public addExtension(input: IKilnExtensionInput<any>): IKiln {
    const {modelName, extension, defaultOptions} = input
    modelAssertions.typeof(extension.name, 'string', 'name')
    modelAssertions.typeof(extension.defaultOptions, 'object', 'options')
    modelAssertions.typeof(extension.build, 'function', 'build')

    if (modelName) {
      this._getModelOrThrow(modelName).extensions.set(extension.name, {extension, defaultOptions})
    } else {
      for (const kilnModel of this._models.values()) {
        kilnModel.extensions.set(extension.name, {extension, defaultOptions})
      }
    }

    return this
  }

 forEach(rootModel.spec.db!.automanage, item => {
   if (item.phase === ValidationPhase.Database) return
   if (!eventMatches(item.event, event)) return
   modelAssertions.typeof(item.supplyWith, 'function')
   const model = findModel(rootModel, item.property)
   model.coerce(item.supplyWith as ICoerceFunction, item.phase)
 })

 private _getExtensionInputOrThrow<TResult, TOptions>(
   modelName: string,
   extensionName: string,
 ): IKilnExtensionInput<TResult, TOptions> {
   const extension = this._getExtensionInput<TResult, TOptions>(modelName, extensionName)
   modelAssertions.ok(extension, `unable to find extension "${extensionName}"`)
   return extension!
 }

  public index(properties: IIndexPropertyInput[]): IDatabaseOptions {
    assertions.typeof(properties, 'array', 'index')
    assertions.ok(properties.length, 'must specify at least 1 property for index')
    properties.forEach((item, i) => {
      properties[i] = DatabaseOptions._determineIndex(item, i)
    })

    this.spec.index.push(properties as IIndexProperty[])
    return this
  }

  private static _determineIndex(property: IIndexPropertyInput, i: number): IIndexProperty {
    if (Array.isArray(property)) {
      return {property, direction: SortDirection.Ascending}
    }

    assertions.typeof(property, 'object')
    assertions.typeof(property.property, 'array', `index.${i}.property`)
    assertions.oneOf(property.direction, values(SortDirection), `index.${i}.property`)
    return property
  }

  public automanage(property: IAutomanagePropertyInput): IDatabaseOptions {
    assertions.typeof(property, 'object', 'automanage')
    property.property = property.property || []
    property.phase = property.phase || ValidationPhase.Parse
    property.supplyWith = DatabaseOptions._determineSupplyWith(property.supplyWith)

    assertions.typeof(property.property, 'array', 'automanage.propertyPath')
    assertions.oneOf(property.event, values(DatabaseEvent), 'automanage.event')
    assertions.oneOf(property.phase, values(ValidationPhase), 'automanage.phase')

    this.spec.automanage.push(property as IAutomanageProperty)
    return this
  }

  public constrain(input: IConstraintInput): IDatabaseOptions {
    assertions.typeof(input, 'object', 'constrain')
    input.properties = input.properties || [[]]
    input.meta = input.meta || {}

    assertions.typeof(input.properties, 'array', 'constrain.propertyPaths')
    assertions.ok(input.properties.length, 'must specify at least 1 property for constrain')
    assertions.oneOf(input.type, values(ConstraintType), 'constrain.type')
    assertions.typeof(input.meta, 'object')

    const constrain = input as IConstraint
    constrain.name = DatabaseOptions.computeConstraintName(constrain)
    constrain.meta = DatabaseOptions.computeMetaProperties(constrain)
    this.spec.constrain.push(constrain)
    return this
  }

  private static _determineSupplyWith(
    supplyWith: ISupplyWithFunction | SupplyWithPreset,
  ): ISupplyWithFunction | SupplyWithPreset {
    if (supplyWith === SupplyWithPreset.AutoIncrement || typeof supplyWith === 'function') {
      return supplyWith
    }

    const supplyWithFunc = supplyWithPresets[supplyWith]
    assertions.ok(supplyWithFunc, 'invalid automanage supplyWith')
    return supplyWithFunc
  }