@tsonic/aspnetcore 10.0.2 → 10.0.6

package/Microsoft.AspNetCore.Authorization/internal/index.d.ts

@@ -8,22 +8,26 @@ import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint12
 // Import types from other namespaces
 import type { PolicyAuthorizationResult } from "../../Microsoft.AspNetCore.Authorization.Policy/internal/index.js";
 import type { HttpContext, RequestDelegate } from "../../Microsoft.AspNetCore.Http/internal/index.js";
-import type { IEnumerable, IList, IReadOnlyList } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Action, Attribute, Boolean as ClrBoolean, Func, IServiceProvider, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System.js";
-import type { ClaimsPrincipal } from "@tsonic/dotnet/System.Security.Claims.js";
-import type { Task } from "@tsonic/dotnet/System.Threading.Tasks.js";
-import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection.js";
-import type { ILogger } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging.js";
-import type { IOptions } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Options.js";
+import type { IEnumerable_1, IList_1, IReadOnlyList_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { ClaimsPrincipal } from "@tsonic/dotnet/System.Security.Claims/internal/index.js";
+import type { Task, Task_1 } from "@tsonic/dotnet/System.Threading.Tasks/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Action_1, Attribute, Boolean as ClrBoolean, Func_2, IServiceProvider, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection/internal/index.js";
+import type { ILogger_1 } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging/internal/index.js";
+import type { IOptions_1 } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Options/internal/index.js";
 
 export interface IAllowAnonymous$instance {
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAllowAnonymous: never;
+
 }
 
 
 export type IAllowAnonymous = IAllowAnonymous$instance;
 
 export interface IAuthorizationEvaluator$instance {
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationEvaluator: never;
+
     Evaluate(context: AuthorizationHandlerContext): AuthorizationResult;
 }
 
@@ -31,6 +35,8 @@ export interface IAuthorizationEvaluator$instance {
 export type IAuthorizationEvaluator = IAuthorizationEvaluator$instance;
 
 export interface IAuthorizationHandler$instance {
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationHandler: never;
+
     HandleAsync(context: AuthorizationHandlerContext): Task;
 }
 
@@ -38,20 +44,26 @@ export interface IAuthorizationHandler$instance {
 export type IAuthorizationHandler = IAuthorizationHandler$instance;
 
 export interface IAuthorizationHandlerContextFactory$instance {
-    CreateContext(requirements: IEnumerable<IAuthorizationRequirement>, user: ClaimsPrincipal, resource: unknown): AuthorizationHandlerContext;
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationHandlerContextFactory: never;
+
+    CreateContext(requirements: IEnumerable_1<IAuthorizationRequirement>, user: ClaimsPrincipal, resource: unknown): AuthorizationHandlerContext;
 }
 
 
 export type IAuthorizationHandlerContextFactory = IAuthorizationHandlerContextFactory$instance;
 
 export interface IAuthorizationHandlerProvider$instance {
-    GetHandlersAsync(context: AuthorizationHandlerContext): Task<IEnumerable<IAuthorizationHandler>>;
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationHandlerProvider: never;
+
+    GetHandlersAsync(context: AuthorizationHandlerContext): Task_1<IEnumerable_1<IAuthorizationHandler>>;
 }
 
 
 export type IAuthorizationHandlerProvider = IAuthorizationHandlerProvider$instance;
 
 export interface IAuthorizationMiddlewareResultHandler$instance {
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationMiddlewareResultHandler: never;
+
     HandleAsync(next: RequestDelegate, context: HttpContext, policy: AuthorizationPolicy, authorizeResult: PolicyAuthorizationResult): Task;
 }
 
@@ -59,36 +71,46 @@ export interface IAuthorizationMiddlewareResultHandler$instance {
 export type IAuthorizationMiddlewareResultHandler = IAuthorizationMiddlewareResultHandler$instance;
 
 export interface IAuthorizationPolicyProvider$instance {
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationPolicyProvider: never;
+
     readonly AllowsCachingPolicies: boolean;
-    GetDefaultPolicyAsync(): Task<AuthorizationPolicy>;
-    GetPolicyAsync(policyName: string): Task<AuthorizationPolicy | undefined>;
+    GetDefaultPolicyAsync(): Task_1<AuthorizationPolicy>;
+    GetPolicyAsync(policyName: string): Task_1<AuthorizationPolicy | undefined>;
 }
 
 
 export type IAuthorizationPolicyProvider = IAuthorizationPolicyProvider$instance;
 
 export interface IAuthorizationRequirement$instance {
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationRequirement: never;
+
 }
 
 
 export type IAuthorizationRequirement = IAuthorizationRequirement$instance;
 
 export interface IAuthorizationRequirementData$instance {
-    GetRequirements(): IEnumerable<IAuthorizationRequirement>;
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationRequirementData: never;
+
+    GetRequirements(): IEnumerable_1<IAuthorizationRequirement>;
 }
 
 
 export type IAuthorizationRequirementData = IAuthorizationRequirementData$instance;
 
 export interface IAuthorizationService$instance {
-    AuthorizeAsync(user: ClaimsPrincipal, resource: unknown, requirements: IEnumerable<IAuthorizationRequirement>): Task<AuthorizationResult>;
-    AuthorizeAsync(user: ClaimsPrincipal, resource: unknown, policyName: string): Task<AuthorizationResult>;
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationService: never;
+
+    AuthorizeAsync(user: ClaimsPrincipal, resource: unknown, requirements: IEnumerable_1<IAuthorizationRequirement>): Task_1<AuthorizationResult>;
+    AuthorizeAsync(user: ClaimsPrincipal, resource: unknown, policyName: string): Task_1<AuthorizationResult>;
 }
 
 
 export type IAuthorizationService = IAuthorizationService$instance;
 
 export interface IAuthorizeData$instance {
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizeData: never;
+
     get Policy(): string | undefined;
     set Policy(value: string | undefined);
     get Roles(): string | undefined;
@@ -101,6 +123,10 @@ export interface IAuthorizeData$instance {
 export type IAuthorizeData = IAuthorizeData$instance;
 
 export interface AllowAnonymousAttribute$instance extends Attribute, IAllowAnonymous {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AllowAnonymousAttribute: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAllowAnonymous: never;
+
     ToString(): string;
 }
 
@@ -113,13 +139,15 @@ export const AllowAnonymousAttribute: {
 export type AllowAnonymousAttribute = AllowAnonymousAttribute$instance;
 
 export interface AuthorizationBuilder$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationBuilder: never;
+
     readonly Services: IServiceCollection;
     AddDefaultPolicy(name: string, policy: AuthorizationPolicy): AuthorizationBuilder;
-    AddDefaultPolicy(name: string, configurePolicy: Action<AuthorizationPolicyBuilder>): AuthorizationBuilder;
+    AddDefaultPolicy(name: string, configurePolicy: Action_1<AuthorizationPolicyBuilder>): AuthorizationBuilder;
     AddFallbackPolicy(name: string, policy: AuthorizationPolicy): AuthorizationBuilder;
-    AddFallbackPolicy(name: string, configurePolicy: Action<AuthorizationPolicyBuilder>): AuthorizationBuilder;
+    AddFallbackPolicy(name: string, configurePolicy: Action_1<AuthorizationPolicyBuilder>): AuthorizationBuilder;
     AddPolicy(name: string, policy: AuthorizationPolicy): AuthorizationBuilder;
-    AddPolicy(name: string, configurePolicy: Action<AuthorizationPolicyBuilder>): AuthorizationBuilder;
+    AddPolicy(name: string, configurePolicy: Action_1<AuthorizationPolicyBuilder>): AuthorizationBuilder;
     SetDefaultPolicy(policy: AuthorizationPolicy): AuthorizationBuilder;
     SetFallbackPolicy(policy: AuthorizationPolicy): AuthorizationBuilder;
     SetInvokeHandlersAfterFailure(invoke: boolean): AuthorizationBuilder;
@@ -134,22 +162,26 @@ export const AuthorizationBuilder: {
 export type AuthorizationBuilder = AuthorizationBuilder$instance;
 
 export interface AuthorizationFailure$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationFailure: never;
+
     FailCalled: boolean;
-    FailedRequirements: IEnumerable<IAuthorizationRequirement>;
-    FailureReasons: IEnumerable<AuthorizationFailureReason>;
+    FailedRequirements: IEnumerable_1<IAuthorizationRequirement>;
+    FailureReasons: IEnumerable_1<AuthorizationFailureReason>;
 }
 
 
 export const AuthorizationFailure: {
     ExplicitFail(): AuthorizationFailure;
-    Failed(reasons: IEnumerable<AuthorizationFailureReason>): AuthorizationFailure;
-    Failed(failed: IEnumerable<IAuthorizationRequirement>): AuthorizationFailure;
+    Failed(reasons: IEnumerable_1<AuthorizationFailureReason>): AuthorizationFailure;
+    Failed(failed: IEnumerable_1<IAuthorizationRequirement>): AuthorizationFailure;
 };
 
 
 export type AuthorizationFailure = AuthorizationFailure$instance;
 
 export interface AuthorizationFailureReason$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationFailureReason: never;
+
     readonly Handler: IAuthorizationHandler;
     readonly Message: string;
 }
@@ -162,7 +194,11 @@ export const AuthorizationFailureReason: {
 
 export type AuthorizationFailureReason = AuthorizationFailureReason$instance;
 
-export interface AuthorizationHandler_1$instance<TRequirement extends IAuthorizationRequirement> {
+export interface AuthorizationHandler_1$instance<TRequirement extends IAuthorizationRequirement> extends IAuthorizationHandler$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationHandler_1: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationHandler: never;
+
     HandleAsync(context: AuthorizationHandlerContext): Task;
     HandleRequirementAsync(context: AuthorizationHandlerContext, requirement: TRequirement): Task;
 }
@@ -176,12 +212,14 @@ export interface __AuthorizationHandler_1$views<TRequirement extends IAuthorizat
     As_IAuthorizationHandler(): IAuthorizationHandler$instance;
 }
 
-export interface AuthorizationHandler_1$instance<TRequirement extends IAuthorizationRequirement> extends IAuthorizationHandler$instance {}
-
 export type AuthorizationHandler_1<TRequirement extends IAuthorizationRequirement> = AuthorizationHandler_1$instance<TRequirement> & __AuthorizationHandler_1$views<TRequirement>;
 
 
-export interface AuthorizationHandler_2$instance<TRequirement extends IAuthorizationRequirement, TResource> {
+export interface AuthorizationHandler_2$instance<TRequirement extends IAuthorizationRequirement, TResource> extends IAuthorizationHandler$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationHandler_2: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationHandler: never;
+
     HandleAsync(context: AuthorizationHandlerContext): Task;
     HandleRequirementAsync(context: AuthorizationHandlerContext, requirement: TRequirement, resource: TResource): Task;
 }
@@ -195,17 +233,17 @@ export interface __AuthorizationHandler_2$views<TRequirement extends IAuthorizat
     As_IAuthorizationHandler(): IAuthorizationHandler$instance;
 }
 
-export interface AuthorizationHandler_2$instance<TRequirement extends IAuthorizationRequirement, TResource> extends IAuthorizationHandler$instance {}
-
 export type AuthorizationHandler_2<TRequirement extends IAuthorizationRequirement, TResource> = AuthorizationHandler_2$instance<TRequirement, TResource> & __AuthorizationHandler_2$views<TRequirement, TResource>;
 
 
 export interface AuthorizationHandlerContext$instance {
-    readonly FailureReasons: IEnumerable<AuthorizationFailureReason>;
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationHandlerContext: never;
+
+    readonly FailureReasons: IEnumerable_1<AuthorizationFailureReason>;
     readonly HasFailed: boolean;
     readonly HasSucceeded: boolean;
-    readonly PendingRequirements: IEnumerable<IAuthorizationRequirement>;
-    readonly Requirements: IEnumerable<IAuthorizationRequirement>;
+    readonly PendingRequirements: IEnumerable_1<IAuthorizationRequirement>;
+    readonly Requirements: IEnumerable_1<IAuthorizationRequirement>;
     readonly Resource: unknown | undefined;
     readonly User: ClaimsPrincipal;
     Fail(): void;
@@ -215,20 +253,22 @@ export interface AuthorizationHandlerContext$instance {
 
 
 export const AuthorizationHandlerContext: {
-    new(requirements: IEnumerable<IAuthorizationRequirement>, user: ClaimsPrincipal, resource: unknown): AuthorizationHandlerContext;
+    new(requirements: IEnumerable_1<IAuthorizationRequirement>, user: ClaimsPrincipal, resource: unknown): AuthorizationHandlerContext;
 };
 
 
 export type AuthorizationHandlerContext = AuthorizationHandlerContext$instance;
 
 export interface AuthorizationMiddleware$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationMiddleware: never;
+
     Invoke(context: HttpContext): Task;
 }
 
 
 export const AuthorizationMiddleware: {
     new(next: RequestDelegate, policyProvider: IAuthorizationPolicyProvider): AuthorizationMiddleware;
-    new(next: RequestDelegate, policyProvider: IAuthorizationPolicyProvider, services: IServiceProvider, logger: ILogger<AuthorizationMiddleware>): AuthorizationMiddleware;
+    new(next: RequestDelegate, policyProvider: IAuthorizationPolicyProvider, services: IServiceProvider, logger: ILogger_1<AuthorizationMiddleware>): AuthorizationMiddleware;
     new(next: RequestDelegate, policyProvider: IAuthorizationPolicyProvider, services: IServiceProvider): AuthorizationMiddleware;
 };
 
@@ -236,12 +276,14 @@ export const AuthorizationMiddleware: {
 export type AuthorizationMiddleware = AuthorizationMiddleware$instance;
 
 export interface AuthorizationOptions$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationOptions: never;
+
     DefaultPolicy: AuthorizationPolicy;
     get FallbackPolicy(): AuthorizationPolicy | undefined;
     set FallbackPolicy(value: AuthorizationPolicy | undefined);
     InvokeHandlersAfterFailure: boolean;
     AddPolicy(name: string, policy: AuthorizationPolicy): void;
-    AddPolicy(name: string, configurePolicy: Action<AuthorizationPolicyBuilder>): void;
+    AddPolicy(name: string, configurePolicy: Action_1<AuthorizationPolicyBuilder>): void;
     GetPolicy(name: string): AuthorizationPolicy | undefined;
 }
 
@@ -254,37 +296,41 @@ export const AuthorizationOptions: {
 export type AuthorizationOptions = AuthorizationOptions$instance;
 
 export interface AuthorizationPolicy$instance {
-    readonly AuthenticationSchemes: IReadOnlyList<System_Internal.String>;
-    readonly Requirements: IReadOnlyList<IAuthorizationRequirement>;
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationPolicy: never;
+
+    readonly AuthenticationSchemes: IReadOnlyList_1<System_Internal.String>;
+    readonly Requirements: IReadOnlyList_1<IAuthorizationRequirement>;
 }
 
 
 export const AuthorizationPolicy: {
-    new(requirements: IEnumerable<IAuthorizationRequirement>, authenticationSchemes: IEnumerable<System_Internal.String>): AuthorizationPolicy;
+    new(requirements: IEnumerable_1<IAuthorizationRequirement>, authenticationSchemes: IEnumerable_1<System_Internal.String>): AuthorizationPolicy;
     Combine(...policies: AuthorizationPolicy[]): AuthorizationPolicy;
-    Combine(policies: IEnumerable<AuthorizationPolicy>): AuthorizationPolicy;
-    CombineAsync(policyProvider: IAuthorizationPolicyProvider, authorizeData: IEnumerable<IAuthorizeData>, policies: IEnumerable<AuthorizationPolicy>): Task<AuthorizationPolicy | undefined>;
-    CombineAsync(policyProvider: IAuthorizationPolicyProvider, authorizeData: IEnumerable<IAuthorizeData>): Task<AuthorizationPolicy | undefined>;
+    Combine(policies: IEnumerable_1<AuthorizationPolicy>): AuthorizationPolicy;
+    CombineAsync(policyProvider: IAuthorizationPolicyProvider, authorizeData: IEnumerable_1<IAuthorizeData>, policies: IEnumerable_1<AuthorizationPolicy>): Task_1<AuthorizationPolicy | undefined>;
+    CombineAsync(policyProvider: IAuthorizationPolicyProvider, authorizeData: IEnumerable_1<IAuthorizeData>): Task_1<AuthorizationPolicy | undefined>;
 };
 
 
 export type AuthorizationPolicy = AuthorizationPolicy$instance;
 
 export interface AuthorizationPolicyBuilder$instance {
-    AuthenticationSchemes: IList<System_Internal.String>;
-    Requirements: IList<IAuthorizationRequirement>;
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationPolicyBuilder: never;
+
+    AuthenticationSchemes: IList_1<System_Internal.String>;
+    Requirements: IList_1<IAuthorizationRequirement>;
     AddAuthenticationSchemes(...schemes: string[]): AuthorizationPolicyBuilder;
     AddRequirements(...requirements: IAuthorizationRequirement[]): AuthorizationPolicyBuilder;
     Build(): AuthorizationPolicy;
     Combine(policy: AuthorizationPolicy): AuthorizationPolicyBuilder;
-    RequireAssertion(handler: Func<AuthorizationHandlerContext, System_Internal.Boolean>): AuthorizationPolicyBuilder;
-    RequireAssertion(handler: Func<AuthorizationHandlerContext, Task<System_Internal.Boolean>>): AuthorizationPolicyBuilder;
+    RequireAssertion(handler: Func_2<AuthorizationHandlerContext, System_Internal.Boolean>): AuthorizationPolicyBuilder;
+    RequireAssertion(handler: Func_2<AuthorizationHandlerContext, Task_1<System_Internal.Boolean>>): AuthorizationPolicyBuilder;
     RequireAuthenticatedUser(): AuthorizationPolicyBuilder;
     RequireClaim(claimType: string, ...allowedValues: string[]): AuthorizationPolicyBuilder;
-    RequireClaim(claimType: string, allowedValues: IEnumerable<System_Internal.String>): AuthorizationPolicyBuilder;
+    RequireClaim(claimType: string, allowedValues: IEnumerable_1<System_Internal.String>): AuthorizationPolicyBuilder;
     RequireClaim(claimType: string): AuthorizationPolicyBuilder;
     RequireRole(...roles: string[]): AuthorizationPolicyBuilder;
-    RequireRole(roles: IEnumerable<System_Internal.String>): AuthorizationPolicyBuilder;
+    RequireRole(roles: IEnumerable_1<System_Internal.String>): AuthorizationPolicyBuilder;
     RequireUserName(userName: string): AuthorizationPolicyBuilder;
 }
 
@@ -298,6 +344,8 @@ export const AuthorizationPolicyBuilder: {
 export type AuthorizationPolicyBuilder = AuthorizationPolicyBuilder$instance;
 
 export interface AuthorizationResult$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizationResult: never;
+
     get Failure(): AuthorizationFailure | undefined;
     set Failure(value: AuthorizationFailure | undefined);
     Succeeded: boolean;
@@ -313,7 +361,11 @@ export const AuthorizationResult: {
 
 export type AuthorizationResult = AuthorizationResult$instance;
 
-export interface AuthorizeAttribute$instance extends Attribute {
+export interface AuthorizeAttribute$instance extends Attribute, IAuthorizeData$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_AuthorizeAttribute: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizeData: never;
+
     get AuthenticationSchemes(): string | undefined;
     set AuthenticationSchemes(value: string | undefined);
     get Policy(): string | undefined;
@@ -334,12 +386,14 @@ export interface __AuthorizeAttribute$views {
     As_IAuthorizeData(): IAuthorizeData$instance;
 }
 
-export interface AuthorizeAttribute$instance extends IAuthorizeData$instance {}
-
 export type AuthorizeAttribute = AuthorizeAttribute$instance & __AuthorizeAttribute$views;
 
 
-export interface DefaultAuthorizationEvaluator$instance {
+export interface DefaultAuthorizationEvaluator$instance extends IAuthorizationEvaluator$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_DefaultAuthorizationEvaluator: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationEvaluator: never;
+
     Evaluate(context: AuthorizationHandlerContext): AuthorizationResult;
 }
 
@@ -353,13 +407,15 @@ export interface __DefaultAuthorizationEvaluator$views {
     As_IAuthorizationEvaluator(): IAuthorizationEvaluator$instance;
 }
 
-export interface DefaultAuthorizationEvaluator$instance extends IAuthorizationEvaluator$instance {}
-
 export type DefaultAuthorizationEvaluator = DefaultAuthorizationEvaluator$instance & __DefaultAuthorizationEvaluator$views;
 
 
-export interface DefaultAuthorizationHandlerContextFactory$instance {
-    CreateContext(requirements: IEnumerable<IAuthorizationRequirement>, user: ClaimsPrincipal, resource: unknown): AuthorizationHandlerContext;
+export interface DefaultAuthorizationHandlerContextFactory$instance extends IAuthorizationHandlerContextFactory$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_DefaultAuthorizationHandlerContextFactory: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationHandlerContextFactory: never;
+
+    CreateContext(requirements: IEnumerable_1<IAuthorizationRequirement>, user: ClaimsPrincipal, resource: unknown): AuthorizationHandlerContext;
 }
 
 
@@ -372,18 +428,20 @@ export interface __DefaultAuthorizationHandlerContextFactory$views {
     As_IAuthorizationHandlerContextFactory(): IAuthorizationHandlerContextFactory$instance;
 }
 
-export interface DefaultAuthorizationHandlerContextFactory$instance extends IAuthorizationHandlerContextFactory$instance {}
-
 export type DefaultAuthorizationHandlerContextFactory = DefaultAuthorizationHandlerContextFactory$instance & __DefaultAuthorizationHandlerContextFactory$views;
 
 
-export interface DefaultAuthorizationHandlerProvider$instance {
-    GetHandlersAsync(context: AuthorizationHandlerContext): Task<IEnumerable<IAuthorizationHandler>>;
+export interface DefaultAuthorizationHandlerProvider$instance extends IAuthorizationHandlerProvider$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_DefaultAuthorizationHandlerProvider: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationHandlerProvider: never;
+
+    GetHandlersAsync(context: AuthorizationHandlerContext): Task_1<IEnumerable_1<IAuthorizationHandler>>;
 }
 
 
 export const DefaultAuthorizationHandlerProvider: {
-    new(handlers: IEnumerable<IAuthorizationHandler>): DefaultAuthorizationHandlerProvider;
+    new(handlers: IEnumerable_1<IAuthorizationHandler>): DefaultAuthorizationHandlerProvider;
 };
 
 
@@ -391,21 +449,23 @@ export interface __DefaultAuthorizationHandlerProvider$views {
     As_IAuthorizationHandlerProvider(): IAuthorizationHandlerProvider$instance;
 }
 
-export interface DefaultAuthorizationHandlerProvider$instance extends IAuthorizationHandlerProvider$instance {}
-
 export type DefaultAuthorizationHandlerProvider = DefaultAuthorizationHandlerProvider$instance & __DefaultAuthorizationHandlerProvider$views;
 
 
-export interface DefaultAuthorizationPolicyProvider$instance {
+export interface DefaultAuthorizationPolicyProvider$instance extends IAuthorizationPolicyProvider$instance {
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_DefaultAuthorizationPolicyProvider: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationPolicyProvider: never;
+
     readonly AllowsCachingPolicies: boolean;
-    GetDefaultPolicyAsync(): Task<AuthorizationPolicy>;
-    GetFallbackPolicyAsync(): Task<AuthorizationPolicy | undefined>;
-    GetPolicyAsync(policyName: string): Task<AuthorizationPolicy | undefined>;
+    GetDefaultPolicyAsync(): Task_1<AuthorizationPolicy>;
+    GetFallbackPolicyAsync(): Task_1<AuthorizationPolicy | undefined>;
+    GetPolicyAsync(policyName: string): Task_1<AuthorizationPolicy | undefined>;
 }
 
 
 export const DefaultAuthorizationPolicyProvider: {
-    new(options: IOptions<AuthorizationOptions>): DefaultAuthorizationPolicyProvider;
+    new(options: IOptions_1<AuthorizationOptions>): DefaultAuthorizationPolicyProvider;
 };
 
 
@@ -413,19 +473,21 @@ export interface __DefaultAuthorizationPolicyProvider$views {
     As_IAuthorizationPolicyProvider(): IAuthorizationPolicyProvider$instance;
 }
 
-export interface DefaultAuthorizationPolicyProvider$instance extends IAuthorizationPolicyProvider$instance {}
-
 export type DefaultAuthorizationPolicyProvider = DefaultAuthorizationPolicyProvider$instance & __DefaultAuthorizationPolicyProvider$views;
 
 
 export interface DefaultAuthorizationService$instance {
-    AuthorizeAsync(user: ClaimsPrincipal, resource: unknown, requirements: IEnumerable<IAuthorizationRequirement>): Task<AuthorizationResult>;
-    AuthorizeAsync(user: ClaimsPrincipal, resource: unknown, policyName: string): Task<AuthorizationResult>;
+    readonly __tsonic_type_Microsoft_AspNetCore_Authorization_DefaultAuthorizationService: never;
+
+    readonly __tsonic_iface_Microsoft_AspNetCore_Authorization_IAuthorizationService: never;
+
+    AuthorizeAsync(user: ClaimsPrincipal, resource: unknown, requirements: IEnumerable_1<IAuthorizationRequirement>): Task_1<AuthorizationResult>;
+    AuthorizeAsync(user: ClaimsPrincipal, resource: unknown, policyName: string): Task_1<AuthorizationResult>;
 }
 
 
 export const DefaultAuthorizationService: {
-    new(policyProvider: IAuthorizationPolicyProvider, handlers: IAuthorizationHandlerProvider, logger: ILogger<DefaultAuthorizationService>, contextFactory: IAuthorizationHandlerContextFactory, evaluator: IAuthorizationEvaluator, options: IOptions<AuthorizationOptions>): DefaultAuthorizationService;
+    new(policyProvider: IAuthorizationPolicyProvider, handlers: IAuthorizationHandlerProvider, logger: ILogger_1<DefaultAuthorizationService>, contextFactory: IAuthorizationHandlerContextFactory, evaluator: IAuthorizationEvaluator, options: IOptions_1<AuthorizationOptions>): DefaultAuthorizationService;
 };
 
 
@@ -437,10 +499,10 @@ export type DefaultAuthorizationService = DefaultAuthorizationService$instance &
 
 
 export abstract class AuthorizationServiceExtensions$instance {
-    static AuthorizeAsync(service: IAuthorizationService, user: ClaimsPrincipal, policy: AuthorizationPolicy): Task<AuthorizationResult>;
-    static AuthorizeAsync(service: IAuthorizationService, user: ClaimsPrincipal, resource: unknown, policy: AuthorizationPolicy): Task<AuthorizationResult>;
-    static AuthorizeAsync(service: IAuthorizationService, user: ClaimsPrincipal, resource: unknown, requirement: IAuthorizationRequirement): Task<AuthorizationResult>;
-    static AuthorizeAsync(service: IAuthorizationService, user: ClaimsPrincipal, policyName: string): Task<AuthorizationResult>;
+    static AuthorizeAsync(service: IAuthorizationService, user: ClaimsPrincipal, policy: AuthorizationPolicy): Task_1<AuthorizationResult>;
+    static AuthorizeAsync(service: IAuthorizationService, user: ClaimsPrincipal, resource: unknown, policy: AuthorizationPolicy): Task_1<AuthorizationResult>;
+    static AuthorizeAsync(service: IAuthorizationService, user: ClaimsPrincipal, resource: unknown, requirement: IAuthorizationRequirement): Task_1<AuthorizationResult>;
+    static AuthorizeAsync(service: IAuthorizationService, user: ClaimsPrincipal, policyName: string): Task_1<AuthorizationResult>;
 }