import type Express from 'express';
import type * as Db from '../database-layer/db.js';
import type { Model } from '../config-loader/config-loader.js';
import type { AnyObject, RequiredField } from './common-types.js';
import type { PickDeferred, Resource } from '@balena/abstract-sql-to-typescript';
declare global {
    namespace Express {
        interface Request {
            tx?: Db.Tx;
            batch?: uriParser.UnparsedRequest[];
        }
    }
}
type LFModel = any[];
import * as AbstractSQLCompiler from '@balena/abstract-sql-compiler';
declare const sbvrTypes: {
    'Big Integer': typeof import("@balena/sbvr-types/out/types/big-integer.js");
    'Big Serial': typeof import("@balena/sbvr-types/out/types/big-serial.js");
    Boolean: typeof import("@balena/sbvr-types/out/types/boolean.js");
    'Case Insensitive Text': typeof import("@balena/sbvr-types/out/types/case-insensitive-text.js");
    Color: typeof import("@balena/sbvr-types/out/types/color.js");
    ConceptType: typeof import("@balena/sbvr-types/out/types/concept-type.js");
    'Date Time': typeof import("@balena/sbvr-types/out/types/date-time.js");
    'Date Time Range': typeof import("@balena/sbvr-types/out/types/date-time-range.js");
    Date: typeof import("@balena/sbvr-types/out/types/date.js");
    File: typeof import("@balena/sbvr-types/out/types/file.js");
    ForeignKey: typeof import("@balena/sbvr-types/out/types/foreign-key.js");
    Hashed: typeof import("@balena/sbvr-types/out/types/hashed.js");
    Integer: typeof import("@balena/sbvr-types/out/types/integer.js");
    Interval: typeof import("@balena/sbvr-types/out/types/interval.js");
    JSON: typeof import("@balena/sbvr-types/out/types/json.js");
    Real: typeof import("@balena/sbvr-types/out/types/real.js");
    Serial: typeof import("@balena/sbvr-types/out/types/serial.js");
    SHA: typeof import("@balena/sbvr-types/out/types/sha.js");
    'Short Text': typeof import("@balena/sbvr-types/out/types/short-text.js");
    Text: typeof import("@balena/sbvr-types/out/types/text.js");
    Time: typeof import("@balena/sbvr-types/out/types/time.js");
    WebResource: typeof import("@balena/sbvr-types/out/types/web-resource.js");
};
import type { ActionParams, ODataOptions, Params } from 'pinejs-client-core';
import { PinejsClientCore, type PromiseResultTypes } from 'pinejs-client-core';
import { generateODataMetadata } from '../odata-metadata/odata-metadata-generator.js';
import type DevModel from './dev.js';
import * as permissions from './permissions.js';
import { HttpError } from './errors.js';
import * as uriParser from './uri-parser.js';
export type { ODataRequest } from './uri-parser.js';
import { type HookArgs } from './hooks.js';
export { type HookReq, type HookArgs, type HookResponse, type Hooks, addPureHook, addSideEffectHook, } from './hooks.js';
export declare let db: Db.Database;
export { sbvrTypes };
export { resolveOdataBind } from './abstract-sql.js';
import { translateAbstractSqlModel } from './translations.js';
import { type MigrationExecutionResult } from '../migrator/utils.js';
export type ExecutableModel = RequiredField<Model, 'apiRoot' | 'modelText'> | RequiredField<Model, 'apiRoot' | 'abstractSql'>;
interface CompiledModel {
    vocab: string;
    translateTo?: string;
    resourceRenames?: ReturnType<typeof translateAbstractSqlModel>;
    se?: string | undefined;
    lf?: LFModel | undefined;
    abstractSql: AbstractSQLCompiler.AbstractSqlModel;
    sql?: AbstractSQLCompiler.SqlModel;
    odataMetadata: ReturnType<typeof generateODataMetadata>;
}
export interface Actor {
    permissions?: string[];
}
export interface User extends Actor {
    id?: number;
    actor: number;
}
export interface ApiKey extends Actor {
    key: string;
    actor: number;
}
export interface Response {
    statusCode: number;
    headers?: {
        [headerName: string]: any;
    } | undefined;
    body?: AnyObject | string;
}
export type ModelExecutionResult = undefined | {
    migrationExecutionResult?: MigrationExecutionResult;
};
export declare const resolveSynonym: (request: Pick<uriParser.ODataRequest, "abstractSqlModel" | "resourceName" | "vocabulary">) => string;
export declare const resolveNavigationResource: (request: Pick<uriParser.ODataRequest, "resourceName" | "vocabulary" | "abstractSqlModel">, navigationName: string) => string;
export declare const isModelNew: (tx: Db.Tx, modelName: string) => Promise<boolean>;
export declare const generateLfModel: (seModel: string) => LFModel;
export declare const generateAbstractSqlModel: (lfModel: LFModel) => AbstractSQLCompiler.AbstractSqlModel;
export declare const generateSqlModel: (abstractSql: AbstractSQLCompiler.AbstractSqlModel, targetDatabaseEngine: AbstractSQLCompiler.Engines) => AbstractSQLCompiler.SqlModel;
export declare function generateModels(model: ExecutableModel & {
    translateTo?: undefined;
}, targetDatabaseEngine: AbstractSQLCompiler.Engines): RequiredField<CompiledModel, 'sql'>;
export declare function generateModels(model: ExecutableModel, targetDatabaseEngine: AbstractSQLCompiler.Engines): CompiledModel;
export declare const executeModel: (tx: Db.Tx, model: ExecutableModel) => Promise<void>;
export declare const executeModels: (tx: Db.Tx, execModels: ExecutableModel[]) => Promise<void>;
export declare const postExecuteModels: (tx: Db.Tx) => Promise<void>;
export declare const runRule: (vocab: string, rule: string) => Promise<AnyObject>;
export type Passthrough = AnyObject & {
    req?: {
        user?: User;
    };
    tx?: Db.Tx;
};
export declare class PinejsClient<M extends {
    [key in keyof M]: Resource;
} = {
    [key in string]: {
        Read: AnyObject;
        Write: AnyObject;
    };
}> extends PinejsClientCore<M> {
    _request({ method, url, body, tx, req, custom, }: {
        method: string;
        url: string;
        body?: AnyObject;
        tx?: Db.Tx;
        req?: permissions.PermissionReq;
        custom?: AnyObject;
    }): Promise<object>;
    post<TResource extends keyof M & string>(params: {
        resource: TResource;
    } & ActionParams & Omit<Params<M[TResource]>, 'method' | 'url' | 'body'>): Promise<unknown>;
    post<TResource extends keyof M & string>(params: {
        resource: TResource;
        options?: Params<M[TResource]>['options'] & {
            returnResource?: true;
        };
    } & Params<M[TResource]>): Promise<PickDeferred<M[TResource]['Read']>>;
    post<TResource extends keyof M & string>(params: {
        resource: TResource;
        options: Params<M[TResource]>['options'] & {
            returnResource: boolean;
        };
    } & Params<M[TResource]>): Promise<Pick<M[TResource]['Read'], 'id'>>;
    compileAuth<TResource extends keyof M & string>(params: {
        modelName: string;
        access: string;
        resource: TResource;
        options?: Pick<ODataOptions<M[TResource]['Read']>, '$filter'>;
    }): string;
}
export interface API {
    [vocab: string]: PinejsClient;
}
export declare const api: API;
export declare const logger: {
    [vocab: string]: Console;
};
export declare const runURI: (method: string, uri: string, body?: AnyObject, tx?: Db.Tx, req?: permissions.PermissionReq, custom?: AnyObject) => Promise<PromiseResultTypes>;
export declare const getAbstractSqlModel: (request: Pick<uriParser.ODataRequest, "vocabulary" | "abstractSqlModel">) => AbstractSQLCompiler.AbstractSqlModel;
export declare const getAffectedIds: <Vocab extends string>(args: HookArgs<Vocab> & {
    tx: Db.Tx;
}) => Promise<number[]>;
export declare const getModel: (vocabulary: string) => CompiledModel & {
    versions: string[];
    modelExecutionResult?: ModelExecutionResult;
};
export declare const getApiRoot: (req: Express.Request) => string | undefined;
export declare const handleODataRequest: Express.Handler;
declare const handleErrorFns: Array<(req: Express.Request, err: HttpError) => void>;
export declare const onHandleHttpError: (fn: (typeof handleErrorFns)[number]) => void;
export declare const handleHttpErrors: (req: Express.Request, res: Express.Response, err: Error) => boolean;
export interface API {
    [devModelConfig.apiRoot]: PinejsClient<DevModel>;
}
declare const devModelConfig: {
    readonly apiRoot: "dev";
    readonly modelText: string;
    readonly logging: {
        readonly log: false;
    };
    readonly migrations: {
        readonly '11.0.0-modified-at': "\n\t\t\tALTER TABLE \"model\"\n\t\t\tADD COLUMN IF NOT EXISTS \"modified at\" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL;\n\t\t";
        readonly '15.0.0-data-types': ($tx: Db.Tx, sbvrUtils: typeof import("./sbvr-utils.js")) => Promise<void>;
        readonly '22.0.0-timestamps': ($tx: Db.Tx, sbvrUtils: typeof import("./sbvr-utils.js")) => Promise<void>;
    };
};
export declare const setup: (_app: Express.Application, $db: Db.Database) => Promise<void>;
export declare const postSetup: (_app: Express.Application, $db: Db.Database) => Promise<void>;