@fastpix/fastpix-node 2.0.6 → 2.0.7

package/src/lib/sdks.ts

@@ -77,8 +77,89 @@ const webWorkerLike = typeof gt === "object"
   && "importScripts" in gt
   && typeof gt["importScripts"] === "function";
 const isBrowserLike = webWorkerLike
-  || (typeof navigator !== "undefined" && "serviceWorker" in navigator)
-  || (typeof window === "object" && typeof window.document !== "undefined");
+  || ("navigator" in globalThis && "serviceWorker" in globalThis.navigator)
+  || ("window" in globalThis && "document" in globalThis.window);
+
+/**
+ * Reads the legacy `fetchOptions` field while it remains supported. The local
+ * type intentionally omits the `@deprecated` tag so internal reads don't surface
+ * deprecation warnings; consumers are still steered away from it via the public
+ * {@link RequestOptions} type.
+ */
+function getLegacyFetchOptions(
+  options: RequestOptions | undefined,
+): Omit<RequestInit, "method" | "body"> | undefined {
+  return (
+    options as
+      | { fetchOptions?: Omit<RequestInit, "method" | "body"> }
+      | undefined
+  )?.fetchOptions;
+}
+
+function buildQueryString(
+  query: string | undefined,
+  security: SecurityState | null,
+): string {
+  let finalQuery = query || "";
+
+  const secQuery: string[] = [];
+  for (const [k, v] of Object.entries(security?.queryParams || {})) {
+    const q = encodeForm(k, v, { charEncoding: "percent" });
+    if (q !== undefined) {
+      secQuery.push(q);
+    }
+  }
+  if (secQuery.length) {
+    finalQuery += `&${secQuery.join("&")}`;
+  }
+
+  return finalQuery;
+}
+
+function buildRequestHeaders(
+  conf: RequestConfig,
+  options: RequestOptions | undefined,
+  security: SecurityState | null,
+): Headers {
+  const headers = new Headers(conf.headers);
+
+  const username = security?.basic.username;
+  const password = security?.basic.password;
+  if (username != null || password != null) {
+    const encoded = stringToBase64([username || "", password || ""].join(":"));
+    headers.set("Authorization", `Basic ${encoded}`);
+  }
+
+  const securityHeaders = new Headers(security?.headers || {});
+  for (const [k, v] of securityHeaders) {
+    headers.set(k, v);
+  }
+
+  let cookie = headers.get("cookie") || "";
+  for (const [k, v] of Object.entries(security?.cookies || {})) {
+    cookie += `; ${k}=${v}`;
+  }
+  cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
+  headers.set("cookie", cookie);
+
+  const userHeaders = new Headers(
+    options?.headers ?? getLegacyFetchOptions(options)?.headers,
+  );
+  for (const [k, v] of userHeaders) {
+    headers.set(k, v);
+  }
+
+  // Only set user agent header in non-browser-like environments since CORS
+  // policy disallows setting it in browsers e.g. Chrome throws an error.
+  if (!isBrowserLike) {
+    headers.set(
+      conf.uaHeader ?? "user-agent",
+      conf.userAgent ?? SDK_METADATA.userAgent,
+    );
+  }
+
+  return headers;
+}
 
 export class ClientSDK {
   readonly #httpClient: HTTPClient;
@@ -105,7 +186,14 @@ export class ClientSDK {
 
     const url = serverURLFromOptions(options);
     if (url) {
-      url.pathname = url.pathname.replace(/\/+$/, "") + "/";
+      // Strip trailing slashes with a linear scan (avoids the super-linear
+      // backtracking of a `/\/+$/` regex), then ensure exactly one trailing "/".
+      const pathname = url.pathname;
+      let end = pathname.length;
+      while (end > 0 && pathname.codePointAt(end - 1) === 47 /* "/" */) {
+        end--;
+      }
+      url.pathname = pathname.slice(0, end) + "/";
     }
     this._baseURL = url;
     this.#httpClient = options.httpClient || defaultHttpClient;
@@ -123,7 +211,7 @@ export class ClientSDK {
     conf: RequestConfig,
     options?: RequestOptions,
   ): Result<Request, InvalidRequestError | UnexpectedClientError> {
-    const { method, path, query, headers: opHeaders, security } = conf;
+    const { method, path, query, security } = conf;
 
     const base = conf.baseURL ?? this._baseURL;
     if (!base) {
@@ -137,65 +225,16 @@ export class ClientSDK {
       reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
     }
 
-    let finalQuery = query || "";
-
-    const secQuery: string[] = [];
-    for (const [k, v] of Object.entries(security?.queryParams || {})) {
-      const q = encodeForm(k, v, { charEncoding: "percent" });
-      if (typeof q !== "undefined") {
-        secQuery.push(q);
-      }
-    }
-    if (secQuery.length) {
-      finalQuery += `&${secQuery.join("&")}`;
-    }
-
+    const finalQuery = buildQueryString(query, security ?? null);
     if (finalQuery) {
       const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
       reqURL.search = `?${q}`;
     }
 
-    const headers = new Headers(opHeaders);
-
-    const username = security?.basic.username;
-    const password = security?.basic.password;
-    if (username != null || password != null) {
-      const encoded = stringToBase64(
-        [username || "", password || ""].join(":"),
-      );
-      headers.set("Authorization", `Basic ${encoded}`);
-    }
-
-    const securityHeaders = new Headers(security?.headers || {});
-    for (const [k, v] of securityHeaders) {
-      headers.set(k, v);
-    }
-
-    let cookie = headers.get("cookie") || "";
-    for (const [k, v] of Object.entries(security?.cookies || {})) {
-      cookie += `; ${k}=${v}`;
-    }
-    cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
-    headers.set("cookie", cookie);
-
-    const userHeaders = new Headers(
-      options?.headers ?? options?.fetchOptions?.headers,
-    );
-    for (const [k, v] of userHeaders) {
-      headers.set(k, v);
-    }
-
-    // Only set user agent header in non-browser-like environments since CORS
-    // policy disallows setting it in browsers e.g. Chrome throws an error.
-    if (!isBrowserLike) {
-      headers.set(
-        conf.uaHeader ?? "user-agent",
-        conf.userAgent ?? SDK_METADATA.userAgent,
-      );
-    }
+    const headers = buildRequestHeaders(conf, options, security ?? null);
 
     const fetchOptions: Omit<RequestInit, "method" | "body"> = {
-      ...options?.fetchOptions,
+      ...getLegacyFetchOptions(options),
       ...options,
     };
     if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
@@ -309,9 +348,12 @@ export class ClientSDK {
   }
 }
 
-const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
+// Single greedy `.*` before the literal/word avoids the super-linear
+// backtracking of the previous `.*?\+*…` form while matching the same inputs
+// (these are only used with `.test()`, so the trailing `.*` was redundant).
+const jsonLikeContentTypeRE = /(application|text)\/.*json/;
 const jsonlLikeContentTypeRE =
-  /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
+  /(application|text)\/(.*\bjsonl\b|.*\bx-ndjson\b)/;
 async function logRequest(logger: Logger | undefined, req: Request) {
   if (!logger) {
     return;

package/src/lib/security.ts

@@ -107,7 +107,7 @@ type SecurityInputOAuth2PasswordCredentials = {
 
 type SecurityInputCustom = {
   type: "http:custom";
-  value: any | null | undefined;
+  value: any;
   fieldName?: string;
 };
 
@@ -152,7 +152,7 @@ export function resolveSecurity(
       } else if (typeof o.value === "string") {
         return !!o.value;
       } else {
-        throw new Error(
+        throw new TypeError(
           `Unrecognized security type: ${o.type} (value type: ${typeof o
             .value})`,
         );

package/src/lib/url.ts

@@ -12,7 +12,7 @@ export function pathToFunc(
   pathPattern: string,
   options?: { charEncoding?: "percent" | "none" },
 ): (params?: Params) => string {
-  const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
+  const paramRE = /\{(\w[\w-]*?)\}/g;
 
   return function buildURLPath(params: Record<string, unknown> = {}): string {
     return pathPattern.replace(paramRE, function (_, placeholder) {
@@ -22,7 +22,7 @@ export function pathToFunc(
 
       const value = params[placeholder];
       if (typeof value !== "string" && typeof value !== "number") {
-        throw new Error(
+        throw new TypeError(
           `Parameter '${placeholder}' must be a string or number`,
         );
       }

package/src/models/errordetails.ts

@@ -11,16 +11,11 @@ import * as types from "../types/primitives.js";
 import { smartUnion } from "../types/smartUnion.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-/**
- * views affected by the specific errors.
- */
-export type ErrorDetailsPercentage = number | number;
-
 export type ErrorDetails = {
   /**
    * views affected by the specific errors.
    */
-  percentage?: number | number | null | undefined;
+  percentage?: number | null | undefined;
   /**
    * Information about the specific error.
    */
@@ -53,13 +48,13 @@ export type ErrorDetails = {
 
 /** @internal */
 export const ErrorDetailsPercentage$inboundSchema: z.ZodMiniType<
-  ErrorDetailsPercentage,
+  number,
   unknown
 > = smartUnion([types.number(), types.number()]);
 
 export function errorDetailsPercentageFromJSON(
   jsonString: string,
-): SafeParseResult<ErrorDetailsPercentage, SDKValidationError> {
+): SafeParseResult<number, SDKValidationError> {
   return safeParse(
     jsonString,
     (x) => ErrorDetailsPercentage$inboundSchema.parse(JSON.parse(x)),

package/src/models/errors/httpclienterrors.ts

@@ -13,14 +13,15 @@ export class HTTPClientError extends Error {
   override name = "HTTPClientError";
   constructor(message: string, opts?: { cause?: unknown }) {
     let msg = message;
-    if (opts?.cause) {
-      msg += `: ${opts.cause}`;
+    if (opts?.cause != null) {
+      const { cause } = opts;
+      msg += `: ${cause instanceof Error ? cause.toString() : JSON.stringify(cause)}`;
     }
 
     super(msg, opts);
     // In older runtimes, the cause field would not have been assigned through
     // the super() call.
-    if (typeof this.cause === "undefined") {
+    if (this.cause === undefined) {
       this.cause = opts?.cause;
     }
   }

package/src/models/toperrordetails.ts

@@ -11,25 +11,15 @@ import * as types from "../types/primitives.js";
 import { smartUnion } from "../types/smartUnion.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-/**
- * views affected by the specific errors.
- */
-export type TopErrorDetailsPercentage = number | number;
-
-/**
- * percentage of unique viewers affected by the specific error.
- */
-export type UniqueViewersEffectedPercentage = number | number;
-
 export type TopErrorDetails = {
   /**
    * views affected by the specific errors.
    */
-  percentage?: number | number | null | undefined;
+  percentage?: number | null | undefined;
   /**
    * percentage of unique viewers affected by the specific error.
    */
-  uniqueViewersEffectedPercentage?: number | number | null | undefined;
+  uniqueViewersEffectedPercentage?: number | null | undefined;
   /**
    * Information about the specific error.
    */
@@ -54,13 +44,13 @@ export type TopErrorDetails = {
 
 /** @internal */
 export const TopErrorDetailsPercentage$inboundSchema: z.ZodMiniType<
-  TopErrorDetailsPercentage,
+  number,
   unknown
 > = smartUnion([types.number(), types.number()]);
 
 export function topErrorDetailsPercentageFromJSON(
   jsonString: string,
-): SafeParseResult<TopErrorDetailsPercentage, SDKValidationError> {
+): SafeParseResult<number, SDKValidationError> {
   return safeParse(
     jsonString,
     (x) => TopErrorDetailsPercentage$inboundSchema.parse(JSON.parse(x)),
@@ -70,13 +60,13 @@ export function topErrorDetailsPercentageFromJSON(
 
 /** @internal */
 export const UniqueViewersEffectedPercentage$inboundSchema: z.ZodMiniType<
-  UniqueViewersEffectedPercentage,
+  number,
   unknown
 > = smartUnion([types.number(), types.number()]);
 
 export function uniqueViewersEffectedPercentageFromJSON(
   jsonString: string,
-): SafeParseResult<UniqueViewersEffectedPercentage, SDKValidationError> {
+): SafeParseResult<number, SDKValidationError> {
   return safeParse(
     jsonString,
     (x) => UniqueViewersEffectedPercentage$inboundSchema.parse(JSON.parse(x)),

package/src/models/updatetrackrequest.ts

@@ -38,7 +38,10 @@ export const UpdateTrackRequest$outboundSchema: z.ZodMiniType<
 > = z.object({
   url: z._default(
     z.string(),
-    "http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/thrust.vtt",
+    // not a live endpoint: spec-provided default example value for the `url`
+    // field; preserved verbatim to avoid changing the request payload the SDK
+    // emits when `url` is omitted.
+    "http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/thrust.vtt", // NOSONAR(typescript:S5332)
   ),
   languageCode: z._default(z.string(), "fr"),
   languageName: z._default(z.string(), "French"),

package/src/sdk/sdk.ts

@@ -29,101 +29,121 @@ import { Views } from "./views.js";
 export class Fastpix extends ClientSDK {
   private _inputVideo?: InputVideo;
   get inputVideo(): InputVideo {
-    return (this._inputVideo ??= new InputVideo(this._options));
+    this._inputVideo ??= new InputVideo(this._options);
+    return this._inputVideo;
   }
 
   private _media?: Media;
   get media(): Media {
-    return (this._media ??= new Media(this._options));
+    this._media ??= new Media(this._options);
+    return this._media;
   }
 
   private _liveStreams?: LiveStreams;
   get liveStreams(): LiveStreams {
-    return (this._liveStreams ??= new LiveStreams(this._options));
+    this._liveStreams ??= new LiveStreams(this._options);
+    return this._liveStreams;
   }
 
   private _manageVideos?: ManageVideos;
   get manageVideos(): ManageVideos {
-    return (this._manageVideos ??= new ManageVideos(this._options));
+    this._manageVideos ??= new ManageVideos(this._options);
+    return this._manageVideos;
   }
 
   private _aiFeatures?: AiFeatures;
   get aiFeatures(): AiFeatures {
-    return (this._aiFeatures ??= new AiFeatures(this._options));
+    this._aiFeatures ??= new AiFeatures(this._options);
+    return this._aiFeatures;
   }
 
   private _inVideoAIfeatures?: InVideoAIfeatures;
   get inVideoAIfeatures(): InVideoAIfeatures {
-    return (this._inVideoAIfeatures ??= new InVideoAIfeatures(this._options));
+    this._inVideoAIfeatures ??= new InVideoAIfeatures(this._options);
+    return this._inVideoAIfeatures;
   }
 
   private _inVideoAI?: InVideoAI;
   get inVideoAI(): InVideoAI {
-    return (this._inVideoAI ??= new InVideoAI(this._options));
+    this._inVideoAI ??= new InVideoAI(this._options);
+    return this._inVideoAI;
   }
 
   private _playback?: Playback;
   get playback(): Playback {
-    return (this._playback ??= new Playback(this._options));
+    this._playback ??= new Playback(this._options);
+    return this._playback;
   }
 
   private _playlist?: Playlist;
   get playlist(): Playlist {
-    return (this._playlist ??= new Playlist(this._options));
+    this._playlist ??= new Playlist(this._options);
+    return this._playlist;
   }
 
   private _playlists?: Playlists;
   get playlists(): Playlists {
-    return (this._playlists ??= new Playlists(this._options));
+    this._playlists ??= new Playlists(this._options);
+    return this._playlists;
   }
 
   private _drmConfigurations?: DrmConfigurations;
   get drmConfigurations(): DrmConfigurations {
-    return (this._drmConfigurations ??= new DrmConfigurations(this._options));
+    this._drmConfigurations ??= new DrmConfigurations(this._options);
+    return this._drmConfigurations;
   }
 
   private _manageLiveStream?: ManageLiveStream;
   get manageLiveStream(): ManageLiveStream {
-    return (this._manageLiveStream ??= new ManageLiveStream(this._options));
+    this._manageLiveStream ??= new ManageLiveStream(this._options);
+    return this._manageLiveStream;
   }
 
   private _livePlayback?: LivePlayback;
   get livePlayback(): LivePlayback {
-    return (this._livePlayback ??= new LivePlayback(this._options));
+    this._livePlayback ??= new LivePlayback(this._options);
+    return this._livePlayback;
   }
 
   private _simulcasts?: Simulcasts;
   get simulcasts(): Simulcasts {
-    return (this._simulcasts ??= new Simulcasts(this._options));
+    this._simulcasts ??= new Simulcasts(this._options);
+    return this._simulcasts;
   }
 
   private _simulcastStreams?: SimulcastStreams;
   get simulcastStreams(): SimulcastStreams {
-    return (this._simulcastStreams ??= new SimulcastStreams(this._options));
+    this._simulcastStreams ??= new SimulcastStreams(this._options);
+    return this._simulcastStreams;
   }
 
   private _signingKeys?: SigningKeys;
   get signingKeys(): SigningKeys {
-    return (this._signingKeys ??= new SigningKeys(this._options));
+    this._signingKeys ??= new SigningKeys(this._options);
+    return this._signingKeys;
   }
 
   private _views?: Views;
   get views(): Views {
-    return (this._views ??= new Views(this._options));
+    this._views ??= new Views(this._options);
+    return this._views;
   }
 
   private _dimensions?: Dimensions;
   get dimensions(): Dimensions {
-    return (this._dimensions ??= new Dimensions(this._options));
+    this._dimensions ??= new Dimensions(this._options);
+    return this._dimensions;
   }
 
   private _metrics?: Metrics;
   get metrics(): Metrics {
-    return (this._metrics ??= new Metrics(this._options));
+    this._metrics ??= new Metrics(this._options);
+    return this._metrics;
   }
 
   private _errors?: Errors;
   get errors(): Errors {
-    return (this._errors ??= new Errors(this._options));
+    this._errors ??= new Errors(this._options);
+    return this._errors;
   }
 }

package/src/types/async.ts

@@ -13,58 +13,50 @@ export type APICall =
   | {
       status: "request-error";
       request: Request;
-      response?: undefined;
+      response?: never;
     }
   | {
       status: "invalid";
-      request?: undefined;
-      response?: undefined;
+      request?: never;
+      response?: never;
     };
 
-export class APIPromise<T> implements Promise<T> {
-  readonly #promise: Promise<[T, APICall]>;
-  readonly #unwrapped: Promise<T>;
+export class APIPromise<T> extends Promise<T> {
+  readonly #inspect: Promise<[T, APICall]>;
 
-  readonly [Symbol.toStringTag] = "APIPromise";
+  override readonly [Symbol.toStringTag] = "APIPromise";
 
-  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
-    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
-    this.#unwrapped =
-      p instanceof Promise
-        ? this.#promise.then(([value]) => value)
-        : Promise.resolve(p[0]);
+  // Derived promises (from then/catch/finally) must be plain Promises, not this
+  // subclass, otherwise the runtime would re-invoke our constructor with an
+  // executor function instead of the expected tuple/promise input.
+  static override get [Symbol.species](): PromiseConstructor {
+    return Promise;
   }
 
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | PromiseLike<TResult1>)
-      | null
-      | undefined,
-    onrejected?:
-      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
-      | null
-      | undefined,
-  ): Promise<TResult1 | TResult2> {
-    return this.#promise.then(
-      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
-      onrejected,
-    );
+  // A Promise subclass must set up resolution in its constructor via
+  // super(executor); the deferred .then() lives inside the executor closure and
+  // does not run during construction, so there is no real async work here.
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) { // NOSONAR(typescript:S7059) - required Promise subclass wiring
+    const inspect = APIPromise.#asInspect(p);
+    super(APIPromise.#executor(inspect));
+    this.#inspect = inspect;
   }
 
-  catch<TResult = never>(
-    onrejected?:
-      | ((reason: any) => TResult | PromiseLike<TResult>)
-      | null
-      | undefined,
-  ): Promise<T | TResult> {
-    return this.#unwrapped.catch(onrejected);
+  static #asInspect<T>(
+    p: [T, APICall] | Promise<[T, APICall]>,
+  ): Promise<[T, APICall]> {
+    return p instanceof Promise ? p : Promise.resolve(p);
   }
 
-  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
-    return this.#unwrapped.finally(onfinally);
+  static #executor<T>(
+    inspect: Promise<[T, APICall]>,
+  ): (resolve: (value: T) => void, reject: (reason?: unknown) => void) => void {
+    return (resolve, reject) => {
+      inspect.then(([value]) => resolve(value), reject);
+    };
   }
 
   $inspect(): Promise<[T, APICall]> {
-    return this.#promise;
+    return this.#inspect;
   }
 }

package/src/types/primitives.ts

@@ -54,7 +54,7 @@ export function number(): z.ZodMiniType<number> {
       z.string(),
       z.transform((x, ctx) => {
         const num = Number(x);
-        if (isNaN(num)) {
+        if (Number.isNaN(num)) {
           ctx.issues.push({
             input: x,
             code: "invalid_type",
@@ -79,7 +79,7 @@ export function bigint(): z.ZodMiniType<bigint> {
       z.transform((x, ctx) => {
         try {
           return BigInt(x);
-        } catch (error) {
+        } catch {
           ctx.issues.push({
             input: x,
             code: "invalid_type",
@@ -107,7 +107,7 @@ export function date(): z.ZodMiniType<Date> {
       z.number(),
       z.transform((x, ctx) => {
         const date = new Date(x);
-        if (isNaN(date.getTime())) {
+        if (Number.isNaN(date.getTime())) {
           ctx.issues.push({
             input: x,
             code: "invalid_type",
@@ -129,7 +129,15 @@ export function literal<T extends string | number | boolean>(
 }
 
 export function literalBigInt<T extends bigint>(value: T): z.ZodMiniType<T> {
-  return z.pipe(z.literal(String(value)), z.transform((x) => BigInt(x))) as any;
+  return z.pipe(
+    z.literal(String(value)),
+    // The cast can't be dropped: `z.transform(BigInt)` fails to type-check, and an
+    // arrow wrapper `(v) => BigInt(v)` only trips a different rule. NOSONAR must be
+    // on this line (the one S4325 is reported on) to take effect.
+    z.transform(BigInt as (value: string) => bigint), // NOSONAR(typescript:S4325)
+    // `as any` required: `T` is a `bigint` subtype the pipe's inferred output
+    // (`bigint`) is not assignable to, so the assertion cannot be removed.
+  ) as any;
 }
 
 export function optional<T extends z.ZodMiniType>(t: T) {

package/src/types/rfcdate.ts

@@ -7,7 +7,7 @@
 const dateRE = /^\d{4}-\d{2}-\d{2}$/;
 
 export class RFCDate {
-  private serialized: string;
+  private readonly serialized: string;
 
   /**
    * Creates a new RFCDate instance using today's date.
@@ -34,7 +34,7 @@ export class RFCDate {
     }
 
     const value = new Date(date);
-    if (isNaN(+value)) {
+    if (Number.isNaN(+value)) {
       throw new RangeError("RFCDate: invalid date provided: " + date);
     }
 

package/temp/example.ts

@@ -4,12 +4,14 @@
  * Your changes will be overwritten during the next generation.
  */
 
+import { PatchResponseData } from "../src/models/patchresponsedata.js";
+
 let value: PatchResponseData = {
   trial: false,
   status: "{\"possibleValue\":\"idle, preparing, active, disabled\",\"example\":\"idle\"}",
   maxResolution: "{\"possibleValue\":\"1080p, 720p, 480p\",\"example\":\"1080p\",\"default\":\"1080p\"}",
   maxDuration: 28800,
-  reconnectWindow: [object Object],
+  reconnectWindow: 60,
   enableRecording: false,
   enableDvrMode: true,
   mediaPolicy: "{\"possibleValue\":\"public, private\",\"example\":\"public\",\"default\":\"public\"}",