import { List } from "@tsplus/stdlib/collections/List/definition";
import { Env } from "@tsplus/stdlib/service/Env";
import type { Tag } from "@tsplus/stdlib/service/Tag";
export declare const PatchSym: unique symbol;
export type PatchSym = typeof PatchSym;
export declare const _Input: unique symbol;
export type _Input = typeof _Input;
export declare const _Output: unique symbol;
export type _Output = typeof _Output;
/**
 * A `Patch<Input, Output>` describes an update that transforms a `Env<Input>`
 * to a `Env<Output>` as a data structure. This allows combining updates to
 * different services in the environment in a compositional way.
 *
 * @tsplus type Patch
 */
export interface Patch<in Input, out Output> {
    readonly [PatchSym]: PatchSym;
    readonly [_Input]: (input: Input) => void;
    readonly [_Output]: () => Output;
}
/**
 * @tsplus type Patch.Ops
 */
export interface PatchOps {
    $: PatchAspects;
}
export declare const Patch: PatchOps;
/**
 * @tsplus type Patch.Aspects
 */
export interface PatchAspects {
}
export declare abstract class BasePatch<Input, Output> implements Patch<Input, Output> {
    readonly [PatchSym]: PatchSym;
    readonly [_Input]: (input: Input) => void;
    readonly [_Output]: () => Output;
}
export declare class Empty<I, O> extends BasePatch<I, O> {
    readonly _tag = "Empty";
    constructor();
}
export declare class AddService<Env, T> extends BasePatch<Env, Env | T> {
    readonly tag: Tag<T>;
    readonly service: T;
    readonly _tag = "AddService";
    constructor(tag: Tag<T>, service: T);
}
export declare class AndThen<Input, Output, Output2> extends BasePatch<Input, Output2> {
    readonly first: Patch<Input, Output>;
    readonly second: Patch<Output, Output2>;
    readonly _tag = "AndThen";
    constructor(first: Patch<Input, Output>, second: Patch<Output, Output2>);
}
export declare class RemoveService<Env, T> extends BasePatch<Env | T, Env> {
    readonly tag: Tag<T>;
    readonly _tag = "RemoveService";
    constructor(tag: Tag<T>);
}
export declare class UpdateService<Env, T> extends BasePatch<Env | T, Env | T> {
    readonly tag: Tag<T>;
    readonly update: (service: T) => T;
    readonly _tag = "UpdateService";
    constructor(tag: Tag<T>, update: (service: T) => T);
}
/**
 * @tsplus macro remove
 */
export declare function concretePatch<Input, Output>(_: Patch<Input, Output>): asserts _ is Empty<any, any> | AddService<any, any> | AndThen<any, any, any> | RemoveService<any, any> | UpdateService<any, any>;
/**
 * Applies a `Patch` to the specified `Env` to produce a new patched `Env`.
 * @tsplus static Patch.Aspects patch
 * @tsplus pipeable Patch patch
 * @tsplus location "@tsplus/stdlib/service/Patch"
 */
export declare function patch<Input>(env: Env<Input>): <Output>(self: Patch<Input, Output>) => Env<Output>;
/**
 * An empty patch which returns the environment unchanged.
 * @tsplus static Patch.Ops empty
 * @tsplus location "@tsplus/stdlib/service/Patch"
 */
export declare function empty<I = never, O = never>(): Patch<I, O>;
/**
 * Combines two patches to produce a new patch that describes applying the
 * updates from this patch and then the updates from the specified patch.
 * @tsplus static Patch.Aspects combine
 * @tsplus pipeable Patch combine
 * @tsplus location "@tsplus/stdlib/service/Patch"
 */
export declare function combine<Output, Output2>(that: Patch<Output, Output2>): <Input>(self: Patch<Input, Output>) => Patch<Input, Output2>;
/**
 * @tsplus static Patch.Ops diff
 * @tsplus location "@tsplus/stdlib/service/Patch"
 */
export declare function diff<Input, Output>(oldValue: Env<Input>, newValue: Env<Output>): Patch<Input, Output>;
//# sourceMappingURL=Patch.d.ts.map