import { config } from 'mssql';
import { EntityMeta, RadsDb } from '_rads-db';

type MaybePromise$1<T> = Promise<T> | T;
type Change<T> = {
    [K in keyof T]?: T[K] extends any[] ? T[K] : T[K] extends {} ? Change<T[K]> : T[K];
};
interface GetManyArgs<EN extends keyof EntityMeta> extends GetArgs<EN> {
    cursor?: string | undefined;
    maxItemCount?: number;
    orderBy?: string;
    orderByArray?: OrderBy<EntityMeta[EN]>;
}
interface VerifyManyArgs<EN extends keyof EntityMeta> extends GetManyArgs<EN> {
    recompute?: string[];
    dryRun?: boolean;
}
interface VerifyManyResponse {
    cursor: string | undefined;
    correctCount: number;
    incorrectCount: number;
    incorrectDocs: {
        id: string;
        diff: any;
        toRemove?: any;
    }[];
}
type Where<EN extends keyof EntityMeta> = EntityMeta[EN]['whereType'] & {
    _not?: Where<EN>;
    _and?: Where<EN>[];
    _or?: Where<EN>[];
};
interface GetArgs<EN extends keyof EntityMeta> {
    where?: Where<EN>;
    include?: GetArgsInclude<EN>;
}
interface GetAggArgs<EN extends keyof EntityMeta> extends Omit<GetManyArgs<EN>, 'include'> {
    agg: GetAggArgsAgg<EN>;
}
type GetAggArgsAgg<EN extends keyof EntityMeta, F extends string = EntityMeta[EN]['aggregates']> = ('_count' | `${F}_min` | `${F}_max` | `${F}_sum`)[];
type GetManyArgsAny = GetManyArgs<any>;
type GetArgsAny = GetArgs<any>;
type GetAggArgsAny = GetAggArgs<any>;
type VerifyManyArgsAny = VerifyManyArgs<any>;
type RelationsAndNestedObjects<EN extends keyof EntityMeta> = EntityMeta[EN]['relations'] & EntityMeta[EN]['nestedObjects'];
type JsonFieldsInclude<EN extends keyof EntityMeta> = [EntityMeta[EN]['jsonFields']] extends [never] ? unknown : {
    [K in EntityMeta[EN]['jsonFields'] & string]?: {
        _pick?: readonly string[];
    };
};
type GetArgsInclude<EN extends keyof EntityMeta, R extends keyof RelationsAndNestedObjects<EN> = keyof RelationsAndNestedObjects<EN>> = [R] extends [never] ? {
    _pick?: readonly (EntityMeta[EN]['primitives'] | EntityMeta[EN]['jsonFields'])[];
} & JsonFieldsInclude<EN> : {
    _pick?: readonly (EntityMeta[EN]['primitives'] | EntityMeta[EN]['jsonFields'] | R)[];
} & {
    [K in R]?: GetArgsInclude<RelationsAndNestedObjects<EN>[K]['entityName']>;
} & JsonFieldsInclude<EN>;
type GetAggResponse<EN extends keyof EntityMeta, A extends GetAggArgs<EN>> = {
    [K in A['agg'][number]]: K extends '_count' ? number : number | undefined;
};
interface GetManyResponse<EN extends keyof EntityMeta, A extends GetArgs<EN>> {
    nodes: GetResponse<EN, A>[];
    cursor: string | undefined;
}
type GetResponse<EN extends keyof EntityMeta, A extends GetArgs<EN>> = (A extends {
    include: any;
} ? GetResponseInclude<EN, A['include']> : GetResponseNoInclude<EN>) & StoredDocumentFields;
/** Fields the database adds to every stored document. */
interface StoredDocumentFields {
    /** Version of the stored document; pass it as `_ifMatch` to a put to make the write conditional. */
    _etag?: string;
}
type Get<EntityName extends keyof EntityMeta, Include extends keyof EntityMeta[EntityName]['relations'] | GetArgsInclude<EntityName> = {}> = [Include] extends [Record<string, any>] ? GetResponse<EntityName, {
    include: Include;
}> : GetResponse<EntityName, {
    include: {
        [K in Include]: {};
    };
}>;
type RelationData<EN extends keyof EntityMeta, K extends keyof EntityMeta[EN]['relations']> = Pick<EntityMeta[EN]['relations'][K]['entity'], EntityMeta[EN]['relations'][K]['denormFields']>;
type KeepArray<TMaybeArray, TType> = NonNullable<TMaybeArray> extends any[] ? TType[] : TType;
type GetResponseInclude<EN extends keyof EntityMeta, I extends GetArgsInclude<EN>> = I extends {
    _pick: readonly string[];
} ? GetResponseIncludeSelect<EN, I> : {
    [K in keyof EntityMeta[EN]['type']]: K extends keyof EntityMeta[EN]['relations'] ? K extends keyof I ? KeepArray<EntityMeta[EN]['type'][K], GetResponseInclude<EntityMeta[EN]['relations'][K]['entityName'], I[K]>> : KeepArray<EntityMeta[EN]['type'][K], RelationData<EN, K>> : K extends keyof EntityMeta[EN]['nestedObjects'] ? K extends keyof I ? KeepArray<EntityMeta[EN]['type'][K], GetResponseInclude<EntityMeta[EN]['nestedObjects'][K]['entityName'], I[K]>> : EntityMeta[EN]['type'][K] : EntityMeta[EN]['type'][K];
};
type GetResponseIncludeSelect<EN extends keyof EntityMeta, I extends GetArgsInclude<EN>> = I extends {
    _pick: readonly (infer P)[];
} ? Pick<{
    [K in keyof EntityMeta[EN]['type']]: K extends keyof EntityMeta[EN]['relations'] ? K extends keyof Omit<I, '_pick'> ? KeepArray<EntityMeta[EN]['type'][K], GetResponseInclude<EntityMeta[EN]['relations'][K]['entityName'], Omit<I, '_pick'>[K]>> : KeepArray<EntityMeta[EN]['type'][K], RelationData<EN, K>> : K extends keyof EntityMeta[EN]['nestedObjects'] ? K extends keyof Omit<I, '_pick'> ? KeepArray<EntityMeta[EN]['type'][K], GetResponseInclude<EntityMeta[EN]['nestedObjects'][K]['entityName'], Omit<I, '_pick'>[K]>> : EntityMeta[EN]['type'][K] : K extends EntityMeta[EN]['jsonFields'] ? K extends keyof Omit<I, '_pick'> ? Omit<I, '_pick'>[K] extends {
        _pick: (infer JP)[];
    } ? Pick<NonNullable<EntityMeta[EN]['type'][K]>, JP & string> : EntityMeta[EN]['type'][K] : EntityMeta[EN]['type'][K] : EntityMeta[EN]['type'][K];
}, ((P & string) | (Exclude<keyof I, '_pick'> & string)) & keyof EntityMeta[EN]['type']> : never;
type GetResponseNoInclude<EN extends keyof EntityMeta> = {
    [K in keyof EntityMeta[EN]['type']]: K extends keyof EntityMeta[EN]['relations'] ? KeepArray<EntityMeta[EN]['type'][K], RelationData<EN, K>> : EntityMeta[EN]['type'][K];
};
type DeepPartialWithNulls<T> = {
    [K in keyof T]?: NonNullable<T[K]> extends any[] ? DeepPartialArrayItem<NonNullable<T[K]>[number]>[] | null : DeepPartialWithNullsItem<NonNullable<T[K]>>;
};
type DeepPartialWithNullsItem<T> = T extends {
    id: string;
} ? Exclude<keyof T, 'id'> extends never ? {
    id: string;
} | null : DeepPartialWithNulls<T> | null : T extends Record<string, any> ? DeepPartialWithNulls<T> | null : T | null;
type DeepPartialArrayItem<T> = T extends {
    id: string;
} ? Exclude<keyof T, 'id'> extends never ? {
    id: string;
} : DeepPartialWithoutNulls<T> : T extends Record<string, any> ? DeepPartialWithoutNulls<T> : T;
type DeepPartialWithoutNulls<T> = {
    [K in keyof T]?: NonNullable<T[K]> extends any[] ? DeepPartialArrayItem<NonNullable<T[K]>[number]>[] : DeepPartialWithoutNullsItem<NonNullable<T[K]>>;
};
type DeepPartialWithoutNullsItem<T> = T extends {
    id: string;
} ? Exclude<keyof T, 'id'> extends never ? {
    id: string;
} : DeepPartialWithoutNulls<T> : T extends Record<string, any> ? DeepPartialWithoutNulls<T> : T;
type DeepPartial<T> = {
    [K in keyof T]?: NonNullable<T[K]> extends any[] ? DeepPartial<NonNullable<T[K]>[number]>[] : NonNullable<T[K]> extends Record<string, any> ? DeepPartial<T[K]> : T[K];
};
/** Indicates that this field is a relation to another entity in the database.
 * Only id will be stored in the database.
 * If you want to store additional fields, please, pass them as the second type argument */
type Relation<T extends {
    id: any;
}, K extends Exclude<keyof T, 'id'> = never> = Pick<T, K | 'id'>;
/** Indicates that this is computed field - all documents that point to this document via Relation<>.
 * Note: this field is not stored in the database at all. Returns up to 100 items and doesn't support pagination
 * If you need more control, please, use separate request instead.
 */
type InverseRelation<EN extends keyof EntityMeta> = EntityMeta[EN]['type'];
type PutId<T> = T extends {
    id: string;
} ? {
    id: string;
} : {};
type Put<EN extends keyof EntityMeta> = PutId<EntityMeta[EN]['type']> & JsonPutOperations<EN> & DeepPartialWithNulls<EntityMeta[EN]['type']> & {
    /** Optimistic concurrency: write only if the stored document still has this `_etag` (read earlier);
     * otherwise the put throws an error with `statusCode: 412`. */
    _ifMatch?: string;
};
type JsonPutOperations<EN extends keyof EntityMeta> = {
    [K in EntityMeta[EN]['jsonFields'] as `${K & string}_replace`]?: EntityMeta[EN]['type'][K];
};
type DeepKeys<T> = T extends object ? {
    [K in (string | number) & keyof T]: `${`.${K}` | (`${K}` extends `${number}` ? `[${K}]` : never)}${'' | DeepKeys<T[K]>}`;
}[(string | number) & keyof T] : never;
interface EntityMethods<E, EN extends keyof EntityMeta> {
    /** Returns object with with random UUID as `id` and prefilled default values */
    construct(defaultValues?: DeepPartial<E>): E;
    /** Used to access underlying mechanism of storage directly.
     * Warning: bypasses all rads features - schema won't be validated, default values won't be filled, etc. */
    driver: Driver;
    get<const A extends GetArgs<EN>>(args: A, ctx?: RadsRequestContext): MaybePromise$1<GetResponse<EN, A>>;
    getMany<const A extends GetManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<GetManyResponse<EN, A>>;
    getAgg<const A extends GetAggArgs<EN>>(args: A, ctx?: RadsRequestContext): MaybePromise$1<GetAggResponse<EN, A>>;
    getAll<const A extends GetManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<GetManyResponse<EN, A>['nodes']>;
    put(data: Put<EN>, ctx?: RadsRequestContext): MaybePromise$1<GetResponseNoInclude<EN>>;
    putMany(data: Put<EN>[], ctx?: RadsRequestContext): MaybePromise$1<GetResponseNoInclude<EN>[]>;
    verifyMany<const A extends VerifyManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<VerifyManyResponse>;
    verifyAll<const A extends VerifyManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<Pick<VerifyManyResponse, 'correctCount' | 'incorrectCount'>>;
}
type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...0[]];
type Primitive = string | number | boolean | symbol | null | undefined;
type OrderByDeepKeys<T, Prefix extends string = '', MaxDepth extends number = 5, Depth extends number = MaxDepth> = Depth extends 0 ? '' : T extends Primitive ? Prefix extends '' ? never : Prefix : T extends object ? {
    [K in keyof T]-?: K extends string | number ? OrderByDeepKeys<T[K], `${Prefix}${K & string}`, MaxDepth, Prev[Depth]> : never;
}[keyof T] : never;
type TrimEnd<T extends string, S extends string> = T extends `${infer R}${S}` ? R : T;
type ValidOrderByKey<T> = TrimEnd<OrderByDeepKeys<T>, '.'>;
type OrderBy<T> = Array<`${ValidOrderByKey<T>}_${'asc' | 'desc'}`>;

interface RadsConfig {
    dataSources: Record<string, RadsConfigDataSource>;
}
interface RadsConfigDataSource {
    schema: () => MaybePromise<SchemaLoadResult>;
}
type MaybePromise<T> = Promise<T> | T;
type RequiredFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
type ValidateFieldDecoratorArgs<T> = T extends string ? ValidateStringDecoratorArgs : T extends number ? ValidateNumberDecoratorArgs : ValidateAnyDecoratorArgs;
interface ValidateEntityDecoratorArgs {
}
interface ValidateAnyDecoratorArgs {
}
interface ValidateNumberDecoratorArgs {
    isWhole?: boolean;
    min?: number;
    max?: number;
}
interface ValidateStringDecoratorArgs {
    preset?: 'text' | 'html' | 'markdown' | 'alpha' | 'alphanum' | 'number' | 'decimalNumber' | 'email' | 'icon' | 'imageUrl' | 'fileUrl' | 'absoluteUrl' | 'relativeUrl' | 'phoneNumber' | 'datetime' | 'date' | 'time' | 'timeInterval' | 'duration' | 'hexColor';
    regex?: RegExp | string;
    minLength?: number;
    maxLength?: number;
    maxSizeKb?: number;
}
interface UiFieldDecoratorArgs {
    /** User-friendly name of the entity (singular).
     * Used as editor field label and column name in exports.
     * Defaults to `_.startCase(fieldName)` */
    name?: string;
    /** Icon to display as editor field icon. E.g. `mdi-user`. */
    icon?: string;
    /** Free text - hint to display under editor field in UI */
    hint?: string;
    /** If true, field is hidden from the rads-ui */
    isHidden?: boolean;
    /** If true, field is readonly in the rads-ui */
    isReadonly?: boolean;
    /** If true, field can be edited only during creation */
    isImmutable?: boolean;
    /** TODO: Preferred component to display or edit this value */
    component?: string;
}
interface UiDecoratorArgs<T = any> {
    /** User-friendly name of the entity (singular).
     * Defaults to `_.startCase(entityName).split(' ').slice(1).join(' ')` (i.e. removes the prefix) */
    name?: string;
    /** User-friendly name of the entity (plural)
     * Defaults to `pluralize(entityName)` */
    namePlural?: string;
    /** Icon to display near this entity. Defaults to `mdi-file-outline` */
    icon?: string;
    /** Field that contains "name" value.
     * Used by Rads UI to set up default search and display behaviour
     * Defaults to (if field with such name exists) `name` > `title` > `id` */
    nameField?: keyof T;
    /** Some important-to-know fields, like "id" or "code" or "description".
     * Used by Rads UI to display in the list view
     * Defaults to `["id"]` */
    captionFields?: (keyof T)[];
    /** Field that contains value that points to either:
     * - icon (e.g. 'mdi-test')
     * - image URL (e.g. 'https://radsjs.com/icon.png'). Make sure it's not too big (around 200x200px)
     * Used by Rads UI to display it in the list view.
     * Defaults to (if exists) `image` > `photo` > `thumbnail` > `icon` > undefined */
    iconField?: keyof T;
    /** Search operator that's used in simple search by name. Defaults to 'istartsWith' */
    searchOperator?: 'startsWith' | 'istartsWith' | 'contains' | 'icontains';
    /** Defines section name in rads-ui where this entity will be grouped under */
    group?: string;
    /** If true, field is hidden from the rads-ui */
    isHidden?: boolean;
}
interface EntityDecoratorArgs {
    driver?: string;
}
interface ComputedDecoratorArgs {
    preset: string;
}
interface FieldDecoratorArgs {
    relation?: Function;
}
type DriverConstructor = (schema: Schema, entity: string) => MinimalDriver;
interface CreateRadsArgsDrivers {
    default: DriverConstructor;
    [driverName: string]: DriverConstructor;
}
interface RestDriverOptions {
    /** @default '/api' */
    baseUrl?: string;
    fetch?: (url: string, options?: {
        body?: any;
        headers?: any;
        method?: string;
    }) => any;
    getHeaders?: (radsDbRequest: {
        args?: any;
        context?: RadsRequestContext;
    }) => Record<string, string> | undefined;
}
interface CreateRadsDbArgs {
    schema?: Schema;
    driver?: DriverConstructor | CreateRadsArgsDrivers;
    fileUploadDriver?: FileUploadDriver;
    noComputed?: boolean;
    noCustomDrivers?: boolean;
    /** Set when driver returns documents with includes already resolved, so they are not resolved again. Defaults to true in createRadsDbClient */
    includesResolvedByDriver?: boolean;
    computed?: Record<string, Record<string, Function> | {
        _entity?: {
            compute: Function;
            recomputeWhen: Record<string, (args: any) => boolean>;
        };
    }>;
    beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<void>;
    context?: Record<string, any> & Omit<RadsRequestContext, 'dryRun' | 'silent'>;
    features?: RadsFeature[];
    keepNulls?: boolean;
}
type CreateRadsDbArgsNormalized = RequiredFields<CreateRadsDbArgs, 'computed' | 'features'> & {
    driver: CreateRadsArgsDrivers;
};
type CreateRadsDbClientArgs = Omit<CreateRadsDbArgs, 'noComputed' | 'noCustomDrivers' | 'driver'> & {
    driver?: RestDriverOptions;
};
type Schema = Record<string, TypeDefinition>;
interface SchemaLoadResult {
    schema: Schema;
    entitiesDir?: string;
    entitiesDirs?: string[];
}
type SchemaValidators = Record<string, (item: any, oldDoc?: any) => any>;
interface TypeDefinition {
    name: string;
    decorators: Record<string, Record<string, any>>;
    comment?: string;
    precomputedFields?: string[];
    computedFields?: string[];
    nestedTypeFields?: string[];
    fields?: Record<string, FieldDefinition>;
    enumValues?: Record<string, EnumDefinition>;
    handle?: string;
    handlePlural?: string;
    isExtending?: string;
    keepHistoryFields?: string[];
    sourceFile?: string;
}
interface FileUploadResult {
    url: string;
}
interface FileUploadDriver {
    driverName: string;
    client?: any;
    uploadFile(args: FileUploadArgs, ctx?: RadsRequestContext): Promise<FileUploadResult>;
}
type RadsDbInstance = RadsDb[keyof RadsDb];
interface GetRestRoutesOptions {
    /** Instance of RadsDb */
    db: RadsDb[keyof RadsDb];
    /** Prefix to use for generated routes. Defaults to "/api/" */
    prefix?: string;
    /** By default, rest endpoints for manipulating local files are exposed when NODE_ENV === 'development'. Set to true or false to override. */
    exposeFilesystem?: boolean;
}
interface GetRestRoutesArgs {
    body?: any;
    context: any;
    headers: Record<string, string | undefined>;
}
type GetRestRoutesResponse = Record<string, Partial<Record<string, (args: GetRestRoutesArgs, ctx?: RadsRequestContext) => Promise<any>>>>;
interface FileUploadArgs {
    blob: Blob;
    fileName: string;
    containerName?: string;
    options?: any;
}
interface MinimalDriver {
    driverName: string;
    /** raw underlying data access service - e.g. sql client or azure storage client */
    client?: any;
    putMany: (items: Record<string, any>[], ctx?: RadsRequestContext) => MaybePromise<any>;
    getMany: (args?: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<{
        nodes: Record<string, any>[];
        cursor: string | undefined;
    }>;
    get?: (args: GetArgsAny, ctx?: RadsRequestContext) => MaybePromise<Record<string, any> | undefined>;
    getAll?: (args: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<Record<string, any>[]>;
    getAgg?: (args: GetAggArgsAny, ctx?: RadsRequestContext) => MaybePromise<Record<string, any>>;
    deleteMany?: (args: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<{
        nodes: Record<string, any>[];
        cursor: string | undefined;
    }>;
    deleteAll?: (args: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<Record<string, any>[]>;
    put?: (data: Record<string, any>, ctx?: RadsRequestContext) => MaybePromise<any>;
    verifyMany?: (args?: VerifyManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<VerifyManyResponse>;
    ensureClientConnected?: () => MaybePromise<void>;
    generateMigrationScript?: () => MaybePromise<{
        createScript: string;
        dropScript: string;
    }>;
}
type Driver = Required<Omit<MinimalDriver, 'verifyMany' | 'client' | 'ensureClientConnected' | 'generateMigrationScript'>> & Pick<MinimalDriver, 'verifyMany' | 'client' | 'ensureClientConnected' | 'generateMigrationScript'>;
interface FieldDefinition {
    name: string;
    type: string;
    defaultValue?: any;
    defaultValueClass?: string;
    defaultValueCopyFrom?: string;
    isRequired?: boolean;
    isArray?: boolean;
    isRelation?: boolean;
    isInverseRelation?: boolean;
    isChange?: boolean;
    inverseRelationField?: string;
    relationDenormFields?: string[];
    comment?: string;
    decorators?: Record<string, Record<string, any>>;
}
interface EnumDefinition {
    name: string;
    comment?: string;
    decorators?: Record<string, Record<string, any>>;
}
interface ComputedContextGlobal {
    db: RadsDbInstance;
    schema: Schema;
    validators: SchemaValidators;
    options: CreateRadsDbArgs;
    drivers: Record<string, Driver>;
    effects: Record<string, PutEffect[]>;
}
interface ComputedContext extends ComputedContextGlobal {
    typeName: string;
    handle: string;
}
interface RadsHookDoc {
    /** Updated document that will be saved to the database */
    doc: any;
    /** Previous version of document - i.e. one that is currently in the database (before saving) */
    oldDoc: any;
    /** If current entity is event sourcing aggregate, you can access all events in the chronological order */
    events?: any[];
    updatedEvents?: any[];
}
interface PutEffect {
    featureName: string;
    beforePut?: (computedContext: ComputedContext, docs: RadsHookDoc[], ctx: RadsRequestContext) => MaybePromise<any>;
    afterPut: (computedContext: ComputedContext, docs: RadsHookDoc[], beforePutResult: any, ctx: RadsRequestContext) => MaybePromise<any>;
}
interface SqlDriverOptions {
    authentication: config['authentication'];
    server: config['server'];
    database: config['database'];
    options?: Omit<config, 'authentication' | 'server' | 'database'>;
    tablePrefix?: string;
    stagingTablePrefix?: string;
}
interface RestFileUploadDriverOptions {
    /** @default '/api' */
    baseUrl?: string;
    fetch?: (url: string, options?: {
        body?: any;
        headers?: any;
        method?: string;
    }) => any;
    /** If true, "multipart/form-data" body will be used (sometimes causes problems in serverless environments).
     * Otherwise, "application/json" body (with base64-encoded binary content) will be used */
    useFormData?: boolean;
}
type GenerateClientOptions = GenerateClientNormalizedOptions;
interface GenerateClientNormalizedOptions {
    /** For servers - path to your entities directory, e.g. "./entities" */
    entitiesDir?: string;
    /** For client-only integrations - base url of your API, e.g. "https://my-website/api" */
    apiUrl?: string;
}
interface RadsVitePluginOptions extends GenerateClientOptions {
    /** To simplify debugging, makes modules available on window.
     * For example, "/src/stores/userStore.ts" will be available at window.stores.userStore.
     * You can pass the regex - if filename satisfies it, it will be exposed.
     * Path inside window is determined by first matching group in said regex.
     * If `true`, default regex is used - `/\/src\/((services|stores)\/(.+))\.[tj]s$/`   */
    exposeModulesInDev?: boolean | RegExp;
}
interface RadsRequestContext {
    _logs?: any[];
    log?: (requestInfo: any) => void;
    getUser?: () => {
        id: string;
        role: string;
    } | undefined;
    /** If true, no changes made to the database - instead, all changes are returned as logs */
    dryRun?: boolean;
    /** (Not supported yet) If true, updatedAt/updatedBy properties are not updated, and log records are not created */
    silent?: boolean;
    /** Mostly for internal use. When entity name is specified, indicates that calling put* on this entity is allowed, even if it's marked as @precomputed or @readonly */
    skipPrecomputedCheckFor?: string;
    /** Skip precomputed calculation for these fields and use provided values instead */
    skipPrecomputed?: string[];
    /** Method that was called - get, getAll, getMany, getAgg, put, putMany, etc */
    method?: 'get' | 'getAll' | 'getMany' | 'getAgg' | 'put' | 'putMany' | 'deleteMany' | 'deleteAll';
    /** if true, all cache layers will be bypassed */
    noCache?: boolean;
    /** Skip these features for this request (blacklist) */
    excludeFeatures?: string[];
    /** Run only these features, skip all others (whitelist). Cannot be used together with excludeFeatures */
    includeFeatures?: string[];
    [key: string]: any;
}
interface FileSystemNode {
    path: string;
    size?: number;
    type: 'blob' | 'tree';
}
interface WhereJsonContains {
    /** Checks for existence of this path inside json object
     * Example: "meta.countries[0].name". */
    path: string;
    /** Checks if value from "path" is exactly null. Note: it is not the same as not having the key in the object. */
    isNull?: boolean;
    /** Checks if value from "path" equals provided value */
    value?: number | string | boolean;
}
type RadsUiSlotName = 'entityListActions' | 'entityActions' | 'fieldActions';
interface RadsUiSlotDefinition {
    entityName?: string | {
        regExp: string;
    };
    fieldName?: string | {
        regExp: string;
    };
    label: string;
    icon?: string;
    endpoint: string;
}
interface RadsFeature {
    name: string;
    radsUiSlots?: Record<RadsUiSlotName, RadsUiSlotDefinition[]>;
    init?: (db: Record<string, any>, context: ComputedContextGlobal) => void;
    enhanceEntityMethods?: (context: ComputedContext, entityMethodsObj: EntityMethods<any, any>) => void;
    beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<any>;
    afterGet?: (items: any[], args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<void>;
    beforePut?: (items: RadsHookDoc[], ctx: RadsRequestContext, computedContext: ComputedContext) => void;
    afterPut?: (items: RadsHookDoc[], ctx: RadsRequestContext, computedContext: ComputedContext) => void;
    beforeUploadFile?: (args: FileUploadArgs) => MaybePromise<any>;
    afterUploadFile?: (result: FileUploadResult, args: FileUploadArgs) => MaybePromise<void>;
}

export { GetAggArgs as $, RestFileUploadDriverOptions as A, GenerateClientOptions as B, ComputedDecoratorArgs as C, DriverConstructor as D, EntityDecoratorArgs as E, FieldDecoratorArgs as F, GetRestRoutesOptions as G, GenerateClientNormalizedOptions as H, RadsVitePluginOptions as I, FileSystemNode as J, RadsUiSlotName as K, RadsUiSlotDefinition as L, MinimalDriver as M, RadsFeature as N, Change as O, PutEffect as P, GetManyArgs as Q, RadsRequestContext as R, Schema as S, TypeDefinition as T, UiDecoratorArgs as U, ValidateEntityDecoratorArgs as V, WhereJsonContains as W, VerifyManyArgs as X, VerifyManyResponse as Y, Where as Z, GetArgs as _, UiFieldDecoratorArgs as a, GetAggArgsAgg as a0, GetManyArgsAny as a1, GetArgsAny as a2, GetAggArgsAny as a3, VerifyManyArgsAny as a4, GetArgsInclude as a5, GetAggResponse as a6, GetManyResponse as a7, GetResponse as a8, StoredDocumentFields as a9, Get as aa, GetResponseInclude as ab, GetResponseIncludeSelect as ac, GetResponseNoInclude as ad, DeepPartialWithNulls as ae, DeepPartialWithNullsItem as af, DeepPartialArrayItem as ag, DeepPartialWithoutNulls as ah, DeepPartialWithoutNullsItem as ai, DeepPartial as aj, Relation as ak, InverseRelation as al, Put as am, JsonPutOperations as an, DeepKeys as ao, EntityMethods as ap, ValidateFieldDecoratorArgs as b, Driver as c, ComputedContext as d, CreateRadsDbArgs as e, CreateRadsDbClientArgs as f, RadsConfig as g, RadsConfigDataSource as h, RequiredFields as i, ValidateStringDecoratorArgs as j, CreateRadsArgsDrivers as k, RestDriverOptions as l, CreateRadsDbArgsNormalized as m, SchemaLoadResult as n, SchemaValidators as o, FileUploadResult as p, FileUploadDriver as q, RadsDbInstance as r, GetRestRoutesArgs as s, GetRestRoutesResponse as t, FileUploadArgs as u, FieldDefinition as v, EnumDefinition as w, ComputedContextGlobal as x, RadsHookDoc as y, SqlDriverOptions as z };