// Generated by tsbindgen - Architecture
// Namespace: Microsoft.EntityFrameworkCore.Metadata.Conventions
// Assembly: Microsoft.EntityFrameworkCore, Microsoft.EntityFrameworkCore.Relational

// Core type aliases from @tsonic/core
import type { fnptr, ptr, sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';


// Import types from other namespaces
import type { IConventionComplexPropertyBuilder, IConventionComplexTypeBuilder, IConventionComplexTypeDiscriminatorBuilder, IConventionDbFunctionBuilder, IConventionDiscriminatorBuilder, IConventionElementTypeBuilder, IConventionEntityTypeBuilder, IConventionForeignKeyBuilder, IConventionIndexBuilder, IConventionKeyBuilder, IConventionModelBuilder, IConventionNavigationBuilder, IConventionPropertyBuilder, IConventionSkipNavigationBuilder, IConventionTriggerBuilder, IConventionTypeBaseBuilder } from "../../Microsoft.EntityFrameworkCore.Metadata.Builders/internal/index.js";
import type { ProviderConventionSetBuilderDependencies, RelationalConventionSetBuilderDependencies } from "../../Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure/internal/index.js";
import type { RuntimeStoredProcedureParameter, RuntimeStoredProcedureResultColumn } from "../../Microsoft.EntityFrameworkCore.Metadata.Internal/internal/index.js";
import type { IComplexProperty, IComplexType, IConventionAnnotation, IConventionComplexProperty, IConventionComplexType, IConventionEntityType, IConventionForeignKey, IConventionIndex, IConventionKey, IConventionModel, IConventionNavigation, IConventionProperty, IConventionSkipNavigation, IConventionTrigger, IConventionTypeBase, IDbFunction, IDbFunctionParameter, IElementType, IEntityType, IEntityTypeMappingFragment, IForeignKey, IIndex, IKey, IMetadataReference_1, IModel, INavigation, IParameterBindingFactory, IProperty, IReadOnlyCheckConstraint, IReadOnlyEntityType, IReadOnlyForeignKey, IReadOnlyIndex, IReadOnlyKey, IReadOnlyModel, IReadOnlyProperty, IReadOnlyTrigger, IRelationalPropertyOverrides, ISequence, IServiceProperty, ISkipNavigation, IStoredProcedure, IStoredProcedureParameter, IStoredProcedureResultColumn, ITrigger, ITypeMappingConfiguration, RuntimeComplexProperty, RuntimeComplexType, RuntimeDbFunction, RuntimeDbFunctionParameter, RuntimeElementType, RuntimeEntityType, RuntimeEntityTypeMappingFragment, RuntimeForeignKey, RuntimeIndex, RuntimeKey, RuntimeModel, RuntimeNavigation, RuntimeProperty, RuntimeRelationalPropertyOverrides, RuntimeSequence, RuntimeServiceProperty, RuntimeSkipNavigation, RuntimeStoredProcedure, RuntimeTrigger, RuntimeTypeMappingConfiguration, StoreObjectIdentifier, ValueGenerated } from "../../Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
import type { CoreTypeMapping } from "../../Microsoft.EntityFrameworkCore.Storage/internal/index.js";
import * as Microsoft_EntityFrameworkCore_Internal from "../../Microsoft.EntityFrameworkCore/internal/index.js";
import type { BackingFieldAttribute, CommentAttribute, DbContext, DeleteBehavior, DeleteBehaviorAttribute, EntityTypeConfigurationAttribute, KeylessAttribute, OwnedAttribute, PrecisionAttribute, UnicodeAttribute } from "../../Microsoft.EntityFrameworkCore/internal/index.js";
import type { Dictionary_2, IEnumerable_1, IList_1, IReadOnlyList_1, List_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
import * as System_ComponentModel_DataAnnotations_Schema_Internal from "@tsonic/dotnet/System.ComponentModel.DataAnnotations.Schema/internal/index.js";
import type { ColumnAttribute, ComplexTypeAttribute, DatabaseGeneratedAttribute, InversePropertyAttribute, NotMappedAttribute, TableAttribute } from "@tsonic/dotnet/System.ComponentModel.DataAnnotations.Schema/internal/index.js";
import * as System_ComponentModel_DataAnnotations_Internal from "@tsonic/dotnet/System.ComponentModel.DataAnnotations/internal/index.js";
import type { ConcurrencyCheckAttribute, KeyAttribute, MaxLengthAttribute, RequiredAttribute, StringLengthAttribute, TimestampAttribute } from "@tsonic/dotnet/System.ComponentModel.DataAnnotations/internal/index.js";
import * as System_Linq_Expressions_Internal from "@tsonic/dotnet/System.Linq.Expressions/internal/index.js";
import type { Expression, ExpressionVisitor, MemberExpression, MethodCallExpression } from "@tsonic/dotnet/System.Linq.Expressions/internal/index.js";
import type { FieldInfo, MemberInfo, NullabilityInfo } from "@tsonic/dotnet/System.Reflection/internal/index.js";
import * as System_Text_Json_Serialization_Internal from "@tsonic/dotnet/System.Text.Json.Serialization/internal/index.js";
import type { JsonPropertyNameAttribute } from "@tsonic/dotnet/System.Text.Json.Serialization/internal/index.js";
import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
import type { Attribute, Boolean as ClrBoolean, IDisposable, Int32, Nullable_1, Object as ClrObject, String as ClrString, Type, Void } from "@tsonic/dotnet/System/internal/index.js";

export interface IComplexPropertyAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;

    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
}


export interface IComplexPropertyAddedConvention$instance extends IConvention$instance {}

export type IComplexPropertyAddedConvention = IComplexPropertyAddedConvention$instance;

export interface IComplexPropertyAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAnnotationChangedConvention: never;

    ProcessComplexPropertyAnnotationChanged(propertyBuilder: IConventionComplexPropertyBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IComplexPropertyAnnotationChangedConvention$instance extends IConvention$instance {}

export type IComplexPropertyAnnotationChangedConvention = IComplexPropertyAnnotationChangedConvention$instance;

export interface IComplexPropertyFieldChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyFieldChangedConvention: never;

    ProcessComplexPropertyFieldChanged(propertyBuilder: IConventionComplexPropertyBuilder, newFieldInfo: FieldInfo | null, oldFieldInfo: FieldInfo | null, context: IConventionContext_1<FieldInfo>): void;
}


export interface IComplexPropertyFieldChangedConvention$instance extends IConvention$instance {}

export type IComplexPropertyFieldChangedConvention = IComplexPropertyFieldChangedConvention$instance;

export interface IComplexPropertyNullabilityChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyNullabilityChangedConvention: never;

    ProcessComplexPropertyNullabilityChanged(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export interface IComplexPropertyNullabilityChangedConvention$instance extends IConvention$instance {}

export type IComplexPropertyNullabilityChangedConvention = IComplexPropertyNullabilityChangedConvention$instance;

export interface IComplexPropertyRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyRemovedConvention: never;

    ProcessComplexPropertyRemoved(typeBaseBuilder: IConventionTypeBaseBuilder, property: IConventionComplexProperty, context: IConventionContext_1<IConventionComplexProperty>): void;
}


export interface IComplexPropertyRemovedConvention$instance extends IConvention$instance {}

export type IComplexPropertyRemovedConvention = IComplexPropertyRemovedConvention$instance;

export interface IComplexTypeAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexTypeAnnotationChangedConvention: never;

    ProcessComplexTypeAnnotationChanged(complexTypeBuilder: IConventionComplexTypeBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IComplexTypeAnnotationChangedConvention$instance extends IConvention$instance {}

export type IComplexTypeAnnotationChangedConvention = IComplexTypeAnnotationChangedConvention$instance;

export interface IComplexTypeMemberIgnoredConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexTypeMemberIgnoredConvention: never;

    ProcessComplexTypeMemberIgnored(complexTypeBuilder: IConventionComplexTypeBuilder, name: string, context: IConventionContext_1<System_Internal.String>): void;
}


export interface IComplexTypeMemberIgnoredConvention$instance extends IConvention$instance {}

export type IComplexTypeMemberIgnoredConvention = IComplexTypeMemberIgnoredConvention$instance;

export interface IConvention$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;

}


export type IConvention = IConvention$instance;

export interface IConventionBatch$instance extends IDisposable {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConventionBatch: never;

    Run(foreignKey: IConventionForeignKey): IConventionForeignKey | null;
    Track(foreignKey: IConventionForeignKey): IMetadataReference_1<IConventionForeignKey>;
}


export interface IConventionBatch$instance extends System_Internal.IDisposable {}

export type IConventionBatch = IConventionBatch$instance;

export interface IConventionContext$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConventionContext: never;

    DelayConventions(): IConventionBatch;
    StopProcessing(): void;
}


export type IConventionContext = IConventionContext$instance;

export interface IConventionContext_1$instance<TMetadata extends unknown> extends IConventionContext {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConventionContext_1: never;

    DelayConventions(): IConventionBatch;
    StopProcessing(): void;
    StopProcessing(result: TMetadata | null): void;
}


export type IConventionContext_1<TMetadata extends unknown> = IConventionContext_1$instance<TMetadata>;

export interface IDiscriminatorPropertySetConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IDiscriminatorPropertySetConvention: never;

    ProcessDiscriminatorPropertySet(structuralTypeBuilder: IConventionTypeBaseBuilder, name: string | null, context: IConventionContext_1<string | null>): void;
}


export interface IDiscriminatorPropertySetConvention$instance extends IConvention$instance {}

export type IDiscriminatorPropertySetConvention = IDiscriminatorPropertySetConvention$instance;

export interface IElementTypeAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IElementTypeAnnotationChangedConvention: never;

    ProcessElementTypeAnnotationChanged(builder: IConventionElementTypeBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IElementTypeAnnotationChangedConvention$instance extends IConvention$instance {}

export type IElementTypeAnnotationChangedConvention = IElementTypeAnnotationChangedConvention$instance;

export interface IElementTypeNullabilityChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IElementTypeNullabilityChangedConvention: never;

    ProcessElementTypeNullabilityChanged(builder: IConventionElementTypeBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export interface IElementTypeNullabilityChangedConvention$instance extends IConvention$instance {}

export type IElementTypeNullabilityChangedConvention = IElementTypeNullabilityChangedConvention$instance;

export interface IEntityTypeAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export interface IEntityTypeAddedConvention$instance extends IConvention$instance {}

export type IEntityTypeAddedConvention = IEntityTypeAddedConvention$instance;

export interface IEntityTypeAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAnnotationChangedConvention: never;

    ProcessEntityTypeAnnotationChanged(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IEntityTypeAnnotationChangedConvention$instance extends IConvention$instance {}

export type IEntityTypeAnnotationChangedConvention = IEntityTypeAnnotationChangedConvention$instance;

export interface IEntityTypeBaseTypeChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;

    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
}


export interface IEntityTypeBaseTypeChangedConvention$instance extends IConvention$instance {}

export type IEntityTypeBaseTypeChangedConvention = IEntityTypeBaseTypeChangedConvention$instance;

export interface IEntityTypeIgnoredConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeIgnoredConvention: never;

    ProcessEntityTypeIgnored(modelBuilder: IConventionModelBuilder, name: string, type: Type | null, context: IConventionContext_1<System_Internal.String>): void;
}


export interface IEntityTypeIgnoredConvention$instance extends IConvention$instance {}

export type IEntityTypeIgnoredConvention = IEntityTypeIgnoredConvention$instance;

export interface IEntityTypeMemberIgnoredConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeMemberIgnoredConvention: never;

    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, context: IConventionContext_1<System_Internal.String>): void;
}


export interface IEntityTypeMemberIgnoredConvention$instance extends IConvention$instance {}

export type IEntityTypeMemberIgnoredConvention = IEntityTypeMemberIgnoredConvention$instance;

export interface IEntityTypePrimaryKeyChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypePrimaryKeyChangedConvention: never;

    ProcessEntityTypePrimaryKeyChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newPrimaryKey: IConventionKey | null, previousPrimaryKey: IConventionKey | null, context: IConventionContext_1<IConventionKey>): void;
}


export interface IEntityTypePrimaryKeyChangedConvention$instance extends IConvention$instance {}

export type IEntityTypePrimaryKeyChangedConvention = IEntityTypePrimaryKeyChangedConvention$instance;

export interface IEntityTypeRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeRemovedConvention: never;

    ProcessEntityTypeRemoved(modelBuilder: IConventionModelBuilder, entityType: IConventionEntityType, context: IConventionContext_1<IConventionEntityType>): void;
}


export interface IEntityTypeRemovedConvention$instance extends IConvention$instance {}

export type IEntityTypeRemovedConvention = IEntityTypeRemovedConvention$instance;

export interface IForeignKeyAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;

    ProcessForeignKeyAdded(foreignKeyBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
}


export interface IForeignKeyAddedConvention$instance extends IConvention$instance {}

export type IForeignKeyAddedConvention = IForeignKeyAddedConvention$instance;

export interface IForeignKeyAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAnnotationChangedConvention: never;

    ProcessForeignKeyAnnotationChanged(relationshipBuilder: IConventionForeignKeyBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IForeignKeyAnnotationChangedConvention$instance extends IConvention$instance {}

export type IForeignKeyAnnotationChangedConvention = IForeignKeyAnnotationChangedConvention$instance;

export interface IForeignKeyDependentRequirednessChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyDependentRequirednessChangedConvention: never;

    ProcessForeignKeyDependentRequirednessChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export interface IForeignKeyDependentRequirednessChangedConvention$instance extends IConvention$instance {}

export type IForeignKeyDependentRequirednessChangedConvention = IForeignKeyDependentRequirednessChangedConvention$instance;

export interface IForeignKeyNullNavigationSetConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyNullNavigationSetConvention: never;

    ProcessForeignKeyNullNavigationSet(relationshipBuilder: IConventionForeignKeyBuilder, pointsToPrincipal: boolean, context: IConventionContext_1<IConventionNavigation>): void;
}


export interface IForeignKeyNullNavigationSetConvention$instance extends IConvention$instance {}

export type IForeignKeyNullNavigationSetConvention = IForeignKeyNullNavigationSetConvention$instance;

export interface IForeignKeyOwnershipChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyOwnershipChangedConvention: never;

    ProcessForeignKeyOwnershipChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export interface IForeignKeyOwnershipChangedConvention$instance extends IConvention$instance {}

export type IForeignKeyOwnershipChangedConvention = IForeignKeyOwnershipChangedConvention$instance;

export interface IForeignKeyPrincipalEndChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPrincipalEndChangedConvention: never;

    ProcessForeignKeyPrincipalEndChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
}


export interface IForeignKeyPrincipalEndChangedConvention$instance extends IConvention$instance {}

export type IForeignKeyPrincipalEndChangedConvention = IForeignKeyPrincipalEndChangedConvention$instance;

export interface IForeignKeyPropertiesChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;

    ProcessForeignKeyPropertiesChanged(relationshipBuilder: IConventionForeignKeyBuilder, oldDependentProperties: IReadOnlyList_1<IConventionProperty>, oldPrincipalKey: IConventionKey, context: IConventionContext_1<IReadOnlyList_1<IConventionProperty>>): void;
}


export interface IForeignKeyPropertiesChangedConvention$instance extends IConvention$instance {}

export type IForeignKeyPropertiesChangedConvention = IForeignKeyPropertiesChangedConvention$instance;

export interface IForeignKeyRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;

    ProcessForeignKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, foreignKey: IConventionForeignKey, context: IConventionContext_1<IConventionForeignKey>): void;
}


export interface IForeignKeyRemovedConvention$instance extends IConvention$instance {}

export type IForeignKeyRemovedConvention = IForeignKeyRemovedConvention$instance;

export interface IForeignKeyRequirednessChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRequirednessChangedConvention: never;

    ProcessForeignKeyRequirednessChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export interface IForeignKeyRequirednessChangedConvention$instance extends IConvention$instance {}

export type IForeignKeyRequirednessChangedConvention = IForeignKeyRequirednessChangedConvention$instance;

export interface IForeignKeyUniquenessChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyUniquenessChangedConvention: never;

    ProcessForeignKeyUniquenessChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export interface IForeignKeyUniquenessChangedConvention$instance extends IConvention$instance {}

export type IForeignKeyUniquenessChangedConvention = IForeignKeyUniquenessChangedConvention$instance;

export interface IIndexAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IIndexAddedConvention: never;

    ProcessIndexAdded(indexBuilder: IConventionIndexBuilder, context: IConventionContext_1<IConventionIndexBuilder>): void;
}


export interface IIndexAddedConvention$instance extends IConvention$instance {}

export type IIndexAddedConvention = IIndexAddedConvention$instance;

export interface IIndexAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IIndexAnnotationChangedConvention: never;

    ProcessIndexAnnotationChanged(indexBuilder: IConventionIndexBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IIndexAnnotationChangedConvention$instance extends IConvention$instance {}

export type IIndexAnnotationChangedConvention = IIndexAnnotationChangedConvention$instance;

export interface IIndexRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IIndexRemovedConvention: never;

    ProcessIndexRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, index: IConventionIndex, context: IConventionContext_1<IConventionIndex>): void;
}


export interface IIndexRemovedConvention$instance extends IConvention$instance {}

export type IIndexRemovedConvention = IIndexRemovedConvention$instance;

export interface IIndexSortOrderChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IIndexSortOrderChangedConvention: never;

    ProcessIndexSortOrderChanged(indexBuilder: IConventionIndexBuilder, context: IConventionContext_1<IReadOnlyList_1<System_Internal.Boolean> | null>): void;
}


export interface IIndexSortOrderChangedConvention$instance extends IConvention$instance {}

export type IIndexSortOrderChangedConvention = IIndexSortOrderChangedConvention$instance;

export interface IIndexUniquenessChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IIndexUniquenessChangedConvention: never;

    ProcessIndexUniquenessChanged(indexBuilder: IConventionIndexBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export interface IIndexUniquenessChangedConvention$instance extends IConvention$instance {}

export type IIndexUniquenessChangedConvention = IIndexUniquenessChangedConvention$instance;

export interface IKeyAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyAddedConvention: never;

    ProcessKeyAdded(keyBuilder: IConventionKeyBuilder, context: IConventionContext_1<IConventionKeyBuilder>): void;
}


export interface IKeyAddedConvention$instance extends IConvention$instance {}

export type IKeyAddedConvention = IKeyAddedConvention$instance;

export interface IKeyAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyAnnotationChangedConvention: never;

    ProcessKeyAnnotationChanged(keyBuilder: IConventionKeyBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IKeyAnnotationChangedConvention$instance extends IConvention$instance {}

export type IKeyAnnotationChangedConvention = IKeyAnnotationChangedConvention$instance;

export interface IKeyRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyRemovedConvention: never;

    ProcessKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, key: IConventionKey, context: IConventionContext_1<IConventionKey>): void;
}


export interface IKeyRemovedConvention$instance extends IConvention$instance {}

export type IKeyRemovedConvention = IKeyRemovedConvention$instance;

export interface IModelAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelAnnotationChangedConvention: never;

    ProcessModelAnnotationChanged(modelBuilder: IConventionModelBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IModelAnnotationChangedConvention$instance extends IConvention$instance {}

export type IModelAnnotationChangedConvention = IModelAnnotationChangedConvention$instance;

export interface IModelEmbeddedDiscriminatorNameConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelEmbeddedDiscriminatorNameConvention: never;

    ProcessEmbeddedDiscriminatorName(modelBuilder: IConventionModelBuilder, newName: string | null, oldName: string | null, context: IConventionContext_1<System_Internal.String>): void;
}


export interface IModelEmbeddedDiscriminatorNameConvention$instance extends IConvention$instance {}

export type IModelEmbeddedDiscriminatorNameConvention = IModelEmbeddedDiscriminatorNameConvention$instance;

export interface IModelFinalizedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizedConvention: never;

    ProcessModelFinalized(model: IModel): IModel;
}


export interface IModelFinalizedConvention$instance extends IConvention$instance {}

export type IModelFinalizedConvention = IModelFinalizedConvention$instance;

export interface IModelFinalizingConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export interface IModelFinalizingConvention$instance extends IConvention$instance {}

export type IModelFinalizingConvention = IModelFinalizingConvention$instance;

export interface IModelInitializedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelInitializedConvention: never;

    ProcessModelInitialized(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export interface IModelInitializedConvention$instance extends IConvention$instance {}

export type IModelInitializedConvention = IModelInitializedConvention$instance;

export interface INavigationAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;

    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
}


export interface INavigationAddedConvention$instance extends IConvention$instance {}

export type INavigationAddedConvention = INavigationAddedConvention$instance;

export interface INavigationAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAnnotationChangedConvention: never;

    ProcessNavigationAnnotationChanged(relationshipBuilder: IConventionForeignKeyBuilder, navigation: IConventionNavigation, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface INavigationAnnotationChangedConvention$instance extends IConvention$instance {}

export type INavigationAnnotationChangedConvention = INavigationAnnotationChangedConvention$instance;

export interface INavigationRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationRemovedConvention: never;

    ProcessNavigationRemoved(sourceEntityTypeBuilder: IConventionEntityTypeBuilder, targetEntityTypeBuilder: IConventionEntityTypeBuilder, navigationName: string, memberInfo: MemberInfo | null, context: IConventionContext_1<System_Internal.String>): void;
}


export interface INavigationRemovedConvention$instance extends IConvention$instance {}

export type INavigationRemovedConvention = INavigationRemovedConvention$instance;

export interface IPropertyAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export interface IPropertyAddedConvention$instance extends IConvention$instance {}

export type IPropertyAddedConvention = IPropertyAddedConvention$instance;

export interface IPropertyAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAnnotationChangedConvention: never;

    ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface IPropertyAnnotationChangedConvention$instance extends IConvention$instance {}

export type IPropertyAnnotationChangedConvention = IPropertyAnnotationChangedConvention$instance;

export interface IPropertyElementTypeChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyElementTypeChangedConvention: never;

    ProcessPropertyElementTypeChanged(propertyBuilder: IConventionPropertyBuilder, newElementType: IElementType | null, oldElementType: IElementType | null, context: IConventionContext_1<IElementType>): void;
}


export interface IPropertyElementTypeChangedConvention$instance extends IConvention$instance {}

export type IPropertyElementTypeChangedConvention = IPropertyElementTypeChangedConvention$instance;

export interface IPropertyFieldChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyFieldChanged(propertyBuilder: IConventionPropertyBuilder, newFieldInfo: FieldInfo | null, oldFieldInfo: FieldInfo | null, context: IConventionContext_1<FieldInfo>): void;
}


export interface IPropertyFieldChangedConvention$instance extends IConvention$instance {}

export type IPropertyFieldChangedConvention = IPropertyFieldChangedConvention$instance;

export interface IPropertyNullabilityChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyNullabilityChangedConvention: never;

    ProcessPropertyNullabilityChanged(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export interface IPropertyNullabilityChangedConvention$instance extends IConvention$instance {}

export type IPropertyNullabilityChangedConvention = IPropertyNullabilityChangedConvention$instance;

export interface IPropertyRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyRemovedConvention: never;

    ProcessPropertyRemoved(typeBaseBuilder: IConventionTypeBaseBuilder, property: IConventionProperty, context: IConventionContext_1<IConventionProperty>): void;
}


export interface IPropertyRemovedConvention$instance extends IConvention$instance {}

export type IPropertyRemovedConvention = IPropertyRemovedConvention$instance;

export interface ISkipNavigationAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationAddedConvention: never;

    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
}


export interface ISkipNavigationAddedConvention$instance extends IConvention$instance {}

export type ISkipNavigationAddedConvention = ISkipNavigationAddedConvention$instance;

export interface ISkipNavigationAnnotationChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationAnnotationChangedConvention: never;

    ProcessSkipNavigationAnnotationChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export interface ISkipNavigationAnnotationChangedConvention$instance extends IConvention$instance {}

export type ISkipNavigationAnnotationChangedConvention = ISkipNavigationAnnotationChangedConvention$instance;

export interface ISkipNavigationForeignKeyChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationForeignKeyChangedConvention: never;

    ProcessSkipNavigationForeignKeyChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, foreignKey: IConventionForeignKey | null, oldForeignKey: IConventionForeignKey | null, context: IConventionContext_1<IConventionForeignKey>): void;
}


export interface ISkipNavigationForeignKeyChangedConvention$instance extends IConvention$instance {}

export type ISkipNavigationForeignKeyChangedConvention = ISkipNavigationForeignKeyChangedConvention$instance;

export interface ISkipNavigationInverseChangedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationInverseChangedConvention: never;

    ProcessSkipNavigationInverseChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, inverse: IConventionSkipNavigation | null, oldInverse: IConventionSkipNavigation | null, context: IConventionContext_1<IConventionSkipNavigation>): void;
}


export interface ISkipNavigationInverseChangedConvention$instance extends IConvention$instance {}

export type ISkipNavigationInverseChangedConvention = ISkipNavigationInverseChangedConvention$instance;

export interface ISkipNavigationRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationRemovedConvention: never;

    ProcessSkipNavigationRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, navigation: IConventionSkipNavigation, context: IConventionContext_1<IConventionSkipNavigation>): void;
}


export interface ISkipNavigationRemovedConvention$instance extends IConvention$instance {}

export type ISkipNavigationRemovedConvention = ISkipNavigationRemovedConvention$instance;

export interface ITriggerAddedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ITriggerAddedConvention: never;

    ProcessTriggerAdded(triggerBuilder: IConventionTriggerBuilder, context: IConventionContext_1<IConventionTriggerBuilder>): void;
}


export interface ITriggerAddedConvention$instance extends IConvention$instance {}

export type ITriggerAddedConvention = ITriggerAddedConvention$instance;

export interface ITriggerRemovedConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ITriggerRemovedConvention: never;

    ProcessTriggerRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, trigger: IConventionTrigger, context: IConventionContext_1<IConventionTrigger>): void;
}


export interface ITriggerRemovedConvention$instance extends IConvention$instance {}

export type ITriggerRemovedConvention = ITriggerRemovedConvention$instance;

export interface ITypeIgnoredConvention$instance extends IConvention {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ITypeIgnoredConvention: never;

    ProcessTypeIgnored(modelBuilder: IConventionModelBuilder, name: string, type: Type | null, context: IConventionContext_1<System_Internal.String>): void;
}


export interface ITypeIgnoredConvention$instance extends IConvention$instance {}

export type ITypeIgnoredConvention = ITypeIgnoredConvention$instance;

export interface BackingFieldAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<BackingFieldAttribute>, IComplexPropertyAddedConvention$instance, IComplexPropertyFieldChangedConvention$instance, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_BackingFieldAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyFieldChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: BackingFieldAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: BackingFieldAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export const BackingFieldAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): BackingFieldAttributeConvention;
};


export interface __BackingFieldAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IComplexPropertyFieldChangedConvention(): IComplexPropertyFieldChangedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type BackingFieldAttributeConvention = BackingFieldAttributeConvention$instance & __BackingFieldAttributeConvention$views;


export interface BackingFieldConvention$instance extends IComplexPropertyAddedConvention$instance, IModelFinalizingConvention$instance, INavigationAddedConvention$instance, IPropertyAddedConvention$instance, ISkipNavigationAddedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_BackingFieldConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationAddedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
}


export const BackingFieldConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): BackingFieldConvention;
};


export interface __BackingFieldConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_ISkipNavigationAddedConvention(): ISkipNavigationAddedConvention$instance;
}

export type BackingFieldConvention = BackingFieldConvention$instance & __BackingFieldConvention$views;


export interface BaseTypeDiscoveryConvention$instance extends IEntityTypeAddedConvention$instance, IForeignKeyRemovedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_BaseTypeDiscoveryConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessForeignKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, foreignKey: IConventionForeignKey, context: IConventionContext_1<IConventionForeignKey>): void;
}


export const BaseTypeDiscoveryConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): BaseTypeDiscoveryConvention;
};


export interface __BaseTypeDiscoveryConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IForeignKeyRemovedConvention(): IForeignKeyRemovedConvention$instance;
}

export type BaseTypeDiscoveryConvention = BaseTypeDiscoveryConvention$instance & __BaseTypeDiscoveryConvention$views;


export interface CascadeDeleteConvention$instance extends IForeignKeyAddedConvention$instance, IForeignKeyRequirednessChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_CascadeDeleteConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRequirednessChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    GetTargetDeleteBehavior(foreignKey: IConventionForeignKey): DeleteBehavior;
    ProcessForeignKeyAdded(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyRequirednessChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export const CascadeDeleteConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): CascadeDeleteConvention;
};


export interface __CascadeDeleteConvention$views {
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IForeignKeyRequirednessChangedConvention(): IForeignKeyRequirednessChangedConvention$instance;
}

export type CascadeDeleteConvention = CascadeDeleteConvention$instance & __CascadeDeleteConvention$views;


export interface ChangeTrackingStrategyConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ChangeTrackingStrategyConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const ChangeTrackingStrategyConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ChangeTrackingStrategyConvention;
};


export interface __ChangeTrackingStrategyConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type ChangeTrackingStrategyConvention = ChangeTrackingStrategyConvention$instance & __ChangeTrackingStrategyConvention$views;


export interface CheckConstraintConvention$instance extends IEntityTypeAddedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_CheckConstraintConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
}


export const CheckConstraintConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): CheckConstraintConvention;
};


export interface __CheckConstraintConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
}

export type CheckConstraintConvention = CheckConstraintConvention$instance & __CheckConstraintConvention$views;


export interface ComplexPropertyDiscoveryConvention$instance extends IComplexPropertyAddedConvention$instance, IEntityTypeAddedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance, IEntityTypeMemberIgnoredConvention$instance, IModelFinalizingConvention$instance, INavigationAddedConvention$instance, INavigationRemovedConvention$instance, IPropertyAddedConvention$instance, IPropertyRemovedConvention$instance, ISkipNavigationAddedConvention$instance, ISkipNavigationRemovedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ComplexPropertyDiscoveryConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeMemberIgnoredConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationRemovedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly UseAttributes: boolean;
    DiscoverComplexProperties(structuralTypeBuilder: IConventionTypeBaseBuilder, context: IConventionContext): void;
    GetMembers(structuralType: IConventionTypeBase): IEnumerable_1<MemberInfo>;
    IsCandidateComplexProperty(memberInfo: MemberInfo, structuralType: IConventionTypeBase, targetClrType: Type | null, isCollection: boolean): boolean;
    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, context: IConventionContext_1<System_Internal.String>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessNavigationRemoved(sourceEntityTypeBuilder: IConventionEntityTypeBuilder, targetEntityTypeBuilder: IConventionEntityTypeBuilder, navigationName: string, memberInfo: MemberInfo | null, context: IConventionContext_1<System_Internal.String>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyRemoved(typeBaseBuilder: IConventionTypeBaseBuilder, property: IConventionProperty, context: IConventionContext_1<IConventionProperty>): void;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
    ProcessSkipNavigationRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, navigation: IConventionSkipNavigation, context: IConventionContext_1<IConventionSkipNavigation>): void;
}


export const ComplexPropertyDiscoveryConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, useAttributes: boolean): ComplexPropertyDiscoveryConvention;
};


export interface __ComplexPropertyDiscoveryConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IEntityTypeMemberIgnoredConvention(): IEntityTypeMemberIgnoredConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
    As_INavigationRemovedConvention(): INavigationRemovedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyRemovedConvention(): IPropertyRemovedConvention$instance;
    As_ISkipNavigationAddedConvention(): ISkipNavigationAddedConvention$instance;
    As_ISkipNavigationRemovedConvention(): ISkipNavigationRemovedConvention$instance;
}

export type ComplexPropertyDiscoveryConvention = ComplexPropertyDiscoveryConvention$instance & __ComplexPropertyDiscoveryConvention$views;


export interface ComplexTypeAttributeConvention$instance extends TypeAttributeConventionBase_1$instance<ComplexTypeAttribute>, IComplexPropertyAddedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ComplexTypeAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, attribute: ComplexTypeAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export const ComplexTypeAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ComplexTypeAttributeConvention;
};


export interface __ComplexTypeAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type ComplexTypeAttributeConvention = ComplexTypeAttributeConvention$instance & __ComplexTypeAttributeConvention$views;


export interface ConcurrencyCheckAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<ConcurrencyCheckAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ConcurrencyCheckAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: ConcurrencyCheckAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: ConcurrencyCheckAttribute, clrMember: MemberInfo, context: IConventionContext): void;
}


export const ConcurrencyCheckAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ConcurrencyCheckAttributeConvention;
};


export interface __ConcurrencyCheckAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type ConcurrencyCheckAttributeConvention = ConcurrencyCheckAttributeConvention$instance & __ConcurrencyCheckAttributeConvention$views;


export interface ConstructorBindingConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ConstructorBindingConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const ConstructorBindingConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ConstructorBindingConvention;
};


export interface __ConstructorBindingConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type ConstructorBindingConvention = ConstructorBindingConvention$instance & __ConstructorBindingConvention$views;


export interface ConventionSet$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ConventionSet: never;

    readonly ComplexPropertyAddedConventions: List_1<IComplexPropertyAddedConvention>;
    readonly ComplexPropertyAnnotationChangedConventions: List_1<IComplexPropertyAnnotationChangedConvention>;
    readonly ComplexPropertyFieldChangedConventions: List_1<IComplexPropertyFieldChangedConvention>;
    readonly ComplexPropertyNullabilityChangedConventions: List_1<IComplexPropertyNullabilityChangedConvention>;
    readonly ComplexPropertyRemovedConventions: List_1<IComplexPropertyRemovedConvention>;
    readonly ComplexTypeAnnotationChangedConventions: List_1<IComplexTypeAnnotationChangedConvention>;
    readonly ComplexTypeMemberIgnoredConventions: List_1<IComplexTypeMemberIgnoredConvention>;
    readonly DiscriminatorPropertySetConventions: List_1<IDiscriminatorPropertySetConvention>;
    readonly ElementTypeAnnotationChangedConventions: List_1<IElementTypeAnnotationChangedConvention>;
    readonly ElementTypeNullabilityChangedConventions: List_1<IElementTypeNullabilityChangedConvention>;
    readonly EntityTypeAddedConventions: List_1<IEntityTypeAddedConvention>;
    readonly EntityTypeAnnotationChangedConventions: List_1<IEntityTypeAnnotationChangedConvention>;
    readonly EntityTypeBaseTypeChangedConventions: List_1<IEntityTypeBaseTypeChangedConvention>;
    readonly EntityTypeMemberIgnoredConventions: List_1<IEntityTypeMemberIgnoredConvention>;
    readonly EntityTypePrimaryKeyChangedConventions: List_1<IEntityTypePrimaryKeyChangedConvention>;
    readonly EntityTypeRemovedConventions: List_1<IEntityTypeRemovedConvention>;
    readonly ForeignKeyAddedConventions: List_1<IForeignKeyAddedConvention>;
    readonly ForeignKeyAnnotationChangedConventions: List_1<IForeignKeyAnnotationChangedConvention>;
    readonly ForeignKeyDependentRequirednessChangedConventions: List_1<IForeignKeyDependentRequirednessChangedConvention>;
    readonly ForeignKeyNullNavigationSetConventions: List_1<IForeignKeyNullNavigationSetConvention>;
    readonly ForeignKeyOwnershipChangedConventions: List_1<IForeignKeyOwnershipChangedConvention>;
    readonly ForeignKeyPrincipalEndChangedConventions: List_1<IForeignKeyPrincipalEndChangedConvention>;
    readonly ForeignKeyPropertiesChangedConventions: List_1<IForeignKeyPropertiesChangedConvention>;
    readonly ForeignKeyRemovedConventions: List_1<IForeignKeyRemovedConvention>;
    readonly ForeignKeyRequirednessChangedConventions: List_1<IForeignKeyRequirednessChangedConvention>;
    readonly ForeignKeyUniquenessChangedConventions: List_1<IForeignKeyUniquenessChangedConvention>;
    readonly IndexAddedConventions: List_1<IIndexAddedConvention>;
    readonly IndexAnnotationChangedConventions: List_1<IIndexAnnotationChangedConvention>;
    readonly IndexRemovedConventions: List_1<IIndexRemovedConvention>;
    readonly IndexSortOrderChangedConventions: List_1<IIndexSortOrderChangedConvention>;
    readonly IndexUniquenessChangedConventions: List_1<IIndexUniquenessChangedConvention>;
    readonly KeyAddedConventions: List_1<IKeyAddedConvention>;
    readonly KeyAnnotationChangedConventions: List_1<IKeyAnnotationChangedConvention>;
    readonly KeyRemovedConventions: List_1<IKeyRemovedConvention>;
    readonly ModelAnnotationChangedConventions: List_1<IModelAnnotationChangedConvention>;
    readonly ModelEmbeddedDiscriminatorNameConventions: List_1<IModelEmbeddedDiscriminatorNameConvention>;
    readonly ModelFinalizedConventions: List_1<IModelFinalizedConvention>;
    readonly ModelFinalizingConventions: List_1<IModelFinalizingConvention>;
    readonly ModelInitializedConventions: List_1<IModelInitializedConvention>;
    readonly NavigationAddedConventions: List_1<INavigationAddedConvention>;
    readonly NavigationAnnotationChangedConventions: List_1<INavigationAnnotationChangedConvention>;
    readonly NavigationRemovedConventions: List_1<INavigationRemovedConvention>;
    readonly PropertyAddedConventions: List_1<IPropertyAddedConvention>;
    readonly PropertyAnnotationChangedConventions: List_1<IPropertyAnnotationChangedConvention>;
    readonly PropertyElementTypeChangedConventions: List_1<IPropertyElementTypeChangedConvention>;
    readonly PropertyFieldChangedConventions: List_1<IPropertyFieldChangedConvention>;
    readonly PropertyNullabilityChangedConventions: List_1<IPropertyNullabilityChangedConvention>;
    readonly PropertyRemovedConventions: List_1<IPropertyRemovedConvention>;
    readonly SkipNavigationAddedConventions: List_1<ISkipNavigationAddedConvention>;
    readonly SkipNavigationAnnotationChangedConventions: List_1<ISkipNavigationAnnotationChangedConvention>;
    readonly SkipNavigationForeignKeyChangedConventions: List_1<ISkipNavigationForeignKeyChangedConvention>;
    readonly SkipNavigationInverseChangedConventions: List_1<ISkipNavigationInverseChangedConvention>;
    readonly SkipNavigationRemovedConventions: List_1<ISkipNavigationRemovedConvention>;
    readonly TriggerAddedConventions: List_1<ITriggerAddedConvention>;
    readonly TriggerRemovedConventions: List_1<ITriggerRemovedConvention>;
    readonly TypeIgnoredConventions: List_1<ITypeIgnoredConvention>;
    Add(convention: IConvention): void;
    Remove(conventionType: Type): void;
    Replace<TImplementation extends unknown & IConvention>(newConvention: TImplementation): void;
}


export const ConventionSet: {
    new(): ConventionSet;
    AddAfter<TConvention extends unknown>(conventionsList: List_1<TConvention>, newConvention: TConvention, existingConventionType: Type): boolean;
    AddBefore<TConvention extends unknown>(conventionsList: List_1<TConvention>, newConvention: TConvention, existingConventionType: Type): boolean;
    CreateConventionSet(context: DbContext): ConventionSet;
    Remove<TConvention extends unknown>(conventionsList: List_1<TConvention>, existingConventionType: Type): boolean;
    Replace<TConvention extends unknown, TImplementation extends unknown & TConvention>(conventionsList: List_1<TConvention>, newConvention: TImplementation): boolean;
};


export type ConventionSet = ConventionSet$instance;

export interface DatabaseGeneratedAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<DatabaseGeneratedAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_DatabaseGeneratedAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: DatabaseGeneratedAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: DatabaseGeneratedAttribute, clrMember: MemberInfo, context: IConventionContext): void;
}


export const DatabaseGeneratedAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): DatabaseGeneratedAttributeConvention;
};


export interface __DatabaseGeneratedAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type DatabaseGeneratedAttributeConvention = DatabaseGeneratedAttributeConvention$instance & __DatabaseGeneratedAttributeConvention$views;


export interface DbSetFindingConvention$instance extends IModelInitializedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_DbSetFindingConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelInitializedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessModelInitialized(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const DbSetFindingConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): DbSetFindingConvention;
};


export interface __DbSetFindingConvention$views {
    As_IModelInitializedConvention(): IModelInitializedConvention$instance;
}

export type DbSetFindingConvention = DbSetFindingConvention$instance & __DbSetFindingConvention$views;


export interface DeleteBehaviorAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<DeleteBehaviorAttribute>, IComplexPropertyAddedConvention$instance, IForeignKeyPrincipalEndChangedConvention$instance, IModelFinalizingConvention$instance, INavigationAddedConvention$instance, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_DeleteBehaviorAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPrincipalEndChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessForeignKeyPrincipalEndChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: DeleteBehaviorAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: DeleteBehaviorAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export const DeleteBehaviorAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): DeleteBehaviorAttributeConvention;
};


export interface __DeleteBehaviorAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IForeignKeyPrincipalEndChangedConvention(): IForeignKeyPrincipalEndChangedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type DeleteBehaviorAttributeConvention = DeleteBehaviorAttributeConvention$instance & __DeleteBehaviorAttributeConvention$views;


export interface DiscriminatorConvention$instance extends IEntityTypeBaseTypeChangedConvention$instance, IEntityTypeRemovedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_DiscriminatorConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IDiscriminatorPropertySetConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeRemovedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessDiscriminatorPropertySet(structuralTypeBuilder: IConventionTypeBaseBuilder, name: string | null, context: IConventionContext_1<System_Internal.String>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeRemoved(modelBuilder: IConventionModelBuilder, entityType: IConventionEntityType, context: IConventionContext_1<IConventionEntityType>): void;
    SetDefaultDiscriminatorValue(complexType: IConventionComplexType, discriminatorBuilder: IConventionComplexTypeDiscriminatorBuilder): void;
    SetDefaultDiscriminatorValues(entityTypes: IEnumerable_1<IConventionEntityType>, discriminatorBuilder: IConventionDiscriminatorBuilder): void;
}


export const DiscriminatorConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): DiscriminatorConvention;
};


export interface __DiscriminatorConvention$views {
    As_IDiscriminatorPropertySetConvention(): IDiscriminatorPropertySetConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IEntityTypeRemovedConvention(): IEntityTypeRemovedConvention$instance;
}

export type DiscriminatorConvention = DiscriminatorConvention$instance & __DiscriminatorConvention$views;


export interface DiscriminatorLengthConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_DiscriminatorLengthConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const DiscriminatorLengthConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): DiscriminatorLengthConvention;
};


export interface __DiscriminatorLengthConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type DiscriminatorLengthConvention = DiscriminatorLengthConvention$instance & __DiscriminatorLengthConvention$views;


export interface ElementMappingConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ElementMappingConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const ElementMappingConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ElementMappingConvention;
};


export interface __ElementMappingConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type ElementMappingConvention = ElementMappingConvention$instance & __ElementMappingConvention$views;


export interface ElementTypeChangedConvention$instance extends IForeignKeyAddedConvention$instance, IForeignKeyPropertiesChangedConvention$instance, IPropertyElementTypeChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ElementTypeChangedConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyElementTypeChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessForeignKeyAdded(foreignKeyBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyPropertiesChanged(relationshipBuilder: IConventionForeignKeyBuilder, oldDependentProperties: IReadOnlyList_1<IConventionProperty>, oldPrincipalKey: IConventionKey, context: IConventionContext_1<IReadOnlyList_1<IConventionProperty>>): void;
    ProcessPropertyElementTypeChanged(propertyBuilder: IConventionPropertyBuilder, newElementType: IElementType | null, oldElementType: IElementType | null, context: IConventionContext_1<IElementType>): void;
}


export const ElementTypeChangedConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ElementTypeChangedConvention;
};


export interface __ElementTypeChangedConvention$views {
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IForeignKeyPropertiesChangedConvention(): IForeignKeyPropertiesChangedConvention$instance;
    As_IPropertyElementTypeChangedConvention(): IPropertyElementTypeChangedConvention$instance;
}

export type ElementTypeChangedConvention = ElementTypeChangedConvention$instance & __ElementTypeChangedConvention$views;


export interface EntitySplittingConvention$instance extends IEntityTypeAddedConvention$instance, IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_EntitySplittingConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const EntitySplittingConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): EntitySplittingConvention;
};


export interface __EntitySplittingConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type EntitySplittingConvention = EntitySplittingConvention$instance & __EntitySplittingConvention$views;


export interface EntityTypeConfigurationAttributeConvention$instance extends TypeAttributeConventionBase_1$instance<EntityTypeConfigurationAttribute>, IComplexPropertyAddedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_EntityTypeConfigurationAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    ProcessComplexTypeAdded(complexTypeBuilder: IConventionComplexTypeBuilder, attribute: EntityTypeConfigurationAttribute, context: IConventionContext): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, attribute: EntityTypeConfigurationAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export const EntityTypeConfigurationAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): EntityTypeConfigurationAttributeConvention;
};


export interface __EntityTypeConfigurationAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type EntityTypeConfigurationAttributeConvention = EntityTypeConfigurationAttributeConvention$instance & __EntityTypeConfigurationAttributeConvention$views;


export interface EntityTypeHierarchyMappingConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_EntityTypeHierarchyMappingConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const EntityTypeHierarchyMappingConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): EntityTypeHierarchyMappingConvention;
};


export interface __EntityTypeHierarchyMappingConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type EntityTypeHierarchyMappingConvention = EntityTypeHierarchyMappingConvention$instance & __EntityTypeHierarchyMappingConvention$views;


export interface ForeignKeyAttributeConvention$instance extends IComplexPropertyAddedConvention$instance, IEntityTypeAddedConvention$instance, IForeignKeyAddedConvention$instance, IModelFinalizingConvention$instance, INavigationAddedConvention$instance, IPropertyAddedConvention$instance, ISkipNavigationForeignKeyChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ForeignKeyAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationForeignKeyChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessForeignKeyAdded(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessSkipNavigationForeignKeyChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, foreignKey: IConventionForeignKey | null, oldForeignKey: IConventionForeignKey | null, context: IConventionContext_1<IConventionForeignKey>): void;
}


export const ForeignKeyAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ForeignKeyAttributeConvention;
};


export interface __ForeignKeyAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_ISkipNavigationForeignKeyChangedConvention(): ISkipNavigationForeignKeyChangedConvention$instance;
}

export type ForeignKeyAttributeConvention = ForeignKeyAttributeConvention$instance & __ForeignKeyAttributeConvention$views;


export interface ForeignKeyIndexConvention$instance extends IEntityTypeBaseTypeChangedConvention$instance, IForeignKeyAddedConvention$instance, IForeignKeyPropertiesChangedConvention$instance, IForeignKeyRemovedConvention$instance, IForeignKeyUniquenessChangedConvention$instance, IIndexAddedConvention$instance, IIndexRemovedConvention$instance, IIndexUniquenessChangedConvention$instance, IKeyAddedConvention$instance, IKeyRemovedConvention$instance, IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ForeignKeyIndexConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyUniquenessChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IIndexAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IIndexRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IIndexUniquenessChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    AreIndexedBy(properties: IReadOnlyList_1<IConventionProperty>, unique: boolean, coveringIndexProperties: IReadOnlyList_1<IConventionProperty>, coveringIndexUnique: boolean): boolean;
    CreateIndex(properties: IReadOnlyList_1<IConventionProperty>, unique: boolean, entityTypeBuilder: IConventionEntityTypeBuilder): IConventionIndex | null;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessForeignKeyAdded(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyPropertiesChanged(relationshipBuilder: IConventionForeignKeyBuilder, oldDependentProperties: IReadOnlyList_1<IConventionProperty>, oldPrincipalKey: IConventionKey, context: IConventionContext_1<IReadOnlyList_1<IConventionProperty>>): void;
    ProcessForeignKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, foreignKey: IConventionForeignKey, context: IConventionContext_1<IConventionForeignKey>): void;
    ProcessForeignKeyUniquenessChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessIndexAdded(indexBuilder: IConventionIndexBuilder, context: IConventionContext_1<IConventionIndexBuilder>): void;
    ProcessIndexRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, index: IConventionIndex, context: IConventionContext_1<IConventionIndex>): void;
    ProcessIndexUniquenessChanged(indexBuilder: IConventionIndexBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessKeyAdded(keyBuilder: IConventionKeyBuilder, context: IConventionContext_1<IConventionKeyBuilder>): void;
    ProcessKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, key: IConventionKey, context: IConventionContext_1<IConventionKey>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const ForeignKeyIndexConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ForeignKeyIndexConvention;
};


export interface __ForeignKeyIndexConvention$views {
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IForeignKeyPropertiesChangedConvention(): IForeignKeyPropertiesChangedConvention$instance;
    As_IForeignKeyRemovedConvention(): IForeignKeyRemovedConvention$instance;
    As_IForeignKeyUniquenessChangedConvention(): IForeignKeyUniquenessChangedConvention$instance;
    As_IIndexAddedConvention(): IIndexAddedConvention$instance;
    As_IIndexRemovedConvention(): IIndexRemovedConvention$instance;
    As_IIndexUniquenessChangedConvention(): IIndexUniquenessChangedConvention$instance;
    As_IKeyAddedConvention(): IKeyAddedConvention$instance;
    As_IKeyRemovedConvention(): IKeyRemovedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type ForeignKeyIndexConvention = ForeignKeyIndexConvention$instance & __ForeignKeyIndexConvention$views;


export interface ForeignKeyPropertyDiscoveryConvention$instance extends IEntityTypeMemberIgnoredConvention$instance, IEntityTypePrimaryKeyChangedConvention$instance, IForeignKeyAddedConvention$instance, IForeignKeyPrincipalEndChangedConvention$instance, IForeignKeyPropertiesChangedConvention$instance, IForeignKeyRequirednessChangedConvention$instance, IForeignKeyUniquenessChangedConvention$instance, IKeyAddedConvention$instance, IKeyRemovedConvention$instance, IModelFinalizingConvention$instance, INavigationAddedConvention$instance, IPropertyAddedConvention$instance, IPropertyFieldChangedConvention$instance, IPropertyNullabilityChangedConvention$instance, ISkipNavigationForeignKeyChangedConvention$instance, ISkipNavigationInverseChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ForeignKeyPropertyDiscoveryConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeMemberIgnoredConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypePrimaryKeyChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPrincipalEndChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRequirednessChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyUniquenessChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyNullabilityChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationForeignKeyChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationInverseChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, context: IConventionContext_1<System_Internal.String>): void;
    ProcessEntityTypePrimaryKeyChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newPrimaryKey: IConventionKey | null, previousPrimaryKey: IConventionKey | null, context: IConventionContext_1<IConventionKey>): void;
    ProcessForeignKeyAdded(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyPrincipalEndChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyPropertiesChanged(relationshipBuilder: IConventionForeignKeyBuilder, oldDependentProperties: IReadOnlyList_1<IConventionProperty>, oldPrincipalKey: IConventionKey, context: IConventionContext_1<IReadOnlyList_1<IConventionProperty>>): void;
    ProcessForeignKeyRequirednessChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessForeignKeyUniquenessChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessKeyAdded(keyBuilder: IConventionKeyBuilder, context: IConventionContext_1<IConventionKeyBuilder>): void;
    ProcessKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, key: IConventionKey, context: IConventionContext_1<IConventionKey>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyFieldChanged(propertyBuilder: IConventionPropertyBuilder, newFieldInfo: FieldInfo | null, oldFieldInfo: FieldInfo | null, context: IConventionContext_1<FieldInfo>): void;
    ProcessPropertyNullabilityChanged(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessSkipNavigationForeignKeyChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, foreignKey: IConventionForeignKey | null, oldForeignKey: IConventionForeignKey | null, context: IConventionContext_1<IConventionForeignKey>): void;
    ProcessSkipNavigationInverseChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, inverse: IConventionSkipNavigation | null, oldInverse: IConventionSkipNavigation | null, context: IConventionContext_1<IConventionSkipNavigation>): void;
}


export const ForeignKeyPropertyDiscoveryConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ForeignKeyPropertyDiscoveryConvention;
    GetPropertyBaseName(foreignKey: IReadOnlyForeignKey): string;
};


export interface __ForeignKeyPropertyDiscoveryConvention$views {
    As_IEntityTypeMemberIgnoredConvention(): IEntityTypeMemberIgnoredConvention$instance;
    As_IEntityTypePrimaryKeyChangedConvention(): IEntityTypePrimaryKeyChangedConvention$instance;
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IForeignKeyPrincipalEndChangedConvention(): IForeignKeyPrincipalEndChangedConvention$instance;
    As_IForeignKeyPropertiesChangedConvention(): IForeignKeyPropertiesChangedConvention$instance;
    As_IForeignKeyRequirednessChangedConvention(): IForeignKeyRequirednessChangedConvention$instance;
    As_IForeignKeyUniquenessChangedConvention(): IForeignKeyUniquenessChangedConvention$instance;
    As_IKeyAddedConvention(): IKeyAddedConvention$instance;
    As_IKeyRemovedConvention(): IKeyRemovedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
    As_IPropertyNullabilityChangedConvention(): IPropertyNullabilityChangedConvention$instance;
    As_ISkipNavigationForeignKeyChangedConvention(): ISkipNavigationForeignKeyChangedConvention$instance;
    As_ISkipNavigationInverseChangedConvention(): ISkipNavigationInverseChangedConvention$instance;
}

export type ForeignKeyPropertyDiscoveryConvention = ForeignKeyPropertyDiscoveryConvention$instance & __ForeignKeyPropertyDiscoveryConvention$views;


export interface IndexAttributeConvention$instance extends IEntityTypeAddedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance, IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_IndexAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const IndexAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): IndexAttributeConvention;
};


export interface __IndexAttributeConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type IndexAttributeConvention = IndexAttributeConvention$instance & __IndexAttributeConvention$views;


export interface InversePropertyAttributeConvention$instance extends NavigationAttributeConventionBase_1<InversePropertyAttribute>, IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_InversePropertyAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeMemberIgnoredConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;

    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: InversePropertyAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: InversePropertyAttribute, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, context: IConventionContext_1<System_Internal.String>): void;
    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: InversePropertyAttribute, context: IConventionContext_1<System_Internal.String>): void;
    ProcessEntityTypeRemoved(modelBuilder: IConventionModelBuilder, entityType: IConventionEntityType, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: InversePropertyAttribute, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeRemoved(modelBuilder: IConventionModelBuilder, entityType: IConventionEntityType, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, attribute: InversePropertyAttribute, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    TryGetTargetEntityTypeBuilder(entityTypeBuilder: IConventionEntityTypeBuilder, targetClrType: Type, navigationMemberInfo: MemberInfo, shouldCreate?: boolean): IConventionEntityTypeBuilder | null;
}


export const InversePropertyAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): InversePropertyAttributeConvention;
    IsAmbiguous(entityType: IConventionEntityType, navigation: MemberInfo, targetEntityType: IConventionEntityType): boolean;
};


export interface __InversePropertyAttributeConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IEntityTypeMemberIgnoredConvention(): IEntityTypeMemberIgnoredConvention$instance;
    As_IEntityTypeRemovedConvention(): IEntityTypeRemovedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
}

export type InversePropertyAttributeConvention = InversePropertyAttributeConvention$instance & __InversePropertyAttributeConvention$views;


export interface KeyAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<KeyAttribute>, IComplexPropertyAddedConvention$instance, IEntityTypeAddedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance, IModelFinalizingConvention$instance, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_KeyAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: KeyAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: KeyAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export const KeyAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): KeyAttributeConvention;
};


export interface __KeyAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type KeyAttributeConvention = KeyAttributeConvention$instance & __KeyAttributeConvention$views;


export interface KeyDiscoveryConvention$instance extends IEntityTypeAddedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance, IEntityTypeMemberIgnoredConvention$instance, IForeignKeyAddedConvention$instance, IForeignKeyOwnershipChangedConvention$instance, IForeignKeyPropertiesChangedConvention$instance, IForeignKeyRemovedConvention$instance, IForeignKeyUniquenessChangedConvention$instance, IKeyRemovedConvention$instance, IPropertyAddedConvention$instance, ISkipNavigationForeignKeyChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_KeyDiscoveryConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeMemberIgnoredConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyOwnershipChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyUniquenessChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationForeignKeyChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    DiscoverKeyProperties(entityType: IConventionEntityType): List_1<IConventionProperty> | null;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, context: IConventionContext_1<System_Internal.String>): void;
    ProcessForeignKeyAdded(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyOwnershipChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessForeignKeyPropertiesChanged(relationshipBuilder: IConventionForeignKeyBuilder, oldDependentProperties: IReadOnlyList_1<IConventionProperty>, oldPrincipalKey: IConventionKey, context: IConventionContext_1<IReadOnlyList_1<IConventionProperty>>): void;
    ProcessForeignKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, foreignKey: IConventionForeignKey, context: IConventionContext_1<IConventionForeignKey>): void;
    ProcessForeignKeyUniquenessChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessKeyProperties(keyProperties: IList_1<IConventionProperty>, entityType: IConventionEntityType): void;
    ProcessKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, key: IConventionKey, context: IConventionContext_1<IConventionKey>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessSkipNavigationForeignKeyChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, foreignKey: IConventionForeignKey | null, oldForeignKey: IConventionForeignKey | null, context: IConventionContext_1<IConventionForeignKey>): void;
    ShouldDiscoverKeyProperties(entityType: IConventionEntityType): boolean;
    TryConfigurePrimaryKey(entityTypeBuilder: IConventionEntityTypeBuilder): void;
}


export const KeyDiscoveryConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): KeyDiscoveryConvention;
    DiscoverKeyProperties(entityType: IConventionEntityType, candidateProperties: IEnumerable_1<IConventionProperty>): IEnumerable_1<IConventionProperty>;
};


export interface __KeyDiscoveryConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IEntityTypeMemberIgnoredConvention(): IEntityTypeMemberIgnoredConvention$instance;
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IForeignKeyOwnershipChangedConvention(): IForeignKeyOwnershipChangedConvention$instance;
    As_IForeignKeyPropertiesChangedConvention(): IForeignKeyPropertiesChangedConvention$instance;
    As_IForeignKeyRemovedConvention(): IForeignKeyRemovedConvention$instance;
    As_IForeignKeyUniquenessChangedConvention(): IForeignKeyUniquenessChangedConvention$instance;
    As_IKeyRemovedConvention(): IKeyRemovedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_ISkipNavigationForeignKeyChangedConvention(): ISkipNavigationForeignKeyChangedConvention$instance;
}

export type KeyDiscoveryConvention = KeyDiscoveryConvention$instance & __KeyDiscoveryConvention$views;


export interface KeylessAttributeConvention$instance extends TypeAttributeConventionBase_1$instance<KeylessAttribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_KeylessAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, attribute: KeylessAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export const KeylessAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): KeylessAttributeConvention;
};


export interface __KeylessAttributeConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type KeylessAttributeConvention = KeylessAttributeConvention$instance & __KeylessAttributeConvention$views;


export interface ManyToManyJoinEntityTypeConvention$instance extends ISkipNavigationAddedConvention$instance, ISkipNavigationForeignKeyChangedConvention$instance, ISkipNavigationInverseChangedConvention$instance, ISkipNavigationRemovedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ManyToManyJoinEntityTypeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationForeignKeyChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationInverseChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationRemovedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    CreateJoinEntityType(joinEntityTypeName: string, skipNavigation: IConventionSkipNavigation): void;
    CreateSkipNavigationForeignKey(skipNavigation: IConventionSkipNavigation, joinEntityTypeBuilder: IConventionEntityTypeBuilder): IConventionForeignKey;
    GenerateJoinTypeName(skipNavigation: IConventionSkipNavigation): string;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
    ProcessSkipNavigationForeignKeyChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, foreignKey: IConventionForeignKey | null, oldForeignKey: IConventionForeignKey | null, context: IConventionContext_1<IConventionForeignKey>): void;
    ProcessSkipNavigationInverseChanged(skipNavigationBuilder: IConventionSkipNavigationBuilder, inverse: IConventionSkipNavigation | null, oldInverse: IConventionSkipNavigation | null, context: IConventionContext_1<IConventionSkipNavigation>): void;
    ProcessSkipNavigationRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, navigation: IConventionSkipNavigation, context: IConventionContext_1<IConventionSkipNavigation>): void;
    ShouldCreateJoinType(skipNavigation: IConventionSkipNavigation): boolean;
}


export const ManyToManyJoinEntityTypeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ManyToManyJoinEntityTypeConvention;
};


export interface __ManyToManyJoinEntityTypeConvention$views {
    As_ISkipNavigationAddedConvention(): ISkipNavigationAddedConvention$instance;
    As_ISkipNavigationForeignKeyChangedConvention(): ISkipNavigationForeignKeyChangedConvention$instance;
    As_ISkipNavigationInverseChangedConvention(): ISkipNavigationInverseChangedConvention$instance;
    As_ISkipNavigationRemovedConvention(): ISkipNavigationRemovedConvention$instance;
}

export type ManyToManyJoinEntityTypeConvention = ManyToManyJoinEntityTypeConvention$instance & __ManyToManyJoinEntityTypeConvention$views;


export interface MaxLengthAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<MaxLengthAttribute>, IComplexPropertyAddedConvention$instance, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_MaxLengthAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: MaxLengthAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: MaxLengthAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export const MaxLengthAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): MaxLengthAttributeConvention;
};


export interface __MaxLengthAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type MaxLengthAttributeConvention = MaxLengthAttributeConvention$instance & __MaxLengthAttributeConvention$views;


export interface ModelCleanupConvention$instance extends IForeignKeyRemovedConvention$instance, IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ModelCleanupConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessForeignKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, foreignKey: IConventionForeignKey, context: IConventionContext_1<IConventionForeignKey>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const ModelCleanupConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ModelCleanupConvention;
};


export interface __ModelCleanupConvention$views {
    As_IForeignKeyRemovedConvention(): IForeignKeyRemovedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type ModelCleanupConvention = ModelCleanupConvention$instance & __ModelCleanupConvention$views;


export interface NavigationAttributeConventionBase_1$instance<TAttribute extends unknown & Attribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_NavigationAttributeConventionBase_1: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: TAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: TAttribute, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, context: IConventionContext_1<System_Internal.String>): void;
    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: TAttribute, context: IConventionContext_1<System_Internal.String>): void;
    ProcessEntityTypeRemoved(modelBuilder: IConventionModelBuilder, entityType: IConventionEntityType, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeRemoved(modelBuilder: IConventionModelBuilder, entityType: IConventionEntityType, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: TAttribute, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessForeignKeyPrincipalEndChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyPrincipalEndChanged(relationshipBuilder: IConventionForeignKeyBuilder, dependentToPrincipalAttributes: IEnumerable_1<TAttribute> | null, principalToDependentAttributes: IEnumerable_1<TAttribute> | null, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, attribute: TAttribute, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, attribute: TAttribute, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
    ProcessTypeIgnored(modelBuilder: IConventionModelBuilder, name: string, type: Type | null, context: IConventionContext_1<System_Internal.String>): void;
    ProcessTypeIgnored(modelBuilder: IConventionModelBuilder, type: Type, navigationMemberInfo: MemberInfo, targetClrType: Type, attribute: TAttribute, context: IConventionContext_1<System_Internal.String>): void;
}


export const NavigationAttributeConventionBase_1: (abstract new<TAttribute extends unknown & Attribute>(dependencies: ProviderConventionSetBuilderDependencies) => NavigationAttributeConventionBase_1<TAttribute>) & {
    GetAttributes<TAttribute extends unknown & Attribute, TCustomAttribute extends unknown & Attribute>(entityType: IConventionEntityType, navigation: IConventionNavigation): IEnumerable_1<TCustomAttribute>;
    GetAttributes<TAttribute extends unknown & Attribute, TCustomAttribute extends unknown & Attribute>(entityType: IConventionEntityType, skipNavigation: IConventionSkipNavigation): IEnumerable_1<TCustomAttribute>;
};


export type NavigationAttributeConventionBase_1<TAttribute extends unknown & Attribute> = NavigationAttributeConventionBase_1$instance<TAttribute>;

export interface NavigationBackingFieldAttributeConvention$instance extends NavigationAttributeConventionBase_1<BackingFieldAttribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_NavigationBackingFieldAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationAddedConvention: never;

    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, attribute: BackingFieldAttribute, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, attribute: BackingFieldAttribute, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
}


export const NavigationBackingFieldAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): NavigationBackingFieldAttributeConvention;
};


export interface __NavigationBackingFieldAttributeConvention$views {
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
    As_ISkipNavigationAddedConvention(): ISkipNavigationAddedConvention$instance;
}

export type NavigationBackingFieldAttributeConvention = NavigationBackingFieldAttributeConvention$instance & __NavigationBackingFieldAttributeConvention$views;


export interface NavigationEagerLoadingConvention$instance extends IForeignKeyOwnershipChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_NavigationEagerLoadingConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyOwnershipChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessForeignKeyOwnershipChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
}


export const NavigationEagerLoadingConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): NavigationEagerLoadingConvention;
};


export interface __NavigationEagerLoadingConvention$views {
    As_IForeignKeyOwnershipChangedConvention(): IForeignKeyOwnershipChangedConvention$instance;
}

export type NavigationEagerLoadingConvention = NavigationEagerLoadingConvention$instance & __NavigationEagerLoadingConvention$views;


export interface NonNullableConventionBase$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_NonNullableConventionBase: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    TryGetNullabilityInfo(modelBuilder: IConventionModelBuilder, memberInfo: MemberInfo, nullabilityInfo: NullabilityInfo | null): boolean;
}


export const NonNullableConventionBase: (abstract new(dependencies: ProviderConventionSetBuilderDependencies) => NonNullableConventionBase) & {
};


export type NonNullableConventionBase = NonNullableConventionBase$instance;

export interface NonNullableNavigationConvention$instance extends NonNullableConventionBase, IForeignKeyPrincipalEndChangedConvention$instance, INavigationAddedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_NonNullableNavigationConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPrincipalEndChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;

    ProcessForeignKeyPrincipalEndChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
}


export const NonNullableNavigationConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): NonNullableNavigationConvention;
};


export interface __NonNullableNavigationConvention$views {
    As_IForeignKeyPrincipalEndChangedConvention(): IForeignKeyPrincipalEndChangedConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
}

export type NonNullableNavigationConvention = NonNullableNavigationConvention$instance & __NonNullableNavigationConvention$views;


export interface NonNullableReferencePropertyConvention$instance extends NonNullableConventionBase, IComplexPropertyAddedConvention$instance, IComplexPropertyFieldChangedConvention$instance, IPropertyAddedConvention$instance, IPropertyElementTypeChangedConvention$instance, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_NonNullableReferencePropertyConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyFieldChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyElementTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessComplexPropertyFieldChanged(propertyBuilder: IConventionComplexPropertyBuilder, newFieldInfo: FieldInfo | null, oldFieldInfo: FieldInfo | null, context: IConventionContext_1<FieldInfo>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyElementTypeChanged(propertyBuilder: IConventionPropertyBuilder, newElementType: IElementType | null, oldElementType: IElementType | null, context: IConventionContext_1<IElementType>): void;
    ProcessPropertyFieldChanged(propertyBuilder: IConventionPropertyBuilder, newFieldInfo: FieldInfo | null, oldFieldInfo: FieldInfo | null, context: IConventionContext_1<FieldInfo>): void;
}


export const NonNullableReferencePropertyConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): NonNullableReferencePropertyConvention;
};


export interface __NonNullableReferencePropertyConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IComplexPropertyFieldChangedConvention(): IComplexPropertyFieldChangedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyElementTypeChangedConvention(): IPropertyElementTypeChangedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type NonNullableReferencePropertyConvention = NonNullableReferencePropertyConvention$instance & __NonNullableReferencePropertyConvention$views;


export interface NotMappedMemberAttributeConvention$instance extends IComplexPropertyAddedConvention$instance, IEntityTypeAddedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_NotMappedMemberAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ShouldIgnore(memberInfo: MemberInfo): boolean;
}


export const NotMappedMemberAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): NotMappedMemberAttributeConvention;
};


export interface __NotMappedMemberAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type NotMappedMemberAttributeConvention = NotMappedMemberAttributeConvention$instance & __NotMappedMemberAttributeConvention$views;


export interface NotMappedTypeAttributeConvention$instance extends TypeAttributeConventionBase_1$instance<NotMappedAttribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_NotMappedTypeAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, attribute: NotMappedAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export const NotMappedTypeAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): NotMappedTypeAttributeConvention;
};


export interface __NotMappedTypeAttributeConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type NotMappedTypeAttributeConvention = NotMappedTypeAttributeConvention$instance & __NotMappedTypeAttributeConvention$views;


export interface OwnedAttributeConvention$instance extends TypeAttributeConventionBase_1$instance<OwnedAttribute>, IComplexPropertyAddedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_OwnedAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    ProcessComplexTypeAdded(complexTypeBuilder: IConventionComplexTypeBuilder, attribute: OwnedAttribute, context: IConventionContext): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, attribute: OwnedAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export const OwnedAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): OwnedAttributeConvention;
};


export interface __OwnedAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type OwnedAttributeConvention = OwnedAttributeConvention$instance & __OwnedAttributeConvention$views;


export interface PrecisionAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<PrecisionAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_PrecisionAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: PrecisionAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: PrecisionAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export const PrecisionAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): PrecisionAttributeConvention;
};


export interface __PrecisionAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type PrecisionAttributeConvention = PrecisionAttributeConvention$instance & __PrecisionAttributeConvention$views;


export interface PropertyAttributeConventionBase_1$instance<TAttribute extends unknown & Attribute> extends IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_PropertyAttributeConventionBase_1: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessComplexPropertyFieldChanged(propertyBuilder: IConventionComplexPropertyBuilder, newFieldInfo: FieldInfo | null, oldFieldInfo: FieldInfo | null, context: IConventionContext_1<FieldInfo>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: TAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: TAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyFieldChanged(propertyBuilder: IConventionPropertyBuilder, newFieldInfo: FieldInfo | null, oldFieldInfo: FieldInfo | null, context: IConventionContext_1<FieldInfo>): void;
}


export const PropertyAttributeConventionBase_1: (abstract new<TAttribute extends unknown & Attribute>(dependencies: ProviderConventionSetBuilderDependencies) => PropertyAttributeConventionBase_1<TAttribute>) & {
};


export interface __PropertyAttributeConventionBase_1$views<TAttribute extends unknown & Attribute> {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type PropertyAttributeConventionBase_1<TAttribute extends unknown & Attribute> = PropertyAttributeConventionBase_1$instance<TAttribute> & __PropertyAttributeConventionBase_1$views<TAttribute>;


export interface PropertyDiscoveryConvention$instance extends IComplexPropertyAddedConvention$instance, IEntityTypeAddedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_PropertyDiscoveryConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly UseAttributes: boolean;
    DiscoverPrimitiveProperties(structuralTypeBuilder: IConventionTypeBaseBuilder, context: IConventionContext): void;
    GetMembers(structuralType: IConventionTypeBase): IEnumerable_1<MemberInfo>;
    IsCandidatePrimitiveProperty(memberInfo: MemberInfo, structuralType: IConventionTypeBase, mapping: CoreTypeMapping | null): boolean;
    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
}


export const PropertyDiscoveryConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, useAttributes: boolean): PropertyDiscoveryConvention;
};


export interface __PropertyDiscoveryConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
}

export type PropertyDiscoveryConvention = PropertyDiscoveryConvention$instance & __PropertyDiscoveryConvention$views;


export interface PropertyOverridesConvention$instance extends IPropertyAddedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_PropertyOverridesConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export const PropertyOverridesConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): PropertyOverridesConvention;
};


export interface __PropertyOverridesConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
}

export type PropertyOverridesConvention = PropertyOverridesConvention$instance & __PropertyOverridesConvention$views;


export interface QueryFilterRewritingConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_QueryFilterRewritingConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    DbSetAccessRewriter: QueryFilterRewritingConvention_DbSetAccessRewritingExpressionVisitor;
    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const QueryFilterRewritingConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): QueryFilterRewritingConvention;
};


export interface __QueryFilterRewritingConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type QueryFilterRewritingConvention = QueryFilterRewritingConvention$instance & __QueryFilterRewritingConvention$views;


export interface QueryFilterRewritingConvention_DbSetAccessRewritingExpressionVisitor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_QueryFilterRewritingConvention_DbSetAccessRewritingExpressionVisitor: never;

    Rewrite(model: IReadOnlyModel, expression: Expression): Expression;
    VisitMember(memberExpression: MemberExpression): Expression;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
}


export const QueryFilterRewritingConvention_DbSetAccessRewritingExpressionVisitor: {
    new(contextType: Type): QueryFilterRewritingConvention_DbSetAccessRewritingExpressionVisitor;
};


export type QueryFilterRewritingConvention_DbSetAccessRewritingExpressionVisitor = QueryFilterRewritingConvention_DbSetAccessRewritingExpressionVisitor$instance;

export interface RelationalColumnAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<ColumnAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalColumnAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: ColumnAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: ColumnAttribute, clrMember: MemberInfo, context: IConventionContext): void;
}


export const RelationalColumnAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalColumnAttributeConvention;
};


export interface __RelationalColumnAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type RelationalColumnAttributeConvention = RelationalColumnAttributeConvention$instance & __RelationalColumnAttributeConvention$views;


export interface RelationalColumnCommentAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<CommentAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalColumnCommentAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: CommentAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: CommentAttribute, clrMember: MemberInfo, context: IConventionContext): void;
}


export const RelationalColumnCommentAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalColumnCommentAttributeConvention;
};


export interface __RelationalColumnCommentAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type RelationalColumnCommentAttributeConvention = RelationalColumnCommentAttributeConvention$instance & __RelationalColumnCommentAttributeConvention$views;


export interface RelationalDbFunctionAttributeConvention$instance extends IModelFinalizingConvention$instance, IModelInitializedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalDbFunctionAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelInitializedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessDbFunctionAdded(dbFunctionBuilder: IConventionDbFunctionBuilder, context: IConventionContext): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessModelInitialized(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const RelationalDbFunctionAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalDbFunctionAttributeConvention;
};


export interface __RelationalDbFunctionAttributeConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_IModelInitializedConvention(): IModelInitializedConvention$instance;
}

export type RelationalDbFunctionAttributeConvention = RelationalDbFunctionAttributeConvention$instance & __RelationalDbFunctionAttributeConvention$views;


export interface RelationalKeyDiscoveryConvention$instance extends KeyDiscoveryConvention$instance, IEntityTypeAddedConvention$instance, IEntityTypeAnnotationChangedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance, IEntityTypeMemberIgnoredConvention$instance, IForeignKeyAddedConvention$instance, IForeignKeyOwnershipChangedConvention$instance, IForeignKeyPropertiesChangedConvention$instance, IForeignKeyRemovedConvention$instance, IForeignKeyUniquenessChangedConvention$instance, IKeyRemovedConvention$instance, IPropertyAddedConvention$instance, ISkipNavigationForeignKeyChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalKeyDiscoveryConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAnnotationChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeMemberIgnoredConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyOwnershipChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyUniquenessChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationForeignKeyChangedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    DiscoverKeyProperties(entityType: IConventionEntityType): List_1<IConventionProperty> | null;
    ProcessEntityTypeAnnotationChanged(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
    ProcessKeyProperties(keyProperties: IList_1<IConventionProperty>, entityType: IConventionEntityType): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export const RelationalKeyDiscoveryConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalKeyDiscoveryConvention;
    readonly SynthesizedOrdinalPropertyName: string;
};


export interface __RelationalKeyDiscoveryConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeAnnotationChangedConvention(): IEntityTypeAnnotationChangedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IEntityTypeMemberIgnoredConvention(): IEntityTypeMemberIgnoredConvention$instance;
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IForeignKeyOwnershipChangedConvention(): IForeignKeyOwnershipChangedConvention$instance;
    As_IForeignKeyPropertiesChangedConvention(): IForeignKeyPropertiesChangedConvention$instance;
    As_IForeignKeyRemovedConvention(): IForeignKeyRemovedConvention$instance;
    As_IForeignKeyUniquenessChangedConvention(): IForeignKeyUniquenessChangedConvention$instance;
    As_IKeyRemovedConvention(): IKeyRemovedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_ISkipNavigationForeignKeyChangedConvention(): ISkipNavigationForeignKeyChangedConvention$instance;
}

export type RelationalKeyDiscoveryConvention = RelationalKeyDiscoveryConvention$instance & __RelationalKeyDiscoveryConvention$views;


export interface RelationalMapToJsonConvention$instance extends IEntityTypeAnnotationChangedConvention$instance, IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalMapToJsonConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAnnotationChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessEntityTypeAnnotationChanged(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const RelationalMapToJsonConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalMapToJsonConvention;
};


export interface __RelationalMapToJsonConvention$views {
    As_IEntityTypeAnnotationChangedConvention(): IEntityTypeAnnotationChangedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type RelationalMapToJsonConvention = RelationalMapToJsonConvention$instance & __RelationalMapToJsonConvention$views;


export interface RelationalMaxIdentifierLengthConvention$instance extends IModelInitializedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalMaxIdentifierLengthConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelInitializedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly MaxIdentifierLength: int;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessModelInitialized(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const RelationalMaxIdentifierLengthConvention: {
    new(maxIdentifierLength: int, dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalMaxIdentifierLengthConvention;
};


export interface __RelationalMaxIdentifierLengthConvention$views {
    As_IModelInitializedConvention(): IModelInitializedConvention$instance;
}

export type RelationalMaxIdentifierLengthConvention = RelationalMaxIdentifierLengthConvention$instance & __RelationalMaxIdentifierLengthConvention$views;


export interface RelationalNavigationJsonPropertyNameAttributeConvention$instance extends NavigationAttributeConventionBase_1<JsonPropertyNameAttribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalNavigationJsonPropertyNameAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, attribute: JsonPropertyNameAttribute, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
}


export const RelationalNavigationJsonPropertyNameAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalNavigationJsonPropertyNameAttributeConvention;
};


export interface __RelationalNavigationJsonPropertyNameAttributeConvention$views {
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
}

export type RelationalNavigationJsonPropertyNameAttributeConvention = RelationalNavigationJsonPropertyNameAttributeConvention$instance & __RelationalNavigationJsonPropertyNameAttributeConvention$views;


export interface RelationalPropertyJsonPropertyNameAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<JsonPropertyNameAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalPropertyJsonPropertyNameAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: JsonPropertyNameAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: JsonPropertyNameAttribute, clrMember: MemberInfo, context: IConventionContext): void;
}


export const RelationalPropertyJsonPropertyNameAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalPropertyJsonPropertyNameAttributeConvention;
};


export interface __RelationalPropertyJsonPropertyNameAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type RelationalPropertyJsonPropertyNameAttributeConvention = RelationalPropertyJsonPropertyNameAttributeConvention$instance & __RelationalPropertyJsonPropertyNameAttributeConvention$views;


export interface RelationalQueryFilterRewritingConvention$instance extends QueryFilterRewritingConvention$instance, IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalQueryFilterRewritingConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
}


export const RelationalQueryFilterRewritingConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalQueryFilterRewritingConvention;
};


export interface __RelationalQueryFilterRewritingConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type RelationalQueryFilterRewritingConvention = RelationalQueryFilterRewritingConvention$instance & __RelationalQueryFilterRewritingConvention$views;


export interface RelationalQueryFilterRewritingConvention_RelationalDbSetAccessRewritingExpressionVisitor$instance extends QueryFilterRewritingConvention_DbSetAccessRewritingExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalQueryFilterRewritingConvention_RelationalDbSetAccessRewritingExpressionVisitor: never;

    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
}


export const RelationalQueryFilterRewritingConvention_RelationalDbSetAccessRewritingExpressionVisitor: {
    new(contextType: Type): RelationalQueryFilterRewritingConvention_RelationalDbSetAccessRewritingExpressionVisitor;
};


export type RelationalQueryFilterRewritingConvention_RelationalDbSetAccessRewritingExpressionVisitor = RelationalQueryFilterRewritingConvention_RelationalDbSetAccessRewritingExpressionVisitor$instance;

export interface RelationalRuntimeModelConvention$instance extends RuntimeModelConvention$instance, IModelFinalizedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalRuntimeModelConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessComplexTypeAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, complexType: IComplexType, runtimeComplexType: RuntimeComplexType, runtime: boolean): void;
    ProcessEntityTypeAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, entityType: IEntityType, runtimeEntityType: RuntimeEntityType, runtime: boolean): void;
    ProcessEntityTypeMappingFragmentAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, entityTypeMappingFragment: IEntityTypeMappingFragment, runtimeEntityTypeMappingFragment: RuntimeEntityTypeMappingFragment, runtime: boolean): void;
    ProcessForeignKeyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, foreignKey: IForeignKey, runtimeForeignKey: RuntimeForeignKey, runtime: boolean): void;
    ProcessFunctionAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, function_: IDbFunction, runtimeFunction: RuntimeDbFunction, runtime: boolean): void;
    ProcessFunctionParameterAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, parameter: IDbFunctionParameter, runtimeParameter: RuntimeDbFunctionParameter, runtime: boolean): void;
    ProcessIndexAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, index: IIndex, runtimeIndex: RuntimeIndex, runtime: boolean): void;
    ProcessKeyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, key: IKey, runtimeKey: RuntimeKey, runtime: boolean): void;
    ProcessModelAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, model: IModel, runtimeModel: RuntimeModel, runtime: boolean): void;
    ProcessPropertyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
    ProcessPropertyOverridesAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, propertyOverrides: IRelationalPropertyOverrides, runtimePropertyOverrides: RuntimeRelationalPropertyOverrides, runtime: boolean): void;
    ProcessSequenceAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, sequence: ISequence, runtimeSequence: RuntimeSequence, runtime: boolean): void;
    ProcessStoredProcedureAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, storedProcedure: IStoredProcedure, runtimeStoredProcedure: RuntimeStoredProcedure, runtime: boolean): void;
    ProcessStoredProcedureParameterAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, parameter: IStoredProcedureParameter, runtimeParameter: RuntimeStoredProcedureParameter, runtime: boolean): void;
    ProcessStoredProcedureResultColumnAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, resultColumn: IStoredProcedureResultColumn, runtimeResultColumn: RuntimeStoredProcedureResultColumn, runtime: boolean): void;
}


export const RelationalRuntimeModelConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalRuntimeModelConvention;
};


export interface __RelationalRuntimeModelConvention$views {
    As_IModelFinalizedConvention(): IModelFinalizedConvention$instance;
}

export type RelationalRuntimeModelConvention = RelationalRuntimeModelConvention$instance & __RelationalRuntimeModelConvention$views;


export interface RelationalTableAttributeConvention$instance extends TypeAttributeConventionBase_1$instance<TableAttribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalTableAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, attribute: TableAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export const RelationalTableAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalTableAttributeConvention;
};


export interface __RelationalTableAttributeConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type RelationalTableAttributeConvention = RelationalTableAttributeConvention$instance & __RelationalTableAttributeConvention$views;


export interface RelationalTableCommentAttributeConvention$instance extends TypeAttributeConventionBase_1$instance<CommentAttribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalTableCommentAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, attribute: CommentAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export const RelationalTableCommentAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalTableCommentAttributeConvention;
};


export interface __RelationalTableCommentAttributeConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type RelationalTableCommentAttributeConvention = RelationalTableCommentAttributeConvention$instance & __RelationalTableCommentAttributeConvention$views;


export interface RelationalValueGenerationConvention$instance extends ValueGenerationConvention$instance, IEntityTypeAnnotationChangedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance, IEntityTypePrimaryKeyChangedConvention$instance, IForeignKeyAddedConvention$instance, IForeignKeyOwnershipChangedConvention$instance, IForeignKeyPropertiesChangedConvention$instance, IForeignKeyRemovedConvention$instance, IPropertyAnnotationChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationalValueGenerationConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAnnotationChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypePrimaryKeyChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyOwnershipChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAnnotationChangedConvention: never;

    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    GetValueGenerated(property: IConventionProperty): Nullable_1<ValueGenerated>;
    MappingStrategyAllowsValueGeneration(property: IConventionProperty, mappingStrategy: string | null): boolean;
    ProcessEntityTypeAnnotationChanged(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
    ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
}


export const RelationalValueGenerationConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): RelationalValueGenerationConvention;
};


export interface __RelationalValueGenerationConvention$views {
    As_IEntityTypeAnnotationChangedConvention(): IEntityTypeAnnotationChangedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IEntityTypePrimaryKeyChangedConvention(): IEntityTypePrimaryKeyChangedConvention$instance;
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IForeignKeyOwnershipChangedConvention(): IForeignKeyOwnershipChangedConvention$instance;
    As_IForeignKeyPropertiesChangedConvention(): IForeignKeyPropertiesChangedConvention$instance;
    As_IForeignKeyRemovedConvention(): IForeignKeyRemovedConvention$instance;
    As_IPropertyAnnotationChangedConvention(): IPropertyAnnotationChangedConvention$instance;
}

export type RelationalValueGenerationConvention = RelationalValueGenerationConvention$instance & __RelationalValueGenerationConvention$views;


export interface RelationshipDiscoveryConvention$instance extends IEntityTypeAddedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance, IEntityTypeMemberIgnoredConvention$instance, IForeignKeyNullNavigationSetConvention$instance, IForeignKeyOwnershipChangedConvention$instance, IForeignKeyRemovedConvention$instance, INavigationAddedConvention$instance, INavigationRemovedConvention$instance, ITypeIgnoredConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RelationshipDiscoveryConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeMemberIgnoredConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyNullNavigationSetConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyOwnershipChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationRemovedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ITypeIgnoredConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly UseAttributes: boolean;
    DiscoverRelationships(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext, discoverUnmatchedInverses?: boolean): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypeMemberIgnored(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, context: IConventionContext_1<System_Internal.String>): void;
    ProcessForeignKeyNullNavigationSet(relationshipBuilder: IConventionForeignKeyBuilder, pointsToPrincipal: boolean, context: IConventionContext_1<IConventionNavigation>): void;
    ProcessForeignKeyOwnershipChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessForeignKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, foreignKey: IConventionForeignKey, context: IConventionContext_1<IConventionForeignKey>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessNavigationRemoved(sourceEntityTypeBuilder: IConventionEntityTypeBuilder, targetEntityTypeBuilder: IConventionEntityTypeBuilder, navigationName: string, memberInfo: MemberInfo | null, context: IConventionContext_1<System_Internal.String>): void;
    ProcessTypeIgnored(modelBuilder: IConventionModelBuilder, name: string, type: Type | null, context: IConventionContext_1<System_Internal.String>): void;
    ShouldBeOwned(targetType: Type, model: IConventionModel): Nullable_1<System_Internal.Boolean>;
    TryGetTargetEntityTypeBuilder(entityTypeBuilder: IConventionEntityTypeBuilder, targetClrType: Type, navigationMemberInfo: MemberInfo, shouldBeOwned?: Nullable_1<System_Internal.Boolean>, shouldCreate?: boolean): IConventionEntityTypeBuilder | null;
}


export const RelationshipDiscoveryConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, useAttributes: boolean): RelationshipDiscoveryConvention;
};


export interface __RelationshipDiscoveryConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IEntityTypeMemberIgnoredConvention(): IEntityTypeMemberIgnoredConvention$instance;
    As_IForeignKeyNullNavigationSetConvention(): IForeignKeyNullNavigationSetConvention$instance;
    As_IForeignKeyOwnershipChangedConvention(): IForeignKeyOwnershipChangedConvention$instance;
    As_IForeignKeyRemovedConvention(): IForeignKeyRemovedConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
    As_INavigationRemovedConvention(): INavigationRemovedConvention$instance;
    As_ITypeIgnoredConvention(): ITypeIgnoredConvention$instance;
}

export type RelationshipDiscoveryConvention = RelationshipDiscoveryConvention$instance & __RelationshipDiscoveryConvention$views;


export interface RequiredNavigationAttributeConvention$instance extends NavigationAttributeConventionBase_1<RequiredAttribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RequiredNavigationAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPrincipalEndChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_INavigationAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_ISkipNavigationAddedConvention: never;

    ProcessForeignKeyPrincipalEndChanged(relationshipBuilder: IConventionForeignKeyBuilder, dependentToPrincipalAttributes: IEnumerable_1<RequiredAttribute> | null, principalToDependentAttributes: IEnumerable_1<RequiredAttribute> | null, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyPrincipalEndChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, attribute: RequiredAttribute, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessNavigationAdded(navigationBuilder: IConventionNavigationBuilder, context: IConventionContext_1<IConventionNavigationBuilder>): void;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, attribute: RequiredAttribute, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
    ProcessSkipNavigationAdded(skipNavigationBuilder: IConventionSkipNavigationBuilder, context: IConventionContext_1<IConventionSkipNavigationBuilder>): void;
}


export const RequiredNavigationAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): RequiredNavigationAttributeConvention;
};


export interface __RequiredNavigationAttributeConvention$views {
    As_IForeignKeyPrincipalEndChangedConvention(): IForeignKeyPrincipalEndChangedConvention$instance;
    As_INavigationAddedConvention(): INavigationAddedConvention$instance;
    As_ISkipNavigationAddedConvention(): ISkipNavigationAddedConvention$instance;
}

export type RequiredNavigationAttributeConvention = RequiredNavigationAttributeConvention$instance & __RequiredNavigationAttributeConvention$views;


export interface RequiredPropertyAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<RequiredAttribute>, IComplexPropertyAddedConvention$instance, IComplexPropertyFieldChangedConvention$instance, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RequiredPropertyAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IComplexPropertyFieldChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: RequiredAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: RequiredAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
}


export const RequiredPropertyAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): RequiredPropertyAttributeConvention;
};


export interface __RequiredPropertyAttributeConvention$views {
    As_IComplexPropertyAddedConvention(): IComplexPropertyAddedConvention$instance;
    As_IComplexPropertyFieldChangedConvention(): IComplexPropertyFieldChangedConvention$instance;
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type RequiredPropertyAttributeConvention = RequiredPropertyAttributeConvention$instance & __RequiredPropertyAttributeConvention$views;


export interface RuntimeModelConvention$instance extends IModelFinalizedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RuntimeModelConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    Create(model: IModel): RuntimeModel;
    GetForeignKey(foreignKey: IForeignKey, entityType: RuntimeEntityType): RuntimeForeignKey;
    GetIndex(index: IIndex, entityType: RuntimeEntityType): RuntimeIndex;
    GetKey(key: IKey, entityType: RuntimeEntityType): RuntimeKey;
    ProcessComplexPropertyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, property: IComplexProperty, runtimeProperty: RuntimeComplexProperty, runtime: boolean): void;
    ProcessComplexTypeAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, complexType: IComplexType, runtimeComplexType: RuntimeComplexType, runtime: boolean): void;
    ProcessElementTypeAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, element: IElementType, runtimeElement: RuntimeElementType, runtime: boolean): void;
    ProcessEntityTypeAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, entityType: IEntityType, runtimeEntityType: RuntimeEntityType, runtime: boolean): void;
    ProcessForeignKeyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, foreignKey: IForeignKey, runtimeForeignKey: RuntimeForeignKey, runtime: boolean): void;
    ProcessIndexAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, index: IIndex, runtimeIndex: RuntimeIndex, runtime: boolean): void;
    ProcessKeyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, key: IKey, runtimeKey: RuntimeKey, runtime: boolean): void;
    ProcessModelAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, model: IModel, runtimeModel: RuntimeModel, runtime: boolean): void;
    ProcessModelFinalized(model: IModel): IModel;
    ProcessNavigationAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, navigation: INavigation, runtimeNavigation: RuntimeNavigation, runtime: boolean): void;
    ProcessPropertyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
    ProcessServicePropertyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, property: IServiceProperty, runtimeProperty: RuntimeServiceProperty, runtime: boolean): void;
    ProcessSkipNavigationAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, skipNavigation: ISkipNavigation, runtimeSkipNavigation: RuntimeSkipNavigation, runtime: boolean): void;
    ProcessTriggerAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, trigger: ITrigger, runtimeTrigger: RuntimeTrigger, runtime: boolean): void;
    ProcessTypeMappingConfigurationAnnotations(annotations: Dictionary_2<System_Internal.String, unknown | null>, typeConfiguration: ITypeMappingConfiguration, runtimeTypeConfiguration: RuntimeTypeMappingConfiguration, runtime: boolean): void;
}


export const RuntimeModelConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): RuntimeModelConvention;
};


export interface __RuntimeModelConvention$views {
    As_IModelFinalizedConvention(): IModelFinalizedConvention$instance;
}

export type RuntimeModelConvention = RuntimeModelConvention$instance & __RuntimeModelConvention$views;


export interface RuntimeModelConvention_QueryRootRewritingExpressionVisitor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_RuntimeModelConvention_QueryRootRewritingExpressionVisitor: never;

    Rewrite(expression: Expression): Expression;
    VisitExtension(extensionExpression: Expression): Expression;
}


export const RuntimeModelConvention_QueryRootRewritingExpressionVisitor: {
    new(model: IModel): RuntimeModelConvention_QueryRootRewritingExpressionVisitor;
};


export type RuntimeModelConvention_QueryRootRewritingExpressionVisitor = RuntimeModelConvention_QueryRootRewritingExpressionVisitor$instance;

export interface SequenceUniquificationConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_SequenceUniquificationConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const SequenceUniquificationConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): SequenceUniquificationConvention;
};


export interface __SequenceUniquificationConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type SequenceUniquificationConvention = SequenceUniquificationConvention$instance & __SequenceUniquificationConvention$views;


export interface ServicePropertyDiscoveryConvention$instance extends IEntityTypeAddedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ServicePropertyDiscoveryConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly UseAttributes: boolean;
    DiscoverServiceProperties(structuralTypeBuilder: IConventionTypeBaseBuilder, context: IConventionContext): void;
    GetMembers(structuralType: IConventionTypeBase): IEnumerable_1<MemberInfo>;
    IsCandidateServiceProperty(memberInfo: MemberInfo, structuralType: IConventionTypeBase, factory: IParameterBindingFactory | null): boolean;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
}


export const ServicePropertyDiscoveryConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, useAttributes: boolean): ServicePropertyDiscoveryConvention;
};


export interface __ServicePropertyDiscoveryConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
}

export type ServicePropertyDiscoveryConvention = ServicePropertyDiscoveryConvention$instance & __ServicePropertyDiscoveryConvention$views;


export interface SharedTableConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_SharedTableConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly CheckConstraintsUniqueAcrossTables: boolean;
    readonly DefaultConstraintsUniqueAcrossTables: boolean;
    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly ForeignKeysUniqueAcrossTables: boolean;
    readonly IndexesUniqueAcrossTables: boolean;
    readonly KeysUniqueAcrossTables: boolean;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    readonly TriggersUniqueAcrossTables: boolean;
    AreCompatible(key: IReadOnlyKey, duplicateKey: IReadOnlyKey, storeObject: StoreObjectIdentifier): boolean;
    AreCompatible(index: IReadOnlyIndex, duplicateIndex: IReadOnlyIndex, storeObject: StoreObjectIdentifier): boolean;
    AreCompatible(foreignKey: IReadOnlyForeignKey, duplicateForeignKey: IReadOnlyForeignKey, storeObject: StoreObjectIdentifier): boolean;
    AreCompatible(checkConstraint: IReadOnlyCheckConstraint, duplicateCheckConstraint: IReadOnlyCheckConstraint, storeObject: StoreObjectIdentifier): boolean;
    AreCompatible(trigger: IReadOnlyTrigger, duplicateTrigger: IReadOnlyTrigger, storeObject: StoreObjectIdentifier): boolean;
    AreCompatibleDefaultConstraints(property: IReadOnlyProperty, duplicateProperty: IReadOnlyProperty, storeObject: StoreObjectIdentifier): boolean;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const SharedTableConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): SharedTableConvention;
};


export interface __SharedTableConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type SharedTableConvention = SharedTableConvention$instance & __SharedTableConvention$views;


export interface StoredProcedureConvention$instance extends IEntityTypeAddedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_StoredProcedureConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
}


export const StoredProcedureConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): StoredProcedureConvention;
};


export interface __StoredProcedureConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type StoredProcedureConvention = StoredProcedureConvention$instance & __StoredProcedureConvention$views;


export interface StoreGenerationConvention$instance extends IModelFinalizingConvention$instance, IPropertyAnnotationChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_StoreGenerationConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAnnotationChangedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
    ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
    Validate(property: IConventionProperty, storeObject: StoreObjectIdentifier): void;
}


export const StoreGenerationConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): StoreGenerationConvention;
};


export interface __StoreGenerationConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
    As_IPropertyAnnotationChangedConvention(): IPropertyAnnotationChangedConvention$instance;
}

export type StoreGenerationConvention = StoreGenerationConvention$instance & __StoreGenerationConvention$views;


export interface StringLengthAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<StringLengthAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_StringLengthAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: StringLengthAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: StringLengthAttribute, clrMember: MemberInfo, context: IConventionContext): void;
}


export const StringLengthAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): StringLengthAttributeConvention;
};


export interface __StringLengthAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type StringLengthAttributeConvention = StringLengthAttributeConvention$instance & __StringLengthAttributeConvention$views;


export interface TableNameFromDbSetConvention$instance extends IEntityTypeAddedConvention$instance, IEntityTypeAnnotationChangedConvention$instance, IEntityTypeBaseTypeChangedConvention$instance, IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_TableNameFromDbSetConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAnnotationChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAnnotationChanged(entityTypeBuilder: IConventionEntityTypeBuilder, name: string, annotation: IConventionAnnotation | null, oldAnnotation: IConventionAnnotation | null, context: IConventionContext_1<IConventionAnnotation>): void;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const TableNameFromDbSetConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): TableNameFromDbSetConvention;
};


export interface __TableNameFromDbSetConvention$views {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
    As_IEntityTypeAnnotationChangedConvention(): IEntityTypeAnnotationChangedConvention$instance;
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type TableNameFromDbSetConvention = TableNameFromDbSetConvention$instance & __TableNameFromDbSetConvention$views;


export interface TableSharingConcurrencyTokenConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_TableSharingConcurrencyTokenConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const TableSharingConcurrencyTokenConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): TableSharingConcurrencyTokenConvention;
    GetConcurrencyTokensMap(storeObject: StoreObjectIdentifier, mappedTypes: IReadOnlyList_1<IReadOnlyEntityType>): Dictionary_2<System_Internal.String, List_1<IReadOnlyProperty>> | null;
    IsConcurrencyTokenMissing(propertiesMappedToConcurrencyColumn: List_1<IReadOnlyProperty>, entityType: IReadOnlyEntityType, mappedTypes: IReadOnlyList_1<IReadOnlyEntityType>): boolean;
};


export interface __TableSharingConcurrencyTokenConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type TableSharingConcurrencyTokenConvention = TableSharingConcurrencyTokenConvention$instance & __TableSharingConcurrencyTokenConvention$views;


export interface TableValuedDbFunctionConvention$instance extends IModelFinalizingConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_TableValuedDbFunctionConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
}


export const TableValuedDbFunctionConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): TableValuedDbFunctionConvention;
};


export interface __TableValuedDbFunctionConvention$views {
    As_IModelFinalizingConvention(): IModelFinalizingConvention$instance;
}

export type TableValuedDbFunctionConvention = TableValuedDbFunctionConvention$instance & __TableValuedDbFunctionConvention$views;


export interface TimestampAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<TimestampAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_TimestampAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: TimestampAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: TimestampAttribute, clrMember: MemberInfo, context: IConventionContext): void;
}


export const TimestampAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): TimestampAttributeConvention;
};


export interface __TimestampAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type TimestampAttributeConvention = TimestampAttributeConvention$instance & __TimestampAttributeConvention$views;


export interface TypeAttributeConventionBase_1$instance<TAttribute extends unknown & Attribute> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_TypeAttributeConventionBase_1: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAddedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    ProcessComplexPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, context: IConventionContext_1<IConventionComplexPropertyBuilder>): void;
    ProcessComplexTypeAdded(complexTypeBuilder: IConventionComplexTypeBuilder, attribute: TAttribute, context: IConventionContext): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ProcessEntityTypeAdded(entityTypeBuilder: IConventionEntityTypeBuilder, attribute: TAttribute, context: IConventionContext_1<IConventionEntityTypeBuilder>): void;
    ReplaceWithEntityType(complexTypeBuilder: IConventionComplexTypeBuilder, shouldBeOwned?: Nullable_1<System_Internal.Boolean>): IConventionEntityTypeBuilder | null;
}


export const TypeAttributeConventionBase_1: (abstract new<TAttribute extends unknown & Attribute>(dependencies: ProviderConventionSetBuilderDependencies) => TypeAttributeConventionBase_1<TAttribute>) & {
};


export interface __TypeAttributeConventionBase_1$views<TAttribute extends unknown & Attribute> {
    As_IEntityTypeAddedConvention(): IEntityTypeAddedConvention$instance;
}

export type TypeAttributeConventionBase_1<TAttribute extends unknown & Attribute> = TypeAttributeConventionBase_1$instance<TAttribute> & __TypeAttributeConventionBase_1$views<TAttribute>;


export interface UnicodeAttributeConvention$instance extends PropertyAttributeConventionBase_1$instance<UnicodeAttribute>, IPropertyFieldChangedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_UnicodeAttributeConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyFieldChangedConvention: never;

    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, attribute: UnicodeAttribute, clrMember: MemberInfo, context: IConventionContext): void;
    ProcessPropertyAdded(propertyBuilder: IConventionPropertyBuilder, context: IConventionContext_1<IConventionPropertyBuilder>): void;
    ProcessPropertyAdded(propertyBuilder: IConventionComplexPropertyBuilder, attribute: UnicodeAttribute, clrMember: MemberInfo, context: IConventionContext): void;
}


export const UnicodeAttributeConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): UnicodeAttributeConvention;
};


export interface __UnicodeAttributeConvention$views {
    As_IPropertyAddedConvention(): IPropertyAddedConvention$instance;
    As_IPropertyFieldChangedConvention(): IPropertyFieldChangedConvention$instance;
}

export type UnicodeAttributeConvention = UnicodeAttributeConvention$instance & __UnicodeAttributeConvention$views;


export interface ValueGenerationConvention$instance extends IEntityTypeBaseTypeChangedConvention$instance, IEntityTypePrimaryKeyChangedConvention$instance, IForeignKeyAddedConvention$instance, IForeignKeyOwnershipChangedConvention$instance, IForeignKeyPropertiesChangedConvention$instance, IForeignKeyRemovedConvention$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_ValueGenerationConvention: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypePrimaryKeyChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyOwnershipChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;

    readonly Dependencies: ProviderConventionSetBuilderDependencies;
    GetValueGenerated(property: IConventionProperty): Nullable_1<ValueGenerated>;
    ProcessEntityTypeBaseTypeChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newBaseType: IConventionEntityType | null, oldBaseType: IConventionEntityType | null, context: IConventionContext_1<IConventionEntityType>): void;
    ProcessEntityTypePrimaryKeyChanged(entityTypeBuilder: IConventionEntityTypeBuilder, newPrimaryKey: IConventionKey | null, previousPrimaryKey: IConventionKey | null, context: IConventionContext_1<IConventionKey>): void;
    ProcessForeignKeyAdded(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<IConventionForeignKeyBuilder>): void;
    ProcessForeignKeyOwnershipChanged(relationshipBuilder: IConventionForeignKeyBuilder, context: IConventionContext_1<Nullable_1<System_Internal.Boolean>>): void;
    ProcessForeignKeyPropertiesChanged(relationshipBuilder: IConventionForeignKeyBuilder, oldDependentProperties: IReadOnlyList_1<IConventionProperty>, oldPrincipalKey: IConventionKey, context: IConventionContext_1<IReadOnlyList_1<IConventionProperty>>): void;
    ProcessForeignKeyRemoved(entityTypeBuilder: IConventionEntityTypeBuilder, foreignKey: IConventionForeignKey, context: IConventionContext_1<IConventionForeignKey>): void;
}


export const ValueGenerationConvention: {
    new(dependencies: ProviderConventionSetBuilderDependencies): ValueGenerationConvention;
    GetValueGenerated(property: IReadOnlyProperty): Nullable_1<ValueGenerated>;
};


export interface __ValueGenerationConvention$views {
    As_IEntityTypeBaseTypeChangedConvention(): IEntityTypeBaseTypeChangedConvention$instance;
    As_IEntityTypePrimaryKeyChangedConvention(): IEntityTypePrimaryKeyChangedConvention$instance;
    As_IForeignKeyAddedConvention(): IForeignKeyAddedConvention$instance;
    As_IForeignKeyOwnershipChangedConvention(): IForeignKeyOwnershipChangedConvention$instance;
    As_IForeignKeyPropertiesChangedConvention(): IForeignKeyPropertiesChangedConvention$instance;
    As_IForeignKeyRemovedConvention(): IForeignKeyRemovedConvention$instance;
}

export type ValueGenerationConvention = ValueGenerationConvention$instance & __ValueGenerationConvention$views;