@tsonic/dotnet 0.7.3 → 0.7.4

package/System.Linq.Expressions/internal/index.d.ts

@@ -302,13 +302,13 @@ export const DynamicExpression: {
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression, arg1: Expression, arg2: Expression): DynamicExpression;
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression, arg1: Expression): DynamicExpression;
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression): DynamicExpression;
-    dynamic(binder: CallSiteBinder, returnType: Type, arguments: Expression[]): DynamicExpression;
+    dynamic(binder: CallSiteBinder, returnType: Type, ...arguments: Expression[]): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arguments: IEnumerable_1<Expression>): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression, arg2: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression): DynamicExpression;
-    makeDynamic(delegateType: Type, binder: CallSiteBinder, arguments: Expression[]): DynamicExpression;
+    makeDynamic(delegateType: Type, binder: CallSiteBinder, ...arguments: Expression[]): DynamicExpression;
 };
 
 
@@ -387,26 +387,26 @@ export const Expression: {
     andAssign(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     andAssign(left: Expression, right: Expression): BinaryExpression;
     arrayAccess(array: Expression, indexes: IEnumerable_1<Expression>): IndexExpression;
-    arrayAccess(array: Expression, indexes: Expression[]): IndexExpression;
+    arrayAccess(array: Expression, ...indexes: Expression[]): IndexExpression;
     arrayIndex(array: Expression, indexes: IEnumerable_1<Expression>): MethodCallExpression;
     arrayIndex(array: Expression, index: Expression): BinaryExpression;
-    arrayIndex(array: Expression, indexes: Expression[]): MethodCallExpression;
+    arrayIndex(array: Expression, ...indexes: Expression[]): MethodCallExpression;
     arrayLength(array: Expression): UnaryExpression;
     assign(left: Expression, right: Expression): BinaryExpression;
     bind(member: MemberInfo, expression: Expression): MemberAssignment;
     bind(propertyAccessor: MethodInfo, expression: Expression): MemberAssignment;
     block(expressions: IEnumerable_1<Expression>): BlockExpression;
     block(variables: IEnumerable_1<ParameterExpression>, expressions: IEnumerable_1<Expression>): BlockExpression;
-    block(variables: IEnumerable_1<ParameterExpression>, expressions: Expression[]): BlockExpression;
+    block(variables: IEnumerable_1<ParameterExpression>, ...expressions: Expression[]): BlockExpression;
     block(arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression, arg4: Expression): BlockExpression;
     block(arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression): BlockExpression;
     block(arg0: Expression, arg1: Expression, arg2: Expression): BlockExpression;
     block(arg0: Expression, arg1: Expression): BlockExpression;
-    block(expressions: Expression[]): BlockExpression;
+    block(...expressions: Expression[]): BlockExpression;
     block(type_: Type, expressions: IEnumerable_1<Expression>): BlockExpression;
     block(type_: Type, variables: IEnumerable_1<ParameterExpression>, expressions: IEnumerable_1<Expression>): BlockExpression;
-    block(type_: Type, variables: IEnumerable_1<ParameterExpression>, expressions: Expression[]): BlockExpression;
-    block(type_: Type, expressions: Expression[]): BlockExpression;
+    block(type_: Type, variables: IEnumerable_1<ParameterExpression>, ...expressions: Expression[]): BlockExpression;
+    block(type_: Type, ...expressions: Expression[]): BlockExpression;
     break_(target: LabelTarget, value: Expression, type_: Type): GotoExpression;
     break_(target: LabelTarget, value: Expression): GotoExpression;
     break_(target: LabelTarget, type_: Type): GotoExpression;
@@ -414,17 +414,17 @@ export const Expression: {
     call(instance: Expression, method: MethodInfo, arguments: IEnumerable_1<Expression>): MethodCallExpression;
     call(instance: Expression, method: MethodInfo, arg0: Expression, arg1: Expression, arg2: Expression): MethodCallExpression;
     call(instance: Expression, method: MethodInfo, arg0: Expression, arg1: Expression): MethodCallExpression;
-    call(instance: Expression, method: MethodInfo, arguments: Expression[]): MethodCallExpression;
+    call(instance: Expression, method: MethodInfo, ...arguments: Expression[]): MethodCallExpression;
     call(instance: Expression, method: MethodInfo): MethodCallExpression;
-    call(instance: Expression, methodName: string, typeArguments: Type[], arguments: Expression[]): MethodCallExpression;
+    call(instance: Expression, methodName: string, typeArguments: Type[], ...arguments: Expression[]): MethodCallExpression;
     call(method: MethodInfo, arguments: IEnumerable_1<Expression>): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression, arg4: Expression): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression, arg1: Expression, arg2: Expression): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression, arg1: Expression): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression): MethodCallExpression;
-    call(method: MethodInfo, arguments: Expression[]): MethodCallExpression;
-    call(type_: Type, methodName: string, typeArguments: Type[], arguments: Expression[]): MethodCallExpression;
+    call(method: MethodInfo, ...arguments: Expression[]): MethodCallExpression;
+    call(type_: Type, methodName: string, typeArguments: Type[], ...arguments: Expression[]): MethodCallExpression;
     catch_(variable: ParameterExpression, body: Expression, filter: Expression): CatchBlock;
     catch_(variable: ParameterExpression, body: Expression): CatchBlock;
     catch_(type_: Type, body: Expression, filter: Expression): CatchBlock;
@@ -456,9 +456,9 @@ export const Expression: {
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression, arg1: Expression, arg2: Expression): DynamicExpression;
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression, arg1: Expression): DynamicExpression;
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression): DynamicExpression;
-    dynamic(binder: CallSiteBinder, returnType: Type, arguments: Expression[]): DynamicExpression;
+    dynamic(binder: CallSiteBinder, returnType: Type, ...arguments: Expression[]): DynamicExpression;
     elementInit(addMethod: MethodInfo, arguments: IEnumerable_1<Expression>): ElementInit;
-    elementInit(addMethod: MethodInfo, arguments: Expression[]): ElementInit;
+    elementInit(addMethod: MethodInfo, ...arguments: Expression[]): ElementInit;
     empty(): DefaultExpression;
     equal(left: Expression, right: Expression, liftToNull: boolean, method: MethodInfo): BinaryExpression;
     equal(left: Expression, right: Expression): BinaryExpression;
@@ -470,9 +470,9 @@ export const Expression: {
     field(expression: Expression, field: FieldInfo): MemberExpression;
     field(expression: Expression, fieldName: string): MemberExpression;
     field(expression: Expression, type_: Type, fieldName: string): MemberExpression;
-    getActionType(typeArgs: Type[]): Type;
-    getDelegateType(typeArgs: Type[]): Type;
-    getFuncType(typeArgs: Type[]): Type;
+    getActionType(...typeArgs: Type[]): Type;
+    getDelegateType(...typeArgs: Type[]): Type;
+    getFuncType(...typeArgs: Type[]): Type;
     goto(target: LabelTarget, value: Expression, type_: Type): GotoExpression;
     goto(target: LabelTarget, value: Expression): GotoExpression;
     goto(target: LabelTarget, type_: Type): GotoExpression;
@@ -486,7 +486,7 @@ export const Expression: {
     increment(expression: Expression, method: MethodInfo): UnaryExpression;
     increment(expression: Expression): UnaryExpression;
     invoke(expression: Expression, arguments: IEnumerable_1<Expression>): InvocationExpression;
-    invoke(expression: Expression, arguments: Expression[]): InvocationExpression;
+    invoke(expression: Expression, ...arguments: Expression[]): InvocationExpression;
     isFalse(expression: Expression, method: MethodInfo): UnaryExpression;
     isFalse(expression: Expression): UnaryExpression;
     isTrue(expression: Expression, method: MethodInfo): UnaryExpression;
@@ -499,20 +499,20 @@ export const Expression: {
     label(type_: Type): LabelTarget;
     lambda<TDelegate>(body: Expression, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): Expression_1<TDelegate>;
     lambda(body: Expression, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
-    lambda<TDelegate>(body: Expression, tailCall: boolean, parameters: ParameterExpression[]): Expression_1<TDelegate>;
-    lambda(body: Expression, tailCall: boolean, parameters: ParameterExpression[]): LambdaExpression;
+    lambda<TDelegate>(body: Expression, tailCall: boolean, ...parameters: ParameterExpression[]): Expression_1<TDelegate>;
+    lambda(body: Expression, tailCall: boolean, ...parameters: ParameterExpression[]): LambdaExpression;
     lambda<TDelegate>(body: Expression, parameters: IEnumerable_1<ParameterExpression>): Expression_1<TDelegate>;
     lambda(body: Expression, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
-    lambda<TDelegate>(body: Expression, parameters: ParameterExpression[]): Expression_1<TDelegate>;
-    lambda(body: Expression, parameters: ParameterExpression[]): LambdaExpression;
+    lambda<TDelegate>(body: Expression, ...parameters: ParameterExpression[]): Expression_1<TDelegate>;
+    lambda(body: Expression, ...parameters: ParameterExpression[]): LambdaExpression;
     lambda<TDelegate>(body: Expression, name: string, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): Expression_1<TDelegate>;
     lambda(body: Expression, name: string, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
     lambda<TDelegate>(body: Expression, name: string, parameters: IEnumerable_1<ParameterExpression>): Expression_1<TDelegate>;
     lambda(body: Expression, name: string, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
     lambda(delegateType: Type, body: Expression, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
-    lambda(delegateType: Type, body: Expression, tailCall: boolean, parameters: ParameterExpression[]): LambdaExpression;
+    lambda(delegateType: Type, body: Expression, tailCall: boolean, ...parameters: ParameterExpression[]): LambdaExpression;
     lambda(delegateType: Type, body: Expression, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
-    lambda(delegateType: Type, body: Expression, parameters: ParameterExpression[]): LambdaExpression;
+    lambda(delegateType: Type, body: Expression, ...parameters: ParameterExpression[]): LambdaExpression;
     lambda(delegateType: Type, body: Expression, name: string, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
     lambda(delegateType: Type, body: Expression, name: string, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
     leftShift(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
@@ -525,15 +525,15 @@ export const Expression: {
     lessThanOrEqual(left: Expression, right: Expression, liftToNull: boolean, method: MethodInfo): BinaryExpression;
     lessThanOrEqual(left: Expression, right: Expression): BinaryExpression;
     listBind(member: MemberInfo, initializers: IEnumerable_1<ElementInit>): MemberListBinding;
-    listBind(member: MemberInfo, initializers: ElementInit[]): MemberListBinding;
+    listBind(member: MemberInfo, ...initializers: ElementInit[]): MemberListBinding;
     listBind(propertyAccessor: MethodInfo, initializers: IEnumerable_1<ElementInit>): MemberListBinding;
-    listBind(propertyAccessor: MethodInfo, initializers: ElementInit[]): MemberListBinding;
+    listBind(propertyAccessor: MethodInfo, ...initializers: ElementInit[]): MemberListBinding;
     listInit(newExpression: NewExpression, initializers: IEnumerable_1<ElementInit>): ListInitExpression;
     listInit(newExpression: NewExpression, initializers: IEnumerable_1<Expression>): ListInitExpression;
-    listInit(newExpression: NewExpression, initializers: ElementInit[]): ListInitExpression;
-    listInit(newExpression: NewExpression, initializers: Expression[]): ListInitExpression;
+    listInit(newExpression: NewExpression, ...initializers: ElementInit[]): ListInitExpression;
+    listInit(newExpression: NewExpression, ...initializers: Expression[]): ListInitExpression;
     listInit(newExpression: NewExpression, addMethod: MethodInfo, initializers: IEnumerable_1<Expression>): ListInitExpression;
-    listInit(newExpression: NewExpression, addMethod: MethodInfo, initializers: Expression[]): ListInitExpression;
+    listInit(newExpression: NewExpression, addMethod: MethodInfo, ...initializers: Expression[]): ListInitExpression;
     loop(body: Expression, break_: LabelTarget, continue_: LabelTarget): LoopExpression;
     loop(body: Expression, break_: LabelTarget): LoopExpression;
     loop(body: Expression): LoopExpression;
@@ -546,7 +546,7 @@ export const Expression: {
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression, arg2: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression): DynamicExpression;
-    makeDynamic(delegateType: Type, binder: CallSiteBinder, arguments: Expression[]): DynamicExpression;
+    makeDynamic(delegateType: Type, binder: CallSiteBinder, ...arguments: Expression[]): DynamicExpression;
     makeGoto(kind: GotoExpressionKind, target: LabelTarget, value: Expression, type_: Type): GotoExpression;
     makeIndex(instance: Expression, indexer: PropertyInfo, arguments: IEnumerable_1<Expression>): IndexExpression;
     makeMemberAccess(expression: Expression, member: MemberInfo): MemberExpression;
@@ -554,11 +554,11 @@ export const Expression: {
     makeUnary(unaryType: ExpressionType, operand: Expression, type_: Type, method: MethodInfo): UnaryExpression;
     makeUnary(unaryType: ExpressionType, operand: Expression, type_: Type): UnaryExpression;
     memberBind(member: MemberInfo, bindings: IEnumerable_1<MemberBinding>): MemberMemberBinding;
-    memberBind(member: MemberInfo, bindings: MemberBinding[]): MemberMemberBinding;
+    memberBind(member: MemberInfo, ...bindings: MemberBinding[]): MemberMemberBinding;
     memberBind(propertyAccessor: MethodInfo, bindings: IEnumerable_1<MemberBinding>): MemberMemberBinding;
-    memberBind(propertyAccessor: MethodInfo, bindings: MemberBinding[]): MemberMemberBinding;
+    memberBind(propertyAccessor: MethodInfo, ...bindings: MemberBinding[]): MemberMemberBinding;
     memberInit(newExpression: NewExpression, bindings: IEnumerable_1<MemberBinding>): MemberInitExpression;
-    memberInit(newExpression: NewExpression, bindings: MemberBinding[]): MemberInitExpression;
+    memberInit(newExpression: NewExpression, ...bindings: MemberBinding[]): MemberInitExpression;
     modulo(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     modulo(left: Expression, right: Expression): BinaryExpression;
     moduloAssign(left: Expression, right: Expression, method: MethodInfo, conversion: LambdaExpression): BinaryExpression;
@@ -579,15 +579,15 @@ export const Expression: {
     negateChecked(expression: Expression, method: MethodInfo): UnaryExpression;
     negateChecked(expression: Expression): UnaryExpression;
     new_(constructor_: ConstructorInfo, arguments: IEnumerable_1<Expression>, members: IEnumerable_1<MemberInfo>): NewExpression;
-    new_(constructor_: ConstructorInfo, arguments: IEnumerable_1<Expression>, members: MemberInfo[]): NewExpression;
+    new_(constructor_: ConstructorInfo, arguments: IEnumerable_1<Expression>, ...members: MemberInfo[]): NewExpression;
     new_(constructor_: ConstructorInfo, arguments: IEnumerable_1<Expression>): NewExpression;
-    new_(constructor_: ConstructorInfo, arguments: Expression[]): NewExpression;
+    new_(constructor_: ConstructorInfo, ...arguments: Expression[]): NewExpression;
     new_(constructor_: ConstructorInfo): NewExpression;
     new_(type_: Type): NewExpression;
     newArrayBounds(type_: Type, bounds: IEnumerable_1<Expression>): NewArrayExpression;
-    newArrayBounds(type_: Type, bounds: Expression[]): NewArrayExpression;
+    newArrayBounds(type_: Type, ...bounds: Expression[]): NewArrayExpression;
     newArrayInit(type_: Type, initializers: IEnumerable_1<Expression>): NewArrayExpression;
-    newArrayInit(type_: Type, initializers: Expression[]): NewArrayExpression;
+    newArrayInit(type_: Type, ...initializers: Expression[]): NewArrayExpression;
     not(expression: Expression, method: MethodInfo): UnaryExpression;
     not(expression: Expression): UnaryExpression;
     notEqual(left: Expression, right: Expression, liftToNull: boolean, method: MethodInfo): BinaryExpression;
@@ -618,9 +618,9 @@ export const Expression: {
     preIncrementAssign(expression: Expression): UnaryExpression;
     property(expression: Expression, propertyAccessor: MethodInfo): MemberExpression;
     property(instance: Expression, indexer: PropertyInfo, arguments: IEnumerable_1<Expression>): IndexExpression;
-    property(instance: Expression, indexer: PropertyInfo, arguments: Expression[]): IndexExpression;
+    property(instance: Expression, indexer: PropertyInfo, ...arguments: Expression[]): IndexExpression;
     property(expression: Expression, property: PropertyInfo): MemberExpression;
-    property(instance: Expression, propertyName: string, arguments: Expression[]): IndexExpression;
+    property(instance: Expression, propertyName: string, ...arguments: Expression[]): IndexExpression;
     property(expression: Expression, propertyName: string): MemberExpression;
     property(expression: Expression, type_: Type, propertyName: string): MemberExpression;
     propertyOrField(expression: Expression, propertyOrFieldName: string): MemberExpression;
@@ -639,7 +639,7 @@ export const Expression: {
     rightShiftAssign(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     rightShiftAssign(left: Expression, right: Expression): BinaryExpression;
     runtimeVariables(variables: IEnumerable_1<ParameterExpression>): RuntimeVariablesExpression;
-    runtimeVariables(variables: ParameterExpression[]): RuntimeVariablesExpression;
+    runtimeVariables(...variables: ParameterExpression[]): RuntimeVariablesExpression;
     subtract(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     subtract(left: Expression, right: Expression): BinaryExpression;
     subtractAssign(left: Expression, right: Expression, method: MethodInfo, conversion: LambdaExpression): BinaryExpression;
@@ -650,22 +650,22 @@ export const Expression: {
     subtractAssignChecked(left: Expression, right: Expression): BinaryExpression;
     subtractChecked(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     subtractChecked(left: Expression, right: Expression): BinaryExpression;
-    switch_(switchValue: Expression, defaultBody: Expression, cases: SwitchCase[]): SwitchExpression;
+    switch_(switchValue: Expression, defaultBody: Expression, ...cases: SwitchCase[]): SwitchExpression;
     switch_(switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, cases: IEnumerable_1<SwitchCase>): SwitchExpression;
-    switch_(switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, cases: SwitchCase[]): SwitchExpression;
-    switch_(switchValue: Expression, cases: SwitchCase[]): SwitchExpression;
+    switch_(switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, ...cases: SwitchCase[]): SwitchExpression;
+    switch_(switchValue: Expression, ...cases: SwitchCase[]): SwitchExpression;
     switch_(type_: Type, switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, cases: IEnumerable_1<SwitchCase>): SwitchExpression;
-    switch_(type_: Type, switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, cases: SwitchCase[]): SwitchExpression;
+    switch_(type_: Type, switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, ...cases: SwitchCase[]): SwitchExpression;
     switchCase(body: Expression, testValues: IEnumerable_1<Expression>): SwitchCase;
-    switchCase(body: Expression, testValues: Expression[]): SwitchCase;
+    switchCase(body: Expression, ...testValues: Expression[]): SwitchCase;
     symbolDocument(fileName: string, language: Guid, languageVendor: Guid, documentType: Guid): SymbolDocumentInfo;
     symbolDocument(fileName: string, language: Guid, languageVendor: Guid): SymbolDocumentInfo;
     symbolDocument(fileName: string, language: Guid): SymbolDocumentInfo;
     symbolDocument(fileName: string): SymbolDocumentInfo;
     throw_(value: Expression, type_: Type): UnaryExpression;
     throw_(value: Expression): UnaryExpression;
-    tryCatch(body: Expression, handlers: CatchBlock[]): TryExpression;
-    tryCatchFinally(body: Expression, finally_: Expression, handlers: CatchBlock[]): TryExpression;
+    tryCatch(body: Expression, ...handlers: CatchBlock[]): TryExpression;
+    tryCatchFinally(body: Expression, finally_: Expression, ...handlers: CatchBlock[]): TryExpression;
     tryFault(body: Expression, fault: Expression): TryExpression;
     tryFinally(body: Expression, finally_: Expression): TryExpression;
     tryGetActionType(typeArgs: Type[], actionType: { value: ref<Type> }): boolean;

package/System.Linq.Expressions.Interpreter/internal/index.d.ts

@@ -35,8 +35,8 @@ export type CLROf<T> =
     T; // Identity fallback for non-primitive types
 
 export interface LightLambda$instance {
-    run(arguments: unknown[]): unknown;
-    runVoid(arguments: unknown[]): unknown;
+    run(...arguments: unknown[]): unknown;
+    runVoid(...arguments: unknown[]): unknown;
 }
 
 

package/System.Linq.Expressions.d.ts

@@ -14,7 +14,6 @@ import type { Boolean as ClrBoolean, Delegate, Enum, Func_2, Guid, IComparable,
 
 // Public API exports (curated - no internal $instance/$views leakage)
 export { BinaryExpression as BinaryExpression } from './System.Linq.Expressions/internal/index.js';
-export { Expression as Expression_0 } from './System.Linq.Expressions/internal/index.js';
 export { BlockExpression as BlockExpression } from './System.Linq.Expressions/internal/index.js';
 export { CatchBlock as CatchBlock } from './System.Linq.Expressions/internal/index.js';
 export { ConditionalExpression as ConditionalExpression } from './System.Linq.Expressions/internal/index.js';
@@ -33,7 +32,6 @@ export { InvocationExpression as InvocationExpression } from './System.Linq.Expr
 export { LabelExpression as LabelExpression } from './System.Linq.Expressions/internal/index.js';
 export { LabelTarget as LabelTarget } from './System.Linq.Expressions/internal/index.js';
 export { LambdaExpression as LambdaExpression } from './System.Linq.Expressions/internal/index.js';
-export { Expression_1 as Expression } from './System.Linq.Expressions/internal/index.js';
 export { ListInitExpression as ListInitExpression } from './System.Linq.Expressions/internal/index.js';
 export { LoopExpression as LoopExpression } from './System.Linq.Expressions/internal/index.js';
 export { MemberAssignment as MemberAssignment } from './System.Linq.Expressions/internal/index.js';
@@ -56,3 +54,14 @@ export { TypeBinaryExpression as TypeBinaryExpression } from './System.Linq.Expr
 export { UnaryExpression as UnaryExpression } from './System.Linq.Expressions/internal/index.js';
 export { DynamicExpressionVisitor as DynamicExpressionVisitor } from './System.Linq.Expressions/internal/index.js';
 export { DynamicExpression as DynamicExpression } from './System.Linq.Expressions/internal/index.js';
+
+// Multi-arity family sentinel (detects unspecified type parameters)
+declare const __unspecified: unique symbol;
+export type __ = typeof __unspecified;
+
+export type Expression<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.Expression :
+  Internal.Expression_1<T1>;
+

package/System.Linq.d.ts

@@ -25,19 +25,44 @@ export { Lookup_2 as Lookup } from './System.Linq/internal/index.js';
 export type IOrderedEnumerable<TElement> = Internal.IOrderedEnumerable_1<TElement>;
 export { AsyncEnumerable$instance as AsyncEnumerable } from './System.Linq/internal/index.js';
 export type IOrderedAsyncEnumerable<TElement> = Internal.IOrderedAsyncEnumerable_1<TElement>;
-export type IQueryable_0 = Internal.IQueryable;
-export type IQueryable<T> = Internal.IQueryable_1<T>;
 export type IQueryProvider = Internal.IQueryProvider;
-export type IOrderedQueryable_0 = Internal.IOrderedQueryable;
-export type IOrderedQueryable<T> = Internal.IOrderedQueryable_1<T>;
 export { OrderedParallelQuery_1 as OrderedParallelQuery } from './System.Linq/internal/index.js';
-export { ParallelQuery as ParallelQuery_0 } from './System.Linq/internal/index.js';
-export { ParallelQuery_1 as ParallelQuery } from './System.Linq/internal/index.js';
 export { ParallelEnumerable$instance as ParallelEnumerable } from './System.Linq/internal/index.js';
 export { ParallelExecutionMode as ParallelExecutionMode } from './System.Linq/internal/index.js';
 export { ParallelMergeOptions as ParallelMergeOptions } from './System.Linq/internal/index.js';
-export { EnumerableExecutor as EnumerableExecutor_0 } from './System.Linq/internal/index.js';
-export { EnumerableExecutor_1 as EnumerableExecutor } from './System.Linq/internal/index.js';
-export { EnumerableQuery as EnumerableQuery_0 } from './System.Linq/internal/index.js';
-export { EnumerableQuery_1 as EnumerableQuery } from './System.Linq/internal/index.js';
 export { Queryable$instance as Queryable } from './System.Linq/internal/index.js';
+
+// Multi-arity family sentinel (detects unspecified type parameters)
+declare const __unspecified: unique symbol;
+export type __ = typeof __unspecified;
+
+export type EnumerableExecutor<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.EnumerableExecutor :
+  Internal.EnumerableExecutor_1<T1>;
+
+export type EnumerableQuery<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.EnumerableQuery :
+  Internal.EnumerableQuery_1<T1>;
+
+export type IOrderedQueryable<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.IOrderedQueryable :
+  Internal.IOrderedQueryable_1<T1>;
+
+export type IQueryable<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.IQueryable :
+  Internal.IQueryable_1<T1>;
+
+export type ParallelQuery<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.ParallelQuery :
+  Internal.ParallelQuery_1<T1>;
+

package/System.Net/internal/index.d.ts

@@ -452,7 +452,8 @@ export interface __IPNetwork$views {
     As_IUtf8SpanParsable_1(): System_Internal.IUtf8SpanParsable_1$instance<IPNetwork>;
 
     // Structural method bridges for numeric interface constraints
-    Equals(other: IPNetwork): boolean;
+    equals(other: IPNetwork): boolean;
+    tryFormat(utf8Destination: import("../../System/internal/index").Span_1<import("../../System/internal/index").CLROf<byte>>, bytesWritten: { value: ref<int> }, format: import("../../System/internal/index").ReadOnlySpan_1<import("../../System/internal/index").CLROf<char>>, provider: import("../../System/internal/index").IFormatProvider): boolean;
 }
 
 export interface IPNetwork$instance extends System_Internal.ISpanParsable_1$instance<IPNetwork> {}
@@ -1270,6 +1271,9 @@ export interface __IPAddress$views {
     As_ISpanParsable_1(): System_Internal.ISpanParsable_1$instance<IPAddress>;
     As_IUtf8SpanFormattable(): System_Internal.IUtf8SpanFormattable$instance;
     As_IUtf8SpanParsable_1(): System_Internal.IUtf8SpanParsable_1$instance<IPAddress>;
+
+    // Structural method bridges for numeric interface constraints
+    tryFormat(utf8Destination: import("../../System/internal/index").Span_1<import("../../System/internal/index").CLROf<byte>>, bytesWritten: { value: ref<int> }, format: import("../../System/internal/index").ReadOnlySpan_1<import("../../System/internal/index").CLROf<char>>, provider: import("../../System/internal/index").IFormatProvider): boolean;
 }
 
 export interface IPAddress$instance extends System_Internal.ISpanParsable_1$instance<IPAddress> {}
@@ -1477,7 +1481,7 @@ export interface __SocketAddress$views {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<SocketAddress>;
 
     // Structural method bridges for numeric interface constraints
-    Equals(other: SocketAddress): boolean;
+    equals(other: SocketAddress): boolean;
 }
 
 export type SocketAddress = SocketAddress$instance & __SocketAddress$views;

package/System.Net.Http/internal/index.d.ts

@@ -396,7 +396,7 @@ export interface __HttpMethod$views {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<HttpMethod>;
 
     // Structural method bridges for numeric interface constraints
-    Equals(other: HttpMethod): boolean;
+    equals(other: HttpMethod): boolean;
 }
 
 export type HttpMethod = HttpMethod$instance & __HttpMethod$views;

package/System.Net.Security/internal/index.d.ts

@@ -476,7 +476,7 @@ export interface __SslApplicationProtocol$views {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<SslApplicationProtocol>;
 
     // Structural method bridges for numeric interface constraints
-    Equals(other: SslApplicationProtocol): boolean;
+    equals(other: SslApplicationProtocol): boolean;
 }
 
 export type SslApplicationProtocol = SslApplicationProtocol$instance & __SslApplicationProtocol$views;

package/System.Net.ServerSentEvents.d.ts

@@ -17,7 +17,16 @@ import type { Action_2, AsyncCallback, Boolean as ClrBoolean, Byte, Delegate, IA
 
 // Public API exports (curated - no internal $instance/$views leakage)
 export { SseFormatter$instance as SseFormatter } from './System.Net.ServerSentEvents/internal/index.js';
-export { SseParser_1 as SseParser } from './System.Net.ServerSentEvents/internal/index.js';
 export { SseItem_1 as SseItem } from './System.Net.ServerSentEvents/internal/index.js';
 export type SseItemParser<T> = Internal.SseItemParser_1<T>;
-export { SseParser$instance as SseParser_0 } from './System.Net.ServerSentEvents/internal/index.js';
+
+// Multi-arity family sentinel (detects unspecified type parameters)
+declare const __unspecified: unique symbol;
+export type __ = typeof __unspecified;
+
+export type SseParser<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.SseParser :
+  Internal.SseParser_1<T1>;
+

package/System.Net.Sockets/internal/index.d.ts

@@ -402,7 +402,7 @@ export interface __IPPacketInformation$views {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<IPPacketInformation>;
 
     // Structural method bridges for numeric interface constraints
-    Equals(other: IPPacketInformation): boolean;
+    equals(other: IPPacketInformation): boolean;
 }
 
 export type IPPacketInformation = IPPacketInformation$instance & __IPPacketInformation$views;
@@ -467,7 +467,7 @@ export interface __UdpReceiveResult$views {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<UdpReceiveResult>;
 
     // Structural method bridges for numeric interface constraints
-    Equals(other: UdpReceiveResult): boolean;
+    equals(other: UdpReceiveResult): boolean;
 }
 
 export type UdpReceiveResult = UdpReceiveResult$instance & __UdpReceiveResult$views;