@tsonic/efcore-sqlserver 0.1.2 → 10.0.2

package/System.ClientModel.Primitives/internal/index.d.ts

@@ -21,62 +21,62 @@ import type { Activity, ActivityContext, ActivityKind, ActivitySource } from "@t
 import type { Stream } from "@tsonic/dotnet/System.IO.js";
 import * as System_Lib from "@tsonic/dotnet/System.js";
 import type { Attribute, Boolean as ClrBoolean, DateTimeOffset, Enum, Exception, Func, IComparable, IConvertible, IDisposable, IFormattable, Int32, ISpanFormattable, Nullable, Object as ClrObject, ReadOnlySpan, String as ClrString, TimeSpan, Type, UInt16, Uri, ValueType, Void } from "@tsonic/dotnet/System.js";
-import type { HttpClient } from "@tsonic/dotnet/System.Net.Http.js";
+import type { HttpClient, HttpRequestMessage, HttpResponseMessage } from "@tsonic/dotnet/System.Net.Http.js";
 import type { JsonSerializerOptions, Utf8JsonReader, Utf8JsonWriter } from "@tsonic/dotnet/System.Text.Json.js";
 import * as System_Text_Json_Serialization_Internal from "@tsonic/dotnet/System.Text.Json.Serialization.js";
 import type { JsonConverter } from "@tsonic/dotnet/System.Text.Json.Serialization.js";
 import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
-import type { ValueTask } from "@tsonic/dotnet/System.Threading.Tasks.js";
+import type { Task, ValueTask } from "@tsonic/dotnet/System.Threading.Tasks.js";
 import type { ILoggerFactory } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging.js";
 
 export enum ClientErrorBehaviors {
-    default = 0,
-    noThrow = 1
+    Default = 0,
+    NoThrow = 1
 }
 
 
 export enum CredentialKind {
-    none = 0,
-    apiKeyString = 1,
-    tokenCredential = 2
+    None = 0,
+    ApiKeyString = 1,
+    TokenCredential = 2
 }
 
 
 export enum PipelinePosition {
-    perCall = 0,
-    perTry = 1,
-    beforeTransport = 2
+    PerCall = 0,
+    PerTry = 1,
+    BeforeTransport = 2
 }
 
 
 export interface IJsonModel_1$instance<T> extends IPersistableModel_1<T> {
-    create(reader: Utf8JsonReader, options: ModelReaderWriterOptions): T | undefined;
-    create(data: BinaryData, options: ModelReaderWriterOptions): T | undefined;
-    create(data: BinaryData, options: ModelReaderWriterOptions): T;
-    getFormatFromOptions(options: ModelReaderWriterOptions): string;
-    write(writer: Utf8JsonWriter, options: ModelReaderWriterOptions): void;
-    write(options: ModelReaderWriterOptions): BinaryData;
+    Create(reader: Utf8JsonReader, options: ModelReaderWriterOptions): T | undefined;
+    Create(data: BinaryData, options: ModelReaderWriterOptions): T | undefined;
+    Create(data: BinaryData, options: ModelReaderWriterOptions): T;
+    GetFormatFromOptions(options: ModelReaderWriterOptions): string;
+    Write(writer: Utf8JsonWriter, options: ModelReaderWriterOptions): void;
+    Write(options: ModelReaderWriterOptions): BinaryData;
 }
 
 
 export type IJsonModel_1<T> = IJsonModel_1$instance<T>;
 
 export interface IPersistableModel_1$instance<T> {
-    create(data: BinaryData, options: ModelReaderWriterOptions): T | undefined;
-    getFormatFromOptions(options: ModelReaderWriterOptions): string;
-    write(options: ModelReaderWriterOptions): BinaryData;
+    Create(data: BinaryData, options: ModelReaderWriterOptions): T | undefined;
+    GetFormatFromOptions(options: ModelReaderWriterOptions): string;
+    Write(options: ModelReaderWriterOptions): BinaryData;
 }
 
 
 export type IPersistableModel_1<T> = IPersistableModel_1$instance<T>;
 
 export interface ClientConnection$instance {
-    readonly credential: unknown | undefined;
-    readonly credentialKind: CredentialKind;
-    readonly id: string;
-    readonly locator: string;
-    toString(): string;
-    tryGetLocatorAsUri(uri: Uri): boolean;
+    readonly Credential: unknown | undefined;
+    readonly CredentialKind: CredentialKind;
+    readonly Id: string;
+    readonly Locator: string;
+    ToString(): string;
+    TryGetLocatorAsUri(uri: Uri): boolean;
 }
 
 
@@ -89,28 +89,29 @@ export const ClientConnection: {
 export type ClientConnection = ClientConnection$instance;
 
 export interface ApiKeyAuthenticationPolicy$instance extends AuthenticationPolicy {
-    process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
-    processAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
+    Process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
+    ProcessAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
 }
 
 
 export const ApiKeyAuthenticationPolicy: {
     new(): ApiKeyAuthenticationPolicy;
-    createBasicAuthorizationPolicy(credential: ApiKeyCredential): ApiKeyAuthenticationPolicy;
-    createBearerAuthorizationPolicy(credential: ApiKeyCredential): ApiKeyAuthenticationPolicy;
-    createHeaderApiKeyPolicy(credential: ApiKeyCredential, headerName: string, keyPrefix?: string): ApiKeyAuthenticationPolicy;
+    CreateBasicAuthorizationPolicy(credential: ApiKeyCredential): ApiKeyAuthenticationPolicy;
+    CreateBearerAuthorizationPolicy(credential: ApiKeyCredential): ApiKeyAuthenticationPolicy;
+    CreateHeaderApiKeyPolicy(credential: ApiKeyCredential, headerName: string, keyPrefix?: string): ApiKeyAuthenticationPolicy;
 };
 
 
 export type ApiKeyAuthenticationPolicy = ApiKeyAuthenticationPolicy$instance;
 
 export interface AsyncCollectionResult$instance {
-    getContinuationToken(page: ClientResult): ContinuationToken | undefined;
-    getRawPagesAsync(): IAsyncEnumerable<ClientResult>;
+    GetContinuationToken(page: ClientResult): ContinuationToken | undefined;
+    GetRawPagesAsync(): IAsyncEnumerable<ClientResult>;
 }
 
 
 export const AsyncCollectionResult: {
+    new(): AsyncCollectionResult;
 };
 
 
@@ -121,16 +122,17 @@ export interface AuthenticationPolicy$instance extends PipelinePolicy {
 
 
 export const AuthenticationPolicy: {
+    new(): AuthenticationPolicy;
 };
 
 
 export type AuthenticationPolicy = AuthenticationPolicy$instance;
 
 export interface AuthenticationToken$instance {
-    readonly expiresOn: Nullable<DateTimeOffset>;
-    readonly refreshOn: Nullable<DateTimeOffset>;
-    readonly tokenType: string;
-    readonly tokenValue: string;
+    readonly ExpiresOn: Nullable<DateTimeOffset>;
+    readonly RefreshOn: Nullable<DateTimeOffset>;
+    readonly TokenType: string;
+    readonly TokenValue: string;
 }
 
 
@@ -142,8 +144,8 @@ export const AuthenticationToken: {
 export type AuthenticationToken = AuthenticationToken$instance;
 
 export interface BearerTokenPolicy$instance extends AuthenticationPolicy {
-    process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
-    processAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
+    Process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
+    ProcessAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
 }
 
 
@@ -156,7 +158,7 @@ export const BearerTokenPolicy: {
 export type BearerTokenPolicy = BearerTokenPolicy$instance;
 
 export interface ClientCache$instance {
-    getClient<T>(clientId: unknown, createClient: Func<T>): T;
+    GetClient<T>(clientId: unknown, createClient: Func<T>): T;
 }
 
 
@@ -167,8 +169,13 @@ export const ClientCache: {
 
 export type ClientCache = ClientCache$instance;
 
-export interface ClientConnectionCollection$instance extends KeyedCollection<System_Internal.String, ClientConnection> {
-    addRange(connections: IEnumerable__System_Collections_Generic<ClientConnection>): void;
+export abstract class ClientConnectionCollection$protected {
+    protected GetKeyForItem(item: ClientConnection): string;
+}
+
+
+export interface ClientConnectionCollection$instance extends ClientConnectionCollection$protected, KeyedCollection<System_Internal.String, ClientConnection> {
+    AddRange(connections: IEnumerable__System_Collections_Generic<ClientConnection>): void;
 }
 
 
@@ -180,28 +187,29 @@ export const ClientConnectionCollection: {
 export type ClientConnectionCollection = ClientConnectionCollection$instance;
 
 export interface ClientConnectionProvider$instance {
-    readonly subclients: ClientCache;
-    getAllConnections(): IEnumerable__System_Collections_Generic<ClientConnection>;
-    getConnection(connectionId: string): ClientConnection;
+    readonly Subclients: ClientCache;
+    GetAllConnections(): IEnumerable__System_Collections_Generic<ClientConnection>;
+    GetConnection(connectionId: string): ClientConnection;
 }
 
 
 export const ClientConnectionProvider: {
+    new(maxCacheSize: int): ClientConnectionProvider;
 };
 
 
 export type ClientConnectionProvider = ClientConnectionProvider$instance;
 
 export interface ClientLoggingOptions$instance {
-    readonly allowedHeaderNames: IList__System_Collections_Generic<System_Internal.String>;
-    readonly allowedQueryParameters: IList__System_Collections_Generic<System_Internal.String>;
-    enableLogging: Nullable<System_Internal.Boolean>;
-    enableMessageContentLogging: Nullable<System_Internal.Boolean>;
-    enableMessageLogging: Nullable<System_Internal.Boolean>;
-    get loggerFactory(): ILoggerFactory | undefined;
-    set loggerFactory(value: ILoggerFactory);
-    messageContentSizeLimit: Nullable<System_Internal.Int32>;
-    freeze(): void;
+    readonly AllowedHeaderNames: IList__System_Collections_Generic<System_Internal.String>;
+    readonly AllowedQueryParameters: IList__System_Collections_Generic<System_Internal.String>;
+    EnableLogging: Nullable<System_Internal.Boolean>;
+    EnableMessageContentLogging: Nullable<System_Internal.Boolean>;
+    EnableMessageLogging: Nullable<System_Internal.Boolean>;
+    get LoggerFactory(): ILoggerFactory | undefined;
+    set LoggerFactory(value: ILoggerFactory);
+    MessageContentSizeLimit: Nullable<System_Internal.Int32>;
+    Freeze(): void;
 }
 
 
@@ -213,33 +221,33 @@ export const ClientLoggingOptions: {
 export type ClientLoggingOptions = ClientLoggingOptions$instance;
 
 export interface ClientPipeline$instance {
-    createMessage(): PipelineMessage;
-    send(message: PipelineMessage): void;
-    sendAsync(message: PipelineMessage): ValueTask;
+    CreateMessage(): PipelineMessage;
+    Send(message: PipelineMessage): void;
+    SendAsync(message: PipelineMessage): ValueTask;
 }
 
 
 export const ClientPipeline: {
     new(): ClientPipeline;
-    create(options: ClientPipelineOptions, perCallPolicies: ReadOnlySpan<PipelinePolicy>, perTryPolicies: ReadOnlySpan<PipelinePolicy>, beforeTransportPolicies: ReadOnlySpan<PipelinePolicy>): ClientPipeline;
-    create(options?: ClientPipelineOptions): ClientPipeline;
+    Create(options: ClientPipelineOptions, perCallPolicies: ReadOnlySpan<PipelinePolicy>, perTryPolicies: ReadOnlySpan<PipelinePolicy>, beforeTransportPolicies: ReadOnlySpan<PipelinePolicy>): ClientPipeline;
+    Create(options?: ClientPipelineOptions): ClientPipeline;
 };
 
 
 export type ClientPipeline = ClientPipeline$instance;
 
 export interface ClientPipelineOptions$instance {
-    get clientLoggingOptions(): ClientLoggingOptions | undefined;
-    set clientLoggingOptions(value: ClientLoggingOptions);
-    enableDistributedTracing: Nullable<System_Internal.Boolean>;
-    get messageLoggingPolicy(): PipelinePolicy | undefined;
-    set messageLoggingPolicy(value: PipelinePolicy);
-    networkTimeout: Nullable<TimeSpan>;
-    get retryPolicy(): PipelinePolicy | undefined;
-    set retryPolicy(value: PipelinePolicy);
-    transport: PipelineTransport;
-    addPolicy(policy: PipelinePolicy, position: PipelinePosition): void;
-    freeze(): void;
+    get ClientLoggingOptions(): ClientLoggingOptions | undefined;
+    set ClientLoggingOptions(value: ClientLoggingOptions);
+    EnableDistributedTracing: Nullable<System_Internal.Boolean>;
+    get MessageLoggingPolicy(): PipelinePolicy | undefined;
+    set MessageLoggingPolicy(value: PipelinePolicy);
+    NetworkTimeout: Nullable<TimeSpan>;
+    get RetryPolicy(): PipelinePolicy | undefined;
+    set RetryPolicy(value: PipelinePolicy);
+    Transport: PipelineTransport;
+    AddPolicy(policy: PipelinePolicy, position: PipelinePosition): void;
+    Freeze(): void;
 }
 
 
@@ -250,51 +258,76 @@ export const ClientPipelineOptions: {
 
 export type ClientPipelineOptions = ClientPipelineOptions$instance;
 
-export interface ClientRetryPolicy$instance extends PipelinePolicy {
-    process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
-    processAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
+export abstract class ClientRetryPolicy$protected {
+    protected GetNextDelay(message: PipelineMessage, tryCount: int): TimeSpan;
+    protected OnRequestSent(message: PipelineMessage): void;
+    protected OnRequestSentAsync(message: PipelineMessage): ValueTask;
+    protected OnSendingRequest(message: PipelineMessage): void;
+    protected OnSendingRequestAsync(message: PipelineMessage): ValueTask;
+    protected OnTryComplete(message: PipelineMessage): void;
+    protected ShouldRetry(message: PipelineMessage, exception: Exception): boolean;
+    protected ShouldRetryAsync(message: PipelineMessage, exception: Exception): ValueTask<System_Internal.Boolean>;
+    protected Wait(time: TimeSpan, cancellationToken: CancellationToken): void;
+    protected WaitAsync(time: TimeSpan, cancellationToken: CancellationToken): Task;
+}
+
+
+export interface ClientRetryPolicy$instance extends ClientRetryPolicy$protected, PipelinePolicy {
+    Process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
+    ProcessAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
 }
 
 
 export const ClientRetryPolicy: {
     new(maxRetries: int): ClientRetryPolicy;
     new(maxRetries: int, enableLogging: boolean, loggerFactory: ILoggerFactory): ClientRetryPolicy;
-    readonly default: ClientRetryPolicy;
+    readonly Default: ClientRetryPolicy;
 };
 
 
 export type ClientRetryPolicy = ClientRetryPolicy$instance;
 
 export interface CollectionResult$instance {
-    getContinuationToken(page: ClientResult): ContinuationToken | undefined;
-    getRawPages(): IEnumerable__System_Collections_Generic<ClientResult>;
+    GetContinuationToken(page: ClientResult): ContinuationToken | undefined;
+    GetRawPages(): IEnumerable__System_Collections_Generic<ClientResult>;
 }
 
 
 export const CollectionResult: {
+    new(): CollectionResult;
 };
 
 
 export type CollectionResult = CollectionResult$instance;
 
 export interface GetTokenOptions$instance {
-    readonly properties: IReadOnlyDictionary<System_Internal.String, unknown>;
+    readonly Properties: IReadOnlyDictionary<System_Internal.String, unknown>;
 }
 
 
 export const GetTokenOptions: {
     new(properties: IReadOnlyDictionary<System_Internal.String, unknown>): GetTokenOptions;
-    readonly scopesPropertyName: string;
-    readonly tokenUrlPropertyName: string;
-    readonly authorizationUrlPropertyName: string;
-    readonly refreshUrlPropertyName: string;
+    readonly ScopesPropertyName: string;
+    readonly TokenUrlPropertyName: string;
+    readonly AuthorizationUrlPropertyName: string;
+    readonly RefreshUrlPropertyName: string;
 };
 
 
 export type GetTokenOptions = GetTokenOptions$instance;
 
-export interface HttpClientPipelineTransport$instance extends PipelineTransport {
-    dispose(): void;
+export abstract class HttpClientPipelineTransport$protected {
+    protected CreateMessageCore(): PipelineMessage;
+    protected Dispose(disposing: boolean): void;
+    protected OnReceivedResponse(message: PipelineMessage, httpResponse: HttpResponseMessage): void;
+    protected OnSendingRequest(message: PipelineMessage, httpRequest: HttpRequestMessage): void;
+    protected ProcessCore(message: PipelineMessage): void;
+    protected ProcessCoreAsync(message: PipelineMessage): ValueTask;
+}
+
+
+export interface HttpClientPipelineTransport$instance extends HttpClientPipelineTransport$protected, PipelineTransport {
+    Dispose(): void;
 }
 
 
@@ -302,16 +335,16 @@ export const HttpClientPipelineTransport: {
     new(): HttpClientPipelineTransport;
     new(client: HttpClient): HttpClientPipelineTransport;
     new(client: HttpClient, enableLogging: boolean, loggerFactory: ILoggerFactory): HttpClientPipelineTransport;
-    readonly shared: HttpClientPipelineTransport;
+    readonly Shared: HttpClientPipelineTransport;
 };
 
 
 export type HttpClientPipelineTransport = HttpClientPipelineTransport$instance;
 
 export interface JsonModelConverter$instance extends JsonConverter<IJsonModel_1<unknown>> {
-    canConvert(typeToConvert: Type): boolean;
-    read(reader: Utf8JsonReader, typeToConvert: Type, options: JsonSerializerOptions): IJsonModel_1<unknown> | undefined;
-    write(writer: Utf8JsonWriter, value: IJsonModel_1<unknown>, options: JsonSerializerOptions): void;
+    CanConvert(typeToConvert: Type): boolean;
+    Read(reader: Utf8JsonReader, typeToConvert: Type, options: JsonSerializerOptions): IJsonModel_1<unknown> | undefined;
+    Write(writer: Utf8JsonWriter, value: IJsonModel_1<unknown>, options: JsonSerializerOptions): void;
 }
 
 
@@ -325,14 +358,14 @@ export const JsonModelConverter: {
 export type JsonModelConverter = JsonModelConverter$instance;
 
 export interface MessageLoggingPolicy$instance extends PipelinePolicy {
-    process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
-    processAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
+    Process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
+    ProcessAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
 }
 
 
 export const MessageLoggingPolicy: {
     new(options: ClientLoggingOptions): MessageLoggingPolicy;
-    readonly default: MessageLoggingPolicy;
+    readonly Default: MessageLoggingPolicy;
 };
 
 
@@ -349,13 +382,19 @@ export const ModelReaderWriterBuildableAttribute: {
 
 export type ModelReaderWriterBuildableAttribute = ModelReaderWriterBuildableAttribute$instance;
 
-export interface ModelReaderWriterContext$instance {
-    getTypeBuilder(type: Type): ModelReaderWriterTypeBuilder;
-    tryGetTypeBuilder(type: Type, builder: ModelReaderWriterTypeBuilder): boolean;
+export abstract class ModelReaderWriterContext$protected {
+    protected TryGetTypeBuilderCore(type: Type, builder: ModelReaderWriterTypeBuilder): boolean;
+}
+
+
+export interface ModelReaderWriterContext$instance extends ModelReaderWriterContext$protected {
+    GetTypeBuilder(type: Type): ModelReaderWriterTypeBuilder;
+    TryGetTypeBuilder(type: Type, builder: ModelReaderWriterTypeBuilder): boolean;
 }
 
 
 export const ModelReaderWriterContext: {
+    new(): ModelReaderWriterContext;
 };
 
 
@@ -373,48 +412,62 @@ export const ModelReaderWriterContextTypeAttribute: {
 export type ModelReaderWriterContextTypeAttribute = ModelReaderWriterContextTypeAttribute$instance;
 
 export interface ModelReaderWriterOptions$instance {
-    readonly format: string;
+    readonly Format: string;
 }
 
 
 export const ModelReaderWriterOptions: {
     new(format: string): ModelReaderWriterOptions;
-    readonly json: ModelReaderWriterOptions;
-    readonly xml: ModelReaderWriterOptions;
+    readonly Json: ModelReaderWriterOptions;
+    readonly Xml: ModelReaderWriterOptions;
 };
 
 
 export type ModelReaderWriterOptions = ModelReaderWriterOptions$instance;
 
-export interface ModelReaderWriterTypeBuilder$instance {
+export abstract class ModelReaderWriterTypeBuilder$protected {
+    protected readonly BuilderType: Type;
+    protected readonly ItemType: Type | undefined;
+    protected AddItem(collectionBuilder: unknown, item: unknown): void;
+    protected AddItemWithKey(collectionBuilder: unknown, key: string, item: unknown): void;
+    protected ConvertCollectionBuilder(collectionBuilder: unknown): unknown;
+    protected abstract CreateInstance(): unknown;
+    protected GetItems(collection: unknown): IEnumerable | undefined;
+}
+
+
+export interface ModelReaderWriterTypeBuilder$instance extends ModelReaderWriterTypeBuilder$protected {
 }
 
 
 export const ModelReaderWriterTypeBuilder: {
+    new(): ModelReaderWriterTypeBuilder;
 };
 
 
 export type ModelReaderWriterTypeBuilder = ModelReaderWriterTypeBuilder$instance;
 
 export interface OperationResult$instance {
-    readonly hasCompleted: boolean;
-    readonly rehydrationToken: ContinuationToken | undefined;
-    getRawResponse(): PipelineResponse;
-    updateStatus(options?: RequestOptions): ClientResult;
-    updateStatusAsync(options?: RequestOptions): ValueTask<ClientResult>;
-    waitForCompletion(cancellationToken?: CancellationToken): void;
-    waitForCompletionAsync(cancellationToken?: CancellationToken): ValueTask;
+    HasCompleted: boolean;
+    get RehydrationToken(): ContinuationToken | undefined;
+    set RehydrationToken(value: ContinuationToken);
+    GetRawResponse(): PipelineResponse;
+    UpdateStatus(options?: RequestOptions): ClientResult;
+    UpdateStatusAsync(options?: RequestOptions): ValueTask<ClientResult>;
+    WaitForCompletion(cancellationToken?: CancellationToken): void;
+    WaitForCompletionAsync(cancellationToken?: CancellationToken): ValueTask;
 }
 
 
 export const OperationResult: {
+    new(response: PipelineResponse): OperationResult;
 };
 
 
 export type OperationResult = OperationResult$instance;
 
 export interface PersistableModelProxyAttribute$instance extends Attribute {
-    readonly proxyType: Type;
+    readonly ProxyType: Type;
 }
 
 
@@ -425,143 +478,184 @@ export const PersistableModelProxyAttribute: {
 
 export type PersistableModelProxyAttribute = PersistableModelProxyAttribute$instance;
 
-export interface PipelineMessage$instance {
-    bufferResponse: boolean;
-    readonly cancellationToken: CancellationToken;
-    networkTimeout: Nullable<TimeSpan>;
-    readonly request: PipelineRequest;
-    readonly response: PipelineResponse;
-    responseClassifier: PipelineMessageClassifier;
-    apply(options: RequestOptions): void;
-    dispose(): void;
-    extractResponse(): PipelineResponse | undefined;
-    setProperty(key: Type, value: unknown): void;
-    tryGetProperty(key: Type, value: unknown): boolean;
+export abstract class PipelineMessage$protected {
+    protected Dispose(disposing: boolean): void;
+}
+
+
+export interface PipelineMessage$instance extends PipelineMessage$protected {
+    BufferResponse: boolean;
+    CancellationToken: CancellationToken;
+    NetworkTimeout: Nullable<TimeSpan>;
+    readonly Request: PipelineRequest;
+    Response: PipelineResponse;
+    ResponseClassifier: PipelineMessageClassifier;
+    Apply(options: RequestOptions): void;
+    Dispose(): void;
+    ExtractResponse(): PipelineResponse | undefined;
+    SetProperty(key: Type, value: unknown): void;
+    TryGetProperty(key: Type, value: unknown): boolean;
 }
 
 
 export const PipelineMessage: {
-    new(): PipelineMessage;
+    new(request: PipelineRequest): PipelineMessage;
 };
 
 
 export type PipelineMessage = PipelineMessage$instance;
 
 export interface PipelineMessageClassifier$instance {
-    tryClassify(message: PipelineMessage, isError: boolean): boolean;
-    tryClassify(message: PipelineMessage, exception: Exception, isRetriable: boolean): boolean;
+    TryClassify(message: PipelineMessage, isError: boolean): boolean;
+    TryClassify(message: PipelineMessage, exception: Exception, isRetriable: boolean): boolean;
 }
 
 
 export const PipelineMessageClassifier: {
-    readonly default: PipelineMessageClassifier;
-    create(successStatusCodes: ReadOnlySpan<System_Internal.UInt16>): PipelineMessageClassifier;
+    new(): PipelineMessageClassifier;
+    readonly Default: PipelineMessageClassifier;
+    Create(successStatusCodes: ReadOnlySpan<System_Internal.UInt16>): PipelineMessageClassifier;
 };
 
 
 export type PipelineMessageClassifier = PipelineMessageClassifier$instance;
 
 export interface PipelinePolicy$instance {
-    process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
-    processAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
+    Process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
+    ProcessAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
 }
 
 
 export const PipelinePolicy: {
+    new(): PipelinePolicy;
+    ProcessNext(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
+    ProcessNextAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
 };
 
 
 export type PipelinePolicy = PipelinePolicy$instance;
 
-export interface PipelineRequest$instance {
-    content: BinaryContent;
-    readonly headers: PipelineRequestHeaders;
-    method: string;
-    uri: Uri;
-    dispose(): void;
+export abstract class PipelineRequest$protected {
+    protected ContentCore: BinaryContent | undefined;
+    protected readonly HeadersCore: PipelineRequestHeaders;
+    protected MethodCore: string;
+    protected UriCore: Uri | undefined;
+}
+
+
+export interface PipelineRequest$instance extends PipelineRequest$protected {
+    Content: BinaryContent;
+    readonly Headers: PipelineRequestHeaders;
+    Method: string;
+    Uri: Uri;
+    Dispose(): void;
 }
 
 
 export const PipelineRequest: {
+    new(): PipelineRequest;
 };
 
 
 export type PipelineRequest = PipelineRequest$instance;
 
 export interface PipelineRequestHeaders$instance {
-    add(name: string, value: string): void;
-    getEnumerator(): IEnumerator<KeyValuePair<System_Internal.String, System_Internal.String>>;
-    remove(name: string): boolean;
-    set(name: string, value: string): void;
-    tryGetValue(name: string, value: string): boolean;
-    tryGetValues(name: string, values: IEnumerable__System_Collections_Generic<System_Internal.String>): boolean;
+    Add(name: string, value: string): void;
+    GetEnumerator(): IEnumerator<KeyValuePair<System_Internal.String, System_Internal.String>>;
+    Remove(name: string): boolean;
+    Set(name: string, value: string): void;
+    TryGetValue(name: string, value: string): boolean;
+    TryGetValues(name: string, values: IEnumerable__System_Collections_Generic<System_Internal.String>): boolean;
 }
 
 
 export const PipelineRequestHeaders: {
+    new(): PipelineRequestHeaders;
 };
 
 
 export type PipelineRequestHeaders = PipelineRequestHeaders$instance;
 
-export interface PipelineResponse$instance {
-    readonly content: BinaryData;
-    get contentStream(): Stream | undefined;
-    set contentStream(value: Stream);
-    readonly headers: PipelineResponseHeaders;
-    readonly isError: boolean;
-    readonly reasonPhrase: string;
-    readonly status: int;
-    bufferContent(cancellationToken?: CancellationToken): BinaryData;
-    bufferContentAsync(cancellationToken?: CancellationToken): ValueTask<BinaryData>;
-    dispose(): void;
+export abstract class PipelineResponse$protected {
+    protected readonly HeadersCore: PipelineResponseHeaders;
+    protected IsErrorCore: boolean;
+}
+
+
+export interface PipelineResponse$instance extends PipelineResponse$protected {
+    readonly Content: BinaryData;
+    get ContentStream(): Stream | undefined;
+    set ContentStream(value: Stream);
+    readonly Headers: PipelineResponseHeaders;
+    readonly IsError: boolean;
+    readonly ReasonPhrase: string;
+    readonly Status: int;
+    BufferContent(cancellationToken?: CancellationToken): BinaryData;
+    BufferContentAsync(cancellationToken?: CancellationToken): ValueTask<BinaryData>;
+    Dispose(): void;
 }
 
 
 export const PipelineResponse: {
+    new(): PipelineResponse;
 };
 
 
 export type PipelineResponse = PipelineResponse$instance;
 
 export interface PipelineResponseHeaders$instance {
-    getEnumerator(): IEnumerator<KeyValuePair<System_Internal.String, System_Internal.String>>;
-    tryGetValue(name: string, value: string): boolean;
-    tryGetValues(name: string, values: IEnumerable__System_Collections_Generic<System_Internal.String>): boolean;
+    GetEnumerator(): IEnumerator<KeyValuePair<System_Internal.String, System_Internal.String>>;
+    TryGetValue(name: string, value: string): boolean;
+    TryGetValues(name: string, values: IEnumerable__System_Collections_Generic<System_Internal.String>): boolean;
 }
 
 
 export const PipelineResponseHeaders: {
+    new(): PipelineResponseHeaders;
 };
 
 
 export type PipelineResponseHeaders = PipelineResponseHeaders$instance;
 
-export interface PipelineTransport$instance extends PipelinePolicy {
-    createMessage(): PipelineMessage;
-    process(message: PipelineMessage): void;
-    process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
-    process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
-    processAsync(message: PipelineMessage): ValueTask;
-    processAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
-    processAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
+export abstract class PipelineTransport$protected {
+    protected abstract CreateMessageCore(): PipelineMessage;
+    protected abstract ProcessCore(message: PipelineMessage): void;
+    protected abstract ProcessCoreAsync(message: PipelineMessage): ValueTask;
+}
+
+
+export interface PipelineTransport$instance extends PipelineTransport$protected, PipelinePolicy {
+    CreateMessage(): PipelineMessage;
+    Process(message: PipelineMessage): void;
+    Process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
+    Process(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): void;
+    ProcessAsync(message: PipelineMessage): ValueTask;
+    ProcessAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
+    ProcessAsync(message: PipelineMessage, pipeline: IReadOnlyList<PipelinePolicy>, currentIndex: int): ValueTask;
 }
 
 
 export const PipelineTransport: {
+    new(): PipelineTransport;
+    new(enableLogging: boolean, loggerFactory: ILoggerFactory): PipelineTransport;
 };
 
 
 export type PipelineTransport = PipelineTransport$instance;
 
-export interface RequestOptions$instance {
-    bufferResponse: boolean;
-    cancellationToken: CancellationToken;
-    errorOptions: ClientErrorBehaviors;
-    addHeader(name: string, value: string): void;
-    addPolicy(policy: PipelinePolicy, position: PipelinePosition): void;
-    freeze(): void;
-    setHeader(name: string, value: string): void;
+export abstract class RequestOptions$protected {
+    protected Apply(message: PipelineMessage): void;
+}
+
+
+export interface RequestOptions$instance extends RequestOptions$protected {
+    BufferResponse: boolean;
+    CancellationToken: CancellationToken;
+    ErrorOptions: ClientErrorBehaviors;
+    AddHeader(name: string, value: string): void;
+    AddPolicy(policy: PipelinePolicy, position: PipelinePosition): void;
+    Freeze(): void;
+    SetHeader(name: string, value: string): void;
 }
 
 
@@ -573,22 +667,22 @@ export const RequestOptions: {
 export type RequestOptions = RequestOptions$instance;
 
 export abstract class ActivityExtensions$instance {
-    static markClientActivityFailed(activity: Activity, exception: Exception): Activity;
-    static startClientActivity(activitySource: ActivitySource, options: ClientPipelineOptions, name: string, kind?: ActivityKind, parentContext?: ActivityContext, tags?: IEnumerable__System_Collections_Generic<KeyValuePair<System_Internal.String, unknown>>): Activity | undefined;
+    static MarkClientActivityFailed(activity: Activity, exception: Exception): Activity;
+    static StartClientActivity(activitySource: ActivitySource, options: ClientPipelineOptions, name: string, kind?: ActivityKind, parentContext?: ActivityContext, tags?: IEnumerable__System_Collections_Generic<KeyValuePair<System_Internal.String, unknown>>): Activity | undefined;
 }
 
 
 export type ActivityExtensions = ActivityExtensions$instance;
 
 export abstract class ModelReaderWriter$instance {
-    static read<T>(data: BinaryData, options: ModelReaderWriterOptions, context: ModelReaderWriterContext): T | undefined;
-    static read<T extends IPersistableModel_1<T>>(data: BinaryData, options?: ModelReaderWriterOptions): T | undefined;
-    static read(data: BinaryData, returnType: Type, options: ModelReaderWriterOptions, context: ModelReaderWriterContext): unknown | undefined;
-    static read(data: BinaryData, returnType: Type, options?: ModelReaderWriterOptions): unknown | undefined;
-    static write(model: unknown, options: ModelReaderWriterOptions, context: ModelReaderWriterContext): BinaryData;
-    static write(model: unknown, options?: ModelReaderWriterOptions): BinaryData;
-    static write<T>(model: T, options: ModelReaderWriterOptions, context: ModelReaderWriterContext): BinaryData;
-    static write<T extends IPersistableModel_1<T>>(model: T, options?: ModelReaderWriterOptions): BinaryData;
+    static Read<T>(data: BinaryData, options: ModelReaderWriterOptions, context: ModelReaderWriterContext): T | undefined;
+    static Read<T extends IPersistableModel_1<T>>(data: BinaryData, options?: ModelReaderWriterOptions): T | undefined;
+    static Read(data: BinaryData, returnType: Type, options: ModelReaderWriterOptions, context: ModelReaderWriterContext): unknown | undefined;
+    static Read(data: BinaryData, returnType: Type, options?: ModelReaderWriterOptions): unknown | undefined;
+    static Write(model: unknown, options: ModelReaderWriterOptions, context: ModelReaderWriterContext): BinaryData;
+    static Write(model: unknown, options?: ModelReaderWriterOptions): BinaryData;
+    static Write<T>(model: T, options: ModelReaderWriterOptions, context: ModelReaderWriterContext): BinaryData;
+    static Write<T extends IPersistableModel_1<T>>(model: T, options?: ModelReaderWriterOptions): BinaryData;
 }