@tsonic/microsoft-extensions 0.1.1

package/Microsoft.Extensions.Logging/internal/index.d.ts

@@ -0,0 +1,438 @@
+// 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
+
+// Primitive type aliases from @tsonic/core
+import type { 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, IList } from "@tsonic/dotnet/System.Collections.Generic.js";
+import type { SourceSwitch, TraceListener } from "@tsonic/dotnet/System.Diagnostics.js";
+import * as System_Internal from "@tsonic/dotnet/System.js";
+import type { Action, Attribute, Boolean as ClrBoolean, Enum, Exception, Func, IComparable, IConvertible, IDisposable, IEquatable, IFormattable, Int32, ISpanFormattable, Nullable, Object as ClrObject, String as ClrString, Type, ValueType, Void } from "@tsonic/dotnet/System.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 {
+    forEachScope<TState>(callback: Action<unknown, TState>, state: TState): void;
+    push(state: unknown): IDisposable;
+}
+
+
+export type IExternalScopeProvider = IExternalScopeProvider$instance;
+
+export interface ILogger$instance {
+    beginScope<TState>(state: TState): IDisposable;
+    isEnabled(logLevel: LogLevel): boolean;
+    log<TState>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception, formatter: Func<TState, Exception, System_Internal.String>): void;
+}
+
+
+export type ILogger = ILogger$instance;
+
+export interface ILogger_1$instance<TCategoryName> extends ILogger {
+    beginScope<TState>(state: TState): IDisposable;
+    isEnabled(logLevel: LogLevel): boolean;
+    log<TState>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception, formatter: Func<TState, Exception, System_Internal.String>): void;
+}
+
+
+export interface ILogger_1$instance<TCategoryName> extends ILogger$instance {}
+
+export type ILogger_1<TCategoryName> = ILogger_1$instance<TCategoryName>;
+
+export interface ILoggerFactory$instance extends IDisposable {
+    addProvider(provider: ILoggerProvider): void;
+    createLogger(categoryName: string): ILogger;
+}
+
+
+export type ILoggerFactory = ILoggerFactory$instance;
+
+export interface ILoggerProvider$instance extends IDisposable {
+    createLogger(categoryName: string): ILogger;
+}
+
+
+export type ILoggerProvider = ILoggerProvider$instance;
+
+export interface ILoggingBuilder$instance {
+    readonly services: IServiceCollection;
+}
+
+
+export type ILoggingBuilder = ILoggingBuilder$instance;
+
+export interface ISupportExternalScope$instance {
+    setScopeProvider(scopeProvider: IExternalScopeProvider): void;
+}
+
+
+export type ISupportExternalScope = ISupportExternalScope$instance;
+
+export interface EventId$instance {
+    readonly id: int;
+    readonly name: string;
+    equals(other: EventId): boolean;
+    equals(obj: unknown): boolean;
+    getHashCode(): int;
+    toString(): string;
+}
+
+
+export const EventId: {
+    new(id: int, name: string): EventId;
+};
+
+
+export type EventId = EventId$instance;
+
+export interface LogDefineOptions$instance {
+    skipEnabledCheck: boolean;
+}
+
+
+export const LogDefineOptions: {
+    new(): LogDefineOptions;
+};
+
+
+export type LogDefineOptions = LogDefineOptions$instance;
+
+export interface Logger_1$instance<T> {
+}
+
+
+export const Logger_1: {
+    new<T>(factory: ILoggerFactory): Logger_1<T>;
+};
+
+
+export interface __Logger_1$views<T> {
+    As_ILogger(): ILogger$instance;
+}
+
+export interface Logger_1$instance<T> extends ILogger_1$instance<T> {}
+
+export type Logger_1<T> = Logger_1$instance<T> & __Logger_1$views<T>;
+
+
+export interface LoggerExternalScopeProvider$instance {
+    forEachScope<TState>(callback: Action<unknown, TState>, state: TState): void;
+    push(state: unknown): IDisposable;
+}
+
+
+export const LoggerExternalScopeProvider: {
+    new(): LoggerExternalScopeProvider;
+};
+
+
+export interface __LoggerExternalScopeProvider$views {
+    As_IExternalScopeProvider(): IExternalScopeProvider$instance;
+}
+
+export interface LoggerExternalScopeProvider$instance extends IExternalScopeProvider$instance {}
+
+export type LoggerExternalScopeProvider = LoggerExternalScopeProvider$instance & __LoggerExternalScopeProvider$views;
+
+
+export interface LoggerFactory$instance {
+    addProvider(provider: ILoggerProvider): void;
+    createLogger(categoryName: string): ILogger;
+    dispose(): void;
+}
+
+
+export const LoggerFactory: {
+    new(): LoggerFactory;
+    new(providers: IEnumerable<ILoggerProvider>): LoggerFactory;
+    new(providers: IEnumerable<ILoggerProvider>, filterOptions: LoggerFilterOptions): LoggerFactory;
+    new(providers: IEnumerable<ILoggerProvider>, filterOption: IOptionsMonitor_1<LoggerFilterOptions>): LoggerFactory;
+    new(providers: IEnumerable<ILoggerProvider>, filterOption: IOptionsMonitor_1<LoggerFilterOptions>, options: IOptions_1<LoggerFactoryOptions>): LoggerFactory;
+    new(providers: IEnumerable<ILoggerProvider>, filterOption: IOptionsMonitor_1<LoggerFilterOptions>, options: IOptions_1<LoggerFactoryOptions>, scopeProvider: IExternalScopeProvider): LoggerFactory;
+    create(configure: Action<ILoggingBuilder>): ILoggerFactory;
+};
+
+
+export interface __LoggerFactory$views {
+    As_ILoggerFactory(): ILoggerFactory$instance;
+}
+
+export interface LoggerFactory$instance extends ILoggerFactory$instance {}
+
+export type LoggerFactory = LoggerFactory$instance & __LoggerFactory$views;
+
+
+export interface LoggerFactoryOptions$instance {
+    activityTrackingOptions: ActivityTrackingOptions;
+}
+
+
+export const LoggerFactoryOptions: {
+    new(): LoggerFactoryOptions;
+};
+
+
+export type LoggerFactoryOptions = LoggerFactoryOptions$instance;
+
+export interface LoggerFilterOptions$instance {
+    captureScopes: boolean;
+    minLevel: LogLevel;
+    readonly rules: IList<LoggerFilterRule>;
+}
+
+
+export const LoggerFilterOptions: {
+    new(): LoggerFilterOptions;
+};
+
+
+export type LoggerFilterOptions = LoggerFilterOptions$instance;
+
+export interface LoggerFilterRule$instance {
+    readonly categoryName: string | undefined;
+    readonly filter: Func<string | undefined, string | undefined, LogLevel, System_Internal.Boolean> | undefined;
+    readonly logLevel: Nullable<LogLevel>;
+    readonly providerName: string | undefined;
+    toString(): string;
+}
+
+
+export const LoggerFilterRule: {
+    new(providerName: string, categoryName: string, logLevel: Nullable<LogLevel>, filter: Func<System_Internal.String, System_Internal.String, LogLevel, System_Internal.Boolean>): LoggerFilterRule;
+};
+
+
+export type LoggerFilterRule = LoggerFilterRule$instance;
+
+export interface LoggerMessageAttribute$instance extends Attribute {
+    eventId: int;
+    get eventName(): string | undefined;
+    set eventName(value: string);
+    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 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<System_Internal.String, LogLevel, System_Internal.Boolean>, includeScopes: boolean): ILoggerFactory;
+    static addConsole(factory: ILoggerFactory, filter: Func<System_Internal.String, LogLevel, System_Internal.Boolean>): ILoggerFactory;
+    static addConsole(factory: ILoggerFactory): ILoggerFactory;
+    static addConsole(builder: ILoggingBuilder, configure: Action<ConsoleLoggerOptions>): ILoggingBuilder;
+    static addConsole(builder: ILoggingBuilder): ILoggingBuilder;
+    static addConsoleFormatter<TFormatter extends ConsoleFormatter, TOptions extends ConsoleFormatterOptions>(builder: ILoggingBuilder, configure: Action<TOptions>): ILoggingBuilder;
+    static addConsoleFormatter<TFormatter extends ConsoleFormatter, TOptions extends ConsoleFormatterOptions>(builder: ILoggingBuilder): ILoggingBuilder;
+    static addJsonConsole(builder: ILoggingBuilder, configure: Action<JsonConsoleFormatterOptions>): ILoggingBuilder;
+    static addJsonConsole(builder: ILoggingBuilder): ILoggingBuilder;
+    static addSimpleConsole(builder: ILoggingBuilder, configure: Action<SimpleConsoleFormatterOptions>): ILoggingBuilder;
+    static addSimpleConsole(builder: ILoggingBuilder): ILoggingBuilder;
+    static addSystemdConsole(builder: ILoggingBuilder, configure: Action<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<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<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<LogLevel, System_Internal.Boolean>): ILoggingBuilder;
+    static addFilter(builder: ILoggingBuilder, categoryLevelFilter: Func<System_Internal.String, LogLevel, System_Internal.Boolean>): ILoggingBuilder;
+    static addFilter(builder: ILoggingBuilder, filter: Func<System_Internal.String, System_Internal.String, LogLevel, System_Internal.Boolean>): ILoggingBuilder;
+    static addFilter(builder: ILoggingBuilder, category: string, level: LogLevel): ILoggingBuilder;
+    static addFilter(builder: ILoggingBuilder, category: string, levelFilter: Func<LogLevel, System_Internal.Boolean>): ILoggingBuilder;
+    static addFilter(builder: LoggerFilterOptions, levelFilter: Func<LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
+    static addFilter(builder: LoggerFilterOptions, categoryLevelFilter: Func<System_Internal.String, LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
+    static addFilter(builder: LoggerFilterOptions, filter: Func<System_Internal.String, System_Internal.String, LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
+    static addFilter(builder: LoggerFilterOptions, category: string, level: LogLevel): LoggerFilterOptions;
+    static addFilter(builder: LoggerFilterOptions, category: string, levelFilter: Func<LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
+}
+
+
+export type FilterLoggingBuilderExtensions = FilterLoggingBuilderExtensions$instance;
+
+export abstract class LoggerExtensions$instance {
+    static beginScope(logger: ILogger, messageFormat: string, ...args: unknown[]): IDisposable | undefined;
+    static log(logger: ILogger, logLevel: LogLevel, eventId: EventId, exception: Exception, message: string, ...args: unknown[]): void;
+    static log(logger: ILogger, logLevel: LogLevel, eventId: EventId, message: string, ...args: unknown[]): void;
+    static log(logger: ILogger, logLevel: LogLevel, exception: Exception, message: string, ...args: unknown[]): void;
+    static log(logger: ILogger, logLevel: LogLevel, message: string, ...args: unknown[]): void;
+    static logCritical(logger: ILogger, eventId: EventId, exception: Exception, message: string, ...args: unknown[]): void;
+    static logCritical(logger: ILogger, eventId: EventId, message: string, ...args: unknown[]): void;
+    static logCritical(logger: ILogger, exception: Exception, message: string, ...args: unknown[]): void;
+    static logCritical(logger: ILogger, message: string, ...args: unknown[]): void;
+    static logDebug(logger: ILogger, eventId: EventId, exception: Exception, message: string, ...args: unknown[]): void;
+    static logDebug(logger: ILogger, eventId: EventId, message: string, ...args: unknown[]): void;
+    static logDebug(logger: ILogger, exception: Exception, message: string, ...args: unknown[]): void;
+    static logDebug(logger: ILogger, message: string, ...args: unknown[]): void;
+    static logError(logger: ILogger, eventId: EventId, exception: Exception, message: string, ...args: unknown[]): void;
+    static logError(logger: ILogger, eventId: EventId, message: string, ...args: unknown[]): void;
+    static logError(logger: ILogger, exception: Exception, message: string, ...args: unknown[]): void;
+    static logError(logger: ILogger, message: string, ...args: unknown[]): void;
+    static logInformation(logger: ILogger, eventId: EventId, exception: Exception, message: string, ...args: unknown[]): void;
+    static logInformation(logger: ILogger, eventId: EventId, message: string, ...args: unknown[]): void;
+    static logInformation(logger: ILogger, exception: Exception, message: string, ...args: unknown[]): void;
+    static logInformation(logger: ILogger, message: string, ...args: unknown[]): void;
+    static logTrace(logger: ILogger, eventId: EventId, exception: Exception, message: string, ...args: unknown[]): void;
+    static logTrace(logger: ILogger, eventId: EventId, message: string, ...args: unknown[]): void;
+    static logTrace(logger: ILogger, exception: Exception, message: string, ...args: unknown[]): void;
+    static logTrace(logger: ILogger, message: string, ...args: unknown[]): void;
+    static logWarning(logger: ILogger, eventId: EventId, exception: Exception, message: string, ...args: unknown[]): void;
+    static logWarning(logger: ILogger, eventId: EventId, message: string, ...args: unknown[]): void;
+    static logWarning(logger: ILogger, exception: Exception, message: string, ...args: unknown[]): void;
+    static logWarning(logger: ILogger, message: string, ...args: unknown[]): void;
+}
+
+
+export type LoggerExtensions = LoggerExtensions$instance;
+
+export abstract class LoggerFactoryExtensions$instance {
+    static createLogger(factory: ILoggerFactory, type_: Type): ILogger;
+    static createLogger<T>(factory: ILoggerFactory): ILogger_1<T>;
+}
+
+
+export type LoggerFactoryExtensions = LoggerFactoryExtensions$instance;
+
+export abstract class LoggerMessage$instance {
+    static define<T1>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action<ILogger, T1, Exception | undefined>;
+    static define<T1, T2>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action<ILogger, T1, T2, Exception | undefined>;
+    static define<T1, T2, T3>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action<ILogger, T1, T2, T3, Exception | undefined>;
+    static define<T1, T2, T3, T4>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action<ILogger, T1, T2, T3, T4, Exception | undefined>;
+    static define<T1, T2, T3, T4, T5>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action<ILogger, T1, T2, T3, T4, T5, Exception | undefined>;
+    static define<T1, T2, T3, T4, T5, T6>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action<ILogger, T1, T2, T3, T4, T5, T6, Exception | undefined>;
+    static define(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action<ILogger, Exception | undefined>;
+    static define<T1>(logLevel: LogLevel, eventId: EventId, formatString: string): Action<ILogger, T1, Exception | undefined>;
+    static define<T1, T2>(logLevel: LogLevel, eventId: EventId, formatString: string): Action<ILogger, T1, T2, Exception | undefined>;
+    static define<T1, T2, T3>(logLevel: LogLevel, eventId: EventId, formatString: string): Action<ILogger, T1, T2, T3, Exception | undefined>;
+    static define<T1, T2, T3, T4>(logLevel: LogLevel, eventId: EventId, formatString: string): Action<ILogger, T1, T2, T3, T4, Exception | undefined>;
+    static define<T1, T2, T3, T4, T5>(logLevel: LogLevel, eventId: EventId, formatString: string): Action<ILogger, T1, T2, T3, T4, T5, Exception | undefined>;
+    static define<T1, T2, T3, T4, T5, T6>(logLevel: LogLevel, eventId: EventId, formatString: string): Action<ILogger, T1, T2, T3, T4, T5, T6, Exception | undefined>;
+    static define(logLevel: LogLevel, eventId: EventId, formatString: string): Action<ILogger, Exception | undefined>;
+    static defineScope<T1>(formatString: string): Func<ILogger, T1, IDisposable | undefined>;
+    static defineScope<T1, T2>(formatString: string): Func<ILogger, T1, T2, IDisposable | undefined>;
+    static defineScope<T1, T2, T3>(formatString: string): Func<ILogger, T1, T2, T3, IDisposable | undefined>;
+    static defineScope<T1, T2, T3, T4>(formatString: string): Func<ILogger, T1, T2, T3, T4, IDisposable | undefined>;
+    static defineScope<T1, T2, T3, T4, T5>(formatString: string): Func<ILogger, T1, T2, T3, T4, T5, IDisposable | undefined>;
+    static defineScope<T1, T2, T3, T4, T5, T6>(formatString: string): Func<ILogger, T1, T2, T3, T4, T5, T6, IDisposable | undefined>;
+    static defineScope(formatString: string): Func<ILogger, IDisposable | undefined>;
+}
+
+
+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<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;
+