// Generated by tsbindgen - Architecture
// Namespace: Microsoft.Extensions.Logging
// Assembly: Microsoft.Extensions.Logging, Microsoft.Extensions.Logging.Abstractions, Microsoft.Extensions.Logging.Configuration, Microsoft.Extensions.Logging.Console, Microsoft.Extensions.Logging.Debug, Microsoft.Extensions.Logging.EventLog, Microsoft.Extensions.Logging.EventSource, Microsoft.Extensions.Logging.TraceSource

// 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 { IConfiguration } from "../../Microsoft.Extensions.Configuration/internal/index.js";
import type { IServiceCollection } from "../../Microsoft.Extensions.DependencyInjection/internal/index.js";
import type { ConsoleFormatter, ConsoleFormatterOptions, ConsoleLoggerOptions, IConsoleLoggerSettings, JsonConsoleFormatterOptions, SimpleConsoleFormatterOptions } from "../../Microsoft.Extensions.Logging.Console/internal/index.js";
import type { EventLogSettings } from "../../Microsoft.Extensions.Logging.EventLog/internal/index.js";
import type { IOptions_1, IOptionsMonitor_1 } from "../../Microsoft.Extensions.Options/internal/index.js";
import type { IEnumerable_1, IList_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
import type { SourceSwitch, TraceListener } from "@tsonic/dotnet/System.Diagnostics/internal/index.js";
import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
import type { Action_1, Action_2, Action_3, Action_4, Action_5, Action_6, Action_7, Action_8, Attribute, Boolean as ClrBoolean, Enum, Exception, Func_2, Func_3, Func_4, Func_5, Func_6, Func_7, Func_8, IComparable, IConvertible, IDisposable, IEquatable_1, IFormattable, Int32, ISpanFormattable, Nullable_1, Object as ClrObject, String as ClrString, Type, ValueType, Void } from "@tsonic/dotnet/System/internal/index.js";

export enum ActivityTrackingOptions {
    None = 0,
    SpanId = 1,
    TraceId = 2,
    ParentId = 4,
    TraceState = 8,
    TraceFlags = 16,
    Tags = 32,
    Baggage = 64
}


export enum LogLevel {
    Trace = 0,
    Debug = 1,
    Information = 2,
    Warning = 3,
    Error = 4,
    Critical = 5,
    None = 6
}


export interface IExternalScopeProvider$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Logging_IExternalScopeProvider: never;

    ForEachScope<TState extends unknown>(callback: Action_2<unknown | null, TState>, state: TState): void;
    Push(state: unknown | null): IDisposable;
}


export type IExternalScopeProvider = IExternalScopeProvider$instance;

export interface ILogger$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Logging_ILogger: never;

    BeginScope<TState extends unknown>(state: TState): IDisposable;
    IsEnabled(logLevel: LogLevel): boolean;
    Log<TState extends unknown>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception | null, formatter: Func_3<TState, Exception | null, System_Internal.String>): void;
}


export type ILogger = ILogger$instance;

export interface ILogger_1$instance<TCategoryName extends unknown> extends ILogger {
    readonly __tsonic_iface_Microsoft_Extensions_Logging_ILogger_1: never;

    BeginScope<TState extends unknown>(state: TState): IDisposable;
    BeginScope<TState>(state: TState): IDisposable;
    IsEnabled(logLevel: LogLevel): boolean;
    Log<TState extends unknown>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception | null, formatter: Func_3<TState, Exception | null, System_Internal.String>): void;
    Log<TState>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception | null, formatter: Func_3<TState, Exception | null, System_Internal.String>): void;
}


export interface ILogger_1$instance<TCategoryName extends unknown> extends ILogger$instance {}

export type ILogger_1<TCategoryName extends unknown> = ILogger_1$instance<TCategoryName>;

export interface ILoggerFactory$instance extends IDisposable {
    readonly __tsonic_iface_Microsoft_Extensions_Logging_ILoggerFactory: never;

    AddProvider(provider: ILoggerProvider): void;
    CreateLogger(categoryName: string): ILogger;
}


export interface ILoggerFactory$instance extends System_Internal.IDisposable {}

export type ILoggerFactory = ILoggerFactory$instance;

export interface ILoggerProvider$instance extends IDisposable {
    readonly __tsonic_iface_Microsoft_Extensions_Logging_ILoggerProvider: never;

    CreateLogger(categoryName: string): ILogger;
}


export interface ILoggerProvider$instance extends System_Internal.IDisposable {}

export type ILoggerProvider = ILoggerProvider$instance;

export interface ILoggingBuilder$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Logging_ILoggingBuilder: never;

    readonly Services: IServiceCollection;
}


export type ILoggingBuilder = ILoggingBuilder$instance;

export interface ISupportExternalScope$instance {
    readonly __tsonic_iface_Microsoft_Extensions_Logging_ISupportExternalScope: never;

    SetScopeProvider(scopeProvider: IExternalScopeProvider): void;
}


export type ISupportExternalScope = ISupportExternalScope$instance;

export interface EventId$instance {
    readonly __tsonic_type_Microsoft_Extensions_Logging_EventId: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    readonly Id: int;
    readonly Name: string | null;
    Equals(other: EventId): boolean;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const EventId: {
    new(id: int, name: string | null): EventId;
};


export type EventId = EventId$instance;

export interface LogDefineOptions$instance {
    readonly __tsonic_type_Microsoft_Extensions_Logging_LogDefineOptions: never;

    SkipEnabledCheck: boolean;
}


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


export type LogDefineOptions = LogDefineOptions$instance;

export interface Logger_1$instance<T extends unknown> extends ILogger_1$instance<T> {
    readonly __tsonic_type_Microsoft_Extensions_Logging_Logger_1: never;

    readonly __tsonic_iface_Microsoft_Extensions_Logging_ILogger: never;
    readonly __tsonic_iface_Microsoft_Extensions_Logging_ILogger_1: never;

}


export const Logger_1: {
    new<T extends unknown>(factory: ILoggerFactory): Logger_1<T>;
};


export interface __Logger_1$views<T extends unknown> {
    As_ILogger(): ILogger$instance;
}

export type Logger_1<T extends unknown> = Logger_1$instance<T> & __Logger_1$views<T>;


export interface LoggerExternalScopeProvider$instance extends IExternalScopeProvider$instance {
    readonly __tsonic_type_Microsoft_Extensions_Logging_LoggerExternalScopeProvider: never;

    readonly __tsonic_iface_Microsoft_Extensions_Logging_IExternalScopeProvider: never;

    ForEachScope<TState extends unknown>(callback: Action_2<unknown | null, TState>, state: TState): void;
    Push(state: unknown | null): IDisposable;
}


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


export interface __LoggerExternalScopeProvider$views {
    As_IExternalScopeProvider(): IExternalScopeProvider$instance;
}

export type LoggerExternalScopeProvider = LoggerExternalScopeProvider$instance & __LoggerExternalScopeProvider$views;


export interface LoggerFactory$instance extends ILoggerFactory$instance {
    readonly __tsonic_type_Microsoft_Extensions_Logging_LoggerFactory: never;

    readonly __tsonic_iface_Microsoft_Extensions_Logging_ILoggerFactory: never;
    readonly __tsonic_iface_System_IDisposable: never;

    AddProvider(provider: ILoggerProvider): void;
    CheckDisposed(): boolean;
    CreateLogger(categoryName: string): ILogger;
    Dispose(): void;
}


export const LoggerFactory: {
    new(): LoggerFactory;
    new(providers: IEnumerable_1<ILoggerProvider>): LoggerFactory;
    new(providers: IEnumerable_1<ILoggerProvider>, filterOptions: LoggerFilterOptions): LoggerFactory;
    new(providers: IEnumerable_1<ILoggerProvider>, filterOption: IOptionsMonitor_1<LoggerFilterOptions>): LoggerFactory;
    new(providers: IEnumerable_1<ILoggerProvider>, filterOption: IOptionsMonitor_1<LoggerFilterOptions>, options: IOptions_1<LoggerFactoryOptions> | null): LoggerFactory;
    new(providers: IEnumerable_1<ILoggerProvider>, filterOption: IOptionsMonitor_1<LoggerFilterOptions>, options: IOptions_1<LoggerFactoryOptions> | null, scopeProvider: IExternalScopeProvider | null): LoggerFactory;
    Create(configure: Action_1<ILoggingBuilder>): ILoggerFactory;
};


export interface __LoggerFactory$views {
    As_ILoggerFactory(): ILoggerFactory$instance;
}

export type LoggerFactory = LoggerFactory$instance & __LoggerFactory$views;


export interface LoggerFactoryOptions$instance {
    readonly __tsonic_type_Microsoft_Extensions_Logging_LoggerFactoryOptions: never;

    ActivityTrackingOptions: ActivityTrackingOptions;
}


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


export type LoggerFactoryOptions = LoggerFactoryOptions$instance;

export interface LoggerFilterOptions$instance {
    readonly __tsonic_type_Microsoft_Extensions_Logging_LoggerFilterOptions: never;

    CaptureScopes: boolean;
    MinLevel: LogLevel;
    readonly Rules: IList_1<LoggerFilterRule>;
}


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


export type LoggerFilterOptions = LoggerFilterOptions$instance;

export interface LoggerFilterRule$instance {
    readonly __tsonic_type_Microsoft_Extensions_Logging_LoggerFilterRule: never;

    readonly CategoryName: string | null;
    readonly Filter: Func_4<string | null, string | null, LogLevel, System_Internal.Boolean> | null;
    readonly LogLevel: Nullable_1<LogLevel>;
    readonly ProviderName: string | null;
    ToString(): string;
}


export const LoggerFilterRule: {
    new(providerName: string | null, categoryName: string | null, logLevel: Nullable_1<LogLevel>, filter: Func_4<string | null, string | null, LogLevel, System_Internal.Boolean> | null): LoggerFilterRule;
};


export type LoggerFilterRule = LoggerFilterRule$instance;

export interface LoggerMessageAttribute$instance extends Attribute {
    readonly __tsonic_type_Microsoft_Extensions_Logging_LoggerMessageAttribute: never;

    EventId: int;
    get EventName(): string | null;
    set EventName(value: string | null);
    Level: LogLevel;
    Message: string;
    SkipEnabledCheck: boolean;
}


export const LoggerMessageAttribute: {
    new(): LoggerMessageAttribute;
    new(eventId: int, level: LogLevel, message: string): LoggerMessageAttribute;
    new(level: LogLevel, message: string): LoggerMessageAttribute;
    new(level: LogLevel): LoggerMessageAttribute;
    new(message: string): LoggerMessageAttribute;
};


export type LoggerMessageAttribute = LoggerMessageAttribute$instance;

export interface ProviderAliasAttribute$instance extends Attribute {
    readonly __tsonic_type_Microsoft_Extensions_Logging_ProviderAliasAttribute: never;

    readonly Alias: string;
}


export const ProviderAliasAttribute: {
    new(alias: string): ProviderAliasAttribute;
};


export type ProviderAliasAttribute = ProviderAliasAttribute$instance;

export abstract class ConsoleLoggerExtensions$instance {
    static AddConsole(factory: ILoggerFactory, configuration: IConfiguration): ILoggerFactory;
    static AddConsole(factory: ILoggerFactory, settings: IConsoleLoggerSettings): ILoggerFactory;
    static AddConsole(factory: ILoggerFactory, minLevel: LogLevel, includeScopes: boolean): ILoggerFactory;
    static AddConsole(factory: ILoggerFactory, minLevel: LogLevel): ILoggerFactory;
    static AddConsole(factory: ILoggerFactory, includeScopes: boolean): ILoggerFactory;
    static AddConsole(factory: ILoggerFactory, filter: Func_3<System_Internal.String, LogLevel, System_Internal.Boolean>, includeScopes: boolean): ILoggerFactory;
    static AddConsole(factory: ILoggerFactory, filter: Func_3<System_Internal.String, LogLevel, System_Internal.Boolean>): ILoggerFactory;
    static AddConsole(factory: ILoggerFactory): ILoggerFactory;
    static AddConsole(builder: ILoggingBuilder, configure: Action_1<ConsoleLoggerOptions>): ILoggingBuilder;
    static AddConsole(builder: ILoggingBuilder): ILoggingBuilder;
    static AddConsoleFormatter<TFormatter extends unknown & ConsoleFormatter, TOptions extends unknown & ConsoleFormatterOptions>(builder: ILoggingBuilder, configure: Action_1<TOptions>): ILoggingBuilder;
    static AddConsoleFormatter<TFormatter extends unknown & ConsoleFormatter, TOptions extends unknown & ConsoleFormatterOptions>(builder: ILoggingBuilder): ILoggingBuilder;
    static AddJsonConsole(builder: ILoggingBuilder, configure: Action_1<JsonConsoleFormatterOptions>): ILoggingBuilder;
    static AddJsonConsole(builder: ILoggingBuilder): ILoggingBuilder;
    static AddSimpleConsole(builder: ILoggingBuilder, configure: Action_1<SimpleConsoleFormatterOptions>): ILoggingBuilder;
    static AddSimpleConsole(builder: ILoggingBuilder): ILoggingBuilder;
    static AddSystemdConsole(builder: ILoggingBuilder, configure: Action_1<ConsoleFormatterOptions>): ILoggingBuilder;
    static AddSystemdConsole(builder: ILoggingBuilder): ILoggingBuilder;
}


export type ConsoleLoggerExtensions = ConsoleLoggerExtensions$instance;

export abstract class DebugLoggerFactoryExtensions$instance {
    static AddDebug(factory: ILoggerFactory, minLevel: LogLevel): ILoggerFactory;
    static AddDebug(factory: ILoggerFactory, filter: Func_3<System_Internal.String, LogLevel, System_Internal.Boolean>): ILoggerFactory;
    static AddDebug(factory: ILoggerFactory): ILoggerFactory;
    static AddDebug(builder: ILoggingBuilder): ILoggingBuilder;
}


export type DebugLoggerFactoryExtensions = DebugLoggerFactoryExtensions$instance;

export abstract class EventLoggerFactoryExtensions$instance {
    static AddEventLog(factory: ILoggerFactory, settings: EventLogSettings): ILoggerFactory;
    static AddEventLog(factory: ILoggerFactory, minLevel: LogLevel): ILoggerFactory;
    static AddEventLog(factory: ILoggerFactory): ILoggerFactory;
    static AddEventLog(builder: ILoggingBuilder, settings: EventLogSettings): ILoggingBuilder;
    static AddEventLog(builder: ILoggingBuilder, configure: Action_1<EventLogSettings>): ILoggingBuilder;
    static AddEventLog(builder: ILoggingBuilder): ILoggingBuilder;
}


export type EventLoggerFactoryExtensions = EventLoggerFactoryExtensions$instance;

export abstract class EventSourceLoggerFactoryExtensions$instance {
    static AddEventSourceLogger(factory: ILoggerFactory): ILoggerFactory;
    static AddEventSourceLogger(builder: ILoggingBuilder): ILoggingBuilder;
}


export type EventSourceLoggerFactoryExtensions = EventSourceLoggerFactoryExtensions$instance;

export abstract class FilterLoggingBuilderExtensions$instance {
    static AddFilter(builder: ILoggingBuilder, levelFilter: Func_2<LogLevel, System_Internal.Boolean>): ILoggingBuilder;
    static AddFilter(builder: ILoggingBuilder, categoryLevelFilter: Func_3<string | null, LogLevel, System_Internal.Boolean>): ILoggingBuilder;
    static AddFilter(builder: ILoggingBuilder, filter: Func_4<string | null, string | null, LogLevel, System_Internal.Boolean>): ILoggingBuilder;
    static AddFilter(builder: ILoggingBuilder, category: string | null, level: LogLevel): ILoggingBuilder;
    static AddFilter(builder: ILoggingBuilder, category: string | null, levelFilter: Func_2<LogLevel, System_Internal.Boolean>): ILoggingBuilder;
    static AddFilter(builder: LoggerFilterOptions, levelFilter: Func_2<LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
    static AddFilter(builder: LoggerFilterOptions, categoryLevelFilter: Func_3<string | null, LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
    static AddFilter(builder: LoggerFilterOptions, filter: Func_4<string | null, string | null, LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
    static AddFilter(builder: LoggerFilterOptions, category: string | null, level: LogLevel): LoggerFilterOptions;
    static AddFilter(builder: LoggerFilterOptions, category: string | null, levelFilter: Func_2<LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
}


export type FilterLoggingBuilderExtensions = FilterLoggingBuilderExtensions$instance;

export abstract class LoggerExtensions$instance {
    static BeginScope(logger: ILogger, messageFormat: string, ...args: (unknown | null)[]): IDisposable | null;
    static Log(logger: ILogger, logLevel: LogLevel, eventId: EventId, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static Log(logger: ILogger, logLevel: LogLevel, eventId: EventId, message: string | null, ...args: (unknown | null)[]): void;
    static Log(logger: ILogger, logLevel: LogLevel, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static Log(logger: ILogger, logLevel: LogLevel, message: string | null, ...args: (unknown | null)[]): void;
    static LogCritical(logger: ILogger, eventId: EventId, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogCritical(logger: ILogger, eventId: EventId, message: string | null, ...args: (unknown | null)[]): void;
    static LogCritical(logger: ILogger, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogCritical(logger: ILogger, message: string | null, ...args: (unknown | null)[]): void;
    static LogDebug(logger: ILogger, eventId: EventId, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogDebug(logger: ILogger, eventId: EventId, message: string | null, ...args: (unknown | null)[]): void;
    static LogDebug(logger: ILogger, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogDebug(logger: ILogger, message: string | null, ...args: (unknown | null)[]): void;
    static LogError(logger: ILogger, eventId: EventId, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogError(logger: ILogger, eventId: EventId, message: string | null, ...args: (unknown | null)[]): void;
    static LogError(logger: ILogger, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogError(logger: ILogger, message: string | null, ...args: (unknown | null)[]): void;
    static LogInformation(logger: ILogger, eventId: EventId, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogInformation(logger: ILogger, eventId: EventId, message: string | null, ...args: (unknown | null)[]): void;
    static LogInformation(logger: ILogger, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogInformation(logger: ILogger, message: string | null, ...args: (unknown | null)[]): void;
    static LogTrace(logger: ILogger, eventId: EventId, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogTrace(logger: ILogger, eventId: EventId, message: string | null, ...args: (unknown | null)[]): void;
    static LogTrace(logger: ILogger, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogTrace(logger: ILogger, message: string | null, ...args: (unknown | null)[]): void;
    static LogWarning(logger: ILogger, eventId: EventId, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogWarning(logger: ILogger, eventId: EventId, message: string | null, ...args: (unknown | null)[]): void;
    static LogWarning(logger: ILogger, exception: Exception | null, message: string | null, ...args: (unknown | null)[]): void;
    static LogWarning(logger: ILogger, message: string | null, ...args: (unknown | null)[]): void;
}


export type LoggerExtensions = LoggerExtensions$instance;

export abstract class LoggerFactoryExtensions$instance {
    static CreateLogger(factory: ILoggerFactory, type: Type): ILogger;
    static CreateLogger<T extends unknown>(factory: ILoggerFactory): ILogger_1<T>;
}


export type LoggerFactoryExtensions = LoggerFactoryExtensions$instance;

export abstract class LoggerMessage$instance {
    static Define<T1 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions | null): Action_3<ILogger, T1, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions | null): Action_4<ILogger, T1, T2, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown, T3 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions | null): Action_5<ILogger, T1, T2, T3, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions | null): Action_6<ILogger, T1, T2, T3, T4, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown, T5 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions | null): Action_7<ILogger, T1, T2, T3, T4, T5, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown, T5 extends unknown, T6 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions | null): Action_8<ILogger, T1, T2, T3, T4, T5, T6, Exception | null>;
    static Define(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions | null): Action_2<ILogger, Exception | null>;
    static Define<T1 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_3<ILogger, T1, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_4<ILogger, T1, T2, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown, T3 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_5<ILogger, T1, T2, T3, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_6<ILogger, T1, T2, T3, T4, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown, T5 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_7<ILogger, T1, T2, T3, T4, T5, Exception | null>;
    static Define<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown, T5 extends unknown, T6 extends unknown>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_8<ILogger, T1, T2, T3, T4, T5, T6, Exception | null>;
    static Define(logLevel: LogLevel, eventId: EventId, formatString: string): Action_2<ILogger, Exception | null>;
    static DefineScope<T1 extends unknown>(formatString: string): Func_3<ILogger, T1, IDisposable | null>;
    static DefineScope<T1 extends unknown, T2 extends unknown>(formatString: string): Func_4<ILogger, T1, T2, IDisposable | null>;
    static DefineScope<T1 extends unknown, T2 extends unknown, T3 extends unknown>(formatString: string): Func_5<ILogger, T1, T2, T3, IDisposable | null>;
    static DefineScope<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown>(formatString: string): Func_6<ILogger, T1, T2, T3, T4, IDisposable | null>;
    static DefineScope<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown, T5 extends unknown>(formatString: string): Func_7<ILogger, T1, T2, T3, T4, T5, IDisposable | null>;
    static DefineScope<T1 extends unknown, T2 extends unknown, T3 extends unknown, T4 extends unknown, T5 extends unknown, T6 extends unknown>(formatString: string): Func_8<ILogger, T1, T2, T3, T4, T5, T6, IDisposable | null>;
    static DefineScope(formatString: string): Func_2<ILogger, IDisposable | null>;
}


export type LoggerMessage = LoggerMessage$instance;

export abstract class LoggingBuilderExtensions$instance {
    static AddProvider(builder: ILoggingBuilder, provider: ILoggerProvider): ILoggingBuilder;
    static ClearProviders(builder: ILoggingBuilder): ILoggingBuilder;
    static Configure(builder: ILoggingBuilder, action: Action_1<LoggerFactoryOptions>): ILoggingBuilder;
    static SetMinimumLevel(builder: ILoggingBuilder, level: LogLevel): ILoggingBuilder;
}


export type LoggingBuilderExtensions = LoggingBuilderExtensions$instance;

export abstract class LoggingBuilderExtensions2$instance {
    static AddConfiguration(builder: ILoggingBuilder, configuration: IConfiguration): ILoggingBuilder;
}


export type LoggingBuilderExtensions2 = LoggingBuilderExtensions2$instance;

export abstract class TraceSourceFactoryExtensions$instance {
    static AddTraceSource(factory: ILoggerFactory, sourceSwitch: SourceSwitch, listener: TraceListener): ILoggerFactory;
    static AddTraceSource(factory: ILoggerFactory, sourceSwitch: SourceSwitch): ILoggerFactory;
    static AddTraceSource(factory: ILoggerFactory, switchName: string, listener: TraceListener): ILoggerFactory;
    static AddTraceSource(factory: ILoggerFactory, switchName: string): ILoggerFactory;
    static AddTraceSource(builder: ILoggingBuilder, sourceSwitch: SourceSwitch, listener: TraceListener): ILoggingBuilder;
    static AddTraceSource(builder: ILoggingBuilder, sourceSwitch: SourceSwitch): ILoggingBuilder;
    static AddTraceSource(builder: ILoggingBuilder, switchName: string, listener: TraceListener): ILoggingBuilder;
    static AddTraceSource(builder: ILoggingBuilder, switchName: string): ILoggingBuilder;
}


export type TraceSourceFactoryExtensions = TraceSourceFactoryExtensions$instance;