// Generated by tsbindgen - Architecture
// Namespace: Microsoft.Extensions.Hosting
// Assembly: Microsoft.Extensions.Hosting, Microsoft.Extensions.Hosting.Abstractions

// Core type aliases from @tsonic/core
import type { fnptr, ptr, sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';


// Import types from other namespaces
import type { ConfigurationManager, IConfiguration, IConfigurationBuilder, IConfigurationManager } from "../../Microsoft.Extensions.Configuration/internal/index.js";
import type { IServiceCollection, IServiceProviderFactory_1, ServiceProviderOptions } from "../../Microsoft.Extensions.DependencyInjection/internal/index.js";
import type { IMetricsBuilder } from "../../Microsoft.Extensions.Diagnostics.Metrics/internal/index.js";
import type { IFileProvider } from "../../Microsoft.Extensions.FileProviders/internal/index.js";
import type { ILoggingBuilder } from "../../Microsoft.Extensions.Logging/internal/index.js";
import type { IDictionary_2 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
import type { ISerializable } from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
import type { Task, Task_1 } from "@tsonic/dotnet/System.Threading.Tasks/internal/index.js";
import type { CancellationToken } from "@tsonic/dotnet/System.Threading/internal/index.js";
import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
import type { Action_1, Action_2, Boolean as ClrBoolean, Enum, Exception, Func_2, IComparable, IConvertible, IDisposable, IFormattable, Int32, IServiceProvider, ISpanFormattable, Object as ClrObject, String as ClrString, TimeSpan, Void } from "@tsonic/dotnet/System/internal/index.js";

export enum BackgroundServiceExceptionBehavior {
    StopHost = 0,
    Ignore = 1
}


export interface IApplicationLifetime$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IApplicationLifetime: never;

    readonly ApplicationStarted: CancellationToken;
    readonly ApplicationStopping: CancellationToken;
    readonly ApplicationStopped: CancellationToken;
    StopApplication(): void;
}


export type IApplicationLifetime = IApplicationLifetime$instance;

export interface IHost$instance extends IDisposable {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHost: never;

    readonly Services: IServiceProvider;
    StartAsync(cancellationToken?: CancellationToken): Task;
}


export interface IHost$instance extends System_Internal.IDisposable {}

export type IHost = IHost$instance;

export interface IHostApplicationBuilder$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostApplicationBuilder: never;

    readonly Properties: IDictionary_2<unknown, unknown>;
    readonly Configuration: IConfigurationManager;
    readonly Environment: IHostEnvironment;
    readonly Logging: ILoggingBuilder;
    readonly Metrics: IMetricsBuilder;
    readonly Services: IServiceCollection;
    ConfigureContainer<TContainerBuilder extends unknown>(factory: IServiceProviderFactory_1<TContainerBuilder>, configure?: Action_1<TContainerBuilder> | null): void;
}


export type IHostApplicationBuilder = IHostApplicationBuilder$instance;

export interface IHostApplicationLifetime$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostApplicationLifetime: never;

    readonly ApplicationStarted: CancellationToken;
    readonly ApplicationStopping: CancellationToken;
    readonly ApplicationStopped: CancellationToken;
    StopApplication(): void;
}


export type IHostApplicationLifetime = IHostApplicationLifetime$instance;

export interface IHostBuilder$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostBuilder: never;

    readonly Properties: IDictionary_2<unknown, unknown>;
    Build(): IHost;
    ConfigureAppConfiguration(configureDelegate: Action_2<HostBuilderContext, IConfigurationBuilder>): IHostBuilder;
    ConfigureHostConfiguration(configureDelegate: Action_1<IConfigurationBuilder>): IHostBuilder;
    UseServiceProviderFactory<TContainerBuilder extends unknown>(factory: Func_2<HostBuilderContext, IServiceProviderFactory_1<TContainerBuilder>>): IHostBuilder;
    UseServiceProviderFactory<TContainerBuilder extends unknown>(factory: IServiceProviderFactory_1<TContainerBuilder>): IHostBuilder;
}


export type IHostBuilder = IHostBuilder$instance;

export interface IHostedLifecycleService$instance extends IHostedService {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostedLifecycleService: never;

    StartingAsync(cancellationToken: CancellationToken): Task;
    StartAsync(cancellationToken: CancellationToken): Task;
}


export interface IHostedLifecycleService$instance extends IHostedService$instance {}

export type IHostedLifecycleService = IHostedLifecycleService$instance;

export interface IHostedService$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostedService: never;

    StartAsync(cancellationToken: CancellationToken): Task;
}


export type IHostedService = IHostedService$instance;

export interface IHostEnvironment$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostEnvironment: never;

    EnvironmentName: string;
    ApplicationName: string;
    ContentRootPath: string;
    ContentRootFileProvider: IFileProvider;
}


export type IHostEnvironment = IHostEnvironment$instance;

export interface IHostingEnvironment$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostingEnvironment: never;

    EnvironmentName: string;
    ApplicationName: string;
    ContentRootPath: string;
    ContentRootFileProvider: IFileProvider;
}


export type IHostingEnvironment = IHostingEnvironment$instance;

export interface IHostLifetime$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostLifetime: never;

    WaitForStartAsync(cancellationToken: CancellationToken): Task;
}


export type IHostLifetime = IHostLifetime$instance;

export interface BackgroundService$instance extends IHostedService$instance, System_Internal.IDisposable {
    readonly __tsonic_type_Microsoft_Extensions_Hosting_BackgroundService: never;

    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostedService: never;
    readonly __tsonic_iface_System_IDisposable: never;

    readonly ExecuteTask: Task | null;
    Dispose(): void;
    ExecuteAsync(stoppingToken: CancellationToken): Task;
    StartAsync(cancellationToken: CancellationToken): Task;
    StopAsync(cancellationToken: CancellationToken): Task;
}


export const BackgroundService: (abstract new() => BackgroundService) & {
};


export interface __BackgroundService$views {
    As_IHostedService(): IHostedService$instance;
}

export type BackgroundService = BackgroundService$instance & __BackgroundService$views;


export interface ConsoleLifetimeOptions$instance {
    readonly __tsonic_type_Microsoft_Extensions_Hosting_ConsoleLifetimeOptions: never;

    SuppressStatusMessages: boolean;
}


export const ConsoleLifetimeOptions: {
    new(): ConsoleLifetimeOptions;
};


export type ConsoleLifetimeOptions = ConsoleLifetimeOptions$instance;

export interface HostAbortedException$instance extends Exception {
    readonly __tsonic_type_Microsoft_Extensions_Hosting_HostAbortedException: never;

    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;

}


export const HostAbortedException: {
    new(): HostAbortedException;
    new(message: string | null): HostAbortedException;
    new(message: string | null, innerException: Exception | null): HostAbortedException;
};


export type HostAbortedException = HostAbortedException$instance;

export interface HostApplicationBuilder$instance {
    readonly __tsonic_type_Microsoft_Extensions_Hosting_HostApplicationBuilder: never;

    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostApplicationBuilder: never;

    readonly Configuration: ConfigurationManager;
    readonly Environment: IHostEnvironment;
    readonly Logging: ILoggingBuilder;
    readonly Metrics: IMetricsBuilder;
    readonly Services: IServiceCollection;
    Build(): IHost;
    ConfigureContainer<TContainerBuilder extends unknown>(factory: IServiceProviderFactory_1<TContainerBuilder>, configure?: Action_1<TContainerBuilder> | null): void;
}


export const HostApplicationBuilder: {
    new(): HostApplicationBuilder;
    new(args: string[] | null): HostApplicationBuilder;
    new(settings: HostApplicationBuilderSettings | null): HostApplicationBuilder;
};


export interface __HostApplicationBuilder$views {
    As_IHostApplicationBuilder(): IHostApplicationBuilder$instance;
}

export type HostApplicationBuilder = HostApplicationBuilder$instance & __HostApplicationBuilder$views;


export interface HostApplicationBuilderSettings$instance {
    readonly __tsonic_type_Microsoft_Extensions_Hosting_HostApplicationBuilderSettings: never;

    get ApplicationName(): string | null;
    set ApplicationName(value: string | null);
    get Args(): string[] | null;
    set Args(value: string[] | null);
    get Configuration(): ConfigurationManager | null;
    set Configuration(value: ConfigurationManager | null);
    get ContentRootPath(): string | null;
    set ContentRootPath(value: string | null);
    DisableDefaults: boolean;
    get EnvironmentName(): string | null;
    set EnvironmentName(value: string | null);
}


export const HostApplicationBuilderSettings: {
    new(): HostApplicationBuilderSettings;
};


export type HostApplicationBuilderSettings = HostApplicationBuilderSettings$instance;

export interface HostBuilder$instance {
    readonly __tsonic_type_Microsoft_Extensions_Hosting_HostBuilder: never;

    readonly __tsonic_iface_Microsoft_Extensions_Hosting_IHostBuilder: never;

    readonly Properties: IDictionary_2<unknown, unknown>;
    Build(): IHost;
    ConfigureAppConfiguration(configureDelegate: Action_2<HostBuilderContext, IConfigurationBuilder>): IHostBuilder;
    ConfigureContainer<TContainerBuilder extends unknown>(configureDelegate: Action_2<HostBuilderContext, TContainerBuilder>): IHostBuilder;
    ConfigureHostConfiguration(configureDelegate: Action_1<IConfigurationBuilder>): IHostBuilder;
    ConfigureServices(configureDelegate: Action_2<HostBuilderContext, IServiceCollection>): IHostBuilder;
    UseServiceProviderFactory<TContainerBuilder extends unknown>(factory: IServiceProviderFactory_1<TContainerBuilder>): IHostBuilder;
    UseServiceProviderFactory<TContainerBuilder extends unknown>(factory: Func_2<HostBuilderContext, IServiceProviderFactory_1<TContainerBuilder>>): IHostBuilder;
}


export const HostBuilder: {
    new(): HostBuilder;
};


export interface __HostBuilder$views {
    As_IHostBuilder(): IHostBuilder$instance;
}

export type HostBuilder = HostBuilder$instance & __HostBuilder$views;


export interface HostBuilderContext$instance {
    readonly __tsonic_type_Microsoft_Extensions_Hosting_HostBuilderContext: never;

    Configuration: IConfiguration;
    HostingEnvironment: IHostEnvironment;
    readonly Properties: IDictionary_2<unknown, unknown>;
}


export const HostBuilderContext: {
    new(properties: IDictionary_2<unknown, unknown>): HostBuilderContext;
};


export type HostBuilderContext = HostBuilderContext$instance;

export interface HostOptions$instance {
    readonly __tsonic_type_Microsoft_Extensions_Hosting_HostOptions: never;

    BackgroundServiceExceptionBehavior: BackgroundServiceExceptionBehavior;
    ServicesStartConcurrently: boolean;
    ServicesStopConcurrently: boolean;
    ShutdownTimeout: TimeSpan;
    StartupTimeout: TimeSpan;
}


export const HostOptions: {
    new(): HostOptions;
};


export type HostOptions = HostOptions$instance;

export abstract class EnvironmentName$instance {
    static readonly Development: string;
    static readonly Staging: string;
    static readonly Production: string;
}


export type EnvironmentName = EnvironmentName$instance;

export abstract class Environments$instance {
    static readonly Development: string;
    static readonly Staging: string;
    static readonly Production: string;
}


export type Environments = Environments$instance;

export abstract class Host$instance {
    static CreateApplicationBuilder(): HostApplicationBuilder;
    static CreateApplicationBuilder(settings: HostApplicationBuilderSettings | null): HostApplicationBuilder;
    static CreateApplicationBuilder(args: string[] | null): HostApplicationBuilder;
    static CreateDefaultBuilder(): IHostBuilder;
    static CreateDefaultBuilder(args: string[] | null): IHostBuilder;
    static CreateEmptyApplicationBuilder(settings: HostApplicationBuilderSettings | null): HostApplicationBuilder;
}


export type Host = Host$instance;

export abstract class HostDefaults$instance {
    static readonly ApplicationKey: string;
    static readonly EnvironmentKey: string;
    static readonly ContentRootKey: string;
}


export type HostDefaults = HostDefaults$instance;

export abstract class HostEnvironmentEnvExtensions$instance {
    static IsDevelopment(hostEnvironment: IHostEnvironment): boolean;
    static IsEnvironment(hostEnvironment: IHostEnvironment, environmentName: string): boolean;
    static IsProduction(hostEnvironment: IHostEnvironment): boolean;
    static IsStaging(hostEnvironment: IHostEnvironment): boolean;
}


export type HostEnvironmentEnvExtensions = HostEnvironmentEnvExtensions$instance;

export abstract class HostingAbstractionsHostBuilderExtensions$instance {
    static Start(hostBuilder: IHostBuilder): IHost;
    static StartAsync(hostBuilder: IHostBuilder, cancellationToken?: CancellationToken): Task_1<IHost>;
}


export type HostingAbstractionsHostBuilderExtensions = HostingAbstractionsHostBuilderExtensions$instance;

export abstract class HostingAbstractionsHostExtensions$instance {
    static Run(host: IHost): void;
    static RunAsync(host: IHost, token?: CancellationToken): Task;
    static Start(host: IHost): void;
    static StopAsync(host: IHost, timeout: TimeSpan): Task;
    static WaitForShutdown(host: IHost): void;
    static WaitForShutdownAsync(host: IHost, token?: CancellationToken): Task;
}


export type HostingAbstractionsHostExtensions = HostingAbstractionsHostExtensions$instance;

export abstract class HostingEnvironmentExtensions$instance {
    static IsDevelopment(hostingEnvironment: IHostingEnvironment): boolean;
    static IsEnvironment(hostingEnvironment: IHostingEnvironment, environmentName: string): boolean;
    static IsProduction(hostingEnvironment: IHostingEnvironment): boolean;
    static IsStaging(hostingEnvironment: IHostingEnvironment): boolean;
}


export type HostingEnvironmentExtensions = HostingEnvironmentExtensions$instance;

export abstract class HostingHostBuilderExtensions$instance {
    static ConfigureAppConfiguration(hostBuilder: IHostBuilder, configureDelegate: Action_1<IConfigurationBuilder>): IHostBuilder;
    static ConfigureContainer<TContainerBuilder extends unknown>(hostBuilder: IHostBuilder, configureDelegate: Action_1<TContainerBuilder>): IHostBuilder;
    static ConfigureDefaults(builder: IHostBuilder, args: string[] | null): IHostBuilder;
    static ConfigureHostOptions(hostBuilder: IHostBuilder, configureOptions: Action_1<HostOptions>): IHostBuilder;
    static ConfigureHostOptions(hostBuilder: IHostBuilder, configureOptions: Action_2<HostBuilderContext, HostOptions>): IHostBuilder;
    static ConfigureLogging(hostBuilder: IHostBuilder, configureLogging: Action_1<ILoggingBuilder>): IHostBuilder;
    static ConfigureLogging(hostBuilder: IHostBuilder, configureLogging: Action_2<HostBuilderContext, ILoggingBuilder>): IHostBuilder;
    static ConfigureMetrics(hostBuilder: IHostBuilder, configureMetrics: Action_1<IMetricsBuilder>): IHostBuilder;
    static ConfigureMetrics(hostBuilder: IHostBuilder, configureMetrics: Action_2<HostBuilderContext, IMetricsBuilder>): IHostBuilder;
    static ConfigureServices(hostBuilder: IHostBuilder, configureDelegate: Action_1<IServiceCollection>): IHostBuilder;
    static RunConsoleAsync(hostBuilder: IHostBuilder, configureOptions: Action_1<ConsoleLifetimeOptions>, cancellationToken?: CancellationToken): Task;
    static RunConsoleAsync(hostBuilder: IHostBuilder, cancellationToken?: CancellationToken): Task;
    static UseConsoleLifetime(hostBuilder: IHostBuilder, configureOptions: Action_1<ConsoleLifetimeOptions>): IHostBuilder;
    static UseConsoleLifetime(hostBuilder: IHostBuilder): IHostBuilder;
    static UseContentRoot(hostBuilder: IHostBuilder, contentRoot: string): IHostBuilder;
    static UseDefaultServiceProvider(hostBuilder: IHostBuilder, configure: Action_1<ServiceProviderOptions>): IHostBuilder;
    static UseDefaultServiceProvider(hostBuilder: IHostBuilder, configure: Action_2<HostBuilderContext, ServiceProviderOptions>): IHostBuilder;
    static UseEnvironment(hostBuilder: IHostBuilder, environment: string): IHostBuilder;
}


export type HostingHostBuilderExtensions = HostingHostBuilderExtensions$instance;