/**------------------------------------------
 *                                          *
 *               GOOD - COP                 *
 *                                          *
---------------------------------------------

/!\ Some code patterns used here may not seem to follow good practice at first /!\
Here are some technical choices that have been taken and may not be intuitive:
* Everything is in this file, since it's impossible to keep the exact `this` type
when putting methods in another file (I tried a lot)
* types and functional code are "separated" with returning `as NextAutocompletionChoices`
this seems like the best way to choose what to display in the autocomplete suggestion
while avoiding a class extension nighmare like in zod (the downside is that autocompletion
is not as strict as in zod, but maintenability is way easier). Autocompletion example:
when typing `_.object().`, `partial` and `complete` are suggested but `greaterThan` is not

/!\ TO ADD A NEW DEFINITION /!\:
=> FirstLevelTypes: the types displayed on first autocomplete suggestion (base types like number, boolean...)
=> UniversalMethods: the types displayed everywhere else
=> You may then select additional methods to suggest via `NextAutocompletionChoices` in the definition

 */
import 'typescript-generic-types';
import { TranslationObj, MaybeArray } from './core-types.js';
import { DefinitionBase } from './DefinitionBaseClass.js';
import { MongoTypeObj, MongoFieldsRead, MongoFieldsWrite } from './helpers/backendDefinitionsHelpers.js';
import { GoodCopAutoWritedFieldNames, GoodCopDateMethods, GoodCopDefCtx, DefinitionObj, GoodCopDefinitionPartial, CoodCopDefinitionClassReceivedModelType, FirstLevelTypes, GenericDef, InferTypeRead, InferTypeWrite, GoodCopInferTypeArrRead, GoodCopInferTypeArrWrite, GoodCopLengthMethods, GoodCopNextDefinition, GoodCopNumberMethods, GoodCopStringMethods, TypedExclude, GoodCopProvidedModels, GoodCopErrorOptions } from './definitionTypes.js';
import { parseRegexp } from 'topkat-utils';
export declare class Definition<ModelsType extends CoodCopDefinitionClassReceivedModelType = any, OverridedTypeRead = 'def', OverridedTypeWrite = 'def', IsRequiredType extends boolean = false> extends DefinitionBase {
    /** Just an alias for tsTypeRead */
    tsType: OverridedTypeRead;
    tsTypeRead: OverridedTypeRead;
    tsTypeWrite: OverridedTypeWrite;
    isRequiredType: IsRequiredType;
    modelTypes: ModelsType;
    constructor(models?: () => GoodCopProvidedModels, // any is for removing type reference and avoid circular type definition
    definition?: MaybeArray<GoodCopDefinitionPartial>, previousThis?: any);
    /** Meant to be used only the first time you init the definition. Eg: new Definition(...).init() to provide correct autocomplete. This is because I couldn't return the good type from constructor. TODO */
    init(): Pick<typeof this, FirstLevelTypes>;
    /** This is to create a new definition from configuration and a given type */
    private _newDef;
    /** This is not a definition. This will output the mongo schema final type for definition. Eg: _.mongoModel([], { field1: _.string(), ... }})._getMongoType() === { field1: { type: String } ... } */
    _getMongoType(): Record<string, any> | MongoTypeObj;
    array<R extends GenericDef | DefinitionObj>(array?: R): GoodCopNextDefinition<ReturnType<typeof this._newDef<GoodCopInferTypeArrRead<Array<R>>, GoodCopInferTypeArrWrite<Array<R>>>>, GoodCopLengthMethods>;
    any(): GoodCopNextDefinition<ReturnType<typeof this._newDef<any, any>>>;
    boolean(): GoodCopNextDefinition<ReturnType<typeof this._newDef<boolean, boolean>>, "mergeWith">;
    date(): GoodCopNextDefinition<ReturnType<typeof this._newDef<Date>>, GoodCopDateMethods>;
    date8(): GoodCopNextDefinition<ReturnType<typeof this._newDef<number>>, GoodCopDateMethods>;
    date12(): GoodCopNextDefinition<ReturnType<typeof this._newDef<number>>, GoodCopDateMethods>;
    /** simple emial validation: /^[^\s@]+@[^\s@]+\.[^\s@]+$/ */
    email(): GoodCopNextDefinition<ReturnType<typeof this._newDef<string>>, GoodCopStringMethods>;
    /** Predefined list of values. Eg: status: _.enum(['success', 'error', 'pending']) OR _.enum([1, 2, 3]) */
    enum<T extends string[] | number[]>(possibleValues: [...T] | readonly [...T]): GoodCopNextDefinition<ReturnType<typeof this._newDef<T[number]>>, TypedExclude<GoodCopStringMethods, "match">>;
    float(): GoodCopNextDefinition<ReturnType<typeof this._newDef<number>>, GoodCopNumberMethods>;
    false(): GoodCopNextDefinition<ReturnType<typeof this._newDef<boolean, boolean>>, "mergeWith">;
    true(): GoodCopNextDefinition<ReturnType<typeof this._newDef<boolean, boolean>>, "mergeWith">;
    /** This is to get the type of an already defined database model. Eg: model('myDb', 'user') to get the user type from a particular db that you registered at initialization */
    model<A extends keyof ModelsType, B extends keyof ModelsType[A], C extends keyof ModelsType[A][B] = 'Read'>(dbId: A, modelName: B, modelType?: C): GoodCopNextDefinition<ReturnType<typeof this._newDef<ModelsType[A][B][C]>>, "partial" | "complete">;
    /** With this, you can create mongo models, handling _id field type automatically and creator, lastUpdater... fields */
    mongoModel<T extends DefinitionObj, U extends readonly GoodCopAutoWritedFieldNames[]>(autoWriteFields: U, model: T): GoodCopNextDefinition<ReturnType<typeof this._newDef<InferTypeRead<T> & MongoFieldsRead<U[number]>, InferTypeWrite<T> & MongoFieldsWrite>>>;
    /** force this field to be the userId instead of any id */
    forceUserId(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>>;
    /** An object which keys can be anything but where the value shall be typed. Eg: { [k: string]: number } */
    genericObject<FieldName extends string | [string, string] | [string, string, string], ValueType extends DefinitionObj | GenericDef>(
    /** field name can be a string or an array, will be typed as { [string1]: { [string2]: myType } } */
    keyName?: FieldName, valueType?: ValueType): GoodCopNextDefinition<ReturnType<typeof this._newDef<FieldName extends string ? {
        [k: string]: InferTypeRead<ValueType>;
    } : FieldName extends [string, string] ? {
        [k: string]: {
            [k: string]: InferTypeRead<ValueType>;
        };
    } : {
        [k: string]: {
            [k: string]: {
                [k: string]: InferTypeRead<ValueType>;
            };
        };
    }, FieldName extends string ? {
        [k: string]: InferTypeRead<ValueType>;
    } : FieldName extends [string, string] ? {
        [k: string]: {
            [k: string]: InferTypeRead<ValueType>;
        };
    } : {
        [k: string]: {
            [k: string]: {
                [k: string]: InferTypeWrite<ValueType>;
            };
        };
    }>>, "partial" | "complete">;
    /** Only valid on objects, allow to merge two objects */
    mergeWith<T extends DefinitionObj>(object: T): GoodCopNextDefinition<ReturnType<typeof this._newDef<InferTypeRead<T> & typeof this.tsTypeRead, InferTypeWrite<T> & typeof this.tsTypeWrite>>, "partial" | "complete">;
    /** Array of predefined size and value: Eg: { signature: _.tuple([_.date(), _.string()]) } */
    tuple<R extends GenericDef[]>(array: [...R]): GoodCopNextDefinition<ReturnType<typeof this._newDef<R extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], .../*elided*/ any] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : [], R extends [infer A_1, ...infer R_2] ? A_1 extends GenericDef ? [A_1["tsTypeWrite"], ...R_2 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], ...R_1 extends [infer A, ...infer R_1] ? A extends GenericDef ? [A["tsTypeRead"], .../*elided*/ any] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []>>>;
    object<T extends DefinitionObj>(object?: T, { 
    /** Whenever to delete fields that are not included in the original model */
    deleteForeignKeys, }?: {
        deleteForeignKeys?: boolean;
    }): GoodCopNextDefinition<ReturnType<typeof this._newDef<InferTypeRead<T>, InferTypeWrite<T>>>, "complete" | "partial" | "mergeWith">;
    /** For all props of an object type to be OPTIONAL */
    partial(): GoodCopNextDefinition<ReturnType<typeof this._newDef<Partial<typeof this.tsTypeRead>, Partial<typeof this.tsTypeWrite>>>, "mergeWith">;
    integer(): GoodCopNextDefinition<ReturnType<typeof this._newDef<number>>, TypedExclude<GoodCopNumberMethods, "round2">>;
    /** String alias for readability. 24 char mongoDb id */
    objectId(): GoodCopNextDefinition<ReturnType<typeof this._newDef<string>>, GoodCopStringMethods>;
    match(...params: [Parameters<typeof this['regexp']>[0], Parameters<typeof this['regexp']>[1]]): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopStringMethods, "match">>;
    number(): GoodCopNextDefinition<ReturnType<typeof this._newDef<number>>, GoodCopNumberMethods>;
    password({ regexp, // at least one upperCase, one lowerCase and a digit
    minLength, maxLength, encrypt }: {
        regexp?: RegExp;
        minLength?: number;
        maxLength?: number;
        encrypt(value: string): string | Promise<string>;
    }): GoodCopNextDefinition<ReturnType<typeof this._newDef<string>>, GoodCopStringMethods>;
    percentage(): GoodCopNextDefinition<ReturnType<typeof this._newDef<number>>, GoodCopNumberMethods>;
    ref<AlwaysPopulated extends boolean, ModelName extends keyof MergeMultipleObjects<ModelsType>>(modelName: ModelName, alwaysPopulated?: AlwaysPopulated): GoodCopNextDefinition<ReturnType<typeof this._newDef<AlwaysPopulated extends true ? MergeMultipleObjects<ModelsType>[ModelName] : AlwaysPopulated extends false ? string : MergeMultipleObjects<ModelsType>[ModelName] | string, string>>>;
    regexp(regexpOrStr: string | RegExp, regexpOptions?: Parameters<typeof parseRegexp>[1]): GoodCopNextDefinition<ReturnType<typeof this._newDef<string>>, TypedExclude<GoodCopStringMethods, "match">>;
    string({ acceptEmpty }?: {
        acceptEmpty?: boolean;
    }): GoodCopNextDefinition<ReturnType<typeof this._newDef<string>>, GoodCopStringMethods>;
    stringConstant<T extends string>(hardCodedValue: T): GoodCopNextDefinition<ReturnType<typeof this._newDef<T>>, GoodCopStringMethods>;
    /** an object who's keys are locale and values are translation string. Eg: `{ fr: 'Salut', en: 'Hi' }` */
    translation(): GoodCopNextDefinition<ReturnType<typeof this._newDef<TranslationObj>>>;
    /** Simple url validation: /^https?:\/\/.+/ */
    url(): GoodCopNextDefinition<ReturnType<typeof this._newDef<string>>, GoodCopStringMethods>;
    year(): GoodCopNextDefinition<ReturnType<typeof this._newDef<number>>, GoodCopDateMethods>;
    /** Should be used if the value is expected to be undefined */
    void(): GoodCopNextDefinition<ReturnType<typeof this._newDef<void>>>;
    /** Should be used if the value is expected to be undefined */
    undefined(): GoodCopNextDefinition<ReturnType<typeof this._newDef<undefined>>>;
    null(): GoodCopNextDefinition<ReturnType<typeof this._newDef<null>>>;
    /** **Note:** formatting will not work for typesOr checks */
    typesOr<T extends GenericDef[]>(types: [...T]): GoodCopNextDefinition<ReturnType<typeof this._newDef<(T extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], .../*elided*/ any] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : [])[number], (T extends [infer A_1, ...infer R_1] ? A_1 extends GenericDef ? [A_1["tsTypeWrite"], ...R_1 extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], ...R extends [infer A, ...infer R] ? A extends GenericDef ? [A["tsTypeRead"], .../*elided*/ any] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : []] : [] : [])[number]>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    /** useful for database types where some fields may be always defined in read (_id, creationDate...) but not required on creation */
    alwaysDefinedInRead(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    between(min: number, max: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "min" | "gt" | "gte" | "greaterThan" | "max" | "lt" | "lte" | "lessThan">>;
    /** For all props of an object type to be REQUIRED */
    complete(): GoodCopNextDefinition<ReturnType<typeof this._newDef<Required<typeof this.tsTypeRead>, Required<typeof this.tsTypeWrite>>>, "mergeWith">;
    gte(minVal: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "min" | "gt" | "gte" | "greaterThan">>;
    greaterThan(minVal: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "min" | "gt" | "gte" | "greaterThan">>;
    gt(minVal: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "min" | "gt" | "gte" | "greaterThan">>;
    isFuture(): GoodCopNextDefinition<ReturnType<typeof this._newDef<number>>, GoodCopDateMethods>;
    length(length: number, comparisonOperator?: '<' | '>' | '==='): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends any[] ? never : GoodCopStringMethods>;
    lessThan(maxVal: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "max" | "lt" | "lte" | "lessThan">>;
    lowerCase(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopStringMethods, "upperCase" | "lowerCase">>;
    upperCase(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopStringMethods, "upperCase" | "lowerCase">>;
    max(maxVal: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "max" | "lt" | "lte" | "lessThan">>;
    lte(maxVal: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "max" | "lt" | "lte" | "lessThan">>;
    lt(maxVal: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "max" | "lt" | "lte" | "lessThan">>;
    min(minVal: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "min" | "gt" | "gte" | "greaterThan">>;
    round2(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "round2">>;
    positive(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopNumberMethods, "positive">>;
    trim(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, TypedExclude<GoodCopStringMethods, "trim">>;
    minLength(minLength: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends any[] ? never : GoodCopStringMethods>;
    maxLength(maxLength: number): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends any[] ? never : GoodCopStringMethods>;
    /** Formatting happens first, before every validations */
    onFormat(callback: ((ctx: GoodCopDefCtx) => any) | ((ctx: GoodCopDefCtx) => Promise<any>)): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    default(defaultValue: ((ctx: GoodCopDefCtx) => any) | (string | any[] | Record<string, any> | Date | boolean | number | null)): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    optional(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite, false>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    required(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite, true>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    /** Append extra infos to any errors that may throw during format and validate */
    errorExtraInfos(errorExtraInfos: GoodCopErrorOptions): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    /** Alias to write paramName in extraInfos */
    name(name: string, paramNumber?: number): Pick<typeof this, FirstLevelTypes>;
    /** NAME => Alias to write paramName in extraInfos */
    n(name: string, paramNumber?: number): Pick<typeof this, FirstLevelTypes>;
    /** Make the callback return false to unvalidate this field and trigger an error. Note: validation happens after formating */
    onValidate(callback: (ctx: GoodCopDefCtx) => any): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    promise(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    unique(): GoodCopNextDefinition<ReturnType<typeof this._newDef<typeof this.tsTypeRead, typeof this.tsTypeWrite>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
    ts<TsTypeRead, TsTypeWrite>(tsString: string, tsTypeWrite?: string): GoodCopNextDefinition<ReturnType<typeof this._newDef<TsTypeRead, TsTypeWrite>>, (typeof this)["tsTypeRead"] extends string ? GoodCopStringMethods : (typeof this)["tsTypeRead"] extends number ? GoodCopNumberMethods : never>;
}
export declare const _: Pick<Definition<any, "def", "def", false>, "string" | "number" | "boolean" | "undefined" | "object" | "n" | "any" | "regexp" | "true" | "false" | "null" | "date" | "objectId" | "array" | "year" | "email" | "name" | "ref" | "model" | "password" | "url" | "float" | "integer" | "date12" | "date8" | "enum" | "genericObject" | "mongoModel" | "percentage" | "stringConstant" | "translation" | "tuple" | "typesOr" | "void">;