@tsonic/microsoft-extensions 10.0.40 → 10.0.42

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

@@ -2,8 +2,9 @@
 // Namespace: Microsoft.Extensions.Localization
 // Assembly: Microsoft.Extensions.Localization, Microsoft.Extensions.Localization.Abstractions
 
-// 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';
+// 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 { ILogger, ILoggerFactory } from "../../Microsoft.Extensions.Logging/internal/index.js";
@@ -18,7 +19,7 @@ import type { Attribute, Boolean as ClrBoolean, Func_2, Object as ClrObject, Str
 export interface IResourceNamesCache$instance {
     readonly __tsonic_iface_Microsoft_Extensions_Localization_IResourceNamesCache: never;
 
-    GetOrAdd(name: string, valueFactory: Func_2<System_Internal.String, IList_1<System_Internal.String>>): IList_1<System_Internal.String> | undefined;
+    GetOrAdd(name: string, valueFactory: Func_2<System_Internal.String, IList_1<System_Internal.String> | null>): IList_1<System_Internal.String> | null;
 }
 
 
@@ -35,7 +36,7 @@ export interface IStringLocalizer$instance {
 
 export type IStringLocalizer = IStringLocalizer$instance;
 
-export interface IStringLocalizer_1$instance<T> extends IStringLocalizer {
+export interface IStringLocalizer_1$instance<T extends unknown> extends IStringLocalizer {
     readonly __tsonic_iface_Microsoft_Extensions_Localization_IStringLocalizer_1: never;
 
     get_Item2(name: string, ...arguments: unknown[]): LocalizedString;
@@ -45,9 +46,9 @@ export interface IStringLocalizer_1$instance<T> extends IStringLocalizer {
 }
 
 
-export interface IStringLocalizer_1$instance<T> extends IStringLocalizer$instance {}
+export interface IStringLocalizer_1$instance<T extends unknown> extends IStringLocalizer$instance {}
 
-export type IStringLocalizer_1<T> = IStringLocalizer_1$instance<T>;
+export type IStringLocalizer_1<T extends unknown> = IStringLocalizer_1$instance<T>;
 
 export interface IStringLocalizerFactory$instance {
     readonly __tsonic_iface_Microsoft_Extensions_Localization_IStringLocalizerFactory: never;
@@ -78,7 +79,7 @@ export interface LocalizedString$instance {
 
     readonly Name: string;
     readonly ResourceNotFound: boolean;
-    readonly SearchedLocation: string | undefined;
+    readonly SearchedLocation: string | null;
     readonly Value: string;
     ToString(): string;
 }
@@ -87,7 +88,7 @@ export interface LocalizedString$instance {
 export const LocalizedString: {
     new(name: string, value: string): LocalizedString;
     new(name: string, value: string, resourceNotFound: boolean): LocalizedString;
-    new(name: string, value: string, resourceNotFound: boolean, searchedLocation: string): LocalizedString;
+    new(name: string, value: string, resourceNotFound: boolean, searchedLocation: string | null): LocalizedString;
 };
 
 
@@ -107,7 +108,7 @@ export const ResourceLocationAttribute: {
 
 export type ResourceLocationAttribute = ResourceLocationAttribute$instance;
 
-export interface ResourceManagerStringLocalizer$instance {
+export interface ResourceManagerStringLocalizer$instance extends IStringLocalizer$instance {
     readonly __tsonic_type_Microsoft_Extensions_Localization_ResourceManagerStringLocalizer: never;
 
     readonly __tsonic_iface_Microsoft_Extensions_Localization_IStringLocalizer: never;
@@ -138,12 +139,12 @@ export interface ResourceManagerStringLocalizerFactory$instance extends IStringL
     Create(resourceSource: Type): IStringLocalizer;
     Create(baseName: string, location: string): IStringLocalizer;
     CreateResourceManagerStringLocalizer(assembly: Assembly, baseName: string): ResourceManagerStringLocalizer;
-    GetResourceLocationAttribute(assembly: Assembly): ResourceLocationAttribute | undefined;
+    GetResourceLocationAttribute(assembly: Assembly): ResourceLocationAttribute | null;
     GetResourcePrefix(typeInfo: TypeInfo): string;
-    GetResourcePrefix(typeInfo: TypeInfo, baseNamespace: string, resourcesRelativePath: string): string;
+    GetResourcePrefix(typeInfo: TypeInfo, baseNamespace: string | null, resourcesRelativePath: string | null): string;
     GetResourcePrefix(baseResourceName: string, baseNamespace: string): string;
     GetResourcePrefix(location: string, baseName: string, resourceLocation: string): string;
-    GetRootNamespaceAttribute(assembly: Assembly): RootNamespaceAttribute | undefined;
+    GetRootNamespaceAttribute(assembly: Assembly): RootNamespaceAttribute | null;
 }
 
 
@@ -164,7 +165,7 @@ export interface ResourceNamesCache$instance extends IResourceNamesCache$instanc
 
     readonly __tsonic_iface_Microsoft_Extensions_Localization_IResourceNamesCache: never;
 
-    GetOrAdd(name: string, valueFactory: Func_2<System_Internal.String, IList_1<System_Internal.String>>): IList_1<System_Internal.String> | undefined;
+    GetOrAdd(name: string, valueFactory: Func_2<System_Internal.String, IList_1<System_Internal.String> | null>): IList_1<System_Internal.String> | null;
 }
 
 
@@ -194,7 +195,7 @@ export const RootNamespaceAttribute: {
 
 export type RootNamespaceAttribute = RootNamespaceAttribute$instance;
 
-export interface StringLocalizer_1$instance<TResourceSource> extends IStringLocalizer_1<TResourceSource> {
+export interface StringLocalizer_1$instance<TResourceSource extends unknown> extends IStringLocalizer_1<TResourceSource>, IStringLocalizer_1$instance<TResourceSource> {
     readonly __tsonic_type_Microsoft_Extensions_Localization_StringLocalizer_1: never;
 
     readonly __tsonic_iface_Microsoft_Extensions_Localization_IStringLocalizer: never;
@@ -207,15 +208,15 @@ export interface StringLocalizer_1$instance<TResourceSource> extends IStringLoca
 
 
 export const StringLocalizer_1: {
-    new<TResourceSource>(factory: IStringLocalizerFactory): StringLocalizer_1<TResourceSource>;
+    new<TResourceSource extends unknown>(factory: IStringLocalizerFactory): StringLocalizer_1<TResourceSource>;
 };
 
 
-export interface __StringLocalizer_1$views<TResourceSource> {
+export interface __StringLocalizer_1$views<TResourceSource extends unknown> {
     As_IStringLocalizer(): IStringLocalizer$instance;
 }
 
-export type StringLocalizer_1<TResourceSource> = StringLocalizer_1$instance<TResourceSource> & __StringLocalizer_1$views<TResourceSource>;
+export type StringLocalizer_1<TResourceSource extends unknown> = StringLocalizer_1$instance<TResourceSource> & __StringLocalizer_1$views<TResourceSource>;
 
 
 export abstract class StringLocalizerExtensions$instance {

package/Microsoft.Extensions.Localization.d.ts

@@ -5,6 +5,10 @@
 // Import internal declarations
 import * as Internal from './Microsoft.Extensions.Localization/internal/index.js';
 
+// 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';
+
+
 // Cross-namespace type imports for constraints
 import type { ILogger, ILoggerFactory } from './Microsoft.Extensions.Logging/internal/index.js';
 import type { IOptions_1 } from './Microsoft.Extensions.Options/internal/index.js';
@@ -34,10 +38,10 @@ declare const __unspecified: unique symbol;
 export type __ = typeof __unspecified;
 
 export type IStringLocalizer<
-  T1 = __,
+  T1 extends unknown | __ = __,
 > =
   [T1] extends [__] ? Internal.IStringLocalizer :
-  Internal.IStringLocalizer_1<T1>;
+  [T1] extends [unknown] ? Internal.IStringLocalizer_1<T1> : never;
 
 // Extension methods (C# using semantics)
 export type { ExtensionMethods_Microsoft_Extensions_Localization as ExtensionMethods } from './__internal/extensions/index.js';

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

@@ -2,8 +2,9 @@
 // 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';
+// 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";
@@ -42,8 +43,8 @@ export enum LogLevel {
 export interface IExternalScopeProvider$instance {
     readonly __tsonic_iface_Microsoft_Extensions_Logging_IExternalScopeProvider: never;
 
-    ForEachScope<TState>(callback: Action_2<unknown, TState>, state: TState): void;
-    Push(state: unknown): IDisposable;
+    ForEachScope<TState extends unknown>(callback: Action_2<unknown | null, TState>, state: TState): void;
+    Push(state: unknown | null): IDisposable;
 }
 
 
@@ -52,26 +53,28 @@ export type IExternalScopeProvider = IExternalScopeProvider$instance;
 export interface ILogger$instance {
     readonly __tsonic_iface_Microsoft_Extensions_Logging_ILogger: never;
 
-    BeginScope<TState>(state: TState): IDisposable;
+    BeginScope<TState extends unknown>(state: TState): IDisposable;
     IsEnabled(logLevel: LogLevel): boolean;
-    Log<TState>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception, formatter: Func_3<TState, Exception, System_Internal.String>): void;
+    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 ILogger {
+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>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception, formatter: Func_3<TState, Exception, System_Internal.String>): void;
+    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 ILogger$instance {}
+export interface ILogger_1$instance<TCategoryName extends unknown> extends ILogger$instance {}
 
-export type ILogger_1<TCategoryName> = ILogger_1$instance<TCategoryName>;
+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;
@@ -120,16 +123,16 @@ export interface EventId$instance {
     readonly __tsonic_iface_System_IEquatable_1: never;
 
     readonly Id: int;
-    readonly Name: string | undefined;
+    readonly Name: string | null;
     Equals(other: EventId): boolean;
-    Equals(obj: unknown): boolean;
+    Equals(obj: unknown | null): boolean;
     GetHashCode(): int;
     ToString(): string;
 }
 
 
 export const EventId: {
-    new(id: int, name: string): EventId;
+    new(id: int, name: string | null): EventId;
 };
 
 
@@ -149,7 +152,7 @@ export const LogDefineOptions: {
 
 export type LogDefineOptions = LogDefineOptions$instance;
 
-export interface Logger_1$instance<T> extends ILogger_1$instance<T> {
+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;
@@ -159,15 +162,15 @@ export interface Logger_1$instance<T> extends ILogger_1$instance<T> {
 
 
 export const Logger_1: {
-    new<T>(factory: ILoggerFactory): Logger_1<T>;
+    new<T extends unknown>(factory: ILoggerFactory): Logger_1<T>;
 };
 
 
-export interface __Logger_1$views<T> {
+export interface __Logger_1$views<T extends unknown> {
     As_ILogger(): ILogger$instance;
 }
 
-export type Logger_1<T> = Logger_1$instance<T> & __Logger_1$views<T>;
+export type Logger_1<T extends unknown> = Logger_1$instance<T> & __Logger_1$views<T>;
 
 
 export interface LoggerExternalScopeProvider$instance extends IExternalScopeProvider$instance {
@@ -175,8 +178,8 @@ export interface LoggerExternalScopeProvider$instance extends IExternalScopeProv
 
     readonly __tsonic_iface_Microsoft_Extensions_Logging_IExternalScopeProvider: never;
 
-    ForEachScope<TState>(callback: Action_2<unknown, TState>, state: TState): void;
-    Push(state: unknown): IDisposable;
+    ForEachScope<TState extends unknown>(callback: Action_2<unknown | null, TState>, state: TState): void;
+    Push(state: unknown | null): IDisposable;
 }
 
 
@@ -210,8 +213,8 @@ export const 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>): LoggerFactory;
-    new(providers: IEnumerable_1<ILoggerProvider>, filterOption: IOptionsMonitor_1<LoggerFilterOptions>, options: IOptions_1<LoggerFactoryOptions>, scopeProvider: IExternalScopeProvider): 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;
 };
 
@@ -256,16 +259,16 @@ export type LoggerFilterOptions = LoggerFilterOptions$instance;
 export interface LoggerFilterRule$instance {
     readonly __tsonic_type_Microsoft_Extensions_Logging_LoggerFilterRule: never;
 
-    readonly CategoryName: string | undefined;
-    readonly Filter: Func_4<string | undefined, string | undefined, LogLevel, System_Internal.Boolean> | undefined;
+    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 | undefined;
+    readonly ProviderName: string | null;
     ToString(): string;
 }
 
 
 export const LoggerFilterRule: {
-    new(providerName: string, categoryName: string, logLevel: Nullable_1<LogLevel>, filter: Func_4<System_Internal.String, System_Internal.String, LogLevel, System_Internal.Boolean>): 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;
 };
 
 
@@ -275,8 +278,8 @@ export interface LoggerMessageAttribute$instance extends Attribute {
     readonly __tsonic_type_Microsoft_Extensions_Logging_LoggerMessageAttribute: never;
 
     EventId: int;
-    get EventName(): string | undefined;
-    set EventName(value: string | undefined);
+    get EventName(): string | null;
+    set EventName(value: string | null);
     Level: LogLevel;
     Message: string;
     SkipEnabledCheck: boolean;
@@ -319,8 +322,8 @@ export abstract class ConsoleLoggerExtensions$instance {
     static AddConsole(factory: ILoggerFactory): ILoggerFactory;
     static AddConsole(builder: ILoggingBuilder, configure: Action_1<ConsoleLoggerOptions>): ILoggingBuilder;
     static AddConsole(builder: ILoggingBuilder): ILoggingBuilder;
-    static AddConsoleFormatter<TFormatter extends ConsoleFormatter, TOptions extends ConsoleFormatterOptions>(builder: ILoggingBuilder, configure: Action_1<TOptions>): ILoggingBuilder;
-    static AddConsoleFormatter<TFormatter extends ConsoleFormatter, TOptions extends ConsoleFormatterOptions>(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;
@@ -364,50 +367,50 @@ export type EventSourceLoggerFactoryExtensions = EventSourceLoggerFactoryExtensi
 
 export abstract class FilterLoggingBuilderExtensions$instance {
     static AddFilter(builder: ILoggingBuilder, levelFilter: Func_2<LogLevel, System_Internal.Boolean>): ILoggingBuilder;
-    static AddFilter(builder: ILoggingBuilder, categoryLevelFilter: Func_3<System_Internal.String, LogLevel, System_Internal.Boolean>): ILoggingBuilder;
-    static AddFilter(builder: ILoggingBuilder, filter: Func_4<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_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<System_Internal.String, LogLevel, System_Internal.Boolean>): LoggerFilterOptions;
-    static AddFilter(builder: LoggerFilterOptions, filter: Func_4<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_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[]): 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;
+    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;
 }
 
 
@@ -415,34 +418,34 @@ 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>;
+    static CreateLogger<T extends unknown>(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_3<ILogger, T1, Exception | undefined>;
-    static Define<T1, T2>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action_4<ILogger, T1, T2, Exception | undefined>;
-    static Define<T1, T2, T3>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action_5<ILogger, T1, T2, T3, Exception | undefined>;
-    static Define<T1, T2, T3, T4>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action_6<ILogger, T1, T2, T3, T4, Exception | undefined>;
-    static Define<T1, T2, T3, T4, T5>(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action_7<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_8<ILogger, T1, T2, T3, T4, T5, T6, Exception | undefined>;
-    static Define(logLevel: LogLevel, eventId: EventId, formatString: string, options: LogDefineOptions): Action_2<ILogger, Exception | undefined>;
-    static Define<T1>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_3<ILogger, T1, Exception | undefined>;
-    static Define<T1, T2>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_4<ILogger, T1, T2, Exception | undefined>;
-    static Define<T1, T2, T3>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_5<ILogger, T1, T2, T3, Exception | undefined>;
-    static Define<T1, T2, T3, T4>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_6<ILogger, T1, T2, T3, T4, Exception | undefined>;
-    static Define<T1, T2, T3, T4, T5>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_7<ILogger, T1, T2, T3, T4, T5, Exception | undefined>;
-    static Define<T1, T2, T3, T4, T5, T6>(logLevel: LogLevel, eventId: EventId, formatString: string): Action_8<ILogger, T1, T2, T3, T4, T5, T6, Exception | undefined>;
-    static Define(logLevel: LogLevel, eventId: EventId, formatString: string): Action_2<ILogger, Exception | undefined>;
-    static DefineScope<T1>(formatString: string): Func_3<ILogger, T1, IDisposable | undefined>;
-    static DefineScope<T1, T2>(formatString: string): Func_4<ILogger, T1, T2, IDisposable | undefined>;
-    static DefineScope<T1, T2, T3>(formatString: string): Func_5<ILogger, T1, T2, T3, IDisposable | undefined>;
-    static DefineScope<T1, T2, T3, T4>(formatString: string): Func_6<ILogger, T1, T2, T3, T4, IDisposable | undefined>;
-    static DefineScope<T1, T2, T3, T4, T5>(formatString: string): Func_7<ILogger, T1, T2, T3, T4, T5, IDisposable | undefined>;
-    static DefineScope<T1, T2, T3, T4, T5, T6>(formatString: string): Func_8<ILogger, T1, T2, T3, T4, T5, T6, IDisposable | undefined>;
-    static DefineScope(formatString: string): Func_2<ILogger, IDisposable | undefined>;
+    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>;
 }
 
 

package/Microsoft.Extensions.Logging.Abstractions/bindings.json

@@ -756,7 +756,10 @@
           "isLiteral": false,
           "visibility": "Public",
           "declaringClrType": "Microsoft.Extensions.Logging.Abstractions.NullLogger\u00601",
-          "declaringAssemblyName": "Microsoft.Extensions.Logging.Abstractions"
+          "declaringAssemblyName": "Microsoft.Extensions.Logging.Abstractions",
+          "emitSemantics": {
+            "callableStaticAccessorKind": "field"
+          }
         }
       ],
       "events": [],

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

@@ -2,8 +2,9 @@
 // Namespace: Microsoft.Extensions.Logging.Abstractions
 // Assembly: Microsoft.Extensions.Logging.Abstractions
 
-// 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';
+// 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 * as Microsoft_Extensions_Logging_Internal from "../../Microsoft.Extensions.Logging/internal/index.js";
@@ -22,24 +23,24 @@ export interface IBufferedLogger$instance {
 
 export type IBufferedLogger = IBufferedLogger$instance;
 
-export interface LogEntry_1$instance<TState> {
+export interface LogEntry_1$instance<TState extends unknown> {
     readonly __tsonic_type_Microsoft_Extensions_Logging_Abstractions_LogEntry_1: never;
 
     readonly Category: string;
     readonly EventId: EventId;
-    readonly Exception: Exception | undefined;
-    readonly Formatter: Func_3<TState, Exception | undefined, System_Internal.String>;
+    readonly Exception: Exception | null;
+    readonly Formatter: Func_3<TState, Exception | null, System_Internal.String>;
     readonly LogLevel: LogLevel;
     readonly State: TState;
 }
 
 
 export const LogEntry_1: {
-    new<TState>(logLevel: LogLevel, category: string, eventId: EventId, state: TState, exception: Exception, formatter: Func_3<TState, Exception, System_Internal.String>): LogEntry_1<TState>;
+    new<TState extends unknown>(logLevel: LogLevel, category: string, eventId: EventId, state: TState, exception: Exception | null, formatter: Func_3<TState, Exception | null, System_Internal.String>): LogEntry_1<TState>;
 };
 
 
-export type LogEntry_1<TState> = LogEntry_1$instance<TState>;
+export type LogEntry_1<TState extends unknown> = LogEntry_1$instance<TState>;
 
 export interface BufferedLogRecord$instance {
     readonly __tsonic_type_Microsoft_Extensions_Logging_Abstractions_BufferedLogRecord: never;
@@ -48,11 +49,11 @@ export interface BufferedLogRecord$instance {
     readonly ActivityTraceId: Nullable_1<ActivityTraceId>;
     readonly Attributes: IReadOnlyList_1<KeyValuePair_2<System_Internal.String, unknown>>;
     readonly EventId: EventId;
-    readonly Exception: string | undefined;
-    readonly FormattedMessage: string | undefined;
+    readonly Exception: string | null;
+    readonly FormattedMessage: string | null;
     readonly LogLevel: LogLevel;
     readonly ManagedThreadId: Nullable_1<System_Internal.Int32>;
-    readonly MessageTemplate: string | undefined;
+    readonly MessageTemplate: string | null;
     readonly Timestamp: DateTimeOffset;
 }
 
@@ -68,9 +69,9 @@ export interface NullLogger$instance extends Microsoft_Extensions_Logging_Intern
 
     readonly __tsonic_iface_Microsoft_Extensions_Logging_ILogger: never;
 
-    BeginScope<TState>(state: TState): IDisposable;
+    BeginScope<TState extends unknown>(state: TState): IDisposable;
     IsEnabled(logLevel: LogLevel): boolean;
-    Log<TState>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception, formatter: Func_3<TState, Exception, System_Internal.String>): void;
+    Log<TState extends unknown>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception | null, formatter: Func_3<TState, Exception | null, System_Internal.String>): void;
 }
 
 
@@ -86,29 +87,29 @@ export interface __NullLogger$views {
 export type NullLogger = NullLogger$instance & __NullLogger$views;
 
 
-export interface NullLogger_1$instance<T> extends ILogger_1<T> {
+export interface NullLogger_1$instance<T extends unknown> extends ILogger_1<T>, Microsoft_Extensions_Logging_Internal.ILogger_1$instance<T> {
     readonly __tsonic_type_Microsoft_Extensions_Logging_Abstractions_NullLogger_1: never;
 
     readonly __tsonic_iface_Microsoft_Extensions_Logging_ILogger: never;
     readonly __tsonic_iface_Microsoft_Extensions_Logging_ILogger_1: never;
 
-    BeginScope<TState>(state: TState): IDisposable;
+    BeginScope<TState extends unknown>(state: TState): IDisposable;
     IsEnabled(logLevel: LogLevel): boolean;
-    Log<TState>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception, formatter: Func_3<TState, Exception, System_Internal.String>): void;
+    Log<TState extends unknown>(logLevel: LogLevel, eventId: EventId, state: TState, exception: Exception | null, formatter: Func_3<TState, Exception | null, System_Internal.String>): void;
 }
 
 
 export const NullLogger_1: {
-    new<T>(): NullLogger_1<T>;
-    readonly Instance: unknown;
+    new<T extends unknown>(): NullLogger_1<T>;
+    readonly Instance: <T extends unknown>() => NullLogger_1<T>;
 };
 
 
-export interface __NullLogger_1$views<T> {
+export interface __NullLogger_1$views<T extends unknown> {
     As_ILogger(): Microsoft_Extensions_Logging_Internal.ILogger$instance;
 }
 
-export type NullLogger_1<T> = NullLogger_1$instance<T> & __NullLogger_1$views<T>;
+export type NullLogger_1<T extends unknown> = NullLogger_1$instance<T> & __NullLogger_1$views<T>;
 
 
 export interface NullLoggerFactory$instance extends Microsoft_Extensions_Logging_Internal.ILoggerFactory$instance {

package/Microsoft.Extensions.Logging.Abstractions.d.ts

@@ -5,6 +5,10 @@
 // Import internal declarations
 import * as Internal from './Microsoft.Extensions.Logging.Abstractions/internal/index.js';
 
+// 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';
+
+
 // Cross-namespace type imports for constraints
 import type { EventId, ILogger, ILogger_1, ILoggerFactory, ILoggerProvider, LogLevel } from './Microsoft.Extensions.Logging/internal/index.js';
 import type { IEnumerable, IReadOnlyList, KeyValuePair } from '@tsonic/dotnet/System.Collections.Generic.js';
@@ -26,8 +30,8 @@ declare const __unspecified: unique symbol;
 export type __ = typeof __unspecified;
 
 export type NullLogger<
-  T1 = __,
+  T1 extends unknown | __ = __,
 > =
   [T1] extends [__] ? Internal.NullLogger :
-  Internal.NullLogger_1<T1>;
+  [T1] extends [unknown] ? Internal.NullLogger_1<T1> : never;