@craft-ts/core 0.7.0-beta.13

package/src/lib/craft-service.d.ts

@@ -0,0 +1,1034 @@
+import { EnvironmentProviders, InjectionToken, Injector, Provider, Signal, Type } from './host/craft-compat';
+import type { Observable } from 'rxjs';
+import { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, type ResolveGeneratorResult } from './craft-generator-runtime';
+import { type YieldableReactiveProperties, type YieldableReactiveValue } from './reactive-read';
+export { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime';
+import { CRAFT_SERVICE_PROVIDER_BRAND, type CRAFT_SERVICE_PROVIDER_TYPE_BRAND } from './craft-service.shared';
+import type { CallableShell, ConcreteServiceScope, MergeObjectUnion, ProvidedInputKey, RealCapableScope, RequirementScope, RootExposureKey, Simplify, UnionToTuple } from './craft-service.shared';
+import type { ServiceTrackedDepsRequest } from './craft-primitive-gen';
+import { type Yieldable } from './yieldable';
+import type { BrandReactiveProperties } from './yieldable';
+export declare const SERVICE_HELPER_DEPENDENCIES: unique symbol;
+export declare const SERVICE_YIELD_METADATA: unique symbol;
+export declare const SERVICE_META_DATA_TYPE: unique symbol;
+declare const SERVICE_APP_START_CALLBACK_YIELDED: unique symbol;
+export declare const SERVICE_EXPOSURE_TOKEN_MARKER: unique symbol;
+export declare const SERVICE_RUNTIME_META: unique symbol;
+type DerivedPropertiesTracking<Used extends object = {}, Exposed extends object = {}> = {
+    derivedPropertiesUsed: Simplify<Used>;
+    derivedPropertiesExposed: Simplify<Exposed>;
+};
+export type ServiceDependencies<Scope = unknown, Dependencies = {}, Derived = undefined> = Simplify<{
+    providedIn: Scope;
+    dependencies: Simplify<Dependencies>;
+} & (Derived extends undefined ? {} : Derived)>;
+type WithTrackedDependencies<Helper, Metadata> = Helper & {
+    readonly [SERVICE_HELPER_DEPENDENCIES]?: Metadata;
+};
+type ExtractTrackedMetadata<Helper> = Helper extends {
+    readonly [SERVICE_HELPER_DEPENDENCIES]?: infer Metadata;
+} ? Metadata : never;
+export type GetServiceDependencies<ServiceHelper> = ResolveServiceTrackingMetadata<ExtractTrackedMetadata<ServiceHelper>>;
+export type GetServiceOutput<ServiceHelper> = ExtractTrackedMetadata<ServiceHelper> extends ServiceTrackingMetadata<any, any, infer Output, any, any, any, any, any> ? Output : never;
+export type GetServiceYields<ServiceHelper> = ExtractTrackedMetadata<ServiceHelper> extends ServiceTrackingMetadata<any, infer Scope extends ConcreteServiceScope, infer Output, any, any, any, any, any> ? ServiceYieldRequest<Scope, Output, ExtractTrackedMetadata<ServiceHelper>> | (Output extends object ? ExposureYield<Output> : never) : never;
+type ConstantCase<Value extends string, IsStart extends boolean = true> = Value extends `${infer First}${infer Rest}` ? First extends Lowercase<First> ? `${Uppercase<First>}${ConstantCase<Rest, false>}` : First extends `${number}` ? `${First}${ConstantCase<Rest, false>}` : `${IsStart extends true ? '' : '_'}${First}${ConstantCase<Rest, false>}` : '';
+type ServiceMetaDataKey<Name extends string> = `${ConstantCase<Name>}_META_DATA`;
+type MetaDataTypeInfo<MetaData> = MetaData extends {
+    readonly [SERVICE_META_DATA_TYPE]?: infer Info;
+} ? Info : never;
+type GetServiceMetaDataInputs<MetaData> = MetaDataTypeInfo<MetaData> extends {
+    inputs: infer Inputs extends object;
+} ? Inputs : {};
+type GetServiceMetaDataOutput<MetaData> = MetaDataTypeInfo<MetaData> extends {
+    output: infer Output;
+} ? Output : never;
+type GetServiceMetaDataTracking<MetaData> = MetaDataTypeInfo<MetaData> extends {
+    tracking: infer Tracking;
+} ? Tracking : never;
+type GetServiceMetaDataProvidedInput<MetaData> = MetaDataTypeInfo<MetaData> extends {
+    providedInput: infer ProvidedInput;
+} ? ProvidedInput : never;
+declare const ABSTRACT_SERVICE_MARKER: unique symbol;
+declare const SERVICE_REQUIREMENT_MARKER: unique symbol;
+declare const PROVIDED_ELSEWHERE: "Provided elsewhere #warn-check-docs:inputs";
+type AnyFactory = (...args: any[]) => any;
+type PublicServiceInputs<Inputs extends object> = Simplify<Omit<Inputs, ProvidedInputKey>>;
+type HasProvidedInput<Inputs extends object> = unknown extends Inputs ? false : ProvidedInputKey extends keyof Inputs ? true : false;
+type ServiceProvidedInput<Inputs extends object> = HasProvidedInput<Inputs> extends true ? Inputs[ProvidedInputKey & keyof Inputs] : never;
+type ExtractHelperValue<HelperObject> = HelperObject[keyof HelperObject];
+type NormalizeProvidedInput<Args extends unknown[]> = Args extends [] ? never : Args extends [infer Only] ? Only : Args;
+type ProvideArguments<ProvidedInput> = [ProvidedInput] extends [never] ? [] : [PublicInputValue<ProvidedInput>];
+export type CraftServiceProvider = Provider | EnvironmentProviders | CraftServiceProvider[];
+export type BrandedServiceProvider<Name extends string = string, Scope extends RequirementScope = RequirementScope, Output = unknown, Yielded = unknown> = Provider & {
+    readonly [CRAFT_SERVICE_PROVIDER_BRAND]?: {
+        name: Name;
+        providedIn: Scope;
+        output: Output;
+        yielded: Yielded;
+    };
+};
+/** Provider type returned by Craft service factories. */
+export type NamedBrandedServiceProvider<Name extends string = string, Scope extends RequirementScope = RequirementScope, Output = unknown, Yielded = unknown> = BrandedServiceProvider<Name, Scope, Output, Yielded> & {
+    readonly [CRAFT_SERVICE_PROVIDER_TYPE_BRAND]: {
+        name: Name;
+    };
+};
+export type ServiceMetaData<Name extends string = string, Scope extends ConcreteServiceScope = ConcreteServiceScope, Inputs extends object = {}, Output = unknown, Dependencies = ServiceDependencies, InjectHelper = (...args: any[]) => unknown, Tracking = unknown, ProvidedInput = never, ProvideArgs extends unknown[] = ProvideArguments<ProvidedInput>, BrowserBoundary extends boolean = false, AppStart extends boolean = false> = Simplify<{
+    readonly kind: 'service-meta-data';
+    readonly name: Name;
+    readonly providedIn: Scope;
+    readonly browserBoundary: BrowserBoundary;
+    readonly appStart: AppStart;
+    readonly inject: InjectHelper;
+    readonly [SERVICE_META_DATA_TYPE]?: {
+        inputs: Inputs;
+        output: Output;
+        dependencies: Dependencies;
+        tracking: Tracking;
+        providedInput: ProvidedInput;
+    };
+    readonly [SERVICE_RUNTIME_META]?: ServiceMetaData<Name, Scope, Inputs, Output, Dependencies, InjectHelper, Tracking, ProvidedInput, ProvideArgs, BrowserBoundary, AppStart>;
+} & (Scope extends 'toProvide' | 'manuallyProvidedAtRoot' ? {
+    readonly provide: (...args: ProvideArgs) => CraftServiceProvider;
+} : {}) & (Scope extends 'manuallyProvidedAtRoot' ? {
+    readonly token: InjectionToken<Output>;
+} : {})>;
+type AnyServiceMetaData = {
+    readonly kind: 'service-meta-data';
+    readonly name: string;
+    readonly providedIn: ConcreteServiceScope;
+    readonly browserBoundary: boolean;
+    readonly appStart: boolean;
+    readonly inject: (...args: any[]) => unknown;
+    readonly provide?: (...args: any[]) => CraftServiceProvider;
+    readonly token?: InjectionToken<unknown>;
+    readonly [SERVICE_META_DATA_TYPE]?: {
+        inputs: any;
+        output: any;
+        dependencies: any;
+        tracking: any;
+        providedInput: any;
+    };
+    readonly [SERVICE_RUNTIME_META]?: AnyServiceMetaData;
+};
+type WithServiceRuntimeMeta<Helper, MetaData extends AnyServiceMetaData> = Helper & {
+    readonly [SERVICE_RUNTIME_META]?: MetaData;
+};
+type ExtractServiceRuntimeMeta<ServiceReference> = ServiceReference extends {
+    readonly [SERVICE_RUNTIME_META]?: infer MetaData extends AnyServiceMetaData;
+} ? MetaData : never;
+type FactoryInputs<Factory> = Factory extends (...args: infer Args) => any ? Args extends [] ? {} : Args[0] extends object ? Args[0] : {} : never;
+type FactoryReturn<Factory> = Factory extends (...args: any[]) => infer Result ? Result : never;
+type FactoryOutput<Factory> = FactoryReturn<Factory> extends Generator<any, infer Result, any> ? Result : FactoryReturn<Factory>;
+type FactoryYields<Factory> = FactoryReturn<Factory> extends Generator<infer Yielded, any, any> ? Yielded : never;
+type YieldedServiceScope<Yielded> = Yielded extends ServiceYieldRequest<infer Scope, any, any> ? Scope : never;
+type ValidateFactoryScope<Scope extends ConcreteServiceScope, Factory extends AnyFactory> = ValidateYieldedScope<Scope, FactoryYields<Factory>, unknown>;
+type ValidateRequirementFactory<Factory extends AnyFactory, Requirement extends ServiceRequirement<any, any>> = FactoryOutput<Factory> extends RequirementContract<Requirement> ? unknown : never;
+type ValidateProvidedInputScope<Scope extends ConcreteServiceScope, Inputs extends object> = HasProvidedInput<Inputs> extends true ? Scope extends RealCapableScope ? unknown : never : unknown;
+type ValidateYieldedScope<Scope extends ConcreteServiceScope, Yielded, Value> = Scope extends 'global' ? Extract<YieldedServiceScope<Yielded>, 'toProvide'> extends never ? Value : never : Value;
+type OptionalKeys<ObjectType extends object> = {
+    [Key in keyof ObjectType]-?: {} extends Pick<ObjectType, Key> ? Key : never;
+}[keyof ObjectType];
+type RequiredKeys<ObjectType extends object> = Exclude<keyof ObjectType, OptionalKeys<ObjectType>>;
+type AppStartResult = Observable<unknown> | Promise<unknown> | void;
+type AppStartCapableScope = 'global' | RealCapableScope;
+type HasRequiredPublicInputs<Inputs extends object> = [
+    RequiredKeys<PublicServiceInputs<Inputs>>
+] extends [never] ? false : true;
+type ValidateAppStartInputs<Inputs extends object, IsEnabled extends boolean> = IsEnabled extends true ? HasProvidedInput<Inputs> extends true ? never : HasRequiredPublicInputs<Inputs> extends true ? never : unknown : unknown;
+type MissingInputKeys<Inputs extends object, Config> = Exclude<RequiredKeys<Inputs>, keyof NonNullable<Config>>;
+type MissingInputsMessage<Inputs extends object, Config> = [
+    MissingInputKeys<Inputs, Config>
+] extends [never] ? never : `Inputs Error, ${MissingInputKeys<Inputs, Config> & string} is not provided`;
+type BrandServiceProperties<Output> = Output extends Signal<any> ? Output : BrandReactiveProperties<Output>;
+type MaybeErrorOutput<Inputs extends object, Config, Output> = MissingInputsMessage<Inputs, Config> extends never ? BrandServiceProperties<Output> : MissingInputsMessage<Inputs, Config>;
+type InputBindings<Inputs extends object, Scope extends ConcreteServiceScope> = keyof Inputs extends never ? {} : {
+    [Key in keyof Inputs]: PublicInputValue<Inputs[Key]> | AllowedProvidedElsewhere<Scope>;
+};
+type PublicInputValue<Value> = Value extends Yieldable<[], infer Resolved, any> ? Resolved | Signal<Resolved> | YieldableReactiveValue<Resolved> | Value : Value;
+type PublicInputBindings<Inputs extends object, Scope extends ConcreteServiceScope> = InputBindings<PublicServiceInputs<Inputs>, Scope>;
+type StrictBindings<Shape extends object, Candidate extends object> = Exclude<keyof Candidate, keyof Shape> extends never ? Candidate : never;
+type AllowedProvidedElsewhere<Scope extends ConcreteServiceScope> = Scope extends 'global' | 'toProvide' | 'manuallyProvidedAtRoot' ? typeof PROVIDED_ELSEWHERE : never;
+type SelectableOutput<Inputs extends object, Config, Output> = MaybeErrorOutput<Inputs, Config, Output> extends infer Result ? Result extends object ? Result : never : never;
+type PublicExposedOutput<Exposed> = Exposed extends object ? BrandReactiveProperties<Omit<Exposed, RootExposureKey>> : Exposed;
+type ExposedOutput<Output, Exposed> = Output extends (...args: any[]) => any ? RootExposureKey extends keyof Exposed ? CallableShell<Output> & PublicExposedOutput<Exposed> : PublicExposedOutput<Exposed> : PublicExposedOutput<Exposed>;
+type OutputDependencyKeys<Output extends object> = Extract<keyof Output, string>;
+type ExposureTokenMetadata<Key extends string = string, Value = unknown> = {
+    key: Key;
+    value: Value;
+};
+type DependencyToken<Key extends string, Value> = {
+    (): Generator<ServiceDependencyAccessRequest<Key, Value>, Value, unknown>;
+    readonly [SERVICE_EXPOSURE_TOKEN_MARKER]: ExposureTokenMetadata<Key, Value>;
+};
+type PropertyExposureTokens<Output extends object> = {
+    [Key in OutputDependencyKeys<Output>]: DependencyToken<Key, Output[Key]>;
+};
+type CallableExposureRootToken<Output extends (...args: any[]) => any> = {
+    /**
+     * Root callable token for the exposed service.
+     *
+     * `yield* $self()` gives access to the original callable service without
+     * exposing it publicly.
+     *
+     * Returning `$self` from the exposure object re-attaches that callable to
+     * the root of the final exposed value.
+     *
+     * Example:
+     * `return { $self, incrementCounter: increment }`
+     *
+     * The final result stays callable via `myRef()`, but never exposes a public
+     * `myRef.$self` property.
+     */
+    $self: DependencyToken<RootExposureKey, Output>;
+};
+type ExposureTokens<Output extends object> = PropertyExposureTokens<Output> & (Output extends (...args: any[]) => any ? CallableExposureRootToken<Output> : {});
+type ExposureTokenKeys<Output extends object> = Extract<keyof ExposureTokens<Output>, string>;
+type ExposureTokenValue<Output extends object, Key extends ExposureTokenKeys<Output>> = Key extends OutputDependencyKeys<Output> ? Output[Key] : Key extends RootExposureKey ? Output : never;
+type TokenSourceKey<Value> = Value extends {
+    readonly [SERVICE_EXPOSURE_TOKEN_MARKER]: ExposureTokenMetadata<infer Key, any>;
+} ? Key : never;
+type TokenResolvedValue<Value> = Value extends {
+    readonly [SERVICE_EXPOSURE_TOKEN_MARKER]: ExposureTokenMetadata<any, infer Resolved>;
+} ? Resolved : never;
+type MaterializeExposureValue<Value> = [TokenResolvedValue<Value>] extends [
+    never
+] ? Value : TokenResolvedValue<Value>;
+type MaterializeExposureResult<Value> = Value extends object ? {
+    [Key in keyof Value]: MaterializeExposureValue<Value[Key]>;
+} : MaterializeExposureValue<Value>;
+type ServiceDependencyAccessRequest<Key extends string, Result> = Readonly<{
+    [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+    key: Key;
+    resolve: () => Result;
+}>;
+type ExposureYield<Output extends object> = {
+    [Key in ExposureTokenKeys<Output>]: ServiceDependencyAccessRequest<Key, ExposureTokenValue<Output, Key>>;
+}[ExposureTokenKeys<Output>];
+type InvalidRootExposureAliases<Exposed extends object> = Extract<{
+    [Key in keyof Exposed]-?: TokenSourceKey<Exposed[Key]> extends RootExposureKey ? Key extends RootExposureKey ? never : Key & string : never;
+}[keyof Exposed], string>;
+type ValidateRootExposure<Exposed extends object> = [
+    InvalidRootExposureAliases<Exposed>
+] extends [never] ? Exposed : never;
+type ExposureSelector<Output extends object, Exposed extends object, Yielded = never> = (dependencies: ExposureTokens<Output>) => ValidateRootExposure<Exposed> | Generator<Yielded, ValidateRootExposure<Exposed>, unknown>;
+type ExposureSourceRecord<Value> = [TokenSourceKey<Value>] extends [never] ? never : {
+    [Key in TokenSourceKey<Value>]: MaterializeExposureValue<Value>;
+};
+type ExposureAliasRecord<Key extends PropertyKey, Value> = [
+    TokenSourceKey<Value>
+] extends [never] ? never : Key extends string ? {
+    [Property in Key]: MaterializeExposureValue<Value>;
+} : never;
+type DirectlyUsedProperties<Exposed extends object> = MergeObjectUnion<{
+    [Key in keyof Exposed]-?: ExposureSourceRecord<Exposed[Key]>;
+}[keyof Exposed]>;
+type DirectlyExposedProperties<Exposed extends object> = MergeObjectUnion<{
+    [Key in keyof Exposed]-?: ExposureAliasRecord<Key, Exposed[Key]>;
+}[keyof Exposed]>;
+type YieldedUsedProperties<Yielded> = MergeObjectUnion<Yielded extends ServiceDependencyAccessRequest<infer Key extends string, infer Result> ? {
+    [Property in Key]: Result;
+} : never>;
+type DerivedPropertiesForExposure<Exposed extends object, Yielded> = DerivedPropertiesTracking<DirectlyUsedProperties<Exposed> & YieldedUsedProperties<Yielded>, DirectlyExposedProperties<Exposed>>;
+export type ServiceTrackingMetadata<Name extends string = string, Scope extends ConcreteServiceScope = ConcreteServiceScope, Output = unknown, Yielded = unknown, Derived = undefined, ProvidedInput = never, BrowserBoundary extends boolean = false, AppStart extends boolean = false> = {
+    name: Name;
+    providedIn: Scope;
+    output: Output;
+    yielded: Yielded;
+    derived: Derived;
+    providedInput: ProvidedInput;
+    browserBoundary: BrowserBoundary;
+    appStart: AppStart;
+};
+type AnyServiceTrackingMetadata = ServiceTrackingMetadata<string, ConcreteServiceScope, unknown, unknown, any, any, boolean, boolean>;
+type WithServiceNodeFlags<Derived, BrowserBoundary extends boolean, AppStart extends boolean> = Simplify<{
+    browserBoundary: BrowserBoundary;
+    appStart: AppStart;
+} & ([Derived] extends [undefined] ? {} : Derived)>;
+type TrackingBrowserBoundary<Metadata> = Metadata extends ServiceTrackingMetadata<any, any, any, any, any, any, infer BrowserBoundary extends boolean, any> ? BrowserBoundary : false;
+type DependencyBrowserBoundary<Node> = Node extends {
+    browserBoundary: infer BrowserBoundary extends boolean;
+} ? BrowserBoundary : false;
+type DependencyAppStart<Node> = Node extends {
+    appStart: infer AppStart extends boolean;
+} ? AppStart : false;
+type OrBoolean<Left extends boolean, Right extends boolean> = true extends Left | Right ? true : false;
+type WholeServiceUsageTracking = {
+    usesWholeService: true;
+};
+type DirectDependencyRequestUnion<Yielded> = Extract<Yielded, ServiceYieldRequest<any, any, any>>;
+type AppStartDependencyRequestUnion<Yielded> = Extract<Yielded, ServiceAppStartRequest<any>> extends infer Request ? Request extends ServiceAppStartRequest<infer AppStartYielded> ? Extract<AppStartYielded, ServiceYieldRequest<any, any, any>> : never : never;
+type DependencyRequests<Yielded> = UnionToTuple<DirectDependencyRequestUnion<Yielded> | AppStartDependencyRequestUnion<Yielded>>;
+type DependencyMetadata<Request> = Request extends ServiceYieldRequest<any, any, infer Metadata> ? Metadata : never;
+type NodeDerivedProperties<Node> = Node extends {
+    derivedPropertiesUsed: infer Used extends object;
+    derivedPropertiesExposed: infer Exposed extends object;
+} ? DerivedPropertiesTracking<Used, Exposed> : undefined;
+type MergeDerivedProperties<Left, Right> = [Left] extends [
+    DerivedPropertiesTracking<infer LeftUsed, infer LeftExposed>
+] ? [Right] extends [
+    DerivedPropertiesTracking<infer RightUsed, infer RightExposed>
+] ? DerivedPropertiesTracking<Simplify<LeftUsed & RightUsed>, Simplify<LeftExposed & RightExposed>> : undefined : undefined;
+type DependencyChildren<Node> = Node extends {
+    dependencies: infer Dependencies extends object;
+} ? Dependencies : {};
+type DependencyScope<Node> = Node extends {
+    providedIn: infer Scope;
+} ? Scope : never;
+type MergeDependencyNodeMaps<Left extends object, Right extends object> = Simplify<{
+    [Name in Extract<keyof Left | keyof Right, string>]: Name extends keyof Left ? Name extends keyof Right ? MergeDependencyNodes<Left[Name], Right[Name]> : Left[Name] : Name extends keyof Right ? Right[Name] : never;
+}>;
+type MergeDependencyNodes<Left, Right> = ServiceDependencies<DependencyScope<Left> & DependencyScope<Right>, MergeDependencyNodeMaps<DependencyChildren<Left>, DependencyChildren<Right>>, WithServiceNodeFlags<MergeDerivedProperties<NodeDerivedProperties<Left>, NodeDerivedProperties<Right>>, DependencyBrowserBoundary<Left> & DependencyBrowserBoundary<Right>, OrBoolean<DependencyAppStart<Left>, DependencyAppStart<Right>>>>;
+type TrackedDepMapOf<Request> = Request extends ServiceTrackedDepsRequest<infer DepMap> ? [DepMap] extends [never] ? never : [keyof DepMap] extends [never] ? never : DepMap : never;
+type AppStartYieldedOf<Request> = Request extends ServiceAppStartRequest<infer AppStartYielded> ? AppStartYielded : never;
+type TrackedDepMapUnion<Yielded> = TrackedDepMapOf<Extract<Yielded, ServiceTrackedDepsRequest<any>>> | TrackedDepMapOf<Extract<AppStartYieldedOf<Extract<Yielded, ServiceAppStartRequest<any>>>, ServiceTrackedDepsRequest<any>>>;
+type MergeAllDependencyNodeMaps<Maps extends object[], Accumulator extends object = {}> = Maps extends [infer First extends object, ...infer Rest extends object[]] ? MergeAllDependencyNodeMaps<Rest, MergeDependencyNodeMaps<Accumulator, First>> : Accumulator;
+type TrackedDepsMapFromYielded<Yielded> = MergeAllDependencyNodeMaps<UnionToTuple<TrackedDepMapUnion<Yielded>> extends infer Tuple extends object[] ? Tuple : []>;
+type ResolveServiceTrackingMetadata<Metadata> = Metadata extends ServiceTrackingMetadata<infer Name extends string, infer Scope extends ConcreteServiceScope, infer Output, infer Yielded, infer Derived, any, infer BrowserBoundary extends boolean, infer AppStart extends boolean> ? ServiceDependencies<Scope, MergeDependencyNodeMaps<BuildDependencyMap<DependencyRequests<Yielded>>, TrackedDepsMapFromYielded<Yielded>>, WithServiceNodeFlags<Derived, BrowserBoundary, AppStart>> : never;
+export type ExtractServiceHelperDependencies<ServiceHelper> = ResolveServiceTrackingMetadata<ExtractTrackedMetadata<ServiceHelper>>;
+export type ExtractServiceHelperDependencyMap<ServiceHelper> = ExtractTrackedMetadata<ServiceHelper> extends ServiceTrackingMetadata<infer Name extends string, ConcreteServiceScope, unknown, unknown, unknown, unknown, boolean, boolean> ? {
+    [Key in Name]: ExtractServiceHelperDependencies<ServiceHelper>;
+} : never;
+export type ServiceDependencyMapFromYielded<Yielded> = BuildDependencyMap<DependencyRequests<Yielded>>;
+type DependencyMapFromValue<Value> = Value extends {
+    readonly [SERVICE_HELPER_DEPENDENCIES]?: infer Dependencies extends object;
+} ? Dependencies : {};
+type DependencyValues<Values> = Values extends object ? Values[keyof Values] : Values;
+type DependencyMapsFromValues<Values> = DependencyMapFromValue<DependencyValues<Values>>;
+/**
+ * Extracts and merges dependency metadata carried by insertion outputs.
+ *
+ * `on$` uses this carrier because subscribing to a source is a consumer-side
+ * dependency, while emitting a source value is only a producer operation.
+ */
+export type ServiceDependencyMapFromValues<Values> = MergeAllDependencyNodeMaps<[
+    Values
+] extends [never] ? [] : UnionToTuple<DependencyMapsFromValues<Values>> extends infer Tuple ? Tuple extends object[] ? Tuple : [] : []>;
+export type MergeServiceDependencyMaps<Left extends object, Right extends object> = MergeDependencyNodeMaps<Left, Right>;
+export type ServiceDependencyMapFromYieldedAndValues<Yielded, Values> = MergeServiceDependencyMaps<ServiceDependencyMapFromYielded<Yielded>, ServiceDependencyMapFromValues<Values>>;
+export type CompleteServiceDependencyMapFromYielded<Yielded> = MergeDependencyNodeMaps<ServiceDependencyMapFromYielded<Yielded>, TrackedDepsMapFromYielded<Yielded>>;
+type DependencyDefinition<Request> = ResolveServiceTrackingMetadata<DependencyMetadata<Request>>;
+type DependencyRecord<Request> = DependencyMetadata<Request> extends ServiceTrackingMetadata<infer Name extends string, any, any, any, any, any, any, any> ? string extends Name ? {} : {
+    [Key in Name]: DependencyDefinition<Request>;
+} : {};
+type BuildDependencyMap<Requests extends unknown[], Accumulator extends object = {}> = Requests extends [infer First, ...infer Rest] ? BuildDependencyMap<Rest, MergeDependencyNodeMaps<Accumulator, DependencyRecord<First>>> : Simplify<Accumulator>;
+type NormalizeWholeServiceUsage<Derived> = [Derived] extends [undefined] ? WholeServiceUsageTracking : Derived;
+type TrackedNodeUsage<Node> = Node extends {
+    usesWholeService: true;
+} ? WholeServiceUsageTracking : NodeDerivedProperties<Node>;
+type MergeTrackedDependencyUsage<Left, Right> = Left extends WholeServiceUsageTracking ? WholeServiceUsageTracking : Right extends WholeServiceUsageTracking ? WholeServiceUsageTracking : [Left] extends [
+    DerivedPropertiesTracking<infer LeftUsed, infer LeftExposed>
+] ? [Right] extends [
+    DerivedPropertiesTracking<infer RightUsed, infer RightExposed>
+] ? DerivedPropertiesTracking<Simplify<LeftUsed & RightUsed>, Simplify<LeftExposed & RightExposed>> : WholeServiceUsageTracking : WholeServiceUsageTracking;
+type MergeTrackedDependencyNodes<Left, Right> = Simplify<{
+    providedIn: DependencyScope<Left> & DependencyScope<Right>;
+    dependencies: MergeTrackedDependencyNodeMaps<DependencyChildren<Left>, DependencyChildren<Right>>;
+} & WithServiceNodeFlags<MergeTrackedDependencyUsage<TrackedNodeUsage<Left>, TrackedNodeUsage<Right>>, DependencyBrowserBoundary<Left> & DependencyBrowserBoundary<Right>, OrBoolean<DependencyAppStart<Left>, DependencyAppStart<Right>>>>;
+type MergeTrackedDependencyNodeMaps<Left extends object, Right extends object> = Simplify<{
+    [Name in Extract<keyof Left | keyof Right, string>]: Name extends keyof Left ? Name extends keyof Right ? MergeTrackedDependencyNodes<Left[Name], Right[Name]> : Left[Name] : Name extends keyof Right ? Right[Name] : never;
+}>;
+type ResolveTrackedDependencyMetadata<Metadata> = Metadata extends ServiceTrackingMetadata<infer Name extends string, infer Scope extends ConcreteServiceScope, infer Output, infer Yielded, infer Derived, any, infer BrowserBoundary extends boolean, infer AppStart extends boolean> ? Simplify<{
+    providedIn: Scope;
+    dependencies: BuildTrackedDependencyMap<DependencyRequests<Yielded>>;
+} & WithServiceNodeFlags<NormalizeWholeServiceUsage<Derived>, BrowserBoundary, AppStart>> : never;
+type TrackedDependencyRecord<Request> = DependencyMetadata<Request> extends ServiceTrackingMetadata<infer Name extends string, any, any, any, any, any, any, any> ? {
+    [Key in Name]: ResolveTrackedDependencyMetadata<DependencyMetadata<Request>>;
+} : {};
+type BuildTrackedDependencyMap<Requests extends unknown[], Accumulator extends object = {}> = Requests extends [infer First, ...infer Rest] ? BuildTrackedDependencyMap<Rest, MergeTrackedDependencyNodeMaps<Accumulator, TrackedDependencyRecord<First>>> : Simplify<Accumulator>;
+type FlattenTrackedDependencyNodeMapFromTracking<Tracking> = Tracking extends ServiceTrackingMetadata<any, any, any, infer Yielded, any, any, any, any> ? BuildFlattenedTrackedDependencyNodeMap<DependencyRequests<Yielded>> : {};
+type BuildFlattenedTrackedDependencyNodeMap<Requests extends unknown[], Accumulator extends object = {}> = Requests extends [infer First, ...infer Rest] ? BuildFlattenedTrackedDependencyNodeMap<Rest, MergeTrackedDependencyNodeMaps<MergeTrackedDependencyNodeMaps<Accumulator, TrackedDependencyRecord<First>>, FlattenTrackedDependencyNodeMapFromTracking<DependencyMetadata<First>>>> : Simplify<Accumulator>;
+type ServiceHelperMetadata<Name extends string, Scope extends ConcreteServiceScope, Factory extends AnyFactory, BrowserBoundary extends boolean = false, AppStart extends boolean = false> = ServiceTrackingMetadata<Name, Scope, FactoryOutput<Factory>, FactoryYields<Factory>, undefined, ServiceProvidedInput<FactoryInputs<Factory>>, BrowserBoundary, AppStart>;
+type WithDerivedProperties<Metadata extends AnyServiceTrackingMetadata, Exposed extends object, Yielded> = Metadata extends ServiceTrackingMetadata<infer Name extends string, infer Scope extends ConcreteServiceScope, infer Output, infer ChildYielded, any, infer ProvidedInput, infer BrowserBoundary extends boolean, infer AppStart extends boolean> ? ServiceTrackingMetadata<Name, Scope, Output, ChildYielded, DerivedPropertiesForExposure<Exposed, Yielded>, ProvidedInput, BrowserBoundary, AppStart> : never;
+export type ServiceYieldRequest<Scope extends ConcreteServiceScope, Result, Metadata extends AnyServiceTrackingMetadata = AnyServiceTrackingMetadata> = Readonly<{
+    [SERVICE_YIELD_REQUEST_MARKER]: true;
+    name: string;
+    readonly [SERVICE_YIELD_METADATA]?: Metadata;
+    providedIn: Scope;
+    resolve: (injector: Injector, hostScope: ConcreteServiceScope) => Result;
+}>;
+type AllowedAppStartYield = ServiceYieldRequest<any, any, any> | ServiceDependencyAccessRequest<string, unknown>;
+type ServiceAppStartRequest<Yielded = never> = Readonly<{
+    [SERVICE_APP_START_REQUEST_MARKER]: true;
+    readonly [SERVICE_APP_START_CALLBACK_YIELDED]?: Yielded;
+    run: () => AppStartResult | Generator<Yielded, AppStartResult, unknown>;
+}>;
+type AbstractMarker<Contract> = {
+    readonly [ABSTRACT_SERVICE_MARKER]: () => Contract;
+};
+type RequirementContract<Requirement> = Requirement extends ServiceRequirement<infer Contract, any> ? Contract : never;
+export type ServiceRequirement<Contract, Name extends string = string> = {
+    readonly [SERVICE_REQUIREMENT_MARKER]: true;
+    readonly token: InjectionToken<Contract>;
+    readonly name: Name;
+};
+type ServiceRuntimeMetaDefinition<Name extends string, Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata, AppStart extends boolean = false, ProvidedInput = ServiceProvidedInput<Inputs>, ProvideArgs extends unknown[] = ProvideArguments<ProvidedInput>> = ServiceMetaData<Name, Scope, PublicServiceInputs<Inputs>, Output, ResolveServiceTrackingMetadata<Metadata>, (...args: any[]) => unknown, Metadata, ProvidedInput, ProvideArgs, TrackingBrowserBoundary<Metadata>, AppStart>;
+type InjectHelper<Name extends string, Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata, AppStart extends boolean = false, ProvidedInput = ServiceProvidedInput<Inputs>, ProvideArgs extends unknown[] = ProvideArguments<ProvidedInput>> = {
+    [Key in `inject${Capitalize<Name>}`]: WithTrackedDependencies<WithServiceRuntimeMeta<{
+        (): MaybeErrorOutput<PublicServiceInputs<Inputs>, undefined, Output>;
+        <Config extends Partial<PublicInputBindings<Inputs, Scope>>>(bindings: StrictBindings<Partial<PublicInputBindings<Inputs, Scope>>, Config>): MaybeErrorOutput<PublicServiceInputs<Inputs>, Config, Output>;
+        <Exposed extends object, Yielded extends ExposureYield<SelectableOutput<PublicServiceInputs<Inputs>, undefined, Output>> = never>(bindings: undefined, expose: ExposureSelector<SelectableOutput<PublicServiceInputs<Inputs>, undefined, Output>, Exposed, Yielded>): ExposedOutput<SelectableOutput<PublicServiceInputs<Inputs>, undefined, Output>, MaterializeExposureResult<ValidateRootExposure<Exposed>>>;
+        <Config extends Partial<PublicInputBindings<Inputs, Scope>>, Exposed extends object, Yielded extends ExposureYield<SelectableOutput<PublicServiceInputs<Inputs>, Config, Output>> = never>(bindings: StrictBindings<Partial<PublicInputBindings<Inputs, Scope>>, Config>, expose: ExposureSelector<SelectableOutput<PublicServiceInputs<Inputs>, Config, Output>, Exposed, Yielded>): ExposedOutput<SelectableOutput<PublicServiceInputs<Inputs>, Config, Output>, MaterializeExposureResult<ValidateRootExposure<Exposed>>>;
+    } & InjectPropertyShortcuts<Scope, Inputs, Output, Metadata> & (keyof PublicServiceInputs<Inputs> extends never ? {} : {
+        OmitInputs: OmitInputsInjectShortcuts<Scope, Inputs, Output, Metadata>;
+    }), ServiceRuntimeMetaDefinition<Name, Scope, Inputs, Output, Metadata, AppStart, ProvidedInput, ProvideArgs>>, Metadata>;
+};
+type SinglePropertyDerivedProperties<Output extends object, Key extends OutputDependencyKeys<Output>> = DerivedPropertiesTracking<{
+    [Property in Key]: Output[Property];
+}, {
+    [Property in Key]: Output[Property];
+}>;
+type WithSinglePropertyDerivedProperties<Metadata extends AnyServiceTrackingMetadata, Output extends object, Key extends OutputDependencyKeys<Output>> = Metadata extends ServiceTrackingMetadata<infer Name extends string, infer Scope extends ConcreteServiceScope, infer ServiceOutput, infer ChildYielded, any, infer ProvidedInput, infer BrowserBoundary extends boolean, infer AppStart extends boolean> ? ServiceTrackingMetadata<Name, Scope, ServiceOutput, ChildYielded, SinglePropertyDerivedProperties<Output, Key>, ProvidedInput, BrowserBoundary, AppStart> : never;
+type NestedPropertyValue<V, NestedKey> = V extends object ? NestedKey extends keyof V ? V[NestedKey] : never : never;
+type NestedPropertyDerivedProperties<Output extends object, Key extends OutputDependencyKeys<Output>, NestedKey extends keyof (Output[Key] extends object ? Output[Key] : never)> = DerivedPropertiesTracking<{
+    [K in Key]: Output[K] extends infer V ? V extends object ? {
+        [NK in NestedKey & keyof V]: V[NK];
+    } : never : never;
+}, {
+    [K in Key]: Output[K] extends infer V ? V extends object ? {
+        [NK in NestedKey & keyof V]: V[NK];
+    } : never : never;
+}>;
+type WithNestedPropertyDerivedProperties<Metadata extends AnyServiceTrackingMetadata, Output extends object, Key extends OutputDependencyKeys<Output>, NestedKey extends keyof (Output[Key] extends object ? Output[Key] : never)> = Metadata extends ServiceTrackingMetadata<infer Name extends string, infer Scope extends ConcreteServiceScope, infer ServiceOutput, infer ChildYielded, any, infer ProvidedInput, infer BrowserBoundary extends boolean, infer AppStart extends boolean> ? ServiceTrackingMetadata<Name, Scope, ServiceOutput, ChildYielded, NestedPropertyDerivedProperties<Output, Key, NestedKey>, ProvidedInput, BrowserBoundary, AppStart> : never;
+type SinglePropertyShortcutResult<Inputs extends object, Config, Output extends object, Key extends OutputDependencyKeys<Output>> = MaybeErrorOutput<PublicServiceInputs<Inputs>, Config, Output> extends infer Result ? Result extends object ? Key extends keyof Result ? Result[Key] : never : Result : never;
+type SinglePropertyShortcutGenerator<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Config, Key extends OutputDependencyKeys<Output>> = Generator<ServiceYieldRequest<Scope, MaybeErrorOutput<PublicServiceInputs<Inputs>, Config, Output>, WithSinglePropertyDerivedProperties<Metadata, Output, Key>>, SinglePropertyShortcutResult<Inputs, Config, Output, Key>, unknown>;
+type InjectPropertyShortcut<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Key extends OutputDependencyKeys<Output>> = WithTrackedDependencies<(keyof PublicServiceInputs<Inputs> extends never ? {
+    (): SinglePropertyShortcutResult<Inputs, undefined, Output, Key>;
+} : {}) & {
+    <Config extends Partial<PublicInputBindings<Inputs, Scope>>>(bindings: StrictBindings<Partial<PublicInputBindings<Inputs, Scope>>, Config>): SinglePropertyShortcutResult<Inputs, Config, Output, Key>;
+} & (keyof PublicServiceInputs<Inputs> extends never ? Output[Key] extends (...args: infer Args) => infer Result ? Args extends [] ? {} : (...args: Args) => ResolveGeneratorResult<Result> : {} : {}) & NestedInjectPropertyShortcuts<Scope, Inputs, Output, Metadata, Key>, WithSinglePropertyDerivedProperties<Metadata, Output, Key>>;
+type NestedInjectPropertyShortcut<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Key extends OutputDependencyKeys<Output>, NestedKey extends keyof (Output[Key] extends object ? Output[Key] : never)> = WithTrackedDependencies<{
+    (): WithTrackedDependencies<NestedPropertyValue<Output[Key], NestedKey>, WithNestedPropertyDerivedProperties<Metadata, Output, Key, NestedKey>>;
+    <Config extends Partial<PublicInputBindings<Inputs, Scope>>>(bindings: StrictBindings<Partial<PublicInputBindings<Inputs, Scope>>, Config>): WithTrackedDependencies<NestedPropertyValue<Output[Key], NestedKey>, WithNestedPropertyDerivedProperties<Metadata, Output, Key, NestedKey>>;
+}, WithNestedPropertyDerivedProperties<Metadata, Output, Key, NestedKey>>;
+type NestedInjectPropertyShortcuts<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Key extends OutputDependencyKeys<Output>> = Output[Key] extends object ? {
+    [NestedKey in Exclude<keyof Output[Key], keyof Function | 'then'>]: NestedInjectPropertyShortcut<Scope, Inputs, Output, Metadata, Key, NestedKey>;
+} : {};
+type YieldPropertyShortcut<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Key extends OutputDependencyKeys<Output>> = WithTrackedDependencies<(keyof PublicServiceInputs<Inputs> extends never ? {
+    (): SinglePropertyShortcutGenerator<Scope, Inputs, Output, Metadata, undefined, Key>;
+} : {}) & {
+    <Config extends Partial<PublicInputBindings<Inputs, Scope>>>(bindings: StrictBindings<Partial<PublicInputBindings<Inputs, Scope>>, Config>): SinglePropertyShortcutGenerator<Scope, Inputs, Output, Metadata, Config, Key>;
+} & (keyof PublicServiceInputs<Inputs> extends never ? Output[Key] extends (...args: infer Args) => infer Result ? Args extends [] ? {} : (...args: Args) => Generator<ServiceYieldRequest<Scope, MaybeErrorOutput<PublicServiceInputs<Inputs>, undefined, Output>, WithSinglePropertyDerivedProperties<Metadata, Output, Key>>, ResolveGeneratorResult<Result>, unknown> : {} : {}) & NestedYieldPropertyShortcuts<Scope, Inputs, Output, Metadata, Key>, WithSinglePropertyDerivedProperties<Metadata, Output, Key>>;
+type NestedYieldPropertyShortcut<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Key extends OutputDependencyKeys<Output>, NestedKey extends keyof (Output[Key] extends object ? Output[Key] : never)> = WithTrackedDependencies<{
+    (): Generator<ServiceYieldRequest<Scope, NestedPropertyValue<Output[Key], NestedKey>, WithNestedPropertyDerivedProperties<Metadata, Output, Key, NestedKey>>, NestedPropertyValue<Output[Key], NestedKey>, unknown>;
+    <Config extends Partial<PublicInputBindings<Inputs, Scope>>>(bindings: StrictBindings<Partial<PublicInputBindings<Inputs, Scope>>, Config>): Generator<ServiceYieldRequest<Scope, NestedPropertyValue<Output[Key], NestedKey>, WithNestedPropertyDerivedProperties<Metadata, Output, Key, NestedKey>>, NestedPropertyValue<Output[Key], NestedKey>, unknown>;
+}, WithNestedPropertyDerivedProperties<Metadata, Output, Key, NestedKey>>;
+type NestedYieldPropertyShortcuts<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Key extends OutputDependencyKeys<Output>> = Output[Key] extends object ? {
+    [NestedKey in Exclude<keyof Output[Key], keyof Function | 'then'>]: NestedYieldPropertyShortcut<Scope, Inputs, Output, Metadata, Key, NestedKey>;
+} : {};
+type YieldPropertyShortcuts<Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata> = Output extends object ? {
+    [Key in Exclude<OutputDependencyKeys<Output>, keyof Function | 'then'>]: YieldPropertyShortcut<Scope, Inputs, Output, Metadata, Key>;
+} : {};
+type InjectPropertyShortcuts<Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata> = Output extends object ? {
+    [Key in Exclude<OutputDependencyKeys<Output>, keyof Function | 'then'>]: InjectPropertyShortcut<Scope, Inputs, Output, Metadata, Key>;
+} : {};
+type OmitInputsInjectPropertyShortcut<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Key extends OutputDependencyKeys<Output>> = WithTrackedDependencies<{
+    (): SinglePropertyShortcutResult<Inputs, undefined, Output, Key>;
+} & NestedInjectPropertyShortcuts<Scope, Inputs, Output, Metadata, Key>, WithSinglePropertyDerivedProperties<Metadata, Output, Key>>;
+type OmitInputsInjectShortcuts<Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata> = Output extends object ? {
+    [Key in Exclude<OutputDependencyKeys<Output>, keyof Function | 'then'>]: OmitInputsInjectPropertyShortcut<Scope, Inputs, Output, Metadata, Key>;
+} : {};
+type OmitInputsYieldPropertyShortcut<Scope extends ConcreteServiceScope, Inputs extends object, Output extends object, Metadata extends AnyServiceTrackingMetadata, Key extends OutputDependencyKeys<Output>> = WithTrackedDependencies<{
+    (): SinglePropertyShortcutGenerator<Scope, Inputs, Output, Metadata, undefined, Key>;
+} & NestedYieldPropertyShortcuts<Scope, Inputs, Output, Metadata, Key>, WithSinglePropertyDerivedProperties<Metadata, Output, Key>>;
+type OmitInputsYieldShortcuts<Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata> = Output extends object ? {
+    [Key in Exclude<OutputDependencyKeys<Output>, keyof Function | 'then'>]: OmitInputsYieldPropertyShortcut<Scope, Inputs, Output, Metadata, Key>;
+} : {};
+type YieldHelper<Name extends string, Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata, AppStart extends boolean = false, ProvidedInput = ServiceProvidedInput<Inputs>, ProvideArgs extends unknown[] = ProvideArguments<ProvidedInput>> = {
+    [Key in Capitalize<Name>]: WithTrackedDependencies<WithServiceRuntimeMeta<{
+        (): Generator<ServiceYieldRequest<Scope, MaybeErrorOutput<PublicServiceInputs<Inputs>, undefined, Output>, Metadata>, MaybeErrorOutput<PublicServiceInputs<Inputs>, undefined, Output>, unknown>;
+        <Config extends Partial<PublicInputBindings<Inputs, Scope>>>(bindings: StrictBindings<Partial<PublicInputBindings<Inputs, Scope>>, Config>): Generator<ServiceYieldRequest<Scope, MaybeErrorOutput<PublicServiceInputs<Inputs>, Config, Output>, Metadata>, MaybeErrorOutput<PublicServiceInputs<Inputs>, Config, Output>, unknown>;
+        <Exposed extends object, Yielded extends ExposureYield<SelectableOutput<PublicServiceInputs<Inputs>, undefined, Output>> = never>(bindings: undefined, expose: ExposureSelector<SelectableOutput<PublicServiceInputs<Inputs>, undefined, Output>, Exposed, Yielded>): Generator<ServiceYieldRequest<Scope, SelectableOutput<PublicServiceInputs<Inputs>, undefined, Output>, WithDerivedProperties<Metadata, Exposed, Yielded>> | ExposureYield<SelectableOutput<PublicServiceInputs<Inputs>, undefined, Output>>, ExposedOutput<SelectableOutput<PublicServiceInputs<Inputs>, undefined, Output>, MaterializeExposureResult<ValidateRootExposure<Exposed>>>, unknown>;
+        <Config extends Partial<PublicInputBindings<Inputs, Scope>>, Exposed extends object, Yielded extends ExposureYield<SelectableOutput<PublicServiceInputs<Inputs>, Config, Output>> = never>(bindings: StrictBindings<Partial<PublicInputBindings<Inputs, Scope>>, Config>, expose: ExposureSelector<SelectableOutput<PublicServiceInputs<Inputs>, Config, Output>, Exposed, Yielded>): Generator<ServiceYieldRequest<Scope, SelectableOutput<PublicServiceInputs<Inputs>, Config, Output>, WithDerivedProperties<Metadata, Exposed, Yielded>> | ExposureYield<SelectableOutput<PublicServiceInputs<Inputs>, Config, Output>>, ExposedOutput<SelectableOutput<PublicServiceInputs<Inputs>, Config, Output>, MaterializeExposureResult<ValidateRootExposure<Exposed>>>, unknown>;
+    } & YieldPropertyShortcuts<Scope, Inputs, Output, Metadata> & (keyof PublicServiceInputs<Inputs> extends never ? {} : {
+        OmitInputs: OmitInputsYieldShortcuts<Scope, Inputs, Output, Metadata>;
+    }), ServiceRuntimeMetaDefinition<Name, Scope, Inputs, Output, Metadata, AppStart, ProvidedInput, ProvideArgs>>, Metadata>;
+};
+type ExtractServiceTrackingYielded<Metadata> = Metadata extends ServiceTrackingMetadata<any, any, any, infer Yielded, any, any, any, any> ? Yielded : never;
+type ProvideHelper<Name extends string, Scope extends RealCapableScope, Output, ProvideArgs extends unknown[], Yielded = never> = {
+    [Key in `provide${Capitalize<Name>}`]: (...args: ProvideArgs) => NamedBrandedServiceProvider<Name, Scope, Output, Yielded>;
+};
+type ToProvideTokenHelper<Name extends string, Output> = {
+    [Key in `${Capitalize<Name>}ToProvide`]: InjectionToken<Output>;
+};
+type RequirementHelper<Name extends string, Contract> = {
+    [Key in `${Capitalize<Name>}Requirement`]: ServiceRequirement<Contract, Name>;
+};
+type ServiceMetaDataHelper<Name extends string, Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata, AppStart extends boolean = false, ProvidedInput = ServiceProvidedInput<Inputs>, ProvideArgs extends unknown[] = ProvideArguments<ProvidedInput>> = {
+    [Key in ServiceMetaDataKey<Name>]: ServiceMetaData<Name, Scope, PublicServiceInputs<Inputs>, Output, ResolveServiceTrackingMetadata<Metadata>, ExtractHelperValue<InjectHelper<Name, Scope, Inputs, Output, Metadata, AppStart, ProvidedInput, ProvideArgs>>, Metadata, ProvidedInput, ProvideArgs, TrackingBrowserBoundary<Metadata>, AppStart>;
+};
+type ConcreteServiceApi<Name extends string, Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata, AppStart extends boolean = false> = YieldHelper<Name, Scope, Inputs, Output, Metadata, AppStart> & ServiceMetaDataHelper<Name, Scope, Inputs, Output, Metadata, AppStart> & (Scope extends 'toProvide' | 'manuallyProvidedAtRoot' ? ProvideHelper<Name, Extract<Scope, RealCapableScope>, Output, ProvideArguments<ServiceProvidedInput<Inputs>>, ExtractServiceTrackingYielded<Metadata>> : {}) & (Scope extends 'manuallyProvidedAtRoot' ? ToProvideTokenHelper<Name, Output> : {});
+export type CraftServiceApi<Name extends string, Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata = ServiceTrackingMetadata<Name, Scope, Output, never>, AppStart extends boolean = false> = ConcreteServiceApi<Name, Scope, Inputs, Output, Metadata, AppStart>;
+type AbstractProvideFactory<Contract> = (() => Contract) | (() => Generator<any, Contract, any>);
+type AbstractProvideHelper<Name extends string, Contract> = {
+    [Key in `provide${Capitalize<Name>}`]: <Factory extends AbstractProvideFactory<Contract>>(factory: Factory) => NamedBrandedServiceProvider<Name, 'toProvide', Contract, FactoryYields<Factory>>;
+};
+type AbstractHelper<Name extends string, Contract> = {
+    [Key in Capitalize<Name>]: () => Generator<ServiceYieldRequest<'toProvide', Contract, ServiceTrackingMetadata<Name, 'toProvide', Contract, never>>, Contract, unknown>;
+};
+export type AbstractServiceApi<Name extends string, Contract> = RequirementHelper<Name, Contract> & AbstractProvideHelper<Name, Contract> & AbstractHelper<Name, Contract>;
+type DependencySourceToken<Output> = Type<Output> | InjectionToken<Output>;
+type DependencySourceOutput<Token> = Token extends Type<infer Output> ? Output : Token extends InjectionToken<infer Output> ? Output : never;
+export type DependencyApi<Name extends string, Scope extends ConcreteServiceScope, Inputs extends object, Output, Metadata extends AnyServiceTrackingMetadata = ServiceTrackingMetadata<Name, Scope, Output, never>, ProvidedInput = ServiceProvidedInput<Inputs>, ProvideArgs extends unknown[] = ProvideArguments<ProvidedInput>> = YieldHelper<Name, Scope, Inputs, Output, Metadata, false, ProvidedInput, ProvideArgs> & ServiceMetaDataHelper<Name, Scope, Inputs, Output, Metadata, false, ProvidedInput, ProvideArgs> & (Scope extends 'toProvide' | 'manuallyProvidedAtRoot' ? ProvideHelper<Name, Extract<Scope, RealCapableScope>, Output, ProvideArgs, ExtractServiceTrackingYielded<Metadata>> : {}) & (Scope extends 'manuallyProvidedAtRoot' ? ToProvideTokenHelper<Name, Output> : {});
+type GlobalInjectedDependencyOptions<Name extends string, Output> = {
+    name: Name;
+    providedIn: 'global';
+    inject: () => Output;
+};
+type DependencyProvideFactory<Inputs extends object> = (...args: ProvideArguments<ServiceProvidedInput<Inputs>>) => CraftServiceProvider;
+type AnyDependencyProvideFactory = (...args: any[]) => CraftServiceProvider;
+type DependencyProvideFactoryArgs<Provide extends AnyDependencyProvideFactory> = Parameters<Provide>;
+type DependencyProvideFactoryInput<Provide extends AnyDependencyProvideFactory> = NormalizeProvidedInput<Parameters<Provide>>;
+type WithDependencyProvidedInput<Inputs extends object, Provide extends AnyDependencyProvideFactory> = [DependencyProvideFactoryInput<Provide>] extends [never] ? Inputs : Inputs & {
+    $provided: DependencyProvideFactoryInput<Provide>;
+};
+type ProviderCapableDependencyOptions<Name extends string, Scope extends RealCapableScope, Token extends DependencySourceToken<any>, Inputs extends object = {}, Provide extends AnyDependencyProvideFactory = DependencyProvideFactory<Inputs>> = {
+    name: Name;
+    providedIn: Scope;
+    token: Token;
+    provide: Provide;
+};
+type DependencyFactoryOutputFromResult<Result> = Result extends Generator<any, infer Output, any> ? Output : Result;
+type DependencyFactoryYieldsFromResult<Result> = Result extends Generator<infer Yielded, any, any> ? Yielded : never;
+export type ServiceReference<Name extends string = string, Scope extends ConcreteServiceScope = ConcreteServiceScope, Inputs extends object = any, Output = unknown, Dependencies = any> = ServiceMetaData<Name, Scope, Inputs, Output, Dependencies, any, any, any, any, boolean, boolean> | {
+    readonly [SERVICE_RUNTIME_META]?: AnyServiceMetaData;
+};
+export type GetServiceReferenceMeta<Reference extends ServiceReference> = Reference extends AnyServiceMetaData ? Reference : ExtractServiceRuntimeMeta<Reference>;
+export type GetServiceInputs<Reference extends ServiceReference> = GetServiceMetaDataInputs<GetServiceReferenceMeta<Reference>>;
+export type GetServiceReferenceOutput<Reference extends ServiceReference> = GetServiceMetaDataOutput<GetServiceReferenceMeta<Reference>>;
+export type GetServiceProvidedInput<Reference extends ServiceReference> = GetServiceMetaDataProvidedInput<GetServiceReferenceMeta<Reference>>;
+export type GetServiceTrackingMetadata<Reference extends ServiceReference> = Reference extends AnyServiceMetaData ? GetServiceMetaDataTracking<Reference> : ExtractTrackedMetadata<Reference>;
+export type GetMergedServiceDependencyNodeMap<Reference extends ServiceReference> = FlattenTrackedDependencyNodeMapFromTracking<GetServiceTrackingMetadata<Reference>>;
+export type ServiceBindings<Reference extends ServiceReference> = Partial<InputBindings<GetServiceInputs<Reference>, Extract<GetServiceReferenceMeta<Reference>['providedIn'], ConcreteServiceScope>>>;
+export type ResolvedServiceOutput<Reference extends ServiceReference, Bindings> = MaybeErrorOutput<GetServiceInputs<Reference>, Bindings, GetServiceReferenceOutput<Reference>>;
+export type ServiceRuntimeOverride = {
+    readonly kind: 'useValue';
+    readonly value: unknown;
+} | {
+    readonly kind: 'instantiate';
+    instance?: unknown;
+};
+export declare const SERVICE_RUNTIME_OVERRIDES: InjectionToken<ReadonlyMap<string, ServiceRuntimeOverride>>;
+/**
+ * A value supplied to a craft service factory.
+ *
+ * Service inputs are consumed as readers so a service can preserve the
+ * reactive-read edge of the value it was given:
+ *
+ * ```ts
+ * function* (inputs: { userId: CraftServiceInput<string> }) {
+ *   const userId = yield* inputs.userId();
+ *   // ...
+ * }
+ * ```
+ *
+ * The public service helper still accepts the resolved value, an Angular
+ * signal, or another Craft reader for this input.
+ */
+export type CraftServiceInput<Value, Yielded = unknown> = Yieldable<[
+], Value, Yielded>;
+export type MaybeSignal<T> = T | Signal<T> | YieldableReactiveValue<T> | CraftServiceInput<T>;
+export declare function toValue<T>(value: MaybeSignal<T>): T;
+export declare function onAppStart(run: () => AppStartResult): Generator<ServiceAppStartRequest<never>, void, unknown>;
+export declare function onAppStart<Yielded extends AllowedAppStartYield>(run: () => Generator<Yielded, AppStartResult, unknown>): Generator<ServiceAppStartRequest<Yielded>, void, unknown>;
+export declare function onAppStart(run: () => Generator<unknown, AppStartResult, unknown>): Generator<ServiceAppStartRequest<unknown>, void, unknown>;
+export declare function abstract<Contract>(): AbstractMarker<Contract>;
+export declare function craftRequirement<Contract>(): ServiceRequirement<Contract>;
+/**
+ * Adapts an external Angular dependency so it can participate in the `craftService`
+ * ecosystem.
+ *
+ * `toCraftService` is useful for services such as `Router`, `HttpClient`,
+ * `ActivatedRoute`, custom `InjectionToken`s, or any dependency resolved through
+ * `inject(...)` that you want to:
+ *
+ * - expose through the generated `Router()` helper
+ * - derive partially with the same opaque exposure tokens as `craftService`
+ * - track as a leaf dependency in `GetServiceDependencies`
+ * - reuse in `setupCraftServiceTest(...)`
+ *
+ * External instance methods are automatically bound to their source instance so
+ * exposing `navigateByUrl`, `get`, or similar methods is safe.
+ *
+ * Use the token form when the dependency should support provider-capable scopes
+ * such as `toProvide` or `manuallyProvidedAtRoot`. Use the callback form only for
+ * `global` dependencies resolved through custom `inject(...)` logic.
+ *
+ * @example
+ * Adapt `Router` as a global dependency
+ * ```ts
+ * import { Router } from './host/craft-router-types';
+ * import { toCraftService } from '@craft-ts/angular';
+ *
+ * const { Router } = toCraftService({
+ *   name: 'Router',
+ *   providedIn: 'global',
+ *   token: Router,
+ * });
+ * ```
+ *
+ * @example
+ * Adapt an injected token through the callback form
+ * ```ts
+ * import { inject, InjectionToken } from './host/craft-compat';
+ * import { toCraftService } from '@craft-ts/angular';
+ *
+ * const CURRENT_ROUTE = new InjectionToken<{ path: string }>('CurrentRoute');
+ *
+ * const { CurrentRoute } = toCraftService({
+ *   name: 'CurrentRoute',
+ *   providedIn: 'global',
+ *   inject: () => inject(CURRENT_ROUTE),
+ * });
+ * ```
+ *
+ * @example
+ * Adapt a provider-capable dependency for explicit test coverage
+ * ```ts
+ * import { Router, provideRouter } from './host/craft-router-types';
+ * import { toCraftService } from '@craft-ts/angular';
+ *
+ * const { provideAppRouter, AppRouterToProvide } = toCraftService({
+ *   name: 'AppRouter',
+ *   providedIn: 'manuallyProvidedAtRoot',
+ *   token: Router,
+ *   provide: () => provideRouter([]),
+ * });
+ * ```
+ */
+export declare function ɵtoCraftService<const Name extends string, Output>(options: {
+    name: Name;
+    providedIn: 'global';
+    token: DependencySourceToken<Output>;
+    browserBoundary: true;
+}): DependencyApi<Name, 'global', {}, Output, ServiceTrackingMetadata<Name, 'global', Output, never, undefined, never, true>>;
+export declare function ɵtoCraftService<const Name extends string, Output>(options: {
+    name: Name;
+    providedIn: 'global';
+    token: DependencySourceToken<Output>;
+    browserBoundary?: false;
+}): DependencyApi<Name, 'global', {}, Output, ServiceTrackingMetadata<Name, 'global', Output, never, undefined, never, false>>;
+export declare function ɵtoCraftService<const Name extends string, Output, Inputs extends object, FactoryResult>(options: {
+    name: Name;
+    providedIn: 'global';
+    token: DependencySourceToken<Output>;
+    browserBoundary: true;
+}, adaptFactory: ((dependency: Output, inputs: Inputs) => FactoryResult) & ValidateProvidedInputScope<'global', Inputs> & ValidateYieldedScope<'global', DependencyFactoryYieldsFromResult<FactoryResult>, unknown>): DependencyApi<Name, 'global', Inputs, DependencyFactoryOutputFromResult<FactoryResult>, ServiceTrackingMetadata<Name, 'global', DependencyFactoryOutputFromResult<FactoryResult>, DependencyFactoryYieldsFromResult<FactoryResult>, undefined, never, true>>;
+export declare function ɵtoCraftService<const Name extends string, Output, Inputs extends object, FactoryResult>(options: {
+    name: Name;
+    providedIn: 'global';
+    token: DependencySourceToken<Output>;
+    browserBoundary?: false;
+}, adaptFactory: ((dependency: Output, inputs: Inputs) => FactoryResult) & ValidateProvidedInputScope<'global', Inputs> & ValidateYieldedScope<'global', DependencyFactoryYieldsFromResult<FactoryResult>, unknown>): DependencyApi<Name, 'global', Inputs, DependencyFactoryOutputFromResult<FactoryResult>, ServiceTrackingMetadata<Name, 'global', DependencyFactoryOutputFromResult<FactoryResult>, DependencyFactoryYieldsFromResult<FactoryResult>, undefined, never, false>>;
+export declare function ɵtoCraftService<const Name extends string, Output>(options: GlobalInjectedDependencyOptions<Name, Output> & {
+    browserBoundary: true;
+}): DependencyApi<Name, 'global', {}, Output, ServiceTrackingMetadata<Name, 'global', Output, never, undefined, never, true>>;
+export declare function ɵtoCraftService<const Name extends string, Output>(options: GlobalInjectedDependencyOptions<Name, Output> & {
+    browserBoundary?: false;
+}): DependencyApi<Name, 'global', {}, Output, ServiceTrackingMetadata<Name, 'global', Output, never, undefined, never, false>>;
+export declare function ɵtoCraftService<const Name extends string, Output, Inputs extends object, FactoryResult>(options: GlobalInjectedDependencyOptions<Name, Output> & {
+    browserBoundary: true;
+}, adaptFactory: ((dependency: Output, inputs: Inputs) => FactoryResult) & ValidateProvidedInputScope<'global', Inputs> & ValidateYieldedScope<'global', DependencyFactoryYieldsFromResult<FactoryResult>, unknown>): DependencyApi<Name, 'global', Inputs, DependencyFactoryOutputFromResult<FactoryResult>, ServiceTrackingMetadata<Name, 'global', DependencyFactoryOutputFromResult<FactoryResult>, DependencyFactoryYieldsFromResult<FactoryResult>, undefined, never, true>>;
+export declare function ɵtoCraftService<const Name extends string, Output, Inputs extends object, FactoryResult>(options: GlobalInjectedDependencyOptions<Name, Output> & {
+    browserBoundary?: false;
+}, adaptFactory: ((dependency: Output, inputs: Inputs) => FactoryResult) & ValidateProvidedInputScope<'global', Inputs> & ValidateYieldedScope<'global', DependencyFactoryYieldsFromResult<FactoryResult>, unknown>): DependencyApi<Name, 'global', Inputs, DependencyFactoryOutputFromResult<FactoryResult>, ServiceTrackingMetadata<Name, 'global', DependencyFactoryOutputFromResult<FactoryResult>, DependencyFactoryYieldsFromResult<FactoryResult>, undefined, never, false>>;
+export declare function ɵtoCraftService<const Name extends string, Scope extends RealCapableScope, Token extends DependencySourceToken<any>, Provide extends AnyDependencyProvideFactory>(options: ProviderCapableDependencyOptions<Name, Scope, Token, {}, Provide> & {
+    browserBoundary: true;
+}): DependencyApi<Name, Scope, {}, DependencySourceOutput<Token>, ServiceTrackingMetadata<Name, Scope, DependencySourceOutput<Token>, never, undefined, DependencyProvideFactoryInput<Provide>, true>, DependencyProvideFactoryInput<Provide>, DependencyProvideFactoryArgs<Provide>>;
+export declare function ɵtoCraftService<const Name extends string, Scope extends RealCapableScope, Token extends DependencySourceToken<any>, Provide extends AnyDependencyProvideFactory>(options: ProviderCapableDependencyOptions<Name, Scope, Token, {}, Provide> & {
+    browserBoundary?: false;
+}): DependencyApi<Name, Scope, {}, DependencySourceOutput<Token>, ServiceTrackingMetadata<Name, Scope, DependencySourceOutput<Token>, never, undefined, DependencyProvideFactoryInput<Provide>, false>, DependencyProvideFactoryInput<Provide>, DependencyProvideFactoryArgs<Provide>>;
+export declare function ɵtoCraftService<const Name extends string, Scope extends RealCapableScope, Token extends DependencySourceToken<any>, Inputs extends object, Provide extends AnyDependencyProvideFactory, FactoryResult>(options: ProviderCapableDependencyOptions<Name, Scope, Token, Inputs, Provide> & {
+    browserBoundary: true;
+}, adaptFactory: ((dependency: YieldableReactiveProperties<DependencySourceOutput<Token>> & DependencySourceOutput<Token>, inputs: WithDependencyProvidedInput<Inputs, Provide>) => FactoryResult) & ValidateYieldedScope<Scope, DependencyFactoryYieldsFromResult<FactoryResult>, unknown>): DependencyApi<Name, Scope, WithDependencyProvidedInput<Inputs, Provide>, DependencyFactoryOutputFromResult<FactoryResult>, ServiceTrackingMetadata<Name, Scope, DependencyFactoryOutputFromResult<FactoryResult>, DependencyFactoryYieldsFromResult<FactoryResult>, undefined, DependencyProvideFactoryInput<Provide>, true>, DependencyProvideFactoryInput<Provide>, DependencyProvideFactoryArgs<Provide>>;
+export declare function ɵtoCraftService<const Name extends string, Scope extends RealCapableScope, Token extends DependencySourceToken<any>, Inputs extends object, Provide extends AnyDependencyProvideFactory, FactoryResult>(options: ProviderCapableDependencyOptions<Name, Scope, Token, Inputs, Provide> & {
+    browserBoundary?: false;
+}, adaptFactory: ((dependency: YieldableReactiveProperties<DependencySourceOutput<Token>> & DependencySourceOutput<Token>, inputs: WithDependencyProvidedInput<Inputs, Provide>) => FactoryResult) & ValidateYieldedScope<Scope, DependencyFactoryYieldsFromResult<FactoryResult>, unknown>): DependencyApi<Name, Scope, WithDependencyProvidedInput<Inputs, Provide>, DependencyFactoryOutputFromResult<FactoryResult>, ServiceTrackingMetadata<Name, Scope, DependencyFactoryOutputFromResult<FactoryResult>, DependencyFactoryYieldsFromResult<FactoryResult>, undefined, DependencyProvideFactoryInput<Provide>, false>, DependencyProvideFactoryInput<Provide>, DependencyProvideFactoryArgs<Provide>>;
+/**
+ * Creates a named Angular-friendly service boundary with generated service,
+ * provider, and metadata helpers.
+ *
+ * `craftService` is designed for composing reactive features through explicit
+ * dependencies instead of hidden `inject(...)` calls inside arbitrary code. Each
+ * crafted service receives a stable name and scope, which are then reflected in
+ * helpers such as:
+ *
+ * - `Counter(...)`
+ * - `provideCounter()` for provider-capable scopes
+ * - `CounterToProvide` for `manuallyProvidedAtRoot`
+ * - `COUNTER_META_DATA`
+ *
+ * When a service yields other crafted services, its dependency tree becomes
+ * available to the type system and to `setupCraftServiceTest(...)`.
+ *
+ * Partial exposure works through opaque dependency tokens. Returned tokens become
+ * public API, while values used internally but not exposed must be declared with
+ * `yield* token()`. Callable services can opt back into exposing their root
+ * callable through the reserved `$self` token.
+ *
+ * The supported scopes are:
+ *
+ * - `global`: singleton provided at root
+ * - `toProvide`: explicit provider helper required
+ * - `manuallyProvidedAtRoot`: explicit provider helper plus public token
+ * - `function`: new instance on each injection
+ * - `abstract`: typed contract only, with no concrete implementation
+ *
+ * Practical recommendations for choosing a providedIn:
+ *
+ * - Prefer `function` for a service owned by a single component. It avoids
+ *   explicit providers and makes it clear the instance is not meant to be
+ *   shared with other components or child components.
+ * - Move to `toProvide` when the same instance must be shared with child
+ *   components, or across several components through a common parent or route.
+ *   In that case, provide it at the component boundary, a parent component, or
+ *   the route. Angular does not report a compilation error when the provider is
+ *   missing, so the failure usually appears at runtime instead.
+ * - Use `global` when the instance is intentionally shared application-wide.
+ * - For startup-only logic that should run when the app boots but is not
+ *   injected elsewhere, prefer `function` together with
+ *   `provideAppInitializer(...)`. If the same instance also needs to be
+ *   injected by other services, use `global` instead.
+ *
+ * @example
+ * Create a global callable counter service
+ * ```ts
+ * import { craftService, state } from '@craft-ts/core';
+ *
+ * const { Counter } = craftService(
+ *   { name: 'Counter', providedIn: 'global' },
+ *   () =>
+ *     state(0, ({ update }) => ({
+ *       increment: () => update((value) => value + 1),
+ *     })),
+ * );
+ * ```
+ *
+ * @example
+ * Compose another service through `yield*`
+ * ```ts
+ * const { Counter } = craftService(
+ *   { name: 'Counter', providedIn: 'global' },
+ *   () =>
+ *     state(0, ({ update }) => ({
+ *       increment: () => update((value) => value + 1),
+ *     })),
+ * );
+ *
+ * const { CounterFacade } = craftService(
+ *   { name: 'CounterFacade', providedIn: 'global' },
+ *   function* () {
+ *     const counter = yield* Counter();
+ *
+ *     return {
+ *       read: () => counter(),
+ *       increment: () => counter.increment(),
+ *     };
+ *   },
+ * );
+ * ```
+ *
+ * @example
+ * Expose only part of a dependency through opaque tokens
+ * ```ts
+ * const { Counter } = craftService(
+ *   { name: 'Counter', providedIn: 'toProvide' },
+ *   () =>
+ *     state(0, ({ update }) => ({
+ *       increment: () => update((value) => value + 1),
+ *       decrement: () => update((value) => value - 1),
+ *     })),
+ * );
+ *
+ * const { CounterExtended } = craftService(
+ *   { name: 'CounterExtended', providedIn: 'toProvide' },
+ *   function* () {
+ *     return yield* Counter(undefined, ({ $self, increment }) => ({
+ *       $self,
+ *       incrementCounter: increment,
+ *     }));
+ *   },
+ * );
+ * ```
+ *
+ * @example
+ * Build a global utility around a browser boundary dependency
+ * ```ts
+ * import { LocalStorageService, craftService } from '@craft-ts/core';
+ *
+ * const { GlobalPersisterHandlerService } = craftService(
+ *   { name: 'GlobalPersisterHandlerService', providedIn: 'global' },
+ *   function* () {
+ *     const storage = yield* LocalStorageService(
+ *       undefined,
+ *       ({ key, length, removeItem }) => ({
+ *         key,
+ *         length,
+ *         removeItem,
+ *       }),
+ *     );
+ *
+ *     return {
+ *       clearAllCache: () => {
+ *         const keysToRemove: string[] = [];
+ *
+ *         for (let index = 0; index < storage.length(); index++) {
+ *           const keyName = storage.key(index);
+ *           if (keyName?.startsWith('craft-ts-')) {
+ *             keysToRemove.push(keyName);
+ *           }
+ *         }
+ *
+ *         keysToRemove.forEach((keyName) => storage.removeItem(keyName));
+ *       },
+ *     };
+ *   },
+ * );
+ * ```
+ */
+export declare function craftService<Name extends string, Contract>(options: {
+    name: Name;
+    providedIn: 'abstract';
+}, marker: AbstractMarker<Contract>): AbstractServiceApi<Name, Contract>;
+export declare function craftService<Name extends string, Scope extends AppStartCapableScope, Requirement extends ServiceRequirement<any, any>, Factory extends AnyFactory, BrowserBoundary extends boolean = false>(options: {
+    name: Name;
+    providedIn: Scope;
+    requirement: Requirement;
+    browserBoundary?: BrowserBoundary;
+    appStart: true;
+    providers?: readonly Provider[];
+}, factory: Factory & ValidateProvidedInputScope<Scope, FactoryInputs<Factory>> & ValidateFactoryScope<Scope, Factory> & ValidateRequirementFactory<Factory, Requirement> & ValidateAppStartInputs<FactoryInputs<Factory>, true>): ConcreteServiceApi<Name, Scope, FactoryInputs<Factory>, FactoryOutput<Factory>, ServiceHelperMetadata<Name, Scope, Factory, BrowserBoundary, true>, true>;
+export declare function craftService<Name extends string, Scope extends RealCapableScope, Requirement extends ServiceRequirement<any, any>, Factory extends AnyFactory, BrowserBoundary extends boolean = false>(options: {
+    name: Name;
+    providedIn: Scope;
+    requirement: Requirement;
+    browserBoundary?: BrowserBoundary;
+    appStart?: false;
+    providers?: readonly Provider[];
+}, factory: Factory & ValidateProvidedInputScope<Scope, FactoryInputs<Factory>> & ValidateFactoryScope<Scope, Factory> & ValidateRequirementFactory<Factory, Requirement>): ConcreteServiceApi<Name, Scope, FactoryInputs<Factory>, FactoryOutput<Factory>, ServiceHelperMetadata<Name, Scope, Factory, BrowserBoundary>, false>;
+export declare function craftService<Name extends string, Scope extends AppStartCapableScope, Factory extends AnyFactory, BrowserBoundary extends boolean = false>(options: {
+    name: Name;
+    providedIn: Scope;
+    browserBoundary?: BrowserBoundary;
+    appStart: true;
+    providers?: readonly Provider[];
+}, factory: Factory & ValidateProvidedInputScope<Scope, FactoryInputs<Factory>> & ValidateFactoryScope<Scope, Factory> & ValidateAppStartInputs<FactoryInputs<Factory>, true>): ConcreteServiceApi<Name, Scope, FactoryInputs<Factory>, FactoryOutput<Factory>, ServiceHelperMetadata<Name, Scope, Factory, BrowserBoundary, true>, true>;
+export declare function craftService<Name extends string, Scope extends ConcreteServiceScope, Factory extends AnyFactory, BrowserBoundary extends boolean = false>(options: {
+    name: Name;
+    providedIn: Scope;
+    browserBoundary?: BrowserBoundary;
+    appStart?: false;
+    providers?: readonly Provider[];
+}, factory: Factory & ValidateProvidedInputScope<Scope, FactoryInputs<Factory>> & ValidateFactoryScope<Scope, Factory>): ConcreteServiceApi<Name, Scope, FactoryInputs<Factory>, FactoryOutput<Factory>, ServiceHelperMetadata<Name, Scope, Factory, BrowserBoundary>, false>;
+export declare function getServiceMetaData(target: unknown): AnyServiceMetaData;
+export declare function runServiceAppStart(reference: ServiceReference, serviceValue: unknown): AppStartResult;
+export declare function getRegisteredAppStartServices(): readonly ServiceReference[];
+export declare function getRegisteredServices(): readonly ServiceReference[];
+export declare function createExposedServiceValue(exposedValue: unknown): unknown;
+export interface CraftTrackTags {
+}
+export type TrackTag = CraftTrackTags extends {
+    Tags: readonly (infer Tag)[];
+} ? Tag & string : never;
+export declare const ɵHOST_TAG_LIST: InjectionToken<readonly string[]>;
+export declare const ɵTRACK_TAGS_LIST: InjectionToken<readonly never[]>;
+export declare const ɵinjectHostName: WithTrackedDependencies<WithServiceRuntimeMeta<{
+    (): string;
+    <Config extends Partial<{}>>(bindings: StrictBindings<Partial<{}>, Config>): string;
+    <Exposed extends object, Yielded extends Readonly<{
+        key: string;
+        resolve: () => never;
+        [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+    }> = never>(bindings: undefined, expose: ExposureSelector<never, Exposed, Yielded>): never;
+    <Config extends Partial<{}>, Exposed extends object, Yielded extends Readonly<{
+        key: string;
+        resolve: () => never;
+        [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+    }> = never>(bindings: StrictBindings<Partial<{}>, Config>, expose: ExposureSelector<never, Exposed, Yielded>): never;
+}, {
+    readonly kind: "service-meta-data";
+    readonly name: "HostName";
+    readonly providedIn: "manuallyProvidedAtRoot";
+    readonly browserBoundary: false;
+    readonly appStart: false;
+    readonly inject: (...args: any[]) => unknown;
+    readonly [SERVICE_META_DATA_TYPE]?: {
+        inputs: {};
+        output: string;
+        dependencies: {
+            providedIn: "manuallyProvidedAtRoot";
+            dependencies: {};
+            browserBoundary: false;
+            appStart: false;
+        };
+        tracking: ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+            $provided: string;
+        }) => string, false, false>;
+        providedInput: string;
+    } | undefined;
+    readonly [SERVICE_RUNTIME_META]?: /*elided*/ any | undefined;
+    readonly provide: (args_0: string) => CraftServiceProvider;
+    readonly token: InjectionToken<string>;
+}>, ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+    $provided: string;
+}) => string, false, false>>;
+export declare const ɵHostName: WithTrackedDependencies<WithServiceRuntimeMeta<{
+    (): Generator<Readonly<{
+        name: string;
+        providedIn: "manuallyProvidedAtRoot";
+        resolve: (injector: Injector, hostScope: ConcreteServiceScope) => string;
+        [SERVICE_YIELD_REQUEST_MARKER]: true;
+        readonly [SERVICE_YIELD_METADATA]?: ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+            $provided: string;
+        }) => string, false, false> | undefined;
+    }>, string, unknown>;
+    <Config extends Partial<{}>>(bindings: StrictBindings<Partial<{}>, Config>): Generator<Readonly<{
+        name: string;
+        providedIn: "manuallyProvidedAtRoot";
+        resolve: (injector: Injector, hostScope: ConcreteServiceScope) => string;
+        [SERVICE_YIELD_REQUEST_MARKER]: true;
+        readonly [SERVICE_YIELD_METADATA]?: ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+            $provided: string;
+        }) => string, false, false> | undefined;
+    }>, string, unknown>;
+    <Exposed extends object, Yielded extends Readonly<{
+        key: string;
+        resolve: () => never;
+        [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+    }> = never>(bindings: undefined, expose: ExposureSelector<never, Exposed, Yielded>): Generator<Readonly<{
+        key: string;
+        resolve: () => never;
+        [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+    }> | Readonly<{
+        name: string;
+        providedIn: "manuallyProvidedAtRoot";
+        resolve: (injector: Injector, hostScope: ConcreteServiceScope) => never;
+        [SERVICE_YIELD_REQUEST_MARKER]: true;
+        readonly [SERVICE_YIELD_METADATA]?: ServiceTrackingMetadata<"HostName", "manuallyProvidedAtRoot", string, never, DerivedPropertiesForExposure<Exposed, Yielded>, string, false, false> | undefined;
+    }>, never, unknown>;
+    <Config extends Partial<{}>, Exposed extends object, Yielded extends Readonly<{
+        key: string;
+        resolve: () => never;
+        [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+    }> = never>(bindings: StrictBindings<Partial<{}>, Config>, expose: ExposureSelector<never, Exposed, Yielded>): Generator<Readonly<{
+        key: string;
+        resolve: () => never;
+        [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+    }> | Readonly<{
+        name: string;
+        providedIn: "manuallyProvidedAtRoot";
+        resolve: (injector: Injector, hostScope: ConcreteServiceScope) => never;
+        [SERVICE_YIELD_REQUEST_MARKER]: true;
+        readonly [SERVICE_YIELD_METADATA]?: ServiceTrackingMetadata<"HostName", "manuallyProvidedAtRoot", string, never, DerivedPropertiesForExposure<Exposed, Yielded>, string, false, false> | undefined;
+    }>, never, unknown>;
+}, {
+    readonly kind: "service-meta-data";
+    readonly name: "HostName";
+    readonly providedIn: "manuallyProvidedAtRoot";
+    readonly browserBoundary: false;
+    readonly appStart: false;
+    readonly inject: (...args: any[]) => unknown;
+    readonly [SERVICE_META_DATA_TYPE]?: {
+        inputs: {};
+        output: string;
+        dependencies: {
+            providedIn: "manuallyProvidedAtRoot";
+            dependencies: {};
+            browserBoundary: false;
+            appStart: false;
+        };
+        tracking: ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+            $provided: string;
+        }) => string, false, false>;
+        providedInput: string;
+    } | undefined;
+    readonly [SERVICE_RUNTIME_META]?: /*elided*/ any | undefined;
+    readonly provide: (args_0: string) => CraftServiceProvider;
+    readonly token: InjectionToken<string>;
+}>, ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+    $provided: string;
+}) => string, false, false>>;
+export declare const ɵHostNameToProvide: InjectionToken<string>;
+export declare const ɵHOST_NAME_META_DATA: {
+    readonly kind: "service-meta-data";
+    readonly name: "HostName";
+    readonly providedIn: "manuallyProvidedAtRoot";
+    readonly browserBoundary: false;
+    readonly appStart: false;
+    readonly inject: WithTrackedDependencies<WithServiceRuntimeMeta<{
+        (): string;
+        <Config extends Partial<{}>>(bindings: StrictBindings<Partial<{}>, Config>): string;
+        <Exposed extends object, Yielded extends Readonly<{
+            key: string;
+            resolve: () => never;
+            [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+        }> = never>(bindings: undefined, expose: ExposureSelector<never, Exposed, Yielded>): never;
+        <Config extends Partial<{}>, Exposed extends object, Yielded extends Readonly<{
+            key: string;
+            resolve: () => never;
+            [SERVICE_DEPENDENCY_ACCESS_MARKER]: true;
+        }> = never>(bindings: StrictBindings<Partial<{}>, Config>, expose: ExposureSelector<never, Exposed, Yielded>): never;
+    }, {
+        readonly kind: "service-meta-data";
+        readonly name: "HostName";
+        readonly providedIn: "manuallyProvidedAtRoot";
+        readonly browserBoundary: false;
+        readonly appStart: false;
+        readonly inject: (...args: any[]) => unknown;
+        readonly [SERVICE_META_DATA_TYPE]?: {
+            inputs: {};
+            output: string;
+            dependencies: {
+                providedIn: "manuallyProvidedAtRoot";
+                dependencies: {};
+                browserBoundary: false;
+                appStart: false;
+            };
+            tracking: ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+                $provided: string;
+            }) => string, false, false>;
+            providedInput: string;
+        } | undefined;
+        readonly [SERVICE_RUNTIME_META]?: /*elided*/ any | undefined;
+        readonly provide: (args_0: string) => CraftServiceProvider;
+        readonly token: InjectionToken<string>;
+    }>, ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+        $provided: string;
+    }) => string, false, false>>;
+    readonly [SERVICE_META_DATA_TYPE]?: {
+        inputs: {};
+        output: string;
+        dependencies: {
+            providedIn: "manuallyProvidedAtRoot";
+            dependencies: {};
+            browserBoundary: false;
+            appStart: false;
+        };
+        tracking: ServiceHelperMetadata<"HostName", "manuallyProvidedAtRoot", (inputs: {
+            $provided: string;
+        }) => string, false, false>;
+        providedInput: string;
+    } | undefined;
+    readonly [SERVICE_RUNTIME_META]?: /*elided*/ any | undefined;
+    readonly provide: (args_0: string) => CraftServiceProvider;
+    readonly token: InjectionToken<string>;
+};
+export declare function ɵprovideHostName(name: string): Provider[];
+export declare function ɵprovideTrackTags(tags: readonly TrackTag[]): Provider[];
+export declare function ɵinjectTrackTags(): readonly TrackTag[];
+export type ɵHostTagYield = Readonly<{
+    [SERVICE_YIELD_REQUEST_MARKER]: true;
+    providedIn: 'function';
+    resolve: (injector: Injector, hostScope: ConcreteServiceScope) => readonly string[];
+}>;
+export declare function ɵHostTag(): Generator<ɵHostTagYield, readonly string[], unknown>;
+export type ɵTrackTagsYield = Readonly<{
+    [SERVICE_YIELD_REQUEST_MARKER]: true;
+    providedIn: 'function';
+    resolve: (injector: Injector, hostScope: ConcreteServiceScope) => readonly TrackTag[];
+}>;
+export declare function ɵTrackTags(): Generator<ɵTrackTagsYield, readonly TrackTag[], unknown>;
+export declare function ɵcreateHostTaggedInjector(injector: Injector, hostName: string, extraProviders?: readonly Provider[], options?: {
+    readonly instanced?: boolean;
+}): Injector;
+//# sourceMappingURL=craft-service.d.ts.map