export declare const NO_PROVIDER: unique symbol;
export declare const DECLARATION_SEPARATOR = ">";
export declare const OPTIONAL_FLAG = "?";
export declare const ALLOWED_INITIALIZER_TYPES: readonly ["provider", "service", "constant"];
export type InitializerTypes = (typeof ALLOWED_INITIALIZER_TYPES)[number];
export type ServiceName = string;
export type Service = any;
export type Disposer = () => Promise<void>;
export type FatalErrorPromise = Promise<void>;
export interface Provider<S extends Service> {
    service: S;
    dispose?: Disposer;
    fatalErrorPromise?: FatalErrorPromise;
}
export type Dependencies<S extends Service = Service> = Record<string, S>;
export type DependencyName = string;
export type DependencyDeclaration = string;
export interface LocationInformation {
    url: string;
    exportName: string;
}
export type ExtraInformation = any;
export interface ParsedDependencyDeclaration {
    serviceName: string;
    mappedName: string;
    optional: boolean;
}
export interface ConstantProperties {
    $type: 'constant';
    $name: DependencyName;
    $singleton: true;
    $location?: LocationInformation;
}
export type ConstantInitializer<S extends Service> = ConstantProperties & {
    $value: S;
};
export interface ProviderProperties {
    $type: 'provider';
    $name: DependencyName;
    $inject?: DependencyDeclaration[];
    $singleton?: boolean;
    $location?: LocationInformation;
    $extra?: ExtraInformation;
}
export interface ProviderInputProperties {
    type: 'provider';
    name: DependencyName;
    inject?: DependencyDeclaration[];
    singleton?: boolean;
    location?: LocationInformation;
    extra?: ExtraInformation;
}
export interface ProviderInitializerReqD<D extends Dependencies, S extends Service> extends ProviderProperties {
    (dependencies: D): Promise<Provider<S>>;
}
export interface ProviderInitializerOptD<D extends Dependencies, S extends Service> extends ProviderProperties {
    (dependencies?: D): Promise<Provider<S>>;
}
export type ProviderInitializer<D extends Dependencies, S extends Service> = ProviderInitializerReqD<D, S> | ProviderInitializerOptD<D, S>;
export type ProviderInitializerBuilder<D extends Dependencies, S extends Service> = ((dependencies: D) => Promise<Provider<S>>) | ((dependencies?: D) => Promise<Provider<S>>);
export interface ServiceProperties {
    $type: 'service';
    $name: DependencyName;
    $inject?: DependencyDeclaration[];
    $singleton?: boolean;
    $location?: LocationInformation;
    $extra?: ExtraInformation;
}
export interface ServiceInputProperties {
    type: 'service';
    name: DependencyName;
    inject?: DependencyDeclaration[];
    singleton?: boolean;
    location?: LocationInformation;
    extra?: ExtraInformation;
}
export interface ServiceInitializerReqD<D extends Dependencies, S extends Service> extends ServiceProperties {
    (dependencies: D): Promise<S>;
}
export interface ServiceInitializerOptD<D extends Dependencies, S extends Service> extends ServiceProperties {
    (dependencies?: D): Promise<S>;
}
export type ServiceInitializer<D extends Dependencies, S extends Service> = ServiceInitializerReqD<D, S> | ServiceInitializerOptD<D, S>;
export type ServiceInitializerBuilder<D extends Dependencies, S extends Service> = ((dependencies: D) => Promise<S>) | ((dependencies?: D) => Promise<S>);
export type InitializerProperties = ConstantProperties | ProviderProperties | ServiceProperties;
export type InitializerBuilder<D extends Dependencies, S extends Service> = ProviderInitializerBuilder<D, S> | ServiceInitializerBuilder<D, S> | Partial<ProviderInitializer<D, S>> | Partial<ServiceInitializer<D, S>>;
export type AsyncInitializer<D extends Dependencies, S extends Service> = ServiceInitializer<D, S> | ProviderInitializer<D, S>;
export type Initializer<S extends Service, D extends Dependencies> = ConstantInitializer<S> | ServiceInitializer<D, S> | ProviderInitializer<D, S>;
export type ServiceInitializerWrapper<S extends Service, D extends Dependencies> = (dependencies: D, baseService: S) => Promise<S>;
export type ProviderInitializerWrapper<S extends Service, D extends Dependencies> = (dependencies: D, baseService: Provider<S>) => Promise<Provider<S>>;
export declare const SPECIAL_PROPS_PREFIX = "$";
export declare const SPECIAL_PROPS: {
    readonly TYPE: "$type";
    readonly NAME: "$name";
    readonly INJECT: "$inject";
    readonly SINGLETON: "$singleton";
    readonly LOCATION: "$location";
    readonly EXTRA: "$extra";
    readonly VALUE: "$value";
};
export declare const ALLOWED_SPECIAL_PROPS: ("$type" | "$name" | "$inject" | "$singleton" | "$location" | "$extra" | "$value")[];
export type InitializerSpecialProp = (typeof ALLOWED_SPECIAL_PROPS)[number];
export declare function parseInjections(source: string, options?: {
    allowEmpty: boolean;
}): DependencyDeclaration[];
export declare function readFunctionName(aFunction: Function): string;
export declare function parseName(functionName: string): string;
/**
 * Apply special props to the given initializer from another one
 *  and optionally amend with new special props
 * @param  {Function} from The initializer in which to pick the props
 * @param  {Function} to   The initializer from which to build the new one
 * @param  {Object}   [amend={}]   Some properties to override
 * @return {Function}      The newly built initializer
 */
export declare function reuseSpecialProps<FD extends Dependencies<any>, TD extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ProviderInitializerBuilder<TD, S>, amend?: Partial<ProviderProperties>): ProviderInitializerBuilder<FD & TD, S>;
export declare function reuseSpecialProps<FD extends Dependencies<any>, TD extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ServiceInitializerBuilder<TD, S>, amend?: Partial<ServiceProperties>): ServiceInitializerBuilder<FD & TD, S>;
/**
 * Decorator that creates an initializer for a constant value
 * @param  {String}    name
 * The constant's name.
 * @param  {any}  value
 * The constant's value
 * @return {Function}
 * Returns a new constant initializer
 * @example
 * import Knifecycle, { constant, service } from 'knifecycle';
 *
 * const { printAnswer } = new Knifecycle()
 *   .register(constant('THE_NUMBER', value))
 *   .register(constant('log', console.log.bind(console)))
 *   .register(service(
 *     async ({ THE_NUMBER, log }) => () => log(THE_NUMBER),
 *     'printAnswer',
 *     ['THE_NUMBER', 'log'],
 *   ))
 *   .run(['printAnswer']);
 *
 * printAnswer(); // 42
 */
export declare function constant<V extends Service>(name: DependencyName, value: V): ConstantInitializer<V>;
/**
 * Decorator that creates an initializer from a service builder
 * @param  {Function}   serviceBuilder
 * An async function to build the service
 * @param  {String}    [name]
 * The service's name
 * @param  {Array<String>}    [dependencies]
 * The service's injected dependencies
 * @param  {Boolean}    [singleton]
 * Whether the service is a singleton or not
 * @param  {any}    [extra]
 * Eventual extra information
 * @return {Function}
 * Returns a new initializer
 * @example
 * import Knifecycle, { constant, service } from 'knifecycle';
 *
 * const { printAnswer } = new Knifecycle()
 *   .register(constant('THE_NUMBER', value))
 *   .register(constant('log', console.log.bind(console)))
 *   .register(service(
 *     async ({ THE_NUMBER, log }) => () => log(THE_NUMBER),
 *     'printAnswer',
 *     ['THE_NUMBER', 'log'],
 *     true
 *   ))
 *   .run(['printAnswer']);
 *
 * printAnswer(); // 42
 */
export declare function service<D extends Dependencies<any>, S>(serviceBuilder: ServiceInitializerBuilder<D, S>, name?: DependencyName, dependencies?: DependencyDeclaration[], singleton?: boolean, extra?: ExtraInformation): ServiceInitializer<D, S>;
/**
 * Decorator that creates an initializer from a service
 *  builder by automatically detecting its name
 *  and dependencies
 * @param  {Function}   serviceBuilder
 * An async function to build the service
 * @return {Function}
 * Returns a new initializer
 */
export declare function autoService<D extends Dependencies<any>, S>(serviceBuilder: ServiceInitializerBuilder<D, S>): ServiceInitializer<D, S>;
/**
 * Decorator that creates an initializer for a provider
 *  builder
 * @param  {Function} providerBuilder
 * An async function to build the service provider
 * @param  {String} [name]
 * The service's name
 * @param  {Array<String>} [dependencies]
 * The service's dependencies
 * @param  {Boolean} [singleton]
 * Whether the service is a singleton or not
 * @param  {any} [extra]
 * Eventual extra information
 * @return {Function}
 * Returns a new provider initializer
 * @example
 *
 * import Knifecycle, { provider } from 'knifecycle'
 * import fs from 'fs';
 *
 * const $ = new Knifecycle();
 *
 * $.register(provider(configProvider, 'config'));
 *
 * async function configProvider() {
 *   return new Promise((resolve, reject) {
 *     fs.readFile('config.js', function(err, data) {
 *       let config;
 *
 *       if(err) {
 *         reject(err);
 *         return;
 *       }
 *
 *       try {
 *         config = JSON.parse(data.toString);
 *       } catch (err) {
 *         reject(err);
 *         return;
 *       }
 *
 *       resolve({
 *         service: config,
 *       });
 *     });
 *   });
 * }
 */
export declare function provider<D extends Dependencies<any>, S>(providerBuilder: ProviderInitializerBuilder<D, S>, name?: DependencyName, dependencies?: DependencyDeclaration[], singleton?: boolean, extra?: ExtraInformation): ProviderInitializer<D, S>;
/**
 * Decorator that creates an initializer from a provider
 *  builder by automatically detecting its name
 *  and dependencies
 * @param  {Function}   providerBuilder
 * An async function to build the service provider
 * @return {Function}
 * Returns a new provider initializer
 */
export declare function autoProvider<D extends Dependencies<any>, S>(providerBuilder: ProviderInitializerBuilder<D, S>): ProviderInitializer<D, S>;
/**
 * Allows to wrap an initializer to add extra initialization steps
 * @param  {Function} wrapper
 * A function taking dependencies and the base
 * service in arguments
 * @param  {Function} baseInitializer
 * The initializer to decorate
 * @return {Function}
 * The new initializer
 */
export declare function wrapInitializer<D extends Dependencies<any>, S>(wrapper: ProviderInitializerWrapper<S, D>, baseInitializer: ProviderInitializer<D, S>): ProviderInitializer<D, S>;
export declare function wrapInitializer<D extends Dependencies<any>, S>(wrapper: ServiceInitializerWrapper<S, D>, baseInitializer: ServiceInitializer<D, S>): ServiceInitializer<D, S>;
/**
 * Decorator creating a new initializer with different
 *  dependencies declarations set to it.
 * @param  {Array<String>}  dependencies
 * List of dependencies declarations to declare which
 *  services the initializer needs to provide its
 *  own service
 * @param  {Function}  initializer
 * The initializer to tweak
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import Knifecycle, { inject } from 'knifecycle'
 * import myServiceInitializer from './service';
 *
 * new Knifecycle()
 *  .register(
 *    service(
 *      inject(['ENV'], myServiceInitializer)
 *      'myService',
 *    )
 *   )
 * );
 */
export declare function inject<D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], initializer: ProviderInitializer<any, S>): ProviderInitializer<D, S>;
export declare function inject<D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], initializer: ProviderInitializerBuilder<any, S>): ProviderInitializerBuilder<D, S>;
export declare function inject<D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], initializer: ServiceInitializer<any, S>): ServiceInitializer<D, S>;
export declare function inject<D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], initializer: ServiceInitializerBuilder<any, S>): ServiceInitializerBuilder<D, S>;
/**
 * Decorator creating a new initializer omitting
 * the given dependencies.
 * @param  {Array<String>}  dependencies
 * List of dependencies to omit (also accept dependencies
 *  declarations but omit the destination part)
 * @param  {Function}  initializer
 * The initializer to tweak
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import Knifecycle, { unInject } from 'knifecycle'
 * import myServiceInitializer from './service';
 *
 * new Knifecycle()
 *  .register(
 *    service(
 *      unInject(['ENV'], myServiceInitializer)
 *      'myService',
 *    )
 *   )
 * );
 */
export declare function unInject<D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], initializer: ProviderInitializer<any, S>): ProviderInitializer<D, S>;
export declare function unInject<D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], initializer: ProviderInitializerBuilder<any, S>): ProviderInitializerBuilder<D, S>;
export declare function unInject<D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], initializer: ServiceInitializer<any, S>): ServiceInitializer<D, S>;
export declare function unInject<D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], initializer: ServiceInitializerBuilder<any, S>): ServiceInitializerBuilder<D, S>;
/**
 * Apply injected dependencies from the given initializer to another one
 * @param  {Function} from The initialization function in which to pick the dependencies
 * @param  {Function} to   The destination initialization function
 * @return {Function}      The newly built initialization function
 */
export declare function useInject<FD extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ProviderInitializer<Dependencies, S>): ProviderInitializer<FD, S>;
export declare function useInject<FD extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ProviderInitializerBuilder<Dependencies, S>): ProviderInitializerBuilder<FD, S>;
export declare function useInject<FD extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ServiceInitializer<Dependencies, S>): ServiceInitializer<FD, S>;
export declare function useInject<FD extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ServiceInitializerBuilder<Dependencies, S>): ServiceInitializerBuilder<FD, S>;
/**
 * Merge injected dependencies of the given initializer with another one
 * @param  {Function} from The initialization function in which to pick the dependencies
 * @param  {Function} to   The destination initialization function
 * @return {Function}      The newly built initialization function
 */
export declare function mergeInject<FD extends Dependencies<any>, D extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ProviderInitializer<D, S>): ProviderInitializer<FD & D, S>;
export declare function mergeInject<FD extends Dependencies<any>, D extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ProviderInitializerBuilder<D, S>): ProviderInitializerBuilder<FD & D, S>;
export declare function mergeInject<FD extends Dependencies<any>, D extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ServiceInitializer<D, S>): ServiceInitializer<FD, S>;
export declare function mergeInject<FD extends Dependencies<any>, D extends Dependencies<any>, S>(from: InitializerBuilder<FD, unknown>, to: ServiceInitializerBuilder<D, S>): ServiceInitializerBuilder<FD, S>;
/**
 * Decorator creating a new initializer with different
 *  dependencies declarations set to it according to the
 *  given function signature.
 * @param  {Function}  initializer
 * The original initializer
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import Knifecycle, { autoInject, name } from 'knifecycle'
 *
 * new Knifecycle()
 *   .register(
 *     name(
 *       'application',
 *       autoInject(
 *         async ({ NODE_ENV, mysql: db }) =>
 *           async () => db.query('SELECT applicationId FROM applications WHERE environment=?', [NODE_ENV])
 *         )
 *       )
 *     )
 *   )
 * );
 */
export declare function autoInject<D extends Dependencies<any>, S>(initializer: ProviderInitializer<D, S>): ProviderInitializer<D, S>;
export declare function autoInject<D extends Dependencies<any>, S>(initializer: ProviderInitializerBuilder<D, S>): ProviderInitializerBuilder<D, S>;
export declare function autoInject<D extends Dependencies<any>, S>(initializer: ServiceInitializer<D, S>): ServiceInitializer<D, S>;
export declare function autoInject<D extends Dependencies<any>, S>(initializer: ServiceInitializerBuilder<D, S>): ServiceInitializerBuilder<D, S>;
/**
 * Decorator creating a new initializer with some
 *  more dependencies declarations appended to it.
 * @param  {Array<String>}  dependencies
 * List of dependencies declarations to append
 * @param  {Function}  initializer
 * The initializer to tweak
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import Knifecycle, { alsoInject } from 'knifecycle'
 * import myServiceInitializer from './service';
 *
 * new Knifecycle()
 * .register(service(
 *   alsoInject(['ENV'], myServiceInitializer),
 *   'myService',
 * ));
 */
export declare function alsoInject<ND extends Dependencies<any>, D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], to: ProviderInitializer<D, S>): ProviderInitializer<ND & D, S>;
export declare function alsoInject<ND extends Dependencies<any>, D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], to: ProviderInitializerBuilder<D, S>): ProviderInitializerBuilder<ND & D, S>;
export declare function alsoInject<ND extends Dependencies<any>, D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], to: ServiceInitializer<D, S>): ServiceInitializer<ND & D, S>;
export declare function alsoInject<ND extends Dependencies<any>, D extends Dependencies<any>, S>(dependencies: DependencyDeclaration[], to: ServiceInitializerBuilder<D, S>): ServiceInitializerBuilder<ND & D, S>;
/**
 * Decorator creating a new initializer with some
 *  extra information appended to it. It is just
 *  a way for user to store some additional
 *  information but has no interaction with the
 *  Knifecycle internals.
 * @param  {Object}  extraInformation
 * An object containing those extra information.
 * @param  {Function}  initializer
 * The initializer to tweak
 * @param  {Boolean}   [merge=false]
 * Whether the extra object should be merged
 * with the existing one or not
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import Knifecycle, { extra } from 'knifecycle'
 * import myServiceInitializer from './service';
 *
 * new Knifecycle()
 * .register(service(
 *   extra({ httpHandler: true }, myServiceInitializer),
 *   'myService',
 * ));
 */
export declare function extra<D extends Dependencies<any>, S>(extraInformation: ExtraInformation, initializer: ProviderInitializer<D, S>, merge?: boolean): ProviderInitializer<D, S>;
export declare function extra<D extends Dependencies<any>, S>(extraInformation: ExtraInformation, initializer: ProviderInitializerBuilder<D, S>, merge?: boolean): ProviderInitializerBuilder<D, S>;
export declare function extra<D extends Dependencies<any>, S>(extraInformation: ExtraInformation, initializer: ServiceInitializer<D, S>): ServiceInitializer<D, S>;
export declare function extra<D extends Dependencies<any>, S>(extraInformation: ExtraInformation, initializer: ServiceInitializerBuilder<D, S>): ServiceInitializerBuilder<D, S>;
/**
 * Decorator to set an initializer singleton option.
 * @param  {Function}  initializer
 * The initializer to tweak
 * @param  {boolean}    [isSingleton=true]
 * Define the initializer singleton option
 * (one instance for several runs if true)
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import Knifecycle, { inject, singleton } from 'knifecycle';
 * import myServiceInitializer from './service';
 *
 * new Knifecycle()
 * .register(service(
 *   inject(['ENV'],
 *     singleton(myServiceInitializer)
 *   ),
 *   'myService',
 * ));
 */
export declare function singleton<D extends Dependencies<any>, S>(initializer: ProviderInitializer<D, S>, isSingleton?: boolean): ProviderInitializer<D, S>;
export declare function singleton<D extends Dependencies<any>, S>(initializer: ProviderInitializerBuilder<D, S>, isSingleton?: boolean): ProviderInitializerBuilder<D, S>;
export declare function singleton<D extends Dependencies<any>, S>(initializer: ServiceInitializer<D, S>, isSingleton?: boolean): ServiceInitializer<D, S>;
export declare function singleton<D extends Dependencies<any>, S>(initializer: ServiceInitializerBuilder<D, S>, isSingleton?: boolean): ServiceInitializerBuilder<D, S>;
/**
 * Decorator to set an initializer location.
 * @param  {Function}  initializer
 * The initializer to tweak
 * @param  {string}    [url]
 * Define the initializer url (import.meta.url) in most situations
 * @param  {string}    [exportName]
 * Define the initializer export name
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import { service, location } from 'knifecycle';
 *
 * export const initMyService = location(
 *  service(async () => {}, 'myService', []),
 *  import.meta.url,
 *  'initMyService',
 * });
 */
export declare function location<D extends Dependencies<any>, S>(initializer: ProviderInitializer<D, S>, url: string, exportName?: string): ProviderInitializer<D, S>;
export declare function location<D extends Dependencies<any>, S>(initializer: ProviderInitializerBuilder<D, S>, url: string, exportName?: string): ProviderInitializerBuilder<D, S>;
export declare function location<D extends Dependencies<any>, S>(initializer: ServiceInitializer<D, S>, url: string, exportName?: string): ServiceInitializer<D, S>;
export declare function location<D extends Dependencies<any>, S>(initializer: ServiceInitializerBuilder<D, S>, url: string, exportName?: string): ServiceInitializerBuilder<D, S>;
export declare function location<D extends Dependencies<any>, S>(initializer: ConstantInitializer<S>, url: string, exportName?: string): ConstantInitializer<S>;
/**
 * Decorator to set an initializer name.
 * @param  {String}    name
 * The name of the service the initializer resolves to.
 * @param  {Function}  initializer
 * The initializer to tweak
 * @return {Function}
 * Returns a new initializer with that name set
 * @example
 *
 * import Knifecycle, { name } from 'knifecycle';
 * import myServiceInitializer from './service';
 *
 * new Knifecycle()
 * .register(name('myService', myServiceInitializer));
 */
export declare function name<D extends Dependencies<any>, S>(name: DependencyName, initializer: ProviderInitializer<D, S>): ProviderInitializer<D, S>;
export declare function name<D extends Dependencies<any>, S>(name: DependencyName, initializer: ProviderInitializerBuilder<D, S>): ProviderInitializerBuilder<D, S>;
export declare function name<D extends Dependencies<any>, S>(name: DependencyName, initializer: ServiceInitializer<D, S>): ServiceInitializer<D, S>;
export declare function name<D extends Dependencies<any>, S>(name: DependencyName, initializer: ServiceInitializerBuilder<D, S>): ServiceInitializerBuilder<D, S>;
/**
 * Decorator to set an initializer name from its function name.
 * @param  {Function}  initializer
 * The initializer to name
 * @return {Function}
 * Returns a new initializer with that name set
 * @example
 *
 * import Knifecycle, { autoName } from 'knifecycle';
 *
 * new Knifecycle()
 * .register(autoName(async function myService() {}));
 */
export declare function autoName<D extends Dependencies<any>, S>(initializer: ProviderInitializer<D, S>): ProviderInitializer<D, S>;
export declare function autoName<D extends Dependencies<any>, S>(initializer: ProviderInitializerBuilder<D, S>): ProviderInitializerBuilder<D, S>;
export declare function autoName<D extends Dependencies<any>, S>(initializer: ServiceInitializer<D, S>): ServiceInitializer<D, S>;
export declare function autoName<D extends Dependencies<any>, S>(initializer: ServiceInitializerBuilder<D, S>): ServiceInitializerBuilder<D, S>;
/**
 * Decorator to set an initializer type.
 * @param  {String}    type
 * The type to set to the initializer.
 * @param  {Function}  initializer
 * The initializer to tweak
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import Knifecycle, { name, type } from 'knifecycle';
 * import myServiceInitializer from './service';
 *
 * new Knifecycle()
 * .register(
 *   type('service',
 *     name('myService',
 *       myServiceInitializer
 *     )
 *   )
 * );
 */
export declare function type<D extends Dependencies<any>, S>(type: 'provider', initializer: ProviderInitializer<D, S>): ProviderInitializer<D, S>;
export declare function type<D extends Dependencies<any>, S>(type: 'provider', initializer: ProviderInitializerBuilder<D, S>): ProviderInitializerBuilder<D, S>;
export declare function type<D extends Dependencies<any>, S>(type: 'service', initializer: ServiceInitializer<D, S>): ServiceInitializer<D, S>;
export declare function type<D extends Dependencies<any>, S>(type: 'service', initializer: ServiceInitializerBuilder<D, S>): ServiceInitializerBuilder<D, S>;
/**
 * Decorator to set an initializer properties.
 * @param  {Object}    properties
 * Properties to set to the service.
 * @param  {Function}  initializer
 * The initializer to tweak
 * @return {Function}
 * Returns a new initializer
 * @example
 *
 * import Knifecycle, { initializer } from 'knifecycle';
 * import myServiceInitializer from './service';
 *
 * new Knifecycle()
 * .register(initializer({
 *   name: 'myService',
 *   type: 'service',
 *   inject: ['ENV'],
 *   singleton: true,
 * }, myServiceInitializer));
 */
export declare function initializer<D extends Dependencies<any>, S>(properties: ProviderInputProperties, initializer: ProviderInitializerBuilder<D, S>): ProviderInitializer<D, S>;
export declare function initializer<D extends Dependencies<any>, S>(properties: ServiceInputProperties, initializer: ServiceInitializerBuilder<D, S>): ServiceInitializer<D, S>;
/**
 * Explode a dependency declaration an returns its parts.
 * @param  {String}  dependencyDeclaration
 * A dependency declaration string
 * @return {Object}
 * The various parts of it
 * @example
 * parseDependencyDeclaration('pgsql>db');
 * // Returns
 * {
 *   serviceName: 'pgsql',
 *   mappedName: 'db',
 *   optional: false,
 * }
 */
export declare function parseDependencyDeclaration(dependencyDeclaration: DependencyDeclaration): ParsedDependencyDeclaration;
/**
 * Stringify a dependency declaration from its parts.
 * @param  {Object}  dependencyDeclarationParts
 * A dependency declaration string
 * @return {String}
 * The various parts of it
 * @example
 * stringifyDependencyDeclaration({
 *   serviceName: 'pgsql',
 *   mappedName: 'db',
 *   optional: false,
 * });
 *
 * // Returns
 * 'pgsql>db'
 */
export declare function stringifyDependencyDeclaration(dependencyDeclarationParts: ParsedDependencyDeclaration): DependencyDeclaration;
/**
 * Utility function to check and reveal initializer properties.
 * @param  {Function}  initializer
 * The initializer to tweak
 * @return {Function}
 * Returns revealed initializer (with TypeScript types for properties)
 */
export declare function unwrapInitializerProperties<S, D extends Dependencies<any>>(initializer: ProviderInitializer<D, S>): ProviderProperties;
export declare function unwrapInitializerProperties<S, D extends Dependencies<any>>(initializer: ServiceInitializer<D, S>): ServiceProperties;
export declare function unwrapInitializerProperties<S, D extends Dependencies<any>>(initializer: ConstantInitializer<S>): ConstantProperties;
export declare function unwrapInitializerProperties<S, D extends Dependencies<any>>(initializer: Initializer<S, D>): InitializerProperties;
export declare function initializerBuilderIsOfType<T extends InitializerTypes, D extends Dependencies<any>, S>(type: T, initializer: InitializerBuilder<D, S> | ConstantInitializer<S>): initializer is T extends 'service' ? ServiceInitializerBuilder<D, S> : T extends 'provider' ? ServiceInitializerBuilder<D, S> : ConstantInitializer<S>;
export declare function pickInitializerBuilderProp<D extends Dependencies<any>, S, T extends InitializerSpecialProp>(initializer: InitializerBuilder<D, S> | ConstantInitializer<S>, prop: T): T extends keyof ServiceProperties ? ServiceProperties[T] : S;