@azure/arm-webpubsub 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/commonjs/models/models.d.ts

@@ -0,0 +1,1506 @@
+/**
+ * This file contains only generated model types and their (de)serializers.
+ * Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input.
+ */
+/** Paged collection of Operation items */
+export interface _OperationList {
+    /** The Operation items on this page */
+    value: Operation[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _operationListDeserializer(item: any): _OperationList;
+export declare function operationArrayDeserializer(result: Array<Operation>): any[];
+/** REST API operation supported by resource provider. */
+export interface Operation {
+    /** Name of the operation with format: {provider}/{resource}/{operation} */
+    name?: string;
+    /** If the operation is a data action. (for data plane rbac) */
+    isDataAction?: boolean;
+    /** The object that describes a operation. */
+    display?: OperationDisplay;
+    /** Optional. The intended executor of the operation; governs the display of the operation in the RBAC UX and the audit logs UX. */
+    origin?: string;
+    /** Extra Operation properties. */
+    properties?: OperationProperties;
+}
+export declare function operationDeserializer(item: any): Operation;
+/** The object that describes a operation. */
+export interface OperationDisplay {
+    /** Friendly name of the resource provider */
+    provider?: string;
+    /** Resource type on which the operation is performed. */
+    resource?: string;
+    /** The localized friendly name for the operation. */
+    operation?: string;
+    /** The localized friendly description for the operation */
+    description?: string;
+}
+export declare function operationDisplayDeserializer(item: any): OperationDisplay;
+/** Extra Operation properties. */
+export interface OperationProperties {
+    /** An object that describes a specification. */
+    serviceSpecification?: ServiceSpecification;
+}
+export declare function operationPropertiesDeserializer(item: any): OperationProperties;
+/** An object that describes a specification. */
+export interface ServiceSpecification {
+    /** Specifications of the Metrics for Azure Monitoring. */
+    metricSpecifications?: MetricSpecification[];
+    /** Specifications of the Logs for Azure Monitoring. */
+    logSpecifications?: LogSpecification[];
+}
+export declare function serviceSpecificationDeserializer(item: any): ServiceSpecification;
+export declare function metricSpecificationArrayDeserializer(result: Array<MetricSpecification>): any[];
+/** Specifications of the Metrics for Azure Monitoring. */
+export interface MetricSpecification {
+    /** Name of the metric. */
+    name?: string;
+    /** Localized friendly display name of the metric. */
+    displayName?: string;
+    /** Localized friendly description of the metric. */
+    displayDescription?: string;
+    /** The unit that makes sense for the metric. */
+    unit?: string;
+    /** Only provide one value for this field. Valid values: Average, Minimum, Maximum, Total, Count. */
+    aggregationType?: string;
+    /**
+     * Optional. If set to true, then zero will be returned for time duration where no metric is emitted/published.
+     * Ex. a metric that returns the number of times a particular error code was emitted. The error code may not appear
+     * often, instead of the RP publishing 0, Shoebox can auto fill in 0s for time periods where nothing was emitted.
+     */
+    fillGapWithZero?: string;
+    /** The name of the metric category that the metric belongs to. A metric can only belong to a single category. */
+    category?: string;
+    /** The dimensions of the metrics. */
+    dimensions?: Dimension[];
+}
+export declare function metricSpecificationDeserializer(item: any): MetricSpecification;
+export declare function dimensionArrayDeserializer(result: Array<Dimension>): any[];
+/** Specifications of the Dimension of metrics. */
+export interface Dimension {
+    /** The public facing name of the dimension. */
+    name?: string;
+    /** Localized friendly display name of the dimension. */
+    displayName?: string;
+    /** Name of the dimension as it appears in MDM. */
+    internalName?: string;
+    /** A Boolean flag indicating whether this dimension should be included for the shoebox export scenario. */
+    toBeExportedForShoebox?: boolean;
+}
+export declare function dimensionDeserializer(item: any): Dimension;
+export declare function logSpecificationArrayDeserializer(result: Array<LogSpecification>): any[];
+/** Specifications of the Logs for Azure Monitoring. */
+export interface LogSpecification {
+    /** Name of the log. */
+    name?: string;
+    /** Localized friendly display name of the log. */
+    displayName?: string;
+}
+export declare function logSpecificationDeserializer(item: any): LogSpecification;
+/** Common error response for all Azure Resource Manager APIs to return error details for failed operations. */
+export interface ErrorResponse {
+    /** The error object. */
+    error?: ErrorDetail;
+}
+export declare function errorResponseDeserializer(item: any): ErrorResponse;
+/** The error detail. */
+export interface ErrorDetail {
+    /** The error code. */
+    readonly code?: string;
+    /** The error message. */
+    readonly message?: string;
+    /** The error target. */
+    readonly target?: string;
+    /** The error details. */
+    readonly details?: ErrorDetail[];
+    /** The error additional info. */
+    readonly additionalInfo?: ErrorAdditionalInfo[];
+}
+export declare function errorDetailDeserializer(item: any): ErrorDetail;
+export declare function errorDetailArrayDeserializer(result: Array<ErrorDetail>): any[];
+export declare function errorAdditionalInfoArrayDeserializer(result: Array<ErrorAdditionalInfo>): any[];
+/** The resource management error additional info. */
+export interface ErrorAdditionalInfo {
+    /** The additional info type. */
+    readonly type?: string;
+    /** The additional info. */
+    readonly info?: any;
+}
+export declare function errorAdditionalInfoDeserializer(item: any): ErrorAdditionalInfo;
+/** A hub setting */
+export interface WebPubSubHub extends ProxyResource {
+    /** Properties of a hub. */
+    properties: WebPubSubHubProperties;
+}
+export declare function webPubSubHubSerializer(item: WebPubSubHub): any;
+export declare function webPubSubHubDeserializer(item: any): WebPubSubHub;
+/** Properties of a hub. */
+export interface WebPubSubHubProperties {
+    /** Event handler of a hub. */
+    eventHandlers?: EventHandler[];
+    /**
+     * Event listener settings for forwarding your client events to listeners.
+     * Event listener is transparent to Web PubSub clients, and it doesn't return any result to clients nor interrupt the lifetime of clients.
+     * One event can be sent to multiple listeners, as long as it matches the filters in those listeners. The order of the array elements doesn't matter.
+     * Maximum count of event listeners among all hubs is 10.
+     */
+    eventListeners?: EventListener[];
+    /** The settings for configuring if anonymous connections are allowed for this hub: "allow" or "deny". Default to "deny". */
+    anonymousConnectPolicy?: string;
+    /** The settings for configuring the WebSocket ping-pong interval in seconds for all clients in the hub. Valid range: 1 to 120. Default to 20 seconds. */
+    webSocketKeepAliveIntervalInSeconds?: number;
+}
+export declare function webPubSubHubPropertiesSerializer(item: WebPubSubHubProperties): any;
+export declare function webPubSubHubPropertiesDeserializer(item: any): WebPubSubHubProperties;
+export declare function eventHandlerArraySerializer(result: Array<EventHandler>): any[];
+export declare function eventHandlerArrayDeserializer(result: Array<EventHandler>): any[];
+/** Properties of event handler. */
+export interface EventHandler {
+    /**
+     * Gets or sets the URL template for the event handler. The actual URL is calculated when the corresponding event is triggered.
+     * The template supports predefined parameters syntax: `{event}`, `{hub}`, and KeyVault reference syntax `{@Microsoft.KeyVault(SecretUri=_your_secret_identifier_)}`
+     * For example, if the template is `http://example.com/api/{event}`, when `connect` event is triggered, a POST request will be sent to the URL `http://example.com/chat/api/connect`.
+     * Note: Parameters are not allowed in the hostname of the URL, and curly brackets `{}` are reserved for parameter syntax only. If your URL path contains literal curly brackets, please URL-encode them to ensure proper handling.
+     */
+    urlTemplate: string;
+    /**
+     * Gets or sets the matching pattern for event names.
+     * There are 3 kinds of patterns supported:
+     * 1. "*", it matches any event name
+     * 2. Combine multiple events with ",", for example "event1,event2", it matches event "event1" and "event2"
+     * 3. A single event name, for example, "event1", it matches "event1"
+     */
+    userEventPattern?: string;
+    /** Gets or sets the list of system events. */
+    systemEvents?: string[];
+    /** Upstream auth settings. If not set, no auth is used for upstream messages. */
+    auth?: UpstreamAuthSettings;
+    /** The group presence events that this event handler is concerned with. Group presence events are triggered when connections join or leave groups in the hub. If the value is null, no presence events will be sent to this event handler. */
+    groupPresenceEvents?: GroupPresenceEventFilters;
+}
+export declare function eventHandlerSerializer(item: EventHandler): any;
+export declare function eventHandlerDeserializer(item: any): EventHandler;
+/** Upstream auth settings. If not set, no auth is used for upstream messages. */
+export interface UpstreamAuthSettings {
+    /** Upstream auth type enum. */
+    type?: UpstreamAuthType;
+    /** Managed identity settings for upstream. */
+    managedIdentity?: ManagedIdentitySettings;
+}
+export declare function upstreamAuthSettingsSerializer(item: UpstreamAuthSettings): any;
+export declare function upstreamAuthSettingsDeserializer(item: any): UpstreamAuthSettings;
+/** Upstream auth type enum. */
+export declare enum KnownUpstreamAuthType {
+    /** None */
+    None = "None",
+    /** ManagedIdentity */
+    ManagedIdentity = "ManagedIdentity"
+}
+/**
+ * Upstream auth type enum. \
+ * {@link KnownUpstreamAuthType} can be used interchangeably with UpstreamAuthType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None** \
+ * **ManagedIdentity**
+ */
+export type UpstreamAuthType = string;
+/** Managed identity settings for upstream. */
+export interface ManagedIdentitySettings {
+    /**
+     * The Resource indicating the App ID URI of the target resource.
+     * It also appears in the aud (audience) claim of the issued token.
+     */
+    resource?: string;
+}
+export declare function managedIdentitySettingsSerializer(item: ManagedIdentitySettings): any;
+export declare function managedIdentitySettingsDeserializer(item: any): ManagedIdentitySettings;
+/** Represents presence event filters for event handler configuration. */
+export interface GroupPresenceEventFilters {
+    /** The concerning event names. Valid values are "joined", "left". If the value is null or empty, no presence events will be sent to the event handler. */
+    eventNames: GroupPresenceEventName[];
+    /** The group filters. Only events from these groups will be sent to the event handler. Each element is a pattern that may match multiple groups. If null or empty, events from all groups will be sent (subject to eventNames). */
+    groupFilters?: string[];
+}
+export declare function groupPresenceEventFiltersSerializer(item: GroupPresenceEventFilters): any;
+export declare function groupPresenceEventFiltersDeserializer(item: any): GroupPresenceEventFilters;
+/** Allowed event names for group presence events. */
+export declare enum KnownGroupPresenceEventName {
+    /** Event triggered when a connection joins a group. */
+    Joined = "joined",
+    /** Event triggered when a connection leaves a group. */
+    Left = "left"
+}
+/**
+ * Allowed event names for group presence events. \
+ * {@link KnownGroupPresenceEventName} can be used interchangeably with GroupPresenceEventName,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **joined**: Event triggered when a connection joins a group. \
+ * **left**: Event triggered when a connection leaves a group.
+ */
+export type GroupPresenceEventName = string;
+export declare function eventListenerArraySerializer(result: Array<EventListener>): any[];
+export declare function eventListenerArrayDeserializer(result: Array<EventListener>): any[];
+/** A setting defines which kinds of events should be sent to which endpoint. */
+export interface EventListener {
+    /** A base class for event filter which determines whether an event should be sent to an event listener. */
+    filter: EventListenerFilterUnion;
+    /** An endpoint specifying where Web PubSub should send events to. */
+    endpoint: EventListenerEndpointUnion;
+}
+export declare function eventListenerSerializer(item: EventListener): any;
+export declare function eventListenerDeserializer(item: any): EventListener;
+/** A base class for event filter which determines whether an event should be sent to an event listener. */
+export interface EventListenerFilter {
+    type: EventListenerFilterDiscriminator;
+}
+export declare function eventListenerFilterSerializer(item: EventListenerFilter): any;
+export declare function eventListenerFilterDeserializer(item: any): EventListenerFilter;
+/** Alias for EventListenerFilterUnion */
+export type EventListenerFilterUnion = EventNameFilter | EventListenerFilter;
+export declare function eventListenerFilterUnionSerializer(item: EventListenerFilterUnion): any;
+export declare function eventListenerFilterUnionDeserializer(item: any): EventListenerFilterUnion;
+/** Known values of {@link EventListenerFilterDiscriminator} that the service accepts. */
+export declare enum KnownEventListenerFilterDiscriminator {
+    /** EventName */
+    EventName = "EventName"
+}
+/** Type of EventListenerFilterDiscriminator */
+export type EventListenerFilterDiscriminator = string;
+/** Filter events by their name. */
+export interface EventNameFilter extends EventListenerFilter {
+    /** Gets or sets a list of system events. Supported events: "connected" and "disconnected". Blocking event "connect" is not supported because it requires a response. */
+    systemEvents?: string[];
+    /**
+     * Gets or sets a matching pattern for event names.
+     * There are 3 kinds of patterns supported:
+     * 1. "*", it matches any event name
+     * 2. Combine multiple events with ",", for example "event1,event2", it matches events "event1" and "event2"
+     * 3. A single event name, for example, "event1", it matches "event1"
+     */
+    userEventPattern?: string;
+    type: "EventName";
+}
+export declare function eventNameFilterSerializer(item: EventNameFilter): any;
+export declare function eventNameFilterDeserializer(item: any): EventNameFilter;
+/** An endpoint specifying where Web PubSub should send events to. */
+export interface EventListenerEndpoint {
+    type: EventListenerEndpointDiscriminator;
+}
+export declare function eventListenerEndpointSerializer(item: EventListenerEndpoint): any;
+export declare function eventListenerEndpointDeserializer(item: any): EventListenerEndpoint;
+/** Alias for EventListenerEndpointUnion */
+export type EventListenerEndpointUnion = EventHubEndpoint | EventListenerEndpoint;
+export declare function eventListenerEndpointUnionSerializer(item: EventListenerEndpointUnion): any;
+export declare function eventListenerEndpointUnionDeserializer(item: any): EventListenerEndpointUnion;
+/** Known values of {@link EventListenerEndpointDiscriminator} that the service accepts. */
+export declare enum KnownEventListenerEndpointDiscriminator {
+    /** EventHub */
+    EventHub = "EventHub"
+}
+/** Type of EventListenerEndpointDiscriminator */
+export type EventListenerEndpointDiscriminator = string;
+/**
+ * An Event Hub endpoint.
+ * The managed identity of Web PubSub service must be enabled, and the identity should have the "Azure Event Hubs Data sender" role to access Event Hub.
+ */
+export interface EventHubEndpoint extends EventListenerEndpoint {
+    /** The fully qualified namespace name of the Event Hub resource. */
+    fullyQualifiedNamespace: string;
+    /** The name of the Event Hub. */
+    eventHubName: string;
+    type: "EventHub";
+}
+export declare function eventHubEndpointSerializer(item: EventHubEndpoint): any;
+export declare function eventHubEndpointDeserializer(item: any): EventHubEndpoint;
+/** The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location */
+export interface ProxyResource extends Resource {
+}
+export declare function proxyResourceSerializer(_item: ProxyResource): any;
+export declare function proxyResourceDeserializer(item: any): ProxyResource;
+/** Common fields that are returned in the response for all Azure Resource Manager resources */
+export interface Resource {
+    /** Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} */
+    readonly id?: string;
+    /** The name of the resource */
+    readonly name?: string;
+    /** The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" */
+    readonly type?: string;
+    /** Azure Resource Manager metadata containing createdBy and modifiedBy information. */
+    readonly systemData?: SystemData;
+}
+export declare function resourceSerializer(_item: Resource): any;
+export declare function resourceDeserializer(item: any): Resource;
+/** Metadata pertaining to creation and last modification of the resource. */
+export interface SystemData {
+    /** The identity that created the resource. */
+    createdBy?: string;
+    /** The type of identity that created the resource. */
+    createdByType?: CreatedByType;
+    /** The timestamp of resource creation (UTC). */
+    createdAt?: Date;
+    /** The identity that last modified the resource. */
+    lastModifiedBy?: string;
+    /** The type of identity that last modified the resource. */
+    lastModifiedByType?: CreatedByType;
+    /** The timestamp of resource last modification (UTC) */
+    lastModifiedAt?: Date;
+}
+export declare function systemDataDeserializer(item: any): SystemData;
+/** The kind of entity that created the resource. */
+export declare enum KnownCreatedByType {
+    /** The entity was created by a user. */
+    User = "User",
+    /** The entity was created by an application. */
+    Application = "Application",
+    /** The entity was created by a managed identity. */
+    ManagedIdentity = "ManagedIdentity",
+    /** The entity was created by a key. */
+    Key = "Key"
+}
+/**
+ * The kind of entity that created the resource. \
+ * {@link KnownCreatedByType} can be used interchangeably with CreatedByType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **User**: The entity was created by a user. \
+ * **Application**: The entity was created by an application. \
+ * **ManagedIdentity**: The entity was created by a managed identity. \
+ * **Key**: The entity was created by a key.
+ */
+export type CreatedByType = string;
+/** Hub setting list */
+export interface _WebPubSubHubList {
+    /** The WebPubSubHub items on this page */
+    value: WebPubSubHub[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _webPubSubHubListDeserializer(item: any): _WebPubSubHubList;
+export declare function webPubSubHubArraySerializer(result: Array<WebPubSubHub>): any[];
+export declare function webPubSubHubArrayDeserializer(result: Array<WebPubSubHub>): any[];
+/** Describes a Shared Private Link Resource */
+export interface SharedPrivateLinkResource extends ProxyResource {
+    /** The group id from the provider of resource the shared private link resource is for */
+    groupId?: string;
+    /** The resource id of the resource the shared private link resource is for */
+    privateLinkResourceId?: string;
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** The request message for requesting approval of the shared private link resource */
+    requestMessage?: string;
+    /** A list of FQDNs for third party private link service */
+    fqdns?: string[];
+    /** Status of the shared private link resource */
+    readonly status?: SharedPrivateLinkResourceStatus;
+}
+export declare function sharedPrivateLinkResourceSerializer(item: SharedPrivateLinkResource): any;
+export declare function sharedPrivateLinkResourceDeserializer(item: any): SharedPrivateLinkResource;
+/** Describes the properties of an existing Shared Private Link Resource */
+export interface SharedPrivateLinkResourceProperties {
+    /** The group id from the provider of resource the shared private link resource is for */
+    groupId: string;
+    /** The resource id of the resource the shared private link resource is for */
+    privateLinkResourceId: string;
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** The request message for requesting approval of the shared private link resource */
+    requestMessage?: string;
+    /** A list of FQDNs for third party private link service */
+    fqdns?: string[];
+    /** Status of the shared private link resource */
+    readonly status?: SharedPrivateLinkResourceStatus;
+}
+export declare function sharedPrivateLinkResourcePropertiesSerializer(item: SharedPrivateLinkResourceProperties): any;
+export declare function sharedPrivateLinkResourcePropertiesDeserializer(item: any): SharedPrivateLinkResourceProperties;
+/** Provisioning state of the resource. */
+export declare enum KnownProvisioningState {
+    /** Unknown provisioning state */
+    Unknown = "Unknown",
+    /** Resource successfully provisioned */
+    Succeeded = "Succeeded",
+    /** Resource provisioning failed */
+    Failed = "Failed",
+    /** Resource provisioning was canceled */
+    Canceled = "Canceled",
+    /** Resource provisioning is running */
+    Running = "Running",
+    /** Resource is being created */
+    Creating = "Creating",
+    /** Resource is being updated */
+    Updating = "Updating",
+    /** Resource is being deleted */
+    Deleting = "Deleting",
+    /** Moving */
+    Moving = "Moving"
+}
+/**
+ * Provisioning state of the resource. \
+ * {@link KnownProvisioningState} can be used interchangeably with ProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Unknown**: Unknown provisioning state \
+ * **Succeeded**: Resource successfully provisioned \
+ * **Failed**: Resource provisioning failed \
+ * **Canceled**: Resource provisioning was canceled \
+ * **Running**: Resource provisioning is running \
+ * **Creating**: Resource is being created \
+ * **Updating**: Resource is being updated \
+ * **Deleting**: Resource is being deleted \
+ * **Moving**
+ */
+export type ProvisioningState = string;
+/** Status of the shared private link resource */
+export declare enum KnownSharedPrivateLinkResourceStatus {
+    /** Pending */
+    Pending = "Pending",
+    /** Approved */
+    Approved = "Approved",
+    /** Rejected */
+    Rejected = "Rejected",
+    /** Disconnected */
+    Disconnected = "Disconnected",
+    /** Timeout */
+    Timeout = "Timeout"
+}
+/**
+ * Status of the shared private link resource \
+ * {@link KnownSharedPrivateLinkResourceStatus} can be used interchangeably with SharedPrivateLinkResourceStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Pending** \
+ * **Approved** \
+ * **Rejected** \
+ * **Disconnected** \
+ * **Timeout**
+ */
+export type SharedPrivateLinkResourceStatus = string;
+/** A list of shared private link resources */
+export interface _SharedPrivateLinkResourceList {
+    /** The SharedPrivateLinkResource items on this page */
+    value: SharedPrivateLinkResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _sharedPrivateLinkResourceListDeserializer(item: any): _SharedPrivateLinkResourceList;
+export declare function sharedPrivateLinkResourceArraySerializer(result: Array<SharedPrivateLinkResource>): any[];
+export declare function sharedPrivateLinkResourceArrayDeserializer(result: Array<SharedPrivateLinkResource>): any[];
+/** A class represent a resource. */
+export interface WebPubSubResource extends TrackedResource {
+    /** The billing information of the resource. */
+    sku?: ResourceSku;
+    /** The kind of the service */
+    kind?: ServiceKind;
+    /** A class represent managed identities used for request and response */
+    identity?: ManagedIdentity;
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** The publicly accessible IP of the resource. */
+    readonly externalIP?: string;
+    /** FQDN of the service instance. */
+    readonly hostName?: string;
+    /** The publicly accessible port of the resource which is designed for browser/client side usage. */
+    readonly publicPort?: number;
+    /** The publicly accessible port of the resource which is designed for customer server side usage. */
+    readonly serverPort?: number;
+    /** Version of the resource. Probably you need the same or higher version of client SDKs. */
+    readonly version?: string;
+    /** Private endpoint connections to the resource. */
+    readonly privateEndpointConnections?: PrivateEndpointConnection[];
+    /** The list of shared private link resources. */
+    readonly sharedPrivateLinkResources?: SharedPrivateLinkResource[];
+    /** TLS settings for the resource */
+    tls?: WebPubSubTlsSettings;
+    /** Deprecated. */
+    readonly hostNamePrefix?: string;
+    /** Live trace configuration of a Microsoft.SignalRService resource. */
+    liveTraceConfiguration?: LiveTraceConfiguration;
+    /** Resource log configuration of a Microsoft.SignalRService resource. */
+    resourceLogConfiguration?: ResourceLogConfiguration;
+    /** Network ACLs for the resource */
+    networkACLs?: WebPubSubNetworkACLs;
+    /** Application firewall settings for the resource */
+    applicationFirewall?: ApplicationFirewallSettings;
+    /**
+     * Enable or disable public network access. Default to "Enabled".
+     * When it's Enabled, network ACLs still apply.
+     * When it's Disabled, public network access is always disabled no matter what you set in network ACLs.
+     */
+    publicNetworkAccess?: string;
+    /**
+     * DisableLocalAuth
+     * Enable or disable local auth with AccessKey
+     * When set as true, connection with AccessKey=xxx won't work.
+     */
+    disableLocalAuth?: boolean;
+    /**
+     * DisableLocalAuth
+     * Enable or disable aad auth
+     * When set as true, connection with AuthType=aad won't work.
+     */
+    disableAadAuth?: boolean;
+    /**
+     * Enable or disable the regional endpoint. Default to "Enabled".
+     * When it's Disabled, new connections will not be routed to this endpoint, however existing connections will not be affected.
+     * This property is replica specific. Disable the regional endpoint without replica is not allowed.
+     */
+    regionEndpointEnabled?: string;
+    /**
+     * Stop or start the resource.  Default to "False".
+     * When it's true, the data plane of the resource is shutdown.
+     * When it's false, the data plane of the resource is started.
+     */
+    resourceStopped?: string;
+    /** SocketIO settings for the resource */
+    socketIO?: WebPubSubSocketIOSettings;
+}
+export declare function webPubSubResourceSerializer(item: WebPubSubResource): any;
+export declare function webPubSubResourceDeserializer(item: any): WebPubSubResource;
+/** A class that describes the properties of the resource */
+export interface WebPubSubProperties {
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** The publicly accessible IP of the resource. */
+    readonly externalIP?: string;
+    /** FQDN of the service instance. */
+    readonly hostName?: string;
+    /** The publicly accessible port of the resource which is designed for browser/client side usage. */
+    readonly publicPort?: number;
+    /** The publicly accessible port of the resource which is designed for customer server side usage. */
+    readonly serverPort?: number;
+    /** Version of the resource. Probably you need the same or higher version of client SDKs. */
+    readonly version?: string;
+    /** Private endpoint connections to the resource. */
+    readonly privateEndpointConnections?: PrivateEndpointConnection[];
+    /** The list of shared private link resources. */
+    readonly sharedPrivateLinkResources?: SharedPrivateLinkResource[];
+    /** TLS settings for the resource */
+    tls?: WebPubSubTlsSettings;
+    /** Deprecated. */
+    readonly hostNamePrefix?: string;
+    /** Live trace configuration of a Microsoft.SignalRService resource. */
+    liveTraceConfiguration?: LiveTraceConfiguration;
+    /** Resource log configuration of a Microsoft.SignalRService resource. */
+    resourceLogConfiguration?: ResourceLogConfiguration;
+    /** Network ACLs for the resource */
+    networkACLs?: WebPubSubNetworkACLs;
+    /** Application firewall settings for the resource */
+    applicationFirewall?: ApplicationFirewallSettings;
+    /**
+     * Enable or disable public network access. Default to "Enabled".
+     * When it's Enabled, network ACLs still apply.
+     * When it's Disabled, public network access is always disabled no matter what you set in network ACLs.
+     */
+    publicNetworkAccess?: string;
+    /**
+     * DisableLocalAuth
+     * Enable or disable local auth with AccessKey
+     * When set as true, connection with AccessKey=xxx won't work.
+     */
+    disableLocalAuth?: boolean;
+    /**
+     * DisableLocalAuth
+     * Enable or disable aad auth
+     * When set as true, connection with AuthType=aad won't work.
+     */
+    disableAadAuth?: boolean;
+    /**
+     * Enable or disable the regional endpoint. Default to "Enabled".
+     * When it's Disabled, new connections will not be routed to this endpoint, however existing connections will not be affected.
+     * This property is replica specific. Disable the regional endpoint without replica is not allowed.
+     */
+    regionEndpointEnabled?: string;
+    /**
+     * Stop or start the resource.  Default to "False".
+     * When it's true, the data plane of the resource is shutdown.
+     * When it's false, the data plane of the resource is started.
+     */
+    resourceStopped?: string;
+    /** SocketIO settings for the resource */
+    socketIO?: WebPubSubSocketIOSettings;
+}
+export declare function webPubSubPropertiesSerializer(item: WebPubSubProperties): any;
+export declare function webPubSubPropertiesDeserializer(item: any): WebPubSubProperties;
+export declare function privateEndpointConnectionArraySerializer(result: Array<PrivateEndpointConnection>): any[];
+export declare function privateEndpointConnectionArrayDeserializer(result: Array<PrivateEndpointConnection>): any[];
+/** A private endpoint connection to an azure resource */
+export interface PrivateEndpointConnection extends ProxyResource {
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** Private endpoint */
+    privateEndpoint?: PrivateEndpoint;
+    /** Group IDs */
+    readonly groupIds?: string[];
+    /** Connection state of the private endpoint connection */
+    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
+}
+export declare function privateEndpointConnectionSerializer(item: PrivateEndpointConnection): any;
+export declare function privateEndpointConnectionDeserializer(item: any): PrivateEndpointConnection;
+/** Private endpoint connection properties */
+export interface PrivateEndpointConnectionProperties {
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** Private endpoint */
+    privateEndpoint?: PrivateEndpoint;
+    /** Group IDs */
+    readonly groupIds?: string[];
+    /** Connection state of the private endpoint connection */
+    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
+}
+export declare function privateEndpointConnectionPropertiesSerializer(item: PrivateEndpointConnectionProperties): any;
+export declare function privateEndpointConnectionPropertiesDeserializer(item: any): PrivateEndpointConnectionProperties;
+/** Private endpoint */
+export interface PrivateEndpoint {
+    /** Full qualified Id of the private endpoint */
+    id?: string;
+}
+export declare function privateEndpointSerializer(item: PrivateEndpoint): any;
+export declare function privateEndpointDeserializer(item: any): PrivateEndpoint;
+/** Connection state of the private endpoint connection */
+export interface PrivateLinkServiceConnectionState {
+    /** Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service. */
+    status?: PrivateLinkServiceConnectionStatus;
+    /** The reason for approval/rejection of the connection. */
+    description?: string;
+    /** A message indicating if changes on the service provider require any updates on the consumer. */
+    actionsRequired?: string;
+}
+export declare function privateLinkServiceConnectionStateSerializer(item: PrivateLinkServiceConnectionState): any;
+export declare function privateLinkServiceConnectionStateDeserializer(item: any): PrivateLinkServiceConnectionState;
+/** Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service. */
+export declare enum KnownPrivateLinkServiceConnectionStatus {
+    /** Pending */
+    Pending = "Pending",
+    /** Approved */
+    Approved = "Approved",
+    /** Rejected */
+    Rejected = "Rejected",
+    /** Disconnected */
+    Disconnected = "Disconnected"
+}
+/**
+ * Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service. \
+ * {@link KnownPrivateLinkServiceConnectionStatus} can be used interchangeably with PrivateLinkServiceConnectionStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Pending** \
+ * **Approved** \
+ * **Rejected** \
+ * **Disconnected**
+ */
+export type PrivateLinkServiceConnectionStatus = string;
+/** TLS settings for the resource */
+export interface WebPubSubTlsSettings {
+    /** Request client certificate during TLS handshake if enabled. Not supported for free tier. Any input will be ignored for free tier. */
+    clientCertEnabled?: boolean;
+}
+export declare function webPubSubTlsSettingsSerializer(item: WebPubSubTlsSettings): any;
+export declare function webPubSubTlsSettingsDeserializer(item: any): WebPubSubTlsSettings;
+/** Live trace configuration of a Microsoft.SignalRService resource. */
+export interface LiveTraceConfiguration {
+    /**
+     * Indicates whether or not enable live trace.
+     * When it's set to true, live trace client can connect to the service.
+     * Otherwise, live trace client can't connect to the service, so that you are unable to receive any log, no matter what you configure in "categories".
+     * Available values: true, false.
+     * Case insensitive.
+     */
+    enabled?: string;
+    /** Gets or sets the list of category configurations. */
+    categories?: LiveTraceCategory[];
+}
+export declare function liveTraceConfigurationSerializer(item: LiveTraceConfiguration): any;
+export declare function liveTraceConfigurationDeserializer(item: any): LiveTraceConfiguration;
+export declare function liveTraceCategoryArraySerializer(result: Array<LiveTraceCategory>): any[];
+export declare function liveTraceCategoryArrayDeserializer(result: Array<LiveTraceCategory>): any[];
+/** Live trace category configuration of a Microsoft.SignalRService resource. */
+export interface LiveTraceCategory {
+    /**
+     * Gets or sets the live trace category's name.
+     * Available values: ConnectivityLogs, MessagingLogs.
+     * Case insensitive.
+     */
+    name?: string;
+    /**
+     * Indicates whether or the live trace category is enabled.
+     * Available values: true, false.
+     * Case insensitive.
+     */
+    enabled?: string;
+}
+export declare function liveTraceCategorySerializer(item: LiveTraceCategory): any;
+export declare function liveTraceCategoryDeserializer(item: any): LiveTraceCategory;
+/** Resource log configuration of a Microsoft.SignalRService resource. */
+export interface ResourceLogConfiguration {
+    /** Gets or sets the list of category configurations. */
+    categories?: ResourceLogCategory[];
+}
+export declare function resourceLogConfigurationSerializer(item: ResourceLogConfiguration): any;
+export declare function resourceLogConfigurationDeserializer(item: any): ResourceLogConfiguration;
+export declare function resourceLogCategoryArraySerializer(result: Array<ResourceLogCategory>): any[];
+export declare function resourceLogCategoryArrayDeserializer(result: Array<ResourceLogCategory>): any[];
+/** Resource log category configuration of a Microsoft.SignalRService resource. */
+export interface ResourceLogCategory {
+    /**
+     * Gets or sets the resource log category's name.
+     * Available values: ConnectivityLogs, MessagingLogs.
+     * Case insensitive.
+     */
+    name?: string;
+    /**
+     * Indicates whether or the resource log category is enabled.
+     * Available values: true, false.
+     * Case insensitive.
+     */
+    enabled?: string;
+}
+export declare function resourceLogCategorySerializer(item: ResourceLogCategory): any;
+export declare function resourceLogCategoryDeserializer(item: any): ResourceLogCategory;
+/** Network ACLs for the resource */
+export interface WebPubSubNetworkACLs {
+    /** Azure Networking ACL Action. */
+    defaultAction?: ACLAction;
+    /** Network ACL */
+    publicNetwork?: NetworkACL;
+    /** ACLs for requests from private endpoints */
+    privateEndpoints?: PrivateEndpointACL[];
+    /** IP rules for filtering public traffic */
+    ipRules?: IPRule[];
+}
+export declare function webPubSubNetworkACLsSerializer(item: WebPubSubNetworkACLs): any;
+export declare function webPubSubNetworkACLsDeserializer(item: any): WebPubSubNetworkACLs;
+/** Azure Networking ACL Action. */
+export declare enum KnownACLAction {
+    /** Allow */
+    Allow = "Allow",
+    /** Deny */
+    Deny = "Deny"
+}
+/**
+ * Azure Networking ACL Action. \
+ * {@link KnownACLAction} can be used interchangeably with ACLAction,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Allow** \
+ * **Deny**
+ */
+export type ACLAction = string;
+/** Network ACL */
+export interface NetworkACL {
+    /** Allowed request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI. */
+    allow?: WebPubSubRequestType[];
+    /** Denied request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI. */
+    deny?: WebPubSubRequestType[];
+}
+export declare function networkACLSerializer(item: NetworkACL): any;
+export declare function networkACLDeserializer(item: any): NetworkACL;
+/** The incoming request type to the service */
+export declare enum KnownWebPubSubRequestType {
+    /** ClientConnection */
+    ClientConnection = "ClientConnection",
+    /** ServerConnection */
+    ServerConnection = "ServerConnection",
+    /** RESTAPI */
+    Restapi = "RESTAPI",
+    /** Trace */
+    Trace = "Trace"
+}
+/**
+ * The incoming request type to the service \
+ * {@link KnownWebPubSubRequestType} can be used interchangeably with WebPubSubRequestType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ClientConnection** \
+ * **ServerConnection** \
+ * **RESTAPI** \
+ * **Trace**
+ */
+export type WebPubSubRequestType = string;
+export declare function privateEndpointACLArraySerializer(result: Array<PrivateEndpointACL>): any[];
+export declare function privateEndpointACLArrayDeserializer(result: Array<PrivateEndpointACL>): any[];
+/** ACL for a private endpoint */
+export interface PrivateEndpointACL extends NetworkACL {
+    /** Name of the private endpoint connection */
+    name: string;
+}
+export declare function privateEndpointACLSerializer(item: PrivateEndpointACL): any;
+export declare function privateEndpointACLDeserializer(item: any): PrivateEndpointACL;
+export declare function ipRuleArraySerializer(result: Array<IPRule>): any[];
+export declare function ipRuleArrayDeserializer(result: Array<IPRule>): any[];
+/** An IP rule */
+export interface IPRule {
+    /** An IP or CIDR or ServiceTag */
+    value?: string;
+    /** Azure Networking ACL Action. */
+    action?: ACLAction;
+}
+export declare function ipRuleSerializer(item: IPRule): any;
+export declare function ipRuleDeserializer(item: any): IPRule;
+/** Application firewall settings for the resource */
+export interface ApplicationFirewallSettings {
+    /** Rules to control the client connection count */
+    clientConnectionCountRules?: ClientConnectionCountRuleUnion[];
+    /** Rules to control the client traffic */
+    clientTrafficControlRules?: ClientTrafficControlRuleUnion[];
+    /** Config to control the client connection lifetime in seconds, can be set to 0 to disable the config */
+    maxClientConnectionLifetimeInSeconds?: number;
+}
+export declare function applicationFirewallSettingsSerializer(item: ApplicationFirewallSettings): any;
+export declare function applicationFirewallSettingsDeserializer(item: any): ApplicationFirewallSettings;
+export declare function clientConnectionCountRuleUnionArraySerializer(result: Array<ClientConnectionCountRuleUnion>): any[];
+export declare function clientConnectionCountRuleUnionArrayDeserializer(result: Array<ClientConnectionCountRuleUnion>): any[];
+/** A base class for client connection count rules */
+export interface ClientConnectionCountRule {
+    type: ClientConnectionCountRuleDiscriminator;
+}
+export declare function clientConnectionCountRuleSerializer(item: ClientConnectionCountRule): any;
+export declare function clientConnectionCountRuleDeserializer(item: any): ClientConnectionCountRule;
+/** Alias for ClientConnectionCountRuleUnion */
+export type ClientConnectionCountRuleUnion = ThrottleByJwtCustomClaimRule | ThrottleByJwtSignatureRule | ThrottleByUserIdRule | ClientConnectionCountRule;
+export declare function clientConnectionCountRuleUnionSerializer(item: ClientConnectionCountRuleUnion): any;
+export declare function clientConnectionCountRuleUnionDeserializer(item: any): ClientConnectionCountRuleUnion;
+/** Known values of {@link ClientConnectionCountRuleDiscriminator} that the service accepts. */
+export declare enum KnownClientConnectionCountRuleDiscriminator {
+    /** ThrottleByJwtSignatureRule */
+    ThrottleByJwtSignatureRule = "ThrottleByJwtSignatureRule",
+    /** ThrottleByUserIdRule */
+    ThrottleByUserIdRule = "ThrottleByUserIdRule",
+    /** ThrottleByJwtCustomClaimRule */
+    ThrottleByJwtCustomClaimRule = "ThrottleByJwtCustomClaimRule"
+}
+/** Type of ClientConnectionCountRuleDiscriminator */
+export type ClientConnectionCountRuleDiscriminator = string;
+/** Throttle the client connection by a custom JWT claim */
+export interface ThrottleByJwtCustomClaimRule extends ClientConnectionCountRule {
+    /** The name of the claim in the JWT token. The client connection with the same claim value will be aggregated. If the claim is not found in the token, the connection will be allowed. */
+    claimName: string;
+    /** Maximum connection count allowed for the same Jwt claim value. Clients with the same Jwt claim will get rejected if the connection count exceeds this value. Default value is 20. */
+    maxCount?: number;
+    type: "ThrottleByJwtCustomClaimRule";
+}
+export declare function throttleByJwtCustomClaimRuleSerializer(item: ThrottleByJwtCustomClaimRule): any;
+export declare function throttleByJwtCustomClaimRuleDeserializer(item: any): ThrottleByJwtCustomClaimRule;
+/** Throttle the client connection by the JWT signature */
+export interface ThrottleByJwtSignatureRule extends ClientConnectionCountRule {
+    /** Maximum connection count allowed for the same JWT signature. Clients with the same JWT signature will get rejected if the connection count exceeds this value. Default value is 20. */
+    maxCount?: number;
+    type: "ThrottleByJwtSignatureRule";
+}
+export declare function throttleByJwtSignatureRuleSerializer(item: ThrottleByJwtSignatureRule): any;
+export declare function throttleByJwtSignatureRuleDeserializer(item: any): ThrottleByJwtSignatureRule;
+/** Throttle the client connection by the user ID */
+export interface ThrottleByUserIdRule extends ClientConnectionCountRule {
+    /** Maximum connection count allowed for the same user ID. Clients with the same user ID will get rejected if the connection count exceeds this value. Default value is 20. */
+    maxCount?: number;
+    type: "ThrottleByUserIdRule";
+}
+export declare function throttleByUserIdRuleSerializer(item: ThrottleByUserIdRule): any;
+export declare function throttleByUserIdRuleDeserializer(item: any): ThrottleByUserIdRule;
+export declare function clientTrafficControlRuleUnionArraySerializer(result: Array<ClientTrafficControlRuleUnion>): any[];
+export declare function clientTrafficControlRuleUnionArrayDeserializer(result: Array<ClientTrafficControlRuleUnion>): any[];
+/** A base class for client traffic control rules */
+export interface ClientTrafficControlRule {
+    type: ClientTrafficControlRuleDiscriminator;
+}
+export declare function clientTrafficControlRuleSerializer(item: ClientTrafficControlRule): any;
+export declare function clientTrafficControlRuleDeserializer(item: any): ClientTrafficControlRule;
+/** Alias for ClientTrafficControlRuleUnion */
+export type ClientTrafficControlRuleUnion = TrafficThrottleByJwtCustomClaimRule | TrafficThrottleByJwtSignatureRule | TrafficThrottleByUserIdRule | ClientTrafficControlRule;
+export declare function clientTrafficControlRuleUnionSerializer(item: ClientTrafficControlRuleUnion): any;
+export declare function clientTrafficControlRuleUnionDeserializer(item: any): ClientTrafficControlRuleUnion;
+/** Known values of {@link ClientTrafficControlRuleDiscriminator} that the service accepts. */
+export declare enum KnownClientTrafficControlRuleDiscriminator {
+    /** TrafficThrottleByJwtSignatureRule */
+    TrafficThrottleByJwtSignatureRule = "TrafficThrottleByJwtSignatureRule",
+    /** TrafficThrottleByUserIdRule */
+    TrafficThrottleByUserIdRule = "TrafficThrottleByUserIdRule",
+    /** TrafficThrottleByJwtCustomClaimRule */
+    TrafficThrottleByJwtCustomClaimRule = "TrafficThrottleByJwtCustomClaimRule"
+}
+/** Type of ClientTrafficControlRuleDiscriminator */
+export type ClientTrafficControlRuleDiscriminator = string;
+/** Throttle the client traffic by a custom JWT claim */
+export interface TrafficThrottleByJwtCustomClaimRule extends ClientTrafficControlRule {
+    /** The name of the claim in the JWT token. The message bytes with the same claim value will be aggregated. If the claim is not found in the token, the rule will be skipped. */
+    claimName: string;
+    /** Maximum accumulated inbound message bytes allowed for the same JWT signature within a time window. Clients with the same JWT claim will get disconnected if the message bytes exceeds this value. Default value is 1GB. */
+    maxInboundMessageBytes?: number;
+    /** The aggregation window for the message bytes. The message bytes will be aggregated in this window and be reset after the window. Default value is 60 seconds. */
+    aggregationWindowInSeconds?: number;
+    type: "TrafficThrottleByJwtCustomClaimRule";
+}
+export declare function trafficThrottleByJwtCustomClaimRuleSerializer(item: TrafficThrottleByJwtCustomClaimRule): any;
+export declare function trafficThrottleByJwtCustomClaimRuleDeserializer(item: any): TrafficThrottleByJwtCustomClaimRule;
+/** Throttle the client traffic by the JWT signature */
+export interface TrafficThrottleByJwtSignatureRule extends ClientTrafficControlRule {
+    /** Maximum accumulated inbound message bytes allowed for the same JWT signature within a time window. Clients with the same JWT signature will get disconnected if the message bytes exceeds this value. Default value is 1GB. */
+    maxInboundMessageBytes?: number;
+    /** The aggregation window for the message bytes. The message bytes will be aggregated in this window and be reset after the window. Default value is 60 seconds. */
+    aggregationWindowInSeconds?: number;
+    type: "TrafficThrottleByJwtSignatureRule";
+}
+export declare function trafficThrottleByJwtSignatureRuleSerializer(item: TrafficThrottleByJwtSignatureRule): any;
+export declare function trafficThrottleByJwtSignatureRuleDeserializer(item: any): TrafficThrottleByJwtSignatureRule;
+/** Throttle the client traffic by the user ID */
+export interface TrafficThrottleByUserIdRule extends ClientTrafficControlRule {
+    /** Maximum accumulated inbound message bytes allowed for the same user ID within a time window. Clients with the same user ID will get disconnected if the message bytes exceeds this value. Default value is 1GB. */
+    maxInboundMessageBytes?: number;
+    /** The aggregation window for the message bytes. The message bytes will be aggregated in this window and be reset after the window. Default value is 60 seconds. */
+    aggregationWindowInSeconds?: number;
+    type: "TrafficThrottleByUserIdRule";
+}
+export declare function trafficThrottleByUserIdRuleSerializer(item: TrafficThrottleByUserIdRule): any;
+export declare function trafficThrottleByUserIdRuleDeserializer(item: any): TrafficThrottleByUserIdRule;
+/** SocketIO settings for the resource */
+export interface WebPubSubSocketIOSettings {
+    /**
+     * The service mode of Web PubSub for Socket.IO. Values allowed:
+     * "Default": have your own backend Socket.IO server
+     * "Serverless": your application doesn't have a backend server
+     */
+    serviceMode?: string;
+}
+export declare function webPubSubSocketIOSettingsSerializer(item: WebPubSubSocketIOSettings): any;
+export declare function webPubSubSocketIOSettingsDeserializer(item: any): WebPubSubSocketIOSettings;
+/** The billing information of the resource. */
+export interface ResourceSku {
+    /**
+     * The name of the SKU. Required.
+     *
+     * Allowed values: Standard_S1, Free_F1, Premium_P1, Premium_P2
+     */
+    name: string;
+    /**
+     * Optional tier of this particular SKU. 'Standard' or 'Free'.
+     *
+     * `Basic` is deprecated, use `Standard` instead.
+     */
+    tier?: WebPubSubSkuTier;
+    /** Not used. Retained for future use. */
+    readonly size?: string;
+    /** Not used. Retained for future use. */
+    readonly family?: string;
+    /**
+     * Optional, integer. The unit count of the resource.
+     * 1 for Free_F1/Standard_S1/Premium_P1, 100 for Premium_P2 by default.
+     *
+     * If present, following values are allowed:
+     * Free_F1: 1;
+     * Standard_S1: 1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100;
+     * Premium_P1:  1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100;
+     * Premium_P2:  100,200,300,400,500,600,700,800,900,1000;
+     */
+    capacity?: number;
+}
+export declare function resourceSkuSerializer(item: ResourceSku): any;
+export declare function resourceSkuDeserializer(item: any): ResourceSku;
+/**
+ * Optional tier of this particular SKU. 'Standard' or 'Free'.
+ *
+ * `Basic` is deprecated, use `Standard` instead.
+ */
+export declare enum KnownWebPubSubSkuTier {
+    /** Free tier for WebPubSub service */
+    Free = "Free",
+    /** Basic tier for WebPubSub service (deprecated, use Standard instead) */
+    Basic = "Basic",
+    /** Standard tier for WebPubSub service */
+    Standard = "Standard",
+    /** Premium tier for WebPubSub service */
+    Premium = "Premium"
+}
+/**
+ * Optional tier of this particular SKU. 'Standard' or 'Free'.
+ *
+ * `Basic` is deprecated, use `Standard` instead. \
+ * {@link KnownWebPubSubSkuTier} can be used interchangeably with WebPubSubSkuTier,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Free**: Free tier for WebPubSub service \
+ * **Basic**: Basic tier for WebPubSub service (deprecated, use Standard instead) \
+ * **Standard**: Standard tier for WebPubSub service \
+ * **Premium**: Premium tier for WebPubSub service
+ */
+export type WebPubSubSkuTier = string;
+/** The kind of the service */
+export declare enum KnownServiceKind {
+    /** WebPubSub */
+    WebPubSub = "WebPubSub",
+    /** SocketIO */
+    SocketIO = "SocketIO"
+}
+/**
+ * The kind of the service \
+ * {@link KnownServiceKind} can be used interchangeably with ServiceKind,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **WebPubSub** \
+ * **SocketIO**
+ */
+export type ServiceKind = string;
+/** A class represent managed identities used for request and response */
+export interface ManagedIdentity {
+    /** Represents the identity type: systemAssigned, userAssigned, None */
+    type?: ManagedIdentityType;
+    /** Get or set the user assigned identities */
+    userAssignedIdentities?: Record<string, UserAssignedIdentityProperty>;
+    /**
+     * Get the principal id for the system assigned identity.
+     * Only be used in response.
+     */
+    readonly principalId?: string;
+    /**
+     * Get the tenant id for the system assigned identity.
+     * Only be used in response
+     */
+    readonly tenantId?: string;
+}
+export declare function managedIdentitySerializer(item: ManagedIdentity): any;
+export declare function managedIdentityDeserializer(item: any): ManagedIdentity;
+/** Represents the identity type: systemAssigned, userAssigned, None */
+export declare enum KnownManagedIdentityType {
+    /** None */
+    None = "None",
+    /** SystemAssigned */
+    SystemAssigned = "SystemAssigned",
+    /** UserAssigned */
+    UserAssigned = "UserAssigned"
+}
+/**
+ * Represents the identity type: systemAssigned, userAssigned, None \
+ * {@link KnownManagedIdentityType} can be used interchangeably with ManagedIdentityType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None** \
+ * **SystemAssigned** \
+ * **UserAssigned**
+ */
+export type ManagedIdentityType = string;
+export declare function userAssignedIdentityPropertyRecordSerializer(item: Record<string, UserAssignedIdentityProperty>): Record<string, any>;
+export declare function userAssignedIdentityPropertyRecordDeserializer(item: Record<string, any>): Record<string, UserAssignedIdentityProperty>;
+/** Properties of user assigned identity. */
+export interface UserAssignedIdentityProperty {
+    /** Get the principal id for the user assigned identity */
+    readonly principalId?: string;
+    /** Get the client id for the user assigned identity */
+    readonly clientId?: string;
+}
+export declare function userAssignedIdentityPropertySerializer(_item: UserAssignedIdentityProperty): any;
+export declare function userAssignedIdentityPropertyDeserializer(item: any): UserAssignedIdentityProperty;
+/** The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location' */
+export interface TrackedResource extends Resource {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The geo-location where the resource lives */
+    location: string;
+}
+export declare function trackedResourceSerializer(item: TrackedResource): any;
+export declare function trackedResourceDeserializer(item: any): TrackedResource;
+/** Object that includes an array of resources and a possible link for next set. */
+export interface _WebPubSubResourceList {
+    /** The WebPubSubResource items on this page */
+    value: WebPubSubResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _webPubSubResourceListDeserializer(item: any): _WebPubSubResourceList;
+export declare function webPubSubResourceArraySerializer(result: Array<WebPubSubResource>): any[];
+export declare function webPubSubResourceArrayDeserializer(result: Array<WebPubSubResource>): any[];
+/** A class represents the access keys of the resource. */
+export interface WebPubSubKeys {
+    /** The primary access key. */
+    primaryKey?: string;
+    /** The secondary access key. */
+    secondaryKey?: string;
+    /** Connection string constructed via the primaryKey */
+    primaryConnectionString?: string;
+    /** Connection string constructed via the secondaryKey */
+    secondaryConnectionString?: string;
+}
+export declare function webPubSubKeysDeserializer(item: any): WebPubSubKeys;
+/** Parameters describes the request to regenerate access keys */
+export interface RegenerateKeyParameters {
+    /** The type of access key. */
+    keyType?: KeyType;
+}
+export declare function regenerateKeyParametersSerializer(item: RegenerateKeyParameters): any;
+/** The type of access key. */
+export declare enum KnownKeyType {
+    /** Primary */
+    Primary = "Primary",
+    /** Secondary */
+    Secondary = "Secondary",
+    /** Salt */
+    Salt = "Salt"
+}
+/**
+ * The type of access key. \
+ * {@link KnownKeyType} can be used interchangeably with KeyType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Primary** \
+ * **Secondary** \
+ * **Salt**
+ */
+export type KeyType = string;
+/** The list skus operation response */
+export interface SkuList {
+    /** The list of skus available for the resource. */
+    readonly value?: Sku[];
+    /**
+     * The URL the client should use to fetch the next page (per server side paging).
+     * It's null for now, added for future use.
+     */
+    readonly nextLink?: string;
+}
+export declare function skuListDeserializer(item: any): SkuList;
+export declare function skuArrayDeserializer(result: Array<Sku>): any[];
+/** Describes an available sku." */
+export interface Sku {
+    /** The resource type that this object applies to */
+    readonly resourceType?: string;
+    /** The billing information of the resource. */
+    readonly sku?: ResourceSku;
+    /** Describes scaling information of a sku. */
+    readonly capacity?: SkuCapacity;
+}
+export declare function skuDeserializer(item: any): Sku;
+/** Describes scaling information of a sku. */
+export interface SkuCapacity {
+    /** The lowest permitted capacity for this resource */
+    readonly minimum?: number;
+    /** The highest permitted capacity for this resource */
+    readonly maximum?: number;
+    /** The default capacity. */
+    readonly default?: number;
+    /** Allows capacity value list. */
+    readonly allowedValues?: number[];
+    /** The scale type applicable to the sku. */
+    readonly scaleType?: ScaleType;
+}
+export declare function skuCapacityDeserializer(item: any): SkuCapacity;
+/** The scale type applicable to the sku. */
+export declare enum KnownScaleType {
+    /** None */
+    None = "None",
+    /** Manual */
+    Manual = "Manual",
+    /** Automatic */
+    Automatic = "Automatic"
+}
+/**
+ * The scale type applicable to the sku. \
+ * {@link KnownScaleType} can be used interchangeably with ScaleType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None** \
+ * **Manual** \
+ * **Automatic**
+ */
+export type ScaleType = string;
+/** Data POST-ed to the nameAvailability action */
+export interface NameAvailabilityParameters {
+    /** The resource type. Can be "Microsoft.SignalRService/SignalR", "Microsoft.SignalRService/WebPubSub", "Microsoft.SignalRService/SignalR/replicas" or "Microsoft.SignalRService/WebPubSub/replicas" */
+    type: string;
+    /** The resource name to validate. e.g."my-resource-name" */
+    name: string;
+}
+export declare function nameAvailabilityParametersSerializer(item: NameAvailabilityParameters): any;
+/** Result of the request to check name availability. It contains a flag and possible reason of failure. */
+export interface NameAvailability {
+    /** Indicates whether the name is available or not. */
+    nameAvailable?: boolean;
+    /** The reason of the availability. Required if name is not available. */
+    reason?: string;
+    /** The message of the operation. */
+    message?: string;
+}
+export declare function nameAvailabilityDeserializer(item: any): NameAvailability;
+/** Contains a list of PrivateLinkResource and a possible link to query more results */
+export interface _PrivateLinkResourceList {
+    /** The PrivateLinkResource items on this page */
+    value: PrivateLinkResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _privateLinkResourceListDeserializer(item: any): _PrivateLinkResourceList;
+export declare function privateLinkResourceArrayDeserializer(result: Array<PrivateLinkResource>): any[];
+/** Private link resource */
+export interface PrivateLinkResource extends ProxyResource {
+    /** Group Id of the private link resource */
+    groupId?: string;
+    /** Required members of the private link resource */
+    requiredMembers?: string[];
+    /** Required private DNS zone names */
+    requiredZoneNames?: string[];
+    /** The list of resources that are onboarded to private link service */
+    shareablePrivateLinkResourceTypes?: ShareablePrivateLinkResourceType[];
+}
+export declare function privateLinkResourceDeserializer(item: any): PrivateLinkResource;
+/** Private link resource properties */
+export interface PrivateLinkResourceProperties {
+    /** Group Id of the private link resource */
+    groupId?: string;
+    /** Required members of the private link resource */
+    requiredMembers?: string[];
+    /** Required private DNS zone names */
+    requiredZoneNames?: string[];
+    /** The list of resources that are onboarded to private link service */
+    shareablePrivateLinkResourceTypes?: ShareablePrivateLinkResourceType[];
+}
+export declare function privateLinkResourcePropertiesDeserializer(item: any): PrivateLinkResourceProperties;
+export declare function shareablePrivateLinkResourceTypeArrayDeserializer(result: Array<ShareablePrivateLinkResourceType>): any[];
+/** Describes a  resource type that has been onboarded to private link service */
+export interface ShareablePrivateLinkResourceType {
+    /** The name of the resource type that has been onboarded to private link service */
+    name?: string;
+    /** Describes the properties of a resource type that has been onboarded to private link service */
+    properties?: ShareablePrivateLinkResourceProperties;
+}
+export declare function shareablePrivateLinkResourceTypeDeserializer(item: any): ShareablePrivateLinkResourceType;
+/** Describes the properties of a resource type that has been onboarded to private link service */
+export interface ShareablePrivateLinkResourceProperties {
+    /** The description of the resource type that has been onboarded to private link service */
+    description?: string;
+    /** The resource provider group id for the resource that has been onboarded to private link service */
+    groupId?: string;
+    /** The resource provider type for the resource that has been onboarded to private link service */
+    type?: string;
+}
+export declare function shareablePrivateLinkResourcePropertiesDeserializer(item: any): ShareablePrivateLinkResourceProperties;
+/** A custom certificate. */
+export interface CustomCertificate extends ProxyResource {
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** Base uri of the KeyVault that stores certificate. */
+    keyVaultBaseUri: string;
+    /** Certificate secret name. */
+    keyVaultSecretName: string;
+    /** Certificate secret version. */
+    keyVaultSecretVersion?: string;
+}
+export declare function customCertificateSerializer(item: CustomCertificate): any;
+export declare function customCertificateDeserializer(item: any): CustomCertificate;
+/** Custom certificate properties. */
+export interface CustomCertificateProperties {
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** Base uri of the KeyVault that stores certificate. */
+    keyVaultBaseUri: string;
+    /** Certificate secret name. */
+    keyVaultSecretName: string;
+    /** Certificate secret version. */
+    keyVaultSecretVersion?: string;
+}
+export declare function customCertificatePropertiesSerializer(item: CustomCertificateProperties): any;
+export declare function customCertificatePropertiesDeserializer(item: any): CustomCertificateProperties;
+/** Custom certificates list. */
+export interface _CustomCertificateList {
+    /** The CustomCertificate items on this page */
+    value: CustomCertificate[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _customCertificateListDeserializer(item: any): _CustomCertificateList;
+export declare function customCertificateArraySerializer(result: Array<CustomCertificate>): any[];
+export declare function customCertificateArrayDeserializer(result: Array<CustomCertificate>): any[];
+/** A custom domain */
+export interface CustomDomain extends ProxyResource {
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** The custom domain name. */
+    domainName: string;
+    /** Reference to a resource. */
+    customCertificate: ResourceReference;
+}
+export declare function customDomainSerializer(item: CustomDomain): any;
+export declare function customDomainDeserializer(item: any): CustomDomain;
+/** Properties of a custom domain. */
+export interface CustomDomainProperties {
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** The custom domain name. */
+    domainName: string;
+    /** Reference to a resource. */
+    customCertificate: ResourceReference;
+}
+export declare function customDomainPropertiesSerializer(item: CustomDomainProperties): any;
+export declare function customDomainPropertiesDeserializer(item: any): CustomDomainProperties;
+/** Reference to a resource. */
+export interface ResourceReference {
+    /** Resource ID. */
+    id?: string;
+}
+export declare function resourceReferenceSerializer(item: ResourceReference): any;
+export declare function resourceReferenceDeserializer(item: any): ResourceReference;
+/** Custom domains list */
+export interface _CustomDomainList {
+    /** The CustomDomain items on this page */
+    value: CustomDomain[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _customDomainListDeserializer(item: any): _CustomDomainList;
+export declare function customDomainArraySerializer(result: Array<CustomDomain>): any[];
+export declare function customDomainArrayDeserializer(result: Array<CustomDomain>): any[];
+/** A list of private endpoint connections */
+export interface _PrivateEndpointConnectionList {
+    /** The PrivateEndpointConnection items on this page */
+    value: PrivateEndpointConnection[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _privateEndpointConnectionListDeserializer(item: any): _PrivateEndpointConnectionList;
+/** A class represent a replica resource. */
+export interface Replica extends TrackedResource {
+    /** The billing information of the resource. */
+    sku?: ResourceSku;
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /**
+     * Enable or disable the regional endpoint. Default to "Enabled".
+     * When it's Disabled, new connections will not be routed to this endpoint, however existing connections will not be affected.
+     */
+    regionEndpointEnabled?: string;
+    /**
+     * Stop or start the resource.  Default to "false".
+     * When it's true, the data plane of the resource is shutdown.
+     * When it's false, the data plane of the resource is started.
+     */
+    resourceStopped?: string;
+}
+export declare function replicaSerializer(item: Replica): any;
+export declare function replicaDeserializer(item: any): Replica;
+/** model interface ReplicaProperties */
+export interface ReplicaProperties {
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /**
+     * Enable or disable the regional endpoint. Default to "Enabled".
+     * When it's Disabled, new connections will not be routed to this endpoint, however existing connections will not be affected.
+     */
+    regionEndpointEnabled?: string;
+    /**
+     * Stop or start the resource.  Default to "false".
+     * When it's true, the data plane of the resource is shutdown.
+     * When it's false, the data plane of the resource is started.
+     */
+    resourceStopped?: string;
+}
+export declare function replicaPropertiesSerializer(item: ReplicaProperties): any;
+export declare function replicaPropertiesDeserializer(item: any): ReplicaProperties;
+/** Paged collection of Replica items */
+export interface _ReplicaList {
+    /** The Replica items on this page */
+    value: Replica[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _replicaListDeserializer(item: any): _ReplicaList;
+export declare function replicaArraySerializer(result: Array<Replica>): any[];
+export declare function replicaArrayDeserializer(result: Array<Replica>): any[];
+/** Object that includes an array of the resource usages and a possible link for next set. */
+export interface _SignalRServiceUsageList {
+    /** The SignalRServiceUsage items on this page */
+    value: SignalRServiceUsage[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _signalRServiceUsageListDeserializer(item: any): _SignalRServiceUsageList;
+export declare function signalRServiceUsageArrayDeserializer(result: Array<SignalRServiceUsage>): any[];
+/** Object that describes a specific usage of the resources. */
+export interface SignalRServiceUsage {
+    /** Fully qualified ARM resource id */
+    id?: string;
+    /** Current value for the usage quota. */
+    currentValue?: number;
+    /** The maximum permitted value for the usage quota. If there is no limit, this value will be -1. */
+    limit?: number;
+    /** Localizable String object containing the name and a localized value. */
+    name?: SignalRServiceUsageName;
+    /** Representing the units of the usage quota. Possible values are: Count, Bytes, Seconds, Percent, CountPerSecond, BytesPerSecond. */
+    unit?: string;
+}
+export declare function signalRServiceUsageDeserializer(item: any): SignalRServiceUsage;
+/** Localizable String object containing the name and a localized value. */
+export interface SignalRServiceUsageName {
+    /** The identifier of the usage. */
+    value?: string;
+    /** Localized name of the usage. */
+    localizedValue?: string;
+}
+export declare function signalRServiceUsageNameDeserializer(item: any): SignalRServiceUsageName;
+/** The available API versions. */
+export declare enum KnownVersions {
+    /** The 2025-01-01-preview API version. */
+    V20250101Preview = "2025-01-01-preview",
+    /** The 2025-08-01-preview API version. */
+    V20250801Preview = "2025-08-01-preview"
+}
+export declare function _sharedPrivateLinkResourcePropertiesSerializer(item: SharedPrivateLinkResource): any;
+export declare function _sharedPrivateLinkResourcePropertiesDeserializer(item: any): {
+    groupId: any;
+    privateLinkResourceId: any;
+    provisioningState: any;
+    requestMessage: any;
+    fqdns: any;
+    status: any;
+};
+export declare function _privateEndpointConnectionPropertiesSerializer(item: PrivateEndpointConnection): any;
+export declare function _privateEndpointConnectionPropertiesDeserializer(item: any): {
+    provisioningState: any;
+    privateEndpoint: any;
+    groupIds: any;
+    privateLinkServiceConnectionState: any;
+};
+export declare function _webPubSubResourcePropertiesSerializer(item: WebPubSubResource): any;
+export declare function _webPubSubResourcePropertiesDeserializer(item: any): {
+    provisioningState: any;
+    externalIP: any;
+    hostName: any;
+    publicPort: any;
+    serverPort: any;
+    version: any;
+    privateEndpointConnections: any;
+    sharedPrivateLinkResources: any;
+    tls: any;
+    hostNamePrefix: any;
+    liveTraceConfiguration: any;
+    resourceLogConfiguration: any;
+    networkACLs: any;
+    applicationFirewall: any;
+    publicNetworkAccess: any;
+    disableLocalAuth: any;
+    disableAadAuth: any;
+    regionEndpointEnabled: any;
+    resourceStopped: any;
+    socketIO: any;
+};
+export declare function _privateLinkResourcePropertiesDeserializer(item: any): {
+    groupId: any;
+    requiredMembers: any;
+    requiredZoneNames: any;
+    shareablePrivateLinkResourceTypes: any;
+};
+export declare function _customCertificatePropertiesSerializer(item: CustomCertificate): any;
+export declare function _customCertificatePropertiesDeserializer(item: any): {
+    provisioningState: any;
+    keyVaultBaseUri: any;
+    keyVaultSecretName: any;
+    keyVaultSecretVersion: any;
+};
+export declare function _customDomainPropertiesSerializer(item: CustomDomain): any;
+export declare function _customDomainPropertiesDeserializer(item: any): {
+    provisioningState: any;
+    domainName: any;
+    customCertificate: ResourceReference;
+};
+export declare function _replicaPropertiesSerializer(item: Replica): any;
+export declare function _replicaPropertiesDeserializer(item: any): {
+    provisioningState: any;
+    regionEndpointEnabled: any;
+    resourceStopped: any;
+};
+//# sourceMappingURL=models.d.ts.map