import { CustomConsumeFunction, CustomPrepareFunction } from "./prepare_consume_chain_builder";
import type { OpenAPIV3 } from "../bundled_openapi_types";
import type { HttpContext } from '@adonisjs/core/http';
import type { ApplicationService } from '@adonisjs/core/types';
import type { ResourcefulDataType } from "../types";
import type { ModelRelationTypes } from '@adonisjs/lucid/types/relations';
import type { LucidModel, LucidRow, ModelColumnOptions, ComputedOptions } from '@adonisjs/lucid/types/model';
import type { AnySchema, StringSchema, BinarySchema, NumberSchema, BooleanSchema, ObjectSchema, ArraySchema, DateSchema } from "./schema_types";
export type PromiseAble<T = unknown> = T | Promise<T> | PromiseLike<T>;
export type Promised<T = unknown> = Promise<T> | PromiseLike<T>;
export interface ResourcefulGeneralAccessControlFilter {
    (ctx: HttpContext, app: ApplicationService): PromiseAble<boolean>;
}
export interface ResourcefulAccessControlFilter<ResourcefulModel extends LucidModel = LucidModel, ResourcefulModelInstance = InstanceType<ResourcefulModel>> {
    (ctx: HttpContext, app: ApplicationService, instance?: ResourcefulModelInstance): PromiseAble<boolean>;
}
export interface ResourcefulResourceAccessControlFilter<ResourcefulModel extends LucidModel = LucidModel, ResourcefulModelInstance = InstanceType<ResourcefulModel>> {
    (ctx: HttpContext, app: ApplicationService, instance: ResourcefulModelInstance): PromiseAble<boolean>;
}
export interface ExternalDocumentationObject {
    description?: string;
    url: string;
}
export interface ResourcefulPropertyDefinition {
    propertyKey: string;
    readAccessControlFilters: ResourcefulAccessControlFilter[];
    writeAccessControlFilters: ResourcefulAccessControlFilter[];
    nullable: boolean;
    description?: string;
    default?: any;
    externalDocs?: ExternalDocumentationObject;
    example?: string;
    deprecated?: boolean;
    prepare?: CustomPrepareFunction;
    consume?: CustomConsumeFunction;
}
export interface ValidationScoper<BaseSchema extends AnySchema> {
    (schema: BaseSchema): void;
}
export interface LocalResourcefulPropertyDefinition<PropertyBaseSchema extends AnySchema> extends ResourcefulPropertyDefinition {
    type: ResourcefulDataType;
    validationScopes?: ValidationScoper<PropertyBaseSchema>[];
}
export interface ResourcefulColumnDefinition<ColumnBaseSchema extends AnySchema> extends LocalResourcefulPropertyDefinition<ColumnBaseSchema> {
    /** Whether this column can be used in filter operations. Defaults to true. */
    filterable: boolean;
    /** Whether this column can be used in sort operations. Defaults to true. */
    sortable: boolean;
    /** Whether this column can be used in aggregation operations. Defaults to false. */
    aggregatable: boolean;
    /** Whether this column is immutable. Defaults to false. */
    immutable: boolean;
    /** The property name of the relationship which this column acts as a key for */
    relationshipKey?: string;
}
export interface ResourcefulComputedAccessorDefinition<ComputedSetterBaseSchema extends AnySchema> extends LocalResourcefulPropertyDefinition<ComputedSetterBaseSchema> {
    writable: boolean;
}
export interface ResourcefulRelationshipDefinition<Model extends LucidModel = LucidModel> extends ResourcefulPropertyDefinition {
    relatedModel: () => Model;
}
export type LucidBinaryValue = Uint8Array | Buffer;
export type LucidPlainObject = {
    [key: string]: unknown;
};
export type ResourcefulPropertySchema = StringSchema | BinarySchema | NumberSchema | BooleanSchema | ObjectSchema | ArraySchema | DateSchema;
export interface ResourcefulModelMetaSchema {
    name: string;
    properties: {
        [key: string]: ResourcefulModelPropertyMetaSchema;
    };
    description?: string;
    externalDocs?: ExternalDocumentationObject;
    example?: string;
}
export interface ResourcefulModelColumnMetaSchema {
    propertyKey: string;
    definition: ResourcefulColumnDefinition<any>;
    lucidDefinitions: ModelColumnOptions;
    canRead: boolean;
    canWrite: boolean;
    kind: 'column';
    validator: AnySchema;
    /** Whether this column can be used in filter operations */
    filterable: boolean;
    /** Whether this column can be used in sort operations */
    sortable: boolean;
    /** Whether this column can be used in aggregation operations */
    aggregatable: boolean;
}
export interface ResourcefulModelComputedAccessorMetaSchema {
    propertyKey: string;
    definition: ResourcefulComputedAccessorDefinition<any>;
    lucidDefinitions: ComputedOptions;
    canRead: boolean;
    canWrite: boolean;
    kind: 'computedAccessor';
    validator: AnySchema;
}
export interface ResourcefulModelRelationshipMetaSchema<Model extends LucidModel = LucidModel> {
    propertyKey: string;
    definition: ResourcefulRelationshipDefinition;
    lucidDefinitions: ReturnType<LucidModel['$getRelation']>;
    canRead: boolean;
    canWrite: boolean;
    kind: 'relationship';
    validator: AnySchema;
    relatedModel: () => Model;
    /** Array of field names from the related model that can be used in filter operations */
    filterable: {
        [key: string]: any;
    };
}
export type ResourcefulModelPropertyMetaSchema = ResourcefulModelColumnMetaSchema | ResourcefulModelComputedAccessorMetaSchema | ResourcefulModelRelationshipMetaSchema;
export type ResourcefulModelOpenApiSchema = OpenAPIV3.SchemaObject & {
    /** Array of field names that can be used in filter operations, including dot-notation for relationships */
    'x-resourceful-filterable'?: {
        [key: string]: any;
    };
    /** Array of field names that can be used in sort operations */
    'x-resourceful-sortable'?: string[];
    /** Array of field names that can be used in aggregation operations */
    'x-resourceful-aggregatable'?: string[];
    /** Properties of this model which are "auto-created" i.e. not required for creation even though they're not nullable  */
    'x-resourceful-auto-create'?: string[];
};
export type ResourcefulModelOpenApiRelatedSchema = OpenAPIV3.ReferenceObject & {
    'x-resourceful-display-key': string;
};
export type ResourcefulModelSerializableAttributes<Model extends LucidRow> = Model['$columns'] extends undefined ? {
    [P in keyof Model as P extends keyof LucidRow | 'serializeExtras' ? never : Model[P] extends Function | ModelRelationTypes ? never : Model extends {
        $columnsDefinitions: Map<infer K, infer V>;
    } ? P extends K ? V extends {
        serializeAs: null;
    } ? never : V extends {
        serializeAs: infer S;
    } ? S extends string ? S : P : P : P : P]: Model[P];
} : Model['$columns'];
export type ResourcefulModelRelationshipMetaChoice = {
    label: string;
    value: any;
};
export type ResourcefulModelRelationshipMeta = {
    title: string;
    multiple: boolean;
    choices: ResourcefulModelRelationshipMetaChoice[] | string;
};
export type ResourcefulModelFieldRelationshipMeta = false | ResourcefulModelRelationshipMeta;
export type { ResourcefulEnum, ResourcefulEnumObject } from "./data_types";