import * as _zenstackhq_language_ast from '@zenstackhq/language/ast';
import { DataFieldAttribute, DataModelAttribute, Model, AstNode, DataField, DataModel, TypeDef, Enum, EnumField, FunctionDecl, Attribute, AttributeParam, Reference, InvocationExpr } from '@zenstackhq/language/ast';
import { AttributeTarget } from '@zenstackhq/language/utils';
import { MaybePromise } from 'langium';

declare function isIdField(field: DataField, contextModel: DataModel): boolean;
declare function hasAttribute(decl: DataModel | TypeDef | DataField | Enum | EnumField | FunctionDecl | Attribute | AttributeParam, name: string): boolean;
declare function getAttribute(decl: AttributeTarget, name: string): DataFieldAttribute | DataModelAttribute | undefined;
declare function isDelegateModel(node: AstNode): boolean;
/**
 * Returns all fields that physically belong to a model's table: its directly declared
 * fields plus fields from its mixins (recursively).
 */
declare function getOwnedFields(model: DataModel | TypeDef): DataField[];
/**
 * Returns the name of the delegate base model that "owns" the given field in the context of
 * `contextModel`. This handles both direct fields of delegate models and mixin fields that
 * belong to a mixin used by a delegate base model.
 */
declare function getDelegateOriginModel(field: DataField, contextModel: DataModel): string | undefined;
declare function isUniqueField(field: DataField): boolean;
declare function isFromStdlib(node: AstNode): boolean;
declare function getContainingModel(node: AstNode | undefined): Model | null;
declare function resolved<T extends AstNode>(ref: Reference<T>): T;
declare function getAuthDecl(model: Model): _zenstackhq_language_ast.AbstractDeclaration | undefined;
declare function getIdFields(dm: DataModel): string[];
/**
 * Prefix for auxiliary relation fields generated for delegated models
 */
declare const DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";

declare const modelUtils_DELEGATE_AUX_RELATION_PREFIX: typeof DELEGATE_AUX_RELATION_PREFIX;
declare const modelUtils_getAttribute: typeof getAttribute;
declare const modelUtils_getAuthDecl: typeof getAuthDecl;
declare const modelUtils_getContainingModel: typeof getContainingModel;
declare const modelUtils_getDelegateOriginModel: typeof getDelegateOriginModel;
declare const modelUtils_getIdFields: typeof getIdFields;
declare const modelUtils_getOwnedFields: typeof getOwnedFields;
declare const modelUtils_hasAttribute: typeof hasAttribute;
declare const modelUtils_isDelegateModel: typeof isDelegateModel;
declare const modelUtils_isFromStdlib: typeof isFromStdlib;
declare const modelUtils_isIdField: typeof isIdField;
declare const modelUtils_isUniqueField: typeof isUniqueField;
declare const modelUtils_resolved: typeof resolved;
declare namespace modelUtils {
  export { modelUtils_DELEGATE_AUX_RELATION_PREFIX as DELEGATE_AUX_RELATION_PREFIX, modelUtils_getAttribute as getAttribute, modelUtils_getAuthDecl as getAuthDecl, modelUtils_getContainingModel as getContainingModel, modelUtils_getDelegateOriginModel as getDelegateOriginModel, modelUtils_getIdFields as getIdFields, modelUtils_getOwnedFields as getOwnedFields, modelUtils_hasAttribute as hasAttribute, modelUtils_isDelegateModel as isDelegateModel, modelUtils_isFromStdlib as isFromStdlib, modelUtils_isIdField as isIdField, modelUtils_isUniqueField as isUniqueField, modelUtils_resolved as resolved };
}

/**
 * Context passed to CLI plugins when calling `generate`.
 */
type CliGeneratorContext = {
    /**
     * ZModel file path.
     */
    schemaFile: string;
    /**
     * ZModel AST.
     */
    model: Model;
    /**
     * Default output path for code generation.
     */
    defaultOutputPath: string;
    /**
     * Plugin options provided by the user.
     */
    pluginOptions: Record<string, unknown>;
};
/**
 * Contract for a CLI plugin.
 */
interface CliPlugin {
    /**
     * Plugin's display name.
     */
    name: string;
    /**
     * Text to show during generation.
     */
    statusText?: string;
    /**
     * Code generation callback.
     */
    generate(context: CliGeneratorContext): MaybePromise<void>;
}

declare class FunctionCall {
    func: string;
    args: FunctionCallArg[];
    constructor(func: string, args?: FunctionCallArg[]);
    toString(): string;
}
declare class FunctionCallArg {
    value: string;
    constructor(value: string);
    toString(): string;
}

/**
 * Generates Prisma schema file
 */
declare class PrismaSchemaGenerator {
    private readonly zmodel;
    private readonly PRELUDE;
    private shortNameMap;
    constructor(zmodel: Model);
    generate(): Promise<string>;
    private generateDataSource;
    private configExprToText;
    private configArrayToText;
    private configInvocationArgToText;
    private literalToText;
    private generateGenerator;
    private generateDefaultGenerator;
    private generateModel;
    private getDatasourceField;
    private datasourceHasSchemasSetting;
    private getDefaultPostgresSchemaName;
    private isPrismaAttribute;
    private getUnsupportedFieldType;
    private generateModelField;
    private isDefaultWithAuthInvocation;
    private makeFieldAttribute;
    private makeAttributeArg;
    private makeAttributeArgValue;
    private exprToText;
    makeFunctionCall(node: InvocationExpr): FunctionCall;
    private generateContainerAttribute;
    private generateEnum;
    private generateEnumField;
    private generateDelegateRelationForBase;
    private generateDelegateRelationForConcrete;
    private getConcreteModels;
    private truncate;
}

type TsSchemaGeneratorOptions = {
    outDir: string;
    lite?: boolean;
    liteOnly?: boolean;
    importWithFileExtension?: string;
    generateModelTypes?: boolean;
    generateInputTypes?: boolean;
};
declare class TsSchemaGenerator {
    private usedExpressionUtils;
    private usedAttributeApplication;
    private usedFieldDefault;
    generate(model: Model, options: TsSchemaGeneratorOptions): Promise<void>;
    private generateSchema;
    private generateSchemaStatements;
    private createExpressionUtilsCall;
    private createSchemaClass;
    private createAsConst;
    private createAttributesTypeAssertion;
    private createDefaultTypeAssertion;
    private createProviderObject;
    private createModelsObject;
    private getAllDataModels;
    private getAllTypeDefs;
    private createTypeDefsObject;
    private createDataModelObject;
    private getSubModels;
    private createTypeDefObject;
    private createComputedFieldsObject;
    private createUpdatedAtObject;
    private mapFieldTypeToTSType;
    private createDataFieldObject;
    private isDiscriminatorField;
    private getDataSourceProvider;
    private getDataSourceDefaultSchema;
    private getFieldMappedDefault;
    private getMappedValue;
    private getMemberAccessChain;
    private isAuthMemberAccess;
    private isAuthInvocation;
    private createRelationObject;
    private getReferenceNames;
    private getForeignKeyFor;
    private getOppositeRelationField;
    private getRelationName;
    private createUniqueFieldsObject;
    private getCompoundUniqueKey;
    private generateFieldTypeLiteral;
    private createEnumObject;
    private getLiteral;
    private createLiteralNode;
    private createNumberLiteral;
    private createProceduresObject;
    private createProcedureObject;
    private generateBannerComments;
    private createAttributeObject;
    private createAttributeArg;
    private createExpression;
    private createThisExpression;
    private createMemberExpression;
    private createNullExpression;
    private createBinaryExpression;
    private createUnaryExpression;
    private createArrayExpression;
    private createRefExpression;
    private createCallExpression;
    private createLiteralExpression;
    private generateModelsAndTypeDefs;
    private generateSchemaImport;
    private generateDocs;
    private generateInputTypes;
}

export { type CliGeneratorContext, type CliPlugin, modelUtils as ModelUtils, PrismaSchemaGenerator, TsSchemaGenerator, type TsSchemaGeneratorOptions };