//#region src/utils.d.ts
type FieldKey = string;
type ObjectType<T = Record<FieldKey, unknown>> = T extends object ? T extends unknown[] ? never : T & {} : never;
declare function getKeysAsProps<T>(object: T): KeyOf<T>[];
/**
 * tells whether `a` & `b` are equals
 * @param  depth how deep in nesting should equality checks be performed for objects
 */
declare function isEqual<T>(a: unknown, b: T, depth?: number): a is T;
declare function isFunctionLike<T extends Function>(value: unknown): value is T;
declare function isNullOrUndefined(value: unknown): value is null | undefined;
declare function isOneOf<T>(value: unknown, values: ArrayOfMinSizeTwo<T> | Readonly<ArrayOfMinSizeTwo<T>>): value is T;
declare function isRecordLike<T extends ObjectType>(value: unknown): value is ObjectType<T>;
declare function isPropertyOf<T>(prop: string | number | symbol, object: T): prop is keyof T;
declare function toArray<T>(value: T | T[]): T[];
//#endregion
//#region src/schema/utils/types.d.ts
declare const SCHEMA_ERRORS: {
  readonly INVALID_SCHEMA: "INVALID_SCHEMA";
};
declare const VALIDATION_ERRORS: {
  readonly NOTHING_TO_UPDATE: "NOTHING_TO_UPDATE";
  readonly VALIDATION_ERROR: "VALIDATION_ERROR";
};
declare const ERRORS: {
  readonly NOTHING_TO_UPDATE: "NOTHING_TO_UPDATE";
  readonly VALIDATION_ERROR: "VALIDATION_ERROR";
  readonly INVALID_SCHEMA: "INVALID_SCHEMA";
};
type ValidationErrorMessage = keyof typeof VALIDATION_ERRORS;
type FieldError = {
  reason: string;
  metadata: Record<FieldKey, unknown> | null;
};
type InputFieldError = FieldError | {
  reason: FieldError['reason'];
} | {
  metadata: FieldError['metadata'];
};
type ErrorPayload<Keys extends FieldKey = FieldKey> = Partial<Record<Keys, FieldError>>;
type InputPayload = Record<FieldKey, string | FieldError>;
type IValidationError<ExtraData extends ObjectType = never> = ({
  message: ValidationErrorMessage;
} & ExtraData) & {};
interface IErrorTool<ExtraData extends ObjectType = never> {
  /** return what your validation error should look like from this method */
  get data(): IValidationError<ExtraData>;
  /** array of fields that have failed validation */
  get fields(): string[];
  /** determines if validation has failed */
  get isLoaded(): boolean;
  /**
  - Appends a field to your final validation error
  - if validation payload already has provided field, only the metadata (if available) will be updated
  */
  set(field: FieldKey, error: FieldError, value?: unknown): this;
  /** method to set the value of the validation error message */
  setMessage(message: ValidationErrorMessage): this;
}
//#endregion
//#region src/schema/utils/error-tool.d.ts
declare class DefaultErrorTool<PayloadKeys extends FieldKey = FieldKey> implements IErrorTool<{
  payload: ErrorPayload<PayloadKeys>;
}> {
  private message;
  private _payload;
  constructor(message: ValidationErrorMessage);
  get data(): {
    message: "NOTHING_TO_UPDATE" | "VALIDATION_ERROR";
    payload: Partial<Record<PayloadKeys, FieldError>>;
  };
  get fields(): string[];
  get isLoaded(): boolean;
  set(field: PayloadKeys, value: FieldError): this;
  setMessage(message: ValidationErrorMessage): this;
}
//#endregion
//#region src/schema/utils/timestamp-tool.d.ts
declare class TimeStampTool {
  private _keys;
  private timestamps;
  private nullable;
  constructor(timestamps: NS.Options<unknown, unknown, unknown>['timestamps']);
  private _makeTimestamps;
  getKeys(): {
    createdAt: string;
    updatedAt: string;
  };
  isTimestampKey: (key: string) => boolean;
  get isNullable(): boolean;
  get withTimestamps(): boolean;
}
//#endregion
//#region src/schema/utils/index.d.ts
declare function isFieldError(data: unknown): data is FieldError;
declare function isInputFieldError(data: unknown): data is Partial<FieldError>;
declare function makeFieldError(value: InputPayload[FieldKey] | InputFieldError, fallbackMessage?: string): FieldError;
//#endregion
//#region src/schema/types.d.ts
type Context<Input, Output = Input> = Readonly<Merge<Input, Output> & {}>;
type SetterFnData<Input, Output = Input, CtxOptions extends ObjectType = {}> = Readonly<WithCtxOptions<{
  ctx: Context<Input, Output>;
}, CtxOptions>>;
type ReadonlyIvoSummary<Input, Output = Input, CtxOptions extends ObjectType = {}> = (Readonly<WithReadonlyCtxOptions<{
  changes: null;
  ctx: Context<Input, Output>;
  inputValues: Partial<RealType<Input>>;
  isUpdate: false;
  previousValues: null;
  values: Readonly<Output>;
}, CtxOptions>> | Readonly<WithReadonlyCtxOptions<{
  changes: Partial<RealType<Output>>;
  ctx: Context<Input, Output>;
  inputValues: Partial<RealType<Input>>;
  isUpdate: true;
  previousValues: Readonly<Output>;
  values: Readonly<Output>;
}, CtxOptions>>) & {};
type IvoSummary<Input, Output = Input, CtxOptions extends ObjectType = {}> = (Readonly<WithCtxOptions<{
  changes: null;
  ctx: Context<Input, Output>;
  inputValues: Partial<RealType<Input>>;
  isUpdate: false;
  previousValues: null;
  values: Readonly<Output>;
}, CtxOptions>> | Readonly<WithCtxOptions<{
  changes: Partial<RealType<Output>>;
  ctx: Context<Input, Output>;
  inputValues: Partial<RealType<Input>>;
  isUpdate: true;
  previousValues: Readonly<Output>;
  values: Readonly<Output>;
}, CtxOptions>>) & {};
type WithReadonlyCtxOptions<T, CtxOptions extends ObjectType> = T & {
  options: Readonly<CtxOptions>;
};
type WithCtxOptions<T, CtxOptions extends ObjectType> = WithReadonlyCtxOptions<T, CtxOptions> & {
  updateOptions: (updates: Partial<CtxOptions>) => void;
} & {};
type TypeOf<T> = Exclude<T, undefined>;
type AsyncSetter<T, Input, Output, CtxOptions extends ObjectType> = (data: SetterFnData<Input, Output, CtxOptions>) => TypeOf<T> | Promise<TypeOf<T>>;
type NotAllowedError = string | InputFieldError;
type SetterWithSummary<T, Input, Output, CtxOptions extends ObjectType> = (summary: IvoSummary<Input, Output, CtxOptions> & {}) => TypeOf<T>;
type Setter<T, Input, Output, CtxOptions extends ObjectType> = (data: SetterFnData<Input, Output, CtxOptions>) => TypeOf<T>;
type RequiredHandlerRes = boolean | [boolean, string] | [boolean, InputFieldError] | readonly [boolean, string] | readonly [boolean, InputFieldError];
type RequiredHandler<Input, Output, CtxOptions extends ObjectType> = (summary: IvoSummary<Input, Output, CtxOptions> & {}) => RequiredHandlerRes | Promise<RequiredHandlerRes>;
type AsyncShouldUpdate<Input, Output, CtxOptions extends ObjectType = {}> = (summary: IvoSummary<Input, Output, CtxOptions> & {}) => boolean | Promise<boolean>;
type Resolver<K extends keyof Output, Input, Output, CtxOptions extends ObjectType> = (summary: IvoSummary<Input, Output, CtxOptions> & {}) => TypeOf<Output[K]> | Promise<TypeOf<Output[K]>>;
type VirtualResolver<K extends keyof Input, Input, Output, CtxOptions extends ObjectType> = (summary: IvoSummary<Input, Output, CtxOptions>) => TypeOf<Input[K]> | Promise<TypeOf<Input[K]>>;
type PostValidator<InputKeys extends KeyOf<Input>, Input, Output, Aliases, CtxOptions extends ObjectType> = (summary: IvoSummary<Input, Output, CtxOptions>, propertiesProvided: InputKeys[]) => undefined | ResponseErrorObject<Input, Aliases> | PostValidatorSanitizedResponse<InputKeys, Input, Output> | Promise<undefined | ResponseErrorObject<Input, Aliases> | PostValidatorSanitizedResponse<InputKeys, Input, Output>>;
type PostValidatorSanitizedResponse<K extends KeyOf<Input>, Input, Output> = { [Key in K]?: {
  validated: TypeOf<Key extends KeyOf<Output> ? Output[Key] : Input[Key]>;
} };
type PostValidationConfig<K extends KeyOf<Input>, Input, Output, Aliases, CtxOptions extends ObjectType> = {
  properties: ArrayOfMinSizeTwo<K>;
  validator: PostValidator<K, Input, Output, Aliases, CtxOptions> | ArrayOfMinSizeOne<PostValidator<K, Input, Output, Aliases, CtxOptions> | ArrayOfMinSizeOne<PostValidator<K, Input, Output, Aliases, CtxOptions>>>;
};
type KeyOf<T> = Extract<keyof T, string>;
declare namespace NS {
  export type LifeCycle = (typeof LIFE_CYCLES)[number];
  export type DeleteHandler<Output, CtxOptions extends ObjectType> = (data: Readonly<Output>, options: Readonly<CtxOptions>) => unknown | Promise<unknown>;
  export type FailureHandler<Input, Output, CtxOptions extends ObjectType = {}> = (ctx: Context<Input, Output>, options: Readonly<CtxOptions>) => unknown | Promise<unknown>;
  export type SuccessHandler<Input, Output, CtxOptions extends ObjectType = {}> = (summary: ReadonlyIvoSummary<Input, Output, CtxOptions>) => unknown | Promise<unknown>;
  export type OnSuccessConfigObject<Input, Output, CtxOptions extends ObjectType> = {
    properties: ArrayOfMinSizeTwo<KeyOf<Input & Output>>;
    handler: SuccessHandler<Input, Output, CtxOptions> | ArrayOfMinSizeOne<SuccessHandler<Input, Output, CtxOptions>>;
  };
  export type OnSuccessConfig<Input, Output, CtxOptions extends ObjectType> = SuccessHandler<Input, Output, CtxOptions> | OnSuccessConfigObject<Input, Output, CtxOptions> | ArrayOfMinSizeOne<SuccessHandler<Input, Output, CtxOptions> | OnSuccessConfigObject<Input, Output, CtxOptions>>;
  export type Definitions<Input, Output, Aliases, CtxOptions extends ObjectType> = PrettyType<{ [K in keyof (Input | Output)]: PublicProperty<K, Input, Output, CtxOptions> } & { [K in keyof Omit<Output, keyof Input>]?: PrivateProperty<K, Input, Output, CtxOptions> } & { [K in keyof Omit<Input, keyof Output>]: Virtual<K, Input, Output, Aliases, CtxOptions> }>;
  type PublicProperty<K extends keyof (Output | Input), Input, Output, CtxOptions extends ObjectType = {}> = Enumerable<Output[K]> & (LaxProperty<K, Input, Output, CtxOptions> | ReadOnly<K, Input, Output, CtxOptions> | ReadonlyNoInit<K, Input, Output, CtxOptions> | Required<K, Input, Output, CtxOptions> | RequiredBy<K, Input, Output, CtxOptions> | RequiredReadonly<K, Input, Output, CtxOptions>);
  type PrivateProperty<K extends keyof Output, Input, Output, CtxOptions extends ObjectType = {}> = XOR<Constant<K, Input, Output, CtxOptions>, Dependent<K, Input, Output, CtxOptions>>;
  export type Definitions_<Input, Output> = { [K in keyof Input]?: Listenable<Input, Output, {}> & {
    allow?: Readonly<ArrayOfMinSizeTwo<unknown>> | {
      values: Readonly<ArrayOfMinSizeTwo<unknown>>;
      error?: NotAllowedError | ((value: unknown, allowedValues: ArrayOfMinSizeOne<unknown>) => NotAllowedError);
    };
    alias?: string;
    constant?: unknown;
    default?: unknown;
    dependsOn?: KeyOf<Input> | KeyOf<Input>[];
    ignore?: SetterWithSummary<boolean, Input, Output, {}>;
    readonly?: boolean | 'lax';
    resolver?: Function;
    required?: boolean | RequiredHandler<Input, Output, {}>;
    sanitizer?: VirtualResolver<K, Input, Output, {}>;
    shouldInit?: false | Setter<boolean, Input, Output, {}>;
    shouldUpdate?: false | Setter<boolean, Input, Output, {}>;
    validator?: Function | [Function, Function];
    value?: unknown;
    virtual?: boolean;
  } };
  export type AliasToVirtualMap<T> = Record<string, KeyOf<T>>;
  export type VirtualToAliasMap<T> = Record<KeyOf<T>, string>;
  export type DependencyMap<T> = { [K in KeyOf<T>]?: KeyOf<T>[] };
  type Listenable<Input, Output, CtxOptions extends ObjectType> = {
    onDelete?: DeleteHandler<Output, CtxOptions> | ArrayOfMinSizeOne<DeleteHandler<Output, CtxOptions>>;
    onFailure?: FailureHandler<Input, Output, CtxOptions> | ArrayOfMinSizeOne<FailureHandler<Input, Output, CtxOptions>>;
    onSuccess?: SuccessHandler<Input, Output, CtxOptions> | ArrayOfMinSizeOne<SuccessHandler<Input, Output, CtxOptions>>;
  };
  type Constant<K extends keyof Output, Input, Output, CtxOptions extends ObjectType> = {
    constant: true;
    onDelete?: DeleteHandler<Output, CtxOptions> | ArrayOfMinSizeOne<DeleteHandler<Output, CtxOptions>>;
    onSuccess?: SuccessHandler<Input, Output, CtxOptions> | ArrayOfMinSizeOne<SuccessHandler<Input, Output, CtxOptions>>;
    value: TypeOf<Output[K]> | AsyncSetter<Output[K], Input, Output, CtxOptions>;
  };
  type Enumerable<T, V extends T | Readonly<T> = T> = {
    allow?: ArrayOfMinSizeTwo<V> | {
      values: ArrayOfMinSizeTwo<V>;
      error?: NotAllowedError | ((value: unknown, allowedValues: ArrayOfMinSizeOne<T>) => NotAllowedError);
    };
  };
  type Dependables<K extends keyof Output, Input, Output> = Exclude<KeyOf<Context<Input, Output>>, K>;
  type Dependent<K extends keyof Output, Input, Output, CtxOptions extends ObjectType> = {
    default: TypeOf<Output[K]> | AsyncSetter<Output[K], Input, Output, CtxOptions>;
    dependsOn: Dependables<K, Input, Output> | ArrayOfMinSizeOne<Dependables<K, Input, Output>>;
    onDelete?: DeleteHandler<Output, CtxOptions> | ArrayOfMinSizeOne<DeleteHandler<Output, CtxOptions>>;
    onSuccess?: SuccessHandler<Input, Output, CtxOptions> | ArrayOfMinSizeOne<SuccessHandler<Input, Output, CtxOptions>>;
    readonly?: true;
    resolver: Resolver<K, Input, Output, CtxOptions>;
  };
  type InitAndUpdateBlockable<Input, Output, CtxOptions extends ObjectType> = XOR<{
    ignore?: SetterWithSummary<boolean, Input, Output, CtxOptions>;
  }, XOR<{
    shouldInit?: Setter<boolean, Input, Output, CtxOptions>;
    shouldUpdate?: Setter<boolean, Input, Output, CtxOptions>;
  }, XOR<{
    shouldInit?: false | Setter<boolean, Input, Output, CtxOptions>;
    shouldUpdate?: Setter<boolean, Input, Output, CtxOptions>;
  }, {
    shouldInit?: Setter<boolean, Input, Output, CtxOptions>;
    shouldUpdate?: false | Setter<boolean, Input, Output, CtxOptions>;
  }>>>;
  type LaxProperty<K extends keyof (Output | Input), Input, Output, CtxOptions extends ObjectType> = Listenable<Input, Output, CtxOptions> & InitAndUpdateBlockable<Input, Output, CtxOptions> & {
    default: TypeOf<Output[K]> | AsyncSetter<Output[K], Input, Output, CtxOptions>;
    validator?: Validator<K, Input, Output, CtxOptions> | [Validator<K, Input, Output, CtxOptions>, SecondaryValidator<Output[K], Input, Output, CtxOptions>];
  };
  type ReadOnly<K extends keyof (Output | Input), Input, Output, CtxOptions extends ObjectType> = Listenable<Input, Output, CtxOptions> & {
    default: TypeOf<Output[K]> | AsyncSetter<Output[K], Input, Output, CtxOptions>;
    readonly: 'lax';
    validator: Validator<K, Input, Output, CtxOptions> | [Validator<K, Input, Output, CtxOptions>, SecondaryValidator<Output[K], Input, Output, CtxOptions>];
  } & XOR<{
    ignore?: SetterWithSummary<boolean, Input, Output, CtxOptions>;
  }, {
    shouldInit?: Setter<boolean, Input, Output, CtxOptions>;
    shouldUpdate?: Setter<boolean, Input, Output, CtxOptions>;
  }>;
  type ReadonlyNoInit<K extends keyof (Output | Input), Input, Output, CtxOptions extends ObjectType> = Listenable<Input, Output, CtxOptions> & {
    default: TypeOf<Output[K]> | AsyncSetter<Output[K], Input, Output, CtxOptions>;
    readonly: true;
    validator?: Validator<K, Input, Output, CtxOptions> | [Validator<K, Input, Output, CtxOptions>, SecondaryValidator<Output[K], Input, Output, CtxOptions>];
  } & XOR<{
    ignore?: SetterWithSummary<boolean, Input, Output, CtxOptions>;
  }, {
    shouldInit?: false | Setter<boolean, Input, Output, CtxOptions>;
    shouldUpdate?: Setter<boolean, Input, Output, CtxOptions>;
  }>;
  type RequiredReadonly<K extends keyof (Output | Input), Input, Output, CtxOptions extends ObjectType> = Listenable<Input, Output, CtxOptions> & {
    readonly: true;
  } & ({
    validator: Validator<K, Input, Output, CtxOptions> | [Validator<K, Input, Output, CtxOptions>, SecondaryValidator<Output[K], Input, Output, CtxOptions>];
  } | (Enumerable<Input[K]> & {
    validator?: Validator<K, Input, Output, CtxOptions> | [Validator<K, Input, Output, CtxOptions>, SecondaryValidator<Output[K], Input, Output, CtxOptions>];
  }));
  type Required<K extends keyof (Output | Input), Input, Output, CtxOptions extends ObjectType> = Listenable<Input, Output, CtxOptions> & {
    required: true;
    shouldUpdate?: false | Setter<boolean, Input, Output, CtxOptions>;
  } & ({
    validator: Validator<K, Input, Output, CtxOptions> | [Validator<K, Input, Output, CtxOptions>, SecondaryValidator<Output[K], Input, Output, CtxOptions>];
  } | (Enumerable<Input[K]> & {
    validator?: Validator<K, Input, Output, CtxOptions> | [Validator<K, Input, Output, CtxOptions>, SecondaryValidator<Output[K], Input, Output, CtxOptions>];
  }));
  type RequiredBy<K extends keyof (Output | Input), Input, Output, CtxOptions extends ObjectType> = Listenable<Input, Output, CtxOptions> & {
    default: TypeOf<Output[K]> | AsyncSetter<Output[K], Input, Output, CtxOptions>;
    required: RequiredHandler<Input, Output, CtxOptions>;
    readonly?: true;
    validator: Validator<K, Input, Output, CtxOptions> | [Validator<K, Input, Output, CtxOptions>, SecondaryValidator<Output[K], Input, Output, CtxOptions>];
  } & XOR<{
    ignore?: SetterWithSummary<boolean, Input, Output, CtxOptions>;
  }, {
    shouldInit?: Setter<boolean, Input, Output, CtxOptions>;
    shouldUpdate?: Setter<boolean, Input, Output, CtxOptions>;
  }>;
  type Virtual<K extends keyof Input, Input, Output, Aliases, CtxOptions extends ObjectType> = InitAndUpdateBlockable<Input, Output, CtxOptions> & Enumerable<Input[K]> & {
    alias?: Exclude<KeyOf<Aliases>, K> extends undefined ? string : Exclude<KeyOf<Aliases>, K>;
    required?: RequiredHandler<Input, Output, CtxOptions>;
    virtual: true;
    sanitizer?: VirtualResolver<K, Input, Output, CtxOptions>;
    onFailure?: FailureHandler<Input, Output, CtxOptions> | ArrayOfMinSizeOne<FailureHandler<Input, Output, CtxOptions>>;
    onSuccess?: SuccessHandler<Input, Output, CtxOptions> | ArrayOfMinSizeOne<SuccessHandler<Input, Output, CtxOptions>>;
    validator: VirtualValidator<K, Input, Output, CtxOptions> | [VirtualValidator<K, Input, Output, CtxOptions>, SecondaryValidator<Input[K], Input, Output, CtxOptions>];
  };
  export type InternalOptions<Input, Output, CtxOptions extends ObjectType, ErrorTool extends IErrorTool<ObjectType> = never> = {
    ErrorTool: ErrorToolClass<ErrorTool, CtxOptions>;
    equalityDepth: number;
    onDelete?: DeleteHandler<Output, CtxOptions> | ArrayOfMinSizeOne<DeleteHandler<Output, CtxOptions>>;
    onSuccess?: SuccessHandler<Input, Output, CtxOptions> | ArrayOfMinSizeOne<SuccessHandler<Input, Output, CtxOptions>>;
    postValidate?: PostValidationConfig<KeyOf<Input>, Input, Output, object, CtxOptions> | ArrayOfMinSizeOne<PostValidationConfig<KeyOf<Input>, Input, Output, object, CtxOptions>>;
    setMissingDefaultsOnUpdate?: boolean;
    shouldUpdate?: boolean | AsyncShouldUpdate<Input, Output, CtxOptions>;
    timestamps?: boolean | {
      createdAt?: boolean | string;
      updatedAt?: boolean | string;
    };
  };
  export type Options<Input, Output, Aliases, ErrorTool extends IErrorTool<ObjectType> = never, CtxOptions extends ObjectType = {}> = {
    ErrorTool?: ErrorToolClass<ErrorTool, CtxOptions>;
    equalityDepth?: number;
    onDelete?: DeleteHandler<Output, CtxOptions> | ArrayOfMinSizeOne<DeleteHandler<Output, CtxOptions>>;
    onSuccess?: OnSuccessConfig<Input, Output, CtxOptions>;
    postValidate?: PostValidationConfig<KeyOf<Input>, Input, Output, Aliases, CtxOptions> | ArrayOfMinSizeOne<PostValidationConfig<KeyOf<Input>, Input, Output, Aliases, CtxOptions>>;
    setMissingDefaultsOnUpdate?: boolean;
    shouldUpdate?: boolean | AsyncShouldUpdate<Input, Output, CtxOptions>;
    timestamps?: boolean | {
      createdAt?: boolean | string;
      updatedAt?: boolean | string | {
        key?: string;
        nullable?: boolean;
      };
    };
  };
  export type OptionsKey<Input, Output, Aliases, ErrorTool extends IErrorTool<never>> = KeyOf<Options<Input, Output, Aliases, ErrorTool>>;
  export type PrivateOptions = {
    timestamps: Timestamp;
  };
  export type Timestamp = {
    createdAt: string;
    updatedAt: string;
  };
  export type ExtensionOptions<ParentInput, ParentOutput, Input, Output, Aliases, ErrorTool extends IErrorTool<ObjectType>, CtxOptions extends ObjectType = {}> = Options<Input, Output, Aliases, ErrorTool, CtxOptions> & {
    remove?: KeyOf<Merge<ParentInput, ParentOutput>> | KeyOf<Merge<ParentInput, ParentOutput>>[];
    useParentOptions?: boolean;
  };
  export {};
}
type ValidationResponse<T> = {
  valid: true;
  validated: T;
} | {
  metadata: FieldError['metadata'];
  reason: string;
  valid: false;
};
type InvalidValidatorResponse = {
  metadata?: FieldError['metadata'];
  reason?: string;
  valid: false;
  value?: unknown;
};
type ValidatorResponseObject<T> = {
  valid: true;
  validated?: T;
} | InvalidValidatorResponse;
type ResponseErrorObject<Input = object, Aliases = object> = { [K in KeyOf<Input & Aliases>]?: string | InputFieldError };
type ValidatorResponse<T> = boolean | (ValidatorResponseObject<T> & {});
type Validator<K extends keyof (Output | Input), Input, Output, CtxOptions extends ObjectType = {}> = (value: unknown, summary: IvoSummary<Input, Output, CtxOptions> & {}) => ValidatorResponse<TypeOf<Output[K]>> | Promise<ValidatorResponse<TypeOf<Output[K]>>>;
type SecondaryValidator<T, Input, Output, CtxOptions extends ObjectType = {}> = (value: T, summary: IvoSummary<Input, Output, CtxOptions> & {}) => ValidatorResponse<T> | Promise<ValidatorResponse<T>>;
type VirtualValidator<K extends keyof Input, Input, Output, CtxOptions extends ObjectType = {}> = (value: unknown, summary: IvoSummary<Input, Output, CtxOptions> & {}) => ValidatorResponse<TypeOf<Input[K]>> | Promise<ValidatorResponse<TypeOf<Input[K]>>>;
type ArrayOfMinSizeOne<T> = [T, ...T[]] | readonly [T, ...T[]];
type ArrayOfMinSizeTwo<T> = [T, T, ...T[]] | readonly [T, T, ...T[]];
declare const DEFINITION_RULES: readonly ["alias", "allow", "constant", "default", "dependsOn", "ignore", "onDelete", "onFailure", "onSuccess", "readonly", "resolver", "required", "sanitizer", "shouldInit", "shouldUpdate", "validator", "value", "virtual"];
type DefinitionRule = (typeof DEFINITION_RULES)[number];
declare const LIFE_CYCLES: readonly ["onDelete", "onFailure", "onSuccess"];
interface ErrorToolClass<ErrorTool, CtxOptions extends ObjectType> {
  new (message: ValidationErrorMessage, ctxOptions: CtxOptions): ErrorTool;
}
type TypeFromPromise<T> = T extends Promise<infer I> ? I : T;
type RealType_<T> = T extends ((...args: never) => infer I) ? I : T;
type PrettyType<T> = { [K in keyof T]: T[K] } & {};
type RealType<T> = { [K in keyof T]: TypeFromPromise<Exclude<T[K], Function> | RealType_<T[K]>> } & {};
type Merge<A, B> = { [K in keyof A | keyof B]: Exclude<K extends keyof A ? K extends keyof B ? A[K] | B[K] : A[K] : K extends keyof B ? B[K] : never, undefined> };
type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
type XOR<T, U> = (T | U extends object ? (Without<T, U> & U) | ((Without<U, T> & T) & {}) : T | U) & {};
//#endregion
//#region src/schema/schema-core.d.ts
declare abstract class SchemaCore<Input, Output, CtxOptions extends ObjectType, ErrorTool extends IErrorTool<ObjectType>> {
  protected _definitions: NS.Definitions_<Input, Output>;
  protected _options: NS.InternalOptions<Input, Output, CtxOptions, ErrorTool>;
  protected defaults: Partial<Output>;
  protected readonly aliasToVirtualMap: NS.AliasToVirtualMap<Input>;
  protected readonly dependencyMap: NS.DependencyMap<Input>;
  protected readonly propsToAllowedValuesMap: Map<string, Set<unknown>>;
  protected readonly propsWithSecondaryValidators: Set<string>;
  protected readonly virtualToAliasMap: NS.AliasToVirtualMap<Input>;
  protected readonly postValidationConfigMap: Map<string, {
    index: number;
    validators: PostValidationConfig<KeyOf<Input>, Input, Output, unknown, CtxOptions>["validator"];
  }>;
  protected readonly propToPostValidationConfigIDsMap: Map<string, Set<string>>;
  protected readonly onSuccessConfigMap: Map<string, {
    index: number;
    handlers: NS.SuccessHandler<Input, Output, CtxOptions>[];
  }>;
  protected readonly propToOnSuccessConfigIDMap: Map<string, Set<string>>;
  protected readonly constants: Set<KeyOf<Output>>;
  protected readonly dependents: Set<KeyOf<Output>>;
  protected readonly laxProps: Set<KeyOf<Input>>;
  protected readonly props: Set<KeyOf<Output>>;
  protected readonly propsRequiredBy: Set<KeyOf<Input>>;
  protected readonly readonlyProps: Set<KeyOf<Input>>;
  protected readonly requiredProps: Set<KeyOf<Input>>;
  protected readonly virtuals: Set<KeyOf<Input>>;
  protected timestampTool: TimeStampTool;
  protected readonly globalDeleteHandlers: NS.DeleteHandler<Output, CtxOptions>[];
  protected readonly globalSuccessHandlers: NS.SuccessHandler<Input, Output, CtxOptions>[];
  constructor(definitions: NS.Definitions_<Input, Output>, options?: NS.Options<Input, Output, unknown>);
  protected _getAliasByVirtual: (prop: KeyOf<Input>) => string | undefined;
  protected _getDependencies: (prop: string) => NonNullable<NS.DependencyMap<Input>[KeyOf<Input>]>;
  protected _getVirtualByAlias: (alias: string) => KeyOf<Input> | undefined;
  private _getCircularDependenciesOf;
  private _getRedundantDependenciesOf;
  private _isRedundantDependencyOf;
  private _setDependencies;
  private _areHandlersOk;
  protected _checkOptions: (options: NS.Options<Input, Output, unknown>) => void;
  protected _checkPropDefinitions: (definitions: NS.Definitions_<Input, Output>) => void;
  protected _hasAllowedValues: (prop: string) => boolean;
  protected _isConstant: (prop: string) => boolean;
  protected _isDefaultable: (prop: string) => boolean;
  protected _isDependentProp: (prop: string) => boolean;
  protected _isInputProp: (prop: string) => boolean;
  protected _isLaxProp: (prop: string) => boolean;
  protected _isProp: (prop: string) => boolean;
  protected _isReadonly: (prop: string) => boolean;
  protected _isRequired: (prop: string) => boolean;
  protected _isRequiredBy: (prop: string) => boolean;
  protected _isRuleInDefinition: (prop: string, rules: DefinitionRule | DefinitionRule[]) => boolean;
  protected _isVirtualAlias: (prop: string) => boolean;
  protected _isVirtual: (prop: string) => boolean;
  protected _getDefinition: (prop: string) => NonNullable<NS.Definitions_<Input, Output>[KeyOf<Input>]>;
  protected _getFrozenCopy: <T>(data: T) => Readonly<T>;
  protected _getHandlers: <T>(prop: string, lifeCycle: NS.LifeCycle) => T[];
  private _isValidatorOk;
  private __hasAllowedValues;
  private __isConstantProp;
  private __isDependentProp;
  private __isPropDefinitionOk;
  private __isReadonly;
  private __isRequiredCommon;
  private __isRequired;
  private __isRequiredBy;
  private __isIgnoreConfigOk;
  private __isShouldInitConfigOk;
  private __isShouldUpdateConfigOk;
  private __isVirtualRequiredBy;
  private __isVirtual;
  private __isVirtualAliasOk;
  private __isVirtualAliasOk2;
  private __isLax;
  private _isPostValidateSingleConfigOk;
  private __isOnSuccessSingleConfigOk;
  private _registerPostValidator;
  private _registerSuccessConfig;
  private _isOnSuccessOptionOk;
  private _isPostValidateOptionOk;
  private _isTimestampsOptionOk;
}
//#endregion
//#region src/schema/index.d.ts
type IvoResultInfo<T extends Model<any, any, any>, Operation extends 'create' | 'update' = 'create'> = {
  data: NonNullable<Awaited<ReturnType<T[Operation]>>['data']>;
  error: null;
} | {
  data: null;
  error: NonNullable<Awaited<ReturnType<T[Operation]>>['error']>;
};
declare class Schema<const Input extends RealType<Input>, const Output extends RealType<Output> = Input, const Aliases = {}, const CtxOptions extends ObjectType = {}, const ErrorTool extends IErrorTool<ObjectType> = DefaultErrorTool<KeyOf<Input & Aliases>>> extends SchemaCore<Input, Output, CtxOptions, ErrorTool> {
  constructor(definitions: NS.Definitions<Input, Output, Aliases, CtxOptions>, options?: NS.Options<Input, Output, Aliases, ErrorTool, CtxOptions>);
  get definitions(): NS.Definitions<Input, Output, Aliases, CtxOptions>;
  get options(): NS.InternalOptions<Input, Output, CtxOptions, ErrorTool>;
  get reservedKeys(): string[];
  extend<const ExtendedInput extends RealType<ExtendedInput>, const ExtendedOutput extends RealType<ExtendedOutput> = ExtendedInput, const Aliases = object, const ExtendedCtxOptions extends ObjectType = CtxOptions, const ExtendedErrorTool extends IErrorTool<ObjectType> = DefaultErrorTool<KeyOf<ExtendedInput & Aliases>>>(definitions: Partial<NS.Definitions<ExtendedInput, ExtendedOutput, Aliases, ExtendedCtxOptions>>, options?: NS.ExtensionOptions<Input, Output, ExtendedInput, ExtendedOutput, Aliases, ExtendedErrorTool, ExtendedCtxOptions>): Schema<ExtendedInput, ExtendedOutput, Aliases, ExtendedCtxOptions, ExtendedErrorTool>;
  getModel(): Model<Input, Output, Aliases, CtxOptions, ErrorTool>;
}
declare class ModelTool<Input extends RealType<Input>, Output extends RealType<Output>, Aliases = {}, CtxOptions extends ObjectType = {}, ErrorTool extends IErrorTool<ObjectType> = DefaultErrorTool<KeyOf<Input & Aliases>>> extends SchemaCore<Input, Output, CtxOptions, ErrorTool> {
  private _regeneratedProps;
  private inputValues;
  private context;
  private contextOptions;
  private partialContext;
  private values;
  constructor(schema: Schema<Input, Output, Aliases, CtxOptions, ErrorTool>);
  protected _getContext(previousValues?: Partial<Output> | null): Readonly<Readonly<Merge<Input, Output>>>;
  protected _getSummary({
    data,
    inputValues,
    isUpdate
  }: {
    data: Partial<Output>;
    inputValues: Partial<RealType<Input>>;
    isUpdate: boolean;
  }): ReadonlyIvoSummary<Input, Output, CtxOptions>;
  protected _getMutableSummary(props: {
    data: Partial<Output>;
    inputValues: Partial<RealType<Input>>;
    isUpdate: boolean;
  }): IvoSummary<Input, Output, CtxOptions>;
  protected _getPartialContext: () => Readonly<Readonly<Merge<Input, Output>>>;
  protected _updateContext: (updates: Partial<Input>) => void;
  protected _updatePartialContext: (updates: Partial<Input>) => void;
  protected _getCtxOptions: () => Readonly<CtxOptions>;
  protected _updateCtxOptions: (options: Partial<CtxOptions>) => Readonly<CtxOptions>;
  protected _getDefaultValue: (prop: string) => Promise<any>;
  protected _getRequiredState: (prop: string, summary: IvoSummary<Input, Output>) => Promise<[boolean, string | FieldError]>;
  protected _getConstantValue: (prop: string) => any;
  protected _getValueBy: (prop: string, rule: DefinitionRule, extraCtx?: ObjectType) => any;
  private _cleanInput;
  private _generateConstants;
  private _isIngnorable;
  private _shouldIgnore;
  private _isInitAllowed;
  private _canInit;
  private _isUpdateAllowed;
  private _isVirtualInit;
  private _getValidationSummary;
  private _getPrimaryValidator;
  private _getSecondaryValidator;
  private _getNotAllowedError;
  private _handleError;
  private _handleInvalidValue;
  private _handleCreationPrimaryValidations;
  private _handleUpdatePrimaryValidations;
  private _handleSecondaryValidations;
  private _isSuccessfulProp;
  private _handlePostValidations;
  private _handlePostValidator;
  private _handleRequiredBy;
  private _handleSanitizationOfVirtuals;
  private _handleObjectValidationResponse;
  private _isSanitizable;
  private _isGloballyUpdatable;
  private _isUpdatable;
  private _isInputOrAlias;
  private _makeHandleFailure;
  private _makeHandleSuccess;
  private _resolveDependentChanges;
  private _setValues;
  private _setMissingDefaults;
  private _setValidValue;
  private _sanitizeValidationResponse;
  private _useConfigProps;
  private _validateAndSet;
  private _validate;
  create(input?: Partial<Input & Aliases>, contextOptions?: Partial<CtxOptions>): Promise<{
    data: null;
    error: ErrorTool["data"];
    handleFailure: () => Promise<void>;
    handleSuccess: null;
  } | {
    data: Output;
    error: null;
    handleFailure: null;
    handleSuccess: () => Promise<void>;
  }>;
  delete(values: Output, contextOptions?: Partial<CtxOptions>): Promise<void>;
  update(values: Output, changes: Partial<Input & Aliases>, ctxOptions?: Partial<CtxOptions>): Promise<{
    data: null;
    error: ErrorTool["data"];
    handleFailure: () => Promise<void>;
    handleSuccess: null;
  } | {
    data: Partial<Output>;
    error: null;
    handleFailure: null;
    handleSuccess: () => Promise<void>;
  }>;
}
declare class Model<Input extends RealType<Input>, Output extends RealType<Output>, Aliases = never, CtxOptions extends ObjectType = never, ErrorTool extends IErrorTool<ObjectType> = DefaultErrorTool<KeyOf<Input & Aliases>>> {
  private modelFactory;
  constructor(modelFactory: () => ModelTool<Input, Output, Aliases, CtxOptions, ErrorTool>);
  create: (values?: Partial<Input & Aliases>, contextOptions?: Partial<CtxOptions>) => Promise<{
    data: null;
    error: ErrorTool["data"];
    handleFailure: () => Promise<void>;
    handleSuccess: null;
  } | {
    data: Output;
    error: null;
    handleFailure: null;
    handleSuccess: () => Promise<void>;
  }>;
  delete: (values: Output, contextOptions?: Partial<CtxOptions>) => Promise<void>;
  update: (values: Output, changes: Partial<Input & Aliases>, contextOptions?: Partial<CtxOptions>) => Promise<{
    data: null;
    error: ErrorTool["data"];
    handleFailure: () => Promise<void>;
    handleSuccess: null;
  } | {
    data: Partial<Output>;
    error: null;
    handleFailure: null;
    handleSuccess: () => Promise<void>;
  }>;
}
//#endregion
//#region src/validators.d.ts
type ArrayValidatorOptions<PreFilteredType, ModType, FinalType> = {
  max?: number | ValueError;
  min?: number | ValueError;
  unique?: boolean;
  uniqueKey?: string;
} & ArrayFilterOptions<PreFilteredType, ModType, FinalType> & ArraySortOptions<FinalType>;
type ArrayFilterOptions<PreFilteredType, ModType, FinalType> = {
  filter: ArrayFilterFn<FinalType>;
  modifier?: never;
  postModFilter?: never;
  map?: never;
} | {
  filter: ArrayFilterFn<PreFilteredType>;
  modifier: (item: PreFilteredType) => ModType | Promise<ModType>;
  postModFilter?: (item: ModType) => boolean | Promise<boolean>;
  map?: (item: ModType) => FinalType | Promise<FinalType>;
};
type ArrayFilterFn<T> = ((item: unknown) => item is T) | ((item: unknown) => boolean | Promise<boolean>);
type ArraySortOptions<T> = {
  sort?: (a: T, b: T) => number;
  sortOrder?: never;
} | {
  sort?: boolean;
  sortOrder?: 'asc' | 'desc';
};
declare function makeArrayValidator<const PreFilteredType, const ModType = PreFilteredType, const FinalType = ModType>({
  filter,
  map,
  modifier,
  postModFilter,
  max,
  min,
  sort,
  sortOrder,
  unique,
  uniqueKey
}: ArrayValidatorOptions<PreFilteredType, ModType, FinalType>): (value: unknown) => Promise<ValidationResponse<FinalType[]>>;
declare function validateBoolean(value: unknown): ValidationResponse<boolean>;
declare const validateCreditCard: (value: unknown) => {
  metadata: FieldError["metadata"];
  reason: string;
  valid: false;
} | {
  valid: true;
  validated: string | number;
};
declare const validateEmail: (value: unknown, regExp?: RegExp) => {
  metadata: FieldError["metadata"];
  reason: string;
  valid: false;
} | {
  valid: true;
  validated: string;
};
type AllowConfig<T> = ArrayOfMinSizeTwo<T> | {
  values: ArrayOfMinSizeTwo<T>;
  error: string;
};
type ExclusionConfig<T> = T | ArrayOfMinSizeTwo<T> | {
  values: T | ArrayOfMinSizeTwo<T>;
  error: string;
};
type ValueError<T = number> = {
  value: T;
  error: string;
};
type NumberValidatorOptions<T extends number | unknown = number> = {
  exclude?: ExclusionConfig<T>;
} & XOR<{
  allow: AllowConfig<T>;
}, {
  max?: number | ValueError;
  min?: number | ValueError;
  nullable?: boolean;
}>;
type StringValidatorOptions<T extends string | unknown = string> = {
  exclude?: ExclusionConfig<T>;
} & XOR<{
  allow: AllowConfig<T>;
}, {
  max?: number | ValueError;
  min?: number | ValueError;
  normalForm?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
  normalize?: boolean;
  nullable?: boolean;
  regExp?: ValueError<RegExp>;
  trim?: boolean;
}>;
declare function makeNumberValidator<const T extends number | unknown = number>({
  exclude,
  allow,
  max,
  min,
  nullable
}?: NumberValidatorOptions<T>): (value: unknown) => ValidationResponse<T>;
declare function makeStringValidator<const T extends string | unknown = string>({
  exclude,
  allow,
  max,
  min,
  normalForm,
  normalize,
  nullable,
  regExp,
  trim
}?: StringValidatorOptions<T>): (value: unknown) => ValidationResponse<T>;
//#endregion
export { type ArrayOfMinSizeOne, type ArrayOfMinSizeTwo, type ArrayValidatorOptions, type Context, ERRORS, type ErrorPayload, type FieldError, type FieldKey, type IErrorTool, type IValidationError, type InputFieldError, type InputPayload, type IvoResultInfo, type IvoSummary, type KeyOf, type Merge, type NumberValidatorOptions, type ObjectType, type ReadonlyIvoSummary, type RealType, SCHEMA_ERRORS, Schema, type SetterFnData, type StringValidatorOptions, VALIDATION_ERRORS, type ValidationErrorMessage, type ValidatorResponse, type ValidatorResponseObject, type XOR, getKeysAsProps, isEqual, isFieldError, isFunctionLike, isInputFieldError, isNullOrUndefined, isOneOf, isPropertyOf, isRecordLike, makeArrayValidator, makeFieldError, makeNumberValidator, makeStringValidator, toArray, validateBoolean, validateCreditCard, validateEmail };