/**
 * Copyright 2013-2026 the original author or authors from the JHipster project.
 *
 * This file is part of the JHipster project, see https://www.jhipster.tech/
 * for more information.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import type { OmitIndexSignature, ReadonlyKeysOf, RequiredKeysOf, SetRequired, Simplify } from 'type-fest';
/**
 * Copy and remove null and undefined values
 * @param object
 */
export declare function removeFieldsWithNullishValues<const T extends Record<string, any>>(object: T): T;
/**
 * Picks every field from source.
 * A field with undefined value is returned for missing fields.
 */
export declare const pickFields: (source: Record<string | number, any>, fields: (string | number)[]) => {
    [k: string]: any;
};
export declare const DelayedMutation = "__DelayedMutation__";
export declare const UndefinedMutation = "__UndefinedMutation__";
export type MutateDataCallbackOptions<Data extends object> = {
    /** Marker to be returned when a property needs to be delayed */
    delayMarker?: typeof DelayedMutation;
    undefinedMarker: typeof UndefinedMutation;
    data: Data;
};
export type MutateDataParam<T extends object> = Simplify<OmitIndexSignature<{
    [Key in keyof (T & {
        __override__?: boolean;
    })]?: Key extends '__override__' ? boolean : Key extends ReadonlyKeysOf<T> ? never : Key extends keyof T ? T[Key] extends Function ? (ctx: T, opts: MutateDataCallbackOptions<T>) => T[Key] | typeof DelayedMutation | typeof UndefinedMutation : T[Key] | ((ctx: T, opts: MutateDataCallbackOptions<T>) => T[Key] | typeof DelayedMutation | typeof UndefinedMutation) : never;
}>>;
/**
 * Utility to ensure required mutation properties are set.
 */
export type MutateDataPropertiesWithRequiredProperties<D extends Record<string, any>, N extends Record<string, any>> = SetRequired<D, RequiredKeysOf<N>>;
declare const OverrideMutation: unique symbol;
export type MutateDataFunction<Data extends object = any> = ((ctx: Data, opts: MutateDataCallbackOptions<Data>) => any) & {
    [OverrideMutation]?: boolean;
};
type MutationContextOptions = {
    autoDelay?: boolean;
    delayContext: Record<string, MutateDataFunction[]>;
};
export declare const overrideMutateDataProperty: <const T extends MutateDataFunction>(fn: T) => T;
export declare const dontOverrideMutateDataProperty: <const T extends MutateDataFunction>(fn: T) => T;
export declare const createDelayedMutationContext: <T extends object>(options?: Omit<MutationContextOptions, "delayContext">) => T;
export declare const finalizeMutations: (context: any) => void;
/**
 * Mutation properties accepts:
 * - functions: receives the data and the return value is set at the data property.
 * - non functions: data property will receive the property in case current value is undefined.
 * - __override__ property: if set to false, functions will not override existing values.
 *
 * Applies each mutation object in order.
 *
 * Note: if data property is expected to be a function, mutation should be a function that returns the desired function.
 *
 * @example
 * // data = { prop: 'foo-bar', prop2: 'foo2', fn: () => 'fn' }
 * mutateData(
 *   data,
 *   { prop: 'foo', prop2: ({ prop }) => prop + 2, fn: () => () => 'fn' },
 *   { prop: ({ prop }) => prop + '-bar', prop2: 'won\'t override' },
 *   { __override__: false, prop: () => 'won\'t override' },
 * );
 */
export declare function mutateData<T extends Record<string | number, any>>(context: T, ...mutations: (MutateDataParam<T> | ((data: T) => MutateDataParam<T>))[]): void;
export {};
