@avonjs/avonjs/dist/Resource.d.ts

A fluent Node.js API generator.

import { Ability, type DetailSerializedResource, type IndexSerializedResource, type Model, type ResourceMetaData, type ReviewSerializedResource, type StoreSerializedResource, type UnknownRecord, type UpdateSerializedResource } from './Contracts';
import type AvonRequest from './Http/Requests/AvonRequest';
declare const Resource_base: (abstract new (...args: import("./Contracts").Args) => {
    beforeCreate(request: AvonRequest): void;
    afterCreate(request: AvonRequest): void;
    created(request: AvonRequest): void;
    beforeUpdate(request: AvonRequest): void;
    afterUpdate(request: AvonRequest, resource: Model): void;
    updated(request: AvonRequest, resource: Model): void;
    beforeDelete(request: AvonRequest): void;
    afterDelete(request: AvonRequest): void;
    beforeForceDelete(request: AvonRequest): void;
    afterForceDelete(request: AvonRequest): void;
    deleted(request: AvonRequest): void;
    beforeRestore(request: AvonRequest): void;
    afterRestore(request: AvonRequest): void;
    restored(request: AvonRequest): void;
}) & (abstract new (...args: import("./Contracts").Args) => {
    resource: Model;
    recordEvents: boolean;
    recordCreationEvent(payload?: import("./Contracts").Payload, transaction?: import("./Contracts").Transaction, userId?: import("./Contracts").PrimaryKey): Promise<void>;
    recordUpdateEvent(previous: Model, payload?: import("./Contracts").Payload, transaction?: import("./Contracts").Transaction, userId?: import("./Contracts").PrimaryKey): Promise<void>;
    recordDeletionEvent(transaction?: import("./Contracts").Transaction, userId?: import("./Contracts").PrimaryKey): Promise<void>;
    recordRestoreEvent(transaction?: import("./Contracts").Transaction, userId?: import("./Contracts").PrimaryKey): Promise<void>;
    recordStandaloneActionEvent(action: import("./Actions").Action, payload?: import("./Contracts").Payload, userId?: import("./Contracts").PrimaryKey): Promise<void>;
    recordBulkActionEvent(action: import("./Actions").Action, changes?: import("./Contracts").BulkActionResult, payload?: import("./Contracts").Payload, userId?: import("./Contracts").PrimaryKey): Promise<void>;
    flushActionEvents(transaction?: import("./Contracts").Transaction): Promise<void>;
    makeActionRepository(transaction?: import("./Contracts").Transaction): import("./Repositories").Repository<Model> & import("./Contracts").ActionEventRepository<Model>;
    actionRepository(): import("./Repositories").Repository & import("./Contracts").ActionEventRepository<Model>;
    isRecordable(): boolean;
    sanitizePayload(payload: import("./Contracts").Payload): import("./Contracts").Payload;
    resourceName(): string;
}) & (abstract new (...args: import("./Contracts").Args) => {
    search(request: AvonRequest, filters?: import("./Contracts").MatchedQueryHandlers<import("./Filters").Filter>, orderings?: import("./Contracts").MatchedQueryHandlers<import("./Orderings").Ordering>, withTrashed?: import("./Contracts").TrashedStatus): Promise<import("./Repositories").Repository<Model>>;
    initializeSearch(request: AvonRequest, filters?: import("./Contracts").MatchedQueryHandlers<import("./Filters").Filter>, orderings?: import("./Contracts").MatchedQueryHandlers<import("./Orderings").Ordering>): Promise<import("./Repositories").Repository<Model>>;
    queryBuilder(request: AvonRequest): import("./Repositories").Repository<Model>;
    resolveRepository(request: AvonRequest): import("./Repositories").Repository<Model>;
    applySoftDeleteConstraint(queryBuilder: import("./Repositories").Repository<Model>, withTrashed: import("./Contracts").TrashedStatus): import("./Repositories").Repository<Model>;
    applyFilters(request: AvonRequest, queryBuilder: import("./Repositories").Repository<Model>, filters: import("./Contracts").MatchedQueryHandlers<import("./Filters").Filter>): Promise<import("./Repositories").Repository<Model>>;
    applyOrderings(request: AvonRequest, queryBuilder: import("./Repositories").Repository<Model>, orderings?: import("./Contracts").MatchedQueryHandlers<import("./Orderings").Ordering>): Promise<import("./Repositories").Repository<Model>>;
    relatableQuery(request: AvonRequest, queryBuilder: import("./Repositories").Repository<Model>): import("./Repositories").Repository<Model>;
    indexQuery(request: AvonRequest, queryBuilder: import("./Repositories").Repository<Model>): import("./Repositories").Repository<Model>;
    detailQuery(request: AvonRequest, queryBuilder: import("./Repositories").Repository<Model>): import("./Repositories").Repository<Model>;
    reviewQuery(request: AvonRequest, queryBuilder: import("./Repositories").Repository<Model>): import("./Repositories").Repository<Model>;
    softDeletes(): boolean;
    repository(): import("./Repositories").Repository<Model>;
}) & (abstract new (...args: import("./Contracts").Args) => {
    validateForCreation(request: AvonRequest): Promise<void>;
    validatorForCreation(request: AvonRequest): import("joi").AnySchema;
    rulesForCreation(request: AvonRequest): import("joi").AnySchema[];
    validateForUpdate(request: AvonRequest, resource?: Resource): Promise<void>;
    validatorForUpdate(request: AvonRequest, resource?: Resource): import("joi").AnySchema;
    rulesForUpdate(request: AvonRequest, resource?: Resource): import("joi").AnySchema[];
    prepareRulesForValidator(rules: import("./Contracts").Rules[]): import("joi").AnySchema[];
    formatRules(request: AvonRequest, rules: import("joi").AnySchema[]): import("joi").AnySchema[];
    dataForValidation(request: AvonRequest): import("./Contracts").AnyRecord;
    afterValidation(request: AvonRequest, validator: unknown): void;
    afterCreationValidation(request: AvonRequest, validator: unknown): void;
    afterUpdateValidation(request: AvonRequest, validator: unknown): void;
}) & (abstract new (...args: import("./Contracts").Args) => {
    fillForCreation<TModel_1 extends Model>(request: AvonRequest, model: TModel_1): import("./Contracts").CallbackStack;
    fillForUpdate<TModel_1 extends Model>(request: AvonRequest, model: TModel_1): import("./Contracts").CallbackStack;
    fillFields<TModel_1 extends Model>(request: AvonRequest, model: TModel_1, fields: import("./Collections/FieldCollection").default): import("./Contracts").CallbackStack;
}) & (abstract new (...args: import("./Contracts").Args) => {
    resource: Model;
    availableForSwagger: boolean;
    availableForIndex: boolean;
    availableForDetail: boolean;
    availableForCreation: boolean;
    availableForUpdate: boolean;
    availableForDelete: boolean;
    availableForForceDelete: boolean;
    availableForRestore: boolean;
    availableForReview: boolean;
    schema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathsObject;
    resourceIndexSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    resourceContentSchema(fields: Record<string, import("./Contracts").OpenApiSchema>): {
        type: string;
        items: {
            type: string;
            properties: {
                metadata: import("./Contracts").OpenApiSchema;
                authorization: {
                    type: string;
                    properties: {
                        authorizedToForceDelete?: {
                            type: string;
                            default: boolean;
                            description: string;
                        } | undefined;
                        authorizedToRestore?: {
                            type: string;
                            default: boolean;
                            description: string;
                        } | undefined;
                        authorizedToReview?: {
                            type: string;
                            default: boolean;
                            description: string;
                        } | undefined;
                        authorizedToView: {
                            type: string;
                            default: boolean;
                            description: string;
                        };
                        authorizedToUpdate: {
                            type: string;
                            default: boolean;
                            description: string;
                        };
                        authorizedToDelete: {
                            type: string;
                            default: boolean;
                            description: string;
                        };
                    };
                };
                fields: {
                    type: string;
                    properties: Record<string, import("./Contracts").OpenApiSchema>;
                };
            };
        };
    };
    resourceMetaDataSchema(): import("./Contracts").OpenApiSchema;
    searchParameters(request: AvonRequest): import("openapi-types").OpenAPIV3.ParameterObject[];
    paginationParameters(request: AvonRequest): import("openapi-types").OpenAPIV3.ParameterObject[];
    softDeleteParameters(request: AvonRequest): import("openapi-types").OpenAPIV3.ParameterObject[];
    orderingParameters(request: AvonRequest): import("openapi-types").OpenAPIV3.ParameterObject[];
    filteringParameters(request: AvonRequest): import("openapi-types").OpenAPIV3.ParameterObject[];
    resourceStoreSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    resourceDetailSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    resourceLookupSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    resourceReviewSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    resourceUpdateSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    resourceDeleteSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    resourceForceDeleteSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    resourceRestoreSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathItemObject | undefined;
    actionsSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathsObject;
    associationSchema(request: AvonRequest): import("openapi-types").OpenAPIV3.PathsObject;
    singleResourceContent(request: AvonRequest, schema?: Record<string, import("./Contracts").OpenApiSchema>): Record<string, import("openapi-types").OpenAPIV3.MediaTypeObject>;
    paginatedResponseSchema(data: UnknownRecord): Record<string, import("openapi-types").OpenAPIV3.MediaTypeObject>;
    jsonResponseSchema(data: UnknownRecord, meta?: UnknownRecord): Record<string, import("openapi-types").OpenAPIV3.MediaTypeObject>;
    reviewResourceContent(request: AvonRequest): Record<string, import("openapi-types").OpenAPIV3.MediaTypeObject>;
    singleResourcePathParameters(request: AvonRequest): import("openapi-types").OpenAPIV3.ParameterObject[];
    actionQueryParameters(request: AvonRequest, action: import("./Actions").Action): import("openapi-types").OpenAPIV3.ParameterObject[];
    apis(request: AvonRequest): Record<string, string>;
    getRouteKeyName(): string;
    label(): string;
    formatResponseFields(request: AvonRequest, fields: import("./Collections/FieldCollection").default): Record<string, import("./Contracts").OpenApiSchema>;
    formatPayloadFields(request: AvonRequest, fields: import("./Collections/FieldCollection").default): Record<string, import("./Contracts").OpenApiSchema>;
    authorizationResponses(): import("openapi-types").OpenAPIV3.ResponsesObject;
    errorsResponses(): import("openapi-types").OpenAPIV3.ResponsesObject;
    validationResponses(): import("openapi-types").OpenAPIV3.ResponsesObject;
    accepts(): string[];
    uriKey(): string;
    availableFields(request: AvonRequest): import("./Collections/FieldCollection").default;
    perPageOptions(): number[];
    availableFieldsOnForms(request: AvonRequest): import("./Collections/FieldCollection").default;
    resolveFilters(request: AvonRequest): import("./Filters").Filter[];
    resolveOrderings(request: AvonRequest): import("./Orderings").Ordering[];
    availableFieldsOnIndexOrDetail(request: AvonRequest): import("./Collections/FieldCollection").default;
    fieldsForIndex(request: AvonRequest): import("./Fields").Field[];
    fieldsForDetail(request: AvonRequest): import("./Fields").Field[];
    fieldsForReview(request: AvonRequest): import("./Fields").Field[];
    fieldsForCreate(request: AvonRequest): import("./Fields").Field[];
    fieldsForUpdate(request: AvonRequest): import("./Fields").Field[];
    resolveActions(request: AvonRequest): import("./Actions").Action[];
    softDeletes(): boolean;
    repository(): import("./Repositories").Repository<Model>;
}) & (abstract new (...args: import("./Contracts").Args) => {
    availableActions(request: AvonRequest): import("./Actions").Action[];
    resolveActions(request: AvonRequest): import("./Actions").Action[];
    actions(request: AvonRequest): import("./Actions").Action[];
}) & (abstract new (...args: import("./Contracts").Args) => {
    availableOrderings(request: AvonRequest): import("./Orderings").Ordering[];
    resolveOrderings(request: AvonRequest): import("./Orderings").Ordering[];
    resolveOrderingsFromFields(request: AvonRequest): import("./Orderings").Ordering[];
    orders(request: AvonRequest): import("./Orderings").Ordering[];
}) & (abstract new (...args: import("./Contracts").Args) => {
    availableFilters(request: AvonRequest): import("./Filters").Filter[];
    resolveFilters(request: AvonRequest): import("./Filters").Filter[];
    resolveFiltersFromFields(request: AvonRequest): import("./Filters").Filter[];
    filters(request: AvonRequest): import("./Filters").Filter[];
}) & (abstract new (...args: import("./Contracts").Args) => {
    resource: Model;
    indexFields(request: AvonRequest, resource: Model): import("./Collections/FieldCollection").default;
    detailFields(request: AvonRequest, resource: Model): import("./Collections/FieldCollection").default;
    creationFields(request: AvonRequest): import("./Collections/FieldCollection").default;
    updateFields(request: AvonRequest): import("./Collections/FieldCollection").default;
    reviewFields(request: AvonRequest, resource: Model): import("./Collections/FieldCollection").default;
    associationFields(request: AvonRequest): import("./Collections/FieldCollection").default;
    filterableFields(request: AvonRequest): import("./Collections/FieldCollection").default<import("./Fields").Field>;
    orderableFields(request: AvonRequest): import("./Collections/FieldCollection").default<import("./Fields").Field>;
    resolveFields(request: AvonRequest, resource?: Model): import("./Collections/FieldCollection").default;
    availableFields(request: AvonRequest): import("./Collections/FieldCollection").default;
    availableFieldsOnIndexOrDetail(request: AvonRequest): import("./Collections/FieldCollection").default;
    availableFieldsOnForms(request: AvonRequest): import("./Collections/FieldCollection").default;
    buildAvailableFields(request: AvonRequest, methods: string[]): import("./Collections/FieldCollection").default;
    callFieldsMethod(method: string, request: AvonRequest): import("./Fields").Field[];
    fieldsMethod(request: AvonRequest): keyof {
        resource: Model;
        indexFields(request: AvonRequest, resource: Model): import("./Collections/FieldCollection").default;
        detailFields(request: AvonRequest, resource: Model): import("./Collections/FieldCollection").default;
        creationFields(request: AvonRequest): import("./Collections/FieldCollection").default;
        updateFields(request: AvonRequest): import("./Collections/FieldCollection").default;
        reviewFields(request: AvonRequest, resource: Model): import("./Collections/FieldCollection").default;
        associationFields(request: AvonRequest): import("./Collections/FieldCollection").default;
        filterableFields(request: AvonRequest): import("./Collections/FieldCollection").default<import("./Fields").Field>;
        orderableFields(request: AvonRequest): import("./Collections/FieldCollection").default<import("./Fields").Field>;
        resolveFields(request: AvonRequest, resource?: Model): import("./Collections/FieldCollection").default;
        availableFields(request: AvonRequest): import("./Collections/FieldCollection").default;
        availableFieldsOnIndexOrDetail(request: AvonRequest): import("./Collections/FieldCollection").default;
        availableFieldsOnForms(request: AvonRequest): import("./Collections/FieldCollection").default;
        buildAvailableFields(request: AvonRequest, methods: string[]): import("./Collections/FieldCollection").default;
        callFieldsMethod(method: string, request: AvonRequest): import("./Fields").Field[];
        fieldsMethod(request: AvonRequest): keyof any;
        fieldsForCreate(request: AvonRequest): import("./Fields").Field[];
        fieldsForUpdate(request: AvonRequest): import("./Fields").Field[];
        fieldsForIndex(request: AvonRequest): import("./Fields").Field[];
        fieldsForDetail(request: AvonRequest): import("./Fields").Field[];
        fieldsForReview(request: AvonRequest): import("./Fields").Field[];
        fieldsForAssociation(request: AvonRequest): import("./Fields").Field[];
        fields(request: AvonRequest): import("./Fields").Field[];
    };
    fieldsForCreate(request: AvonRequest): import("./Fields").Field[];
    fieldsForUpdate(request: AvonRequest): import("./Fields").Field[];
    fieldsForIndex(request: AvonRequest): import("./Fields").Field[];
    fieldsForDetail(request: AvonRequest): import("./Fields").Field[];
    fieldsForReview(request: AvonRequest): import("./Fields").Field[];
    fieldsForAssociation(request: AvonRequest): import("./Fields").Field[];
    fields(request: AvonRequest): import("./Fields").Field[];
}) & (abstract new (...args: import("./Contracts").Args) => {
    authorizeTo(request: AvonRequest, ability: Ability, args?: import("./Contracts").AnyArray): Promise<void>;
    authorizedTo(request: AvonRequest, ability: Ability, args?: import("./Contracts").AnyArray): Promise<boolean>;
    authorizable(): boolean;
    makeAuthorizationCallback(ability: string): string;
    authorizedToViewAny(request: AvonRequest): Promise<boolean>;
    authorizedToView(request: AvonRequest): Promise<boolean>;
    authorizedToCreate(request: AvonRequest): Promise<boolean>;
    authorizedToUpdate(request: AvonRequest): Promise<boolean>;
    authorizedToDelete(request: AvonRequest): Promise<boolean>;
    authorizedToForceDelete(request: AvonRequest): Promise<boolean>;
    authorizedToRestore(request: AvonRequest): Promise<boolean>;
    authorizedToAdd(request: AvonRequest, resource: Model): Promise<boolean>;
    authorizedToAttach(request: AvonRequest, resource: Model): Promise<boolean>;
    authorizedToDetach(request: AvonRequest, resource: Model): Promise<boolean>;
}) & {
    new (): {};
};
export default abstract class Resource<TModel extends Model = Model> extends Resource_base {
    /**
     * The resource model instance.
     */
    resource: TModel;
    /**
     * The number of results to display when searching relatable resource.
     */
    relatableSearchResults: number;
    constructor(resource?: TModel);
    /**
     * Create a new instance of the resource for the given model.
     */
    forModel(resource: Model): Resource;
    /**
     * Get the uri-key name of the resource
     */
    uriKey(): string;
    /**
     * Get the pagination per-page values
     */
    perPageOptions(): number[];
    /**
     * Prepare the resource for JSON serialization.
     */
    serializeForIndex(request: AvonRequest): Promise<IndexSerializedResource>;
    /**
     * Prepare the resource for JSON serialization.
     */
    serializeForAssociation(request: AvonRequest): Promise<IndexSerializedResource>;
    /**
     * Prepare the resource for JSON serialization.
     */
    protected serializeIndex(request: AvonRequest, fields: UnknownRecord): Promise<{
        metadata: ResourceMetaData;
        authorization: {
            authorizedToView: boolean;
            authorizedToUpdate: boolean;
            authorizedToDelete: boolean;
            authorizedToForceDelete: boolean | undefined;
            authorizedToRestore: boolean | undefined;
            authorizedToReview: boolean | undefined;
        };
        fields: UnknownRecord;
    }>;
    /**
     * Prepare the resource for JSON serialization.
     */
    serializeForStore(request: AvonRequest): Promise<StoreSerializedResource>;
    /**
     * Prepare the resource for JSON serialization.
     */
    serializeForUpdate(request: AvonRequest): Promise<UpdateSerializedResource>;
    /**
     * Prepare the resource for JSON serialization.
     */
    serializeForDetail(request: AvonRequest): Promise<DetailSerializedResource>;
    /**
     * Prepare the resource for JSON serialization.
     */
    serializeForReview(request: AvonRequest): Promise<ReviewSerializedResource>;
    /**
     * Get the resource metadata.
     */
    protected resourceMetaData(): ResourceMetaData;
    /**
     * Determine whether a given resource is "soft-deleted".
     */
    isSoftDeleted(): boolean;
    /**
     * Get the resource name fo events.
     */
    resourceName(): string;
}
export {};