beautify

types/fm-websync/index.d.ts

@@ -12,58 +12,58 @@ declare namespace fm {
              * (See disconnectConfig for details.) Note that automatic disconnects are a best-effort. The only way to guarantee success is to execute the disconnect synchronously
              * and target a request URL on the same domain as the page ({ sync: true, requestUrl: '...relative path.../request.ashx' }). Defaults to false.
              */
-            autoDisconnect ? : boolean;
+            autoDisconnect?: boolean;
 
             /**
              * The amount of time in milliseconds to add to the delay between each reconnect attempt in the event of network failure. Defaults to 3000 (3 seconds).
              */
 
-            backoffInterval ? : number;
+            backoffInterval?: number;
 
             /**
              * The URL of the HTML frame to be used with HTML5 postMessage for cross-domain environments. Must have the same domain as requestUrl.
              * Defaults to a dynamically generated URL based on the host of the client script URL (or the host web.config attribute, if specified) and the path to the WebSync Server
              * ClientHandler registered in web.config with "frame" added to the query.
              */
-            clientFrameUrl ? : string;
+            clientFrameUrl?: string;
 
             /**
              * The domain key to send with each request. If using WebSync On-Demand, this should be set to the public or private API key specified in the Frozen Mountain Portal.
              * If using WebSync Server, this should be used only if grouping connections. Defaults to "11111111-1111-1111-1111-111111111111".
              */
-            key ? : string;
+            key?: string;
 
             /**
              * The callback to invoke after onSuccess or onFailure. See initializeCompleteArgs for callback argument details.
              */
-            onComplete ? : (args: baseArgs) => void;
+            onComplete?: (args: baseArgs) => void;
 
             /**
              * The callback to invoke if the initialize fails. Defaults to an alert of the error. See initializeFailureArgs for callback argument details.
              */
-            onFailure ? : (args: initializeFailureArgs) => void;
+            onFailure?: (args: initializeFailureArgs) => void;
 
             /**
              * The callback to invoke if the initialize succeeds. See initializeSuccessArgs for callback argument details.
              */
-            onSuccess ? : (args: baseArgs) => void;
+            onSuccess?: (args: baseArgs) => void;
 
             /**
              * Whether or not to suppress the alerting of a failure if the client is already initialized.
              */
-            quiet ? : boolean;
+            quiet?: boolean;
 
             /**
              * The URL of the WebSync request handler. This URL typically ends with request.ashx. Must have the same domain as clientFrameUrl.
              * Defaults to a dynamically generated URL based on the host of the client script URL (or the host web.config attribute, if specified) and the path to the
              * WebSync Server RequestHandler registered in web.config.
              */
-            requestUrl ? : string;
+            requestUrl?: string;
 
             /**
              * The number of times to retry a request in the event of network failure before considering it failed and invoking the corresponding OnFailure callback. Defaults to 3.
              */
-            retries ? : number;
+            retries?: number;
 
             /**
              * The URLs to use for streaming connections. Three properties are available:
@@ -79,18 +79,18 @@ declare namespace fm {
              * timeout: number
              *      Same as the root timeout parameter, but used for streaming connections. Defaults to the root timeout + 25000 (25 seconds).
              */
-            stream ? : any;
+            stream?: any;
 
             /**
              * The number of milliseconds to wait for a standard request to return a response before it is cancelled and a new attempt is made. Defaults to 15000 (15 seconds).
              */
-            timeout ? : number;
+            timeout?: number;
 
             /**
              * The token sent with every client request identifying it for query-based load balancing. Defaults to the current timestamp.
              */
 
-            token ? : string;
+            token?: string;
 
             /**
              * An object specifying URLs to be used for specific client methods. Overrides initializeConfig.requestUrl for the specified method type, but can be overridden
@@ -117,7 +117,7 @@ declare namespace fm {
              * disconnect: string
              * The URL to use for all client.disconnect requests.
              */
-            urls ? : any;
+            urls?: any;
         }
 
         interface baseArgs {
@@ -128,37 +128,37 @@ declare namespace fm {
             /**
              * Extra meta data to associate with the request/response.
              */
-            meta ? : any;
+            meta?: any;
 
             /**
              * The URL of the proxy to use for this request.
              */
-            requestUrl ? : string;
+            requestUrl?: string;
 
             /**
              * Whether to ignore errors when parsing the server response. If true, any errors thrown while parsing the JSON response received from the server will be ignored.
              * Defaults to false.
              */
-            suppressErrors ? : boolean;
+            suppressErrors?: boolean;
 
             /**
              * Whether the request should be executed asynchronously. If true, the request will be executed synchronously if supported by the browser; otherwise,
              * it will be executed asynchronously. All browsers support synchronous requests if the request URL is the same domain as the page. Synchronous requests
              * are not supported in IE6 and IE7 for cross-domain environments. Defaults to false.
              */
-            sync ? : boolean;
+            sync?: boolean;
         }
 
         interface connectConfig extends baseRequestConfig {
             /**
              * The callback to invoke after onSuccess or onFailure. See connectCompleteArgs for callback argument details.
              */
-            onComplete ? : (args: connectCompleteArgs) => void;
+            onComplete?: (args: connectCompleteArgs) => void;
 
             /**
              * The callback to invoke if the connect fails. Defaults to an alert of the error. See connectFailureArgs for callback argument details.
              */
-            onFailure ? : (args: connectFailureArgs) => void;
+            onFailure?: (args: connectFailureArgs) => void;
 
             /**
              * The callback to invoke if the streaming connection fails. See streamFailureArgs for callback argument details.
@@ -169,62 +169,62 @@ declare namespace fm {
              * If the reconnect fails, the callback specified by onFailure will be invoked with isReconnect set to false.
              * With the exception of UI updates, invocations of this callback with willReconnect set to true can be ignored.
              */
-            onStreamFailure ? : (args: streamFailureArgs) => void;
+            onStreamFailure?: (args: streamFailureArgs) => void;
 
             /**
              * The callback to invoke if the connect succeeds. See connectSuccessArgs for callback argument details.
              */
-            onSuccess ? : (args: connectSuccessArgs) => void;
+            onSuccess?: (args: connectSuccessArgs) => void;
 
             /**
              * The callback to invoke when a message is received on a channel that has no local callback specified to handle it. See receiveArgs for callback argument details.
              * This can occur if (a) a client is manually subscribed to a channel by the server or (b) a client subscribed to a channel and then manually removed the local callback using client.
              */
-            onUnhandledReceive ? : (args: receiveArgs) => void;
+            onUnhandledReceive?: (args: receiveArgs) => void;
 
             /**
              * Whether to always attempt to stay connected in the event of network failure. If true, the client will continually reconnect, even after exhausting the specified number
              * of retries specified by initializeConfig.retries. If false, the client will stop reconnecting if all retry attempts fail.
              */
-            stayConnected ? : boolean;
+            stayConnected?: boolean;
         }
 
         interface subscribeConfig extends baseRequestConfig {
             /**
              * The channel to which the client should be subscribed. Must start with a forward slash (/). Overrides channels.
              */
-            channel ? : string;
+            channel?: string;
 
             /**
              * The channels to which the client should be subscribed. Each must start with a forward slash (/). Overrides channel.
              */
-            channels ? : string[];
+            channels?: string[];
 
             /**
              * The callback to invoke after onSuccess or onFailure. See subscribeCompleteArgs for callback argument details.
              */
-            onComplete ? : (args: subscribeCompleteArgs) => void;
+            onComplete?: (args: subscribeCompleteArgs) => void;
 
             /**
              * (OptionalThe callback to invoke if the subscribe fails. See subscribeFailureArgs for callback argument details.
              */
-            onFailure ? : (args: subscribeFailureArgs) => void;
+            onFailure?: (args: subscribeFailureArgs) => void;
 
             /**
              * The callback to invoke when data is received on the channel(s). See receiveArgs for callback argument details.
              */
-            onReceive ? : (args: receiveArgs) => void;
+            onReceive?: (args: receiveArgs) => void;
 
             /**
              * Subscribers extension. The callback to invoke when a subscribers change notification is received (i.e. when a client subscribes to or unsubscribes from the channel(s)).
              * The current subscribe request will trigger this callback. See subscribersChangeArgs for callback argument details.
              */
-            onSubscribersChange ? : (args: subscribersChangeArgs) => void;
+            onSubscribersChange?: (args: subscribersChangeArgs) => void;
 
             /**
              * The callback to invoke if the subscribe succeeds. See subscribeSuccessArgs for callback argument details.
              */
-            onSuccess ? : (args: subscribeSuccessArgs) => void;
+            onSuccess?: (args: subscribeSuccessArgs) => void;
         }
 
         interface initializeFailureArgs extends baseArgs {
@@ -363,12 +363,12 @@ declare namespace fm {
             /**
              * The details of the change that occurred.
              */
-            change ? : fm.websync.subscribersChange
+            change?: fm.websync.subscribersChange
 
             /**
              * The channel on which the change occurred.
              */
-            channel ? : string;
+            channel?: string;
         }
 
         interface publishingClient {
@@ -411,17 +411,17 @@ declare namespace fm {
             /**
              * The callback to invoke after onSuccess or onFailure. See disconnectCompleteArgs for callback argument details.
              */
-            onComplete ? : (args: baseResponseArgs) => void;
+            onComplete?: (args: baseResponseArgs) => void;
 
             /**
              * The callback to invoke if the disconnect fails. See disconnectFailureArgs for callback argument details.
              */
-            onFailure ? : (args: baseFailureArgs) => void;
+            onFailure?: (args: baseFailureArgs) => void;
 
             /**
              * The callback to invoke if the disconnect succeeds. See disconnectSuccessArgs for callback argument details.
              */
-            onSuccess ? : (args: baseResponseArgs) => void;
+            onSuccess?: (args: baseResponseArgs) => void;
         }
 
         interface unsubscribeSuccessArgs extends baseResponseArgs {
@@ -440,27 +440,27 @@ declare namespace fm {
             /**
              * The channel from which the client should be unsubscribed. Must start with a forward slash (/). Overrides channels.
              */
-            channel ? : string;
+            channel?: string;
 
             /**
              * The channels from which the client should be unsubscribed. Each must start with a forward slash (/). Overrides channel.
              */
-            channels ? : string[];
+            channels?: string[];
 
             /**
              * The callback to invoke after onSuccess or onFailure. See unsubscribeCompleteArgs for callback argument details.
              */
-            onComplete ? : (args: baseResponseArgs) => void;
+            onComplete?: (args: baseResponseArgs) => void;
 
             /**
              * The callback to invoke if the unsubscribe fails. See unsubscribeFailureArgs for callback argument details.
              */
-            onFailure ? : (args: baseFailureArgs) => void;
+            onFailure?: (args: baseFailureArgs) => void;
 
             /**
              * The callback to invoke if the unsubscribe succeeds. See unsubscribeSuccessArgs for callback argument details.
              */
-            onSuccess ? : (args: unsubscribeSuccessArgs) => void;
+            onSuccess?: (args: unsubscribeSuccessArgs) => void;
         }
 
         export class client {