@seamapi/http 0.5.0 → 0.7.0

package/README.md

@@ -38,7 +38,7 @@ $ npm install @seamapi/http
 ## Usage
 
 ```ts
-import { SeamHttp } from '@seamapi/http'
+import { SeamHttp } from '@seamapi/http/connect'
 
 const seam = new SeamHttp('your-api-key')
 const devices = await seam.devices.list()
@@ -213,7 +213,7 @@ Options are deep merged with the default options.
 The Axios client is exposed and may be used or configured directly:
 
 ```ts
-import { SeamHttp, DevicesListResponse } from '@seamapi/http'
+import { SeamHttp, DevicesListResponse } from '@seamapi/http/connect'
 
 const seam = new SeamHttp()
 

package/dist/connect.cjs

@@ -10,90 +10,8 @@ var axios__default = /*#__PURE__*/_interopDefault(axios);
 var axiosBetterStacktrace__default = /*#__PURE__*/_interopDefault(axiosBetterStacktrace);
 var axiosRetry__default = /*#__PURE__*/_interopDefault(axiosRetry);
 
-// src/lib/seam/connect/error-interceptor.ts
-
-// src/lib/seam/connect/seam-http-error.ts
-var SeamHttpApiError = class extends Error {
-  constructor(error, statusCode, requestId) {
-    const { type, message, data } = error;
-    super(message);
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-    this.code = type;
-    this.statusCode = statusCode;
-    this.requestId = requestId;
-    if (data != null)
-      this.data = data;
-  }
-};
-var isSeamHttpApiError = (error) => {
-  return error instanceof SeamHttpApiError;
-};
-var SeamHttpUnauthorizedError = class extends SeamHttpApiError {
-  constructor(requestId) {
-    const type = "unauthorized";
-    const status = 401;
-    super({ type, message: "Unauthorized" }, status, requestId);
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-    this.code = type;
-    this.statusCode = status;
-    this.requestId = requestId;
-  }
-};
-var isSeamHttpUnauthorizedError = (error) => {
-  return error instanceof SeamHttpUnauthorizedError;
-};
-var SeamHttpInvalidInputError = class extends SeamHttpApiError {
-  constructor(error, statusCode, requestId) {
-    super(error, statusCode, requestId);
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-    this.code = "invalid_input";
-  }
-};
-var isSeamHttpInvalidInputError = (error) => {
-  return error instanceof SeamHttpInvalidInputError;
-};
-
-// src/lib/seam/connect/error-interceptor.ts
-var errorInterceptor = async (err) => {
-  if (!axios.isAxiosError(err))
-    throw err;
-  const { response } = err;
-  const status = response?.status;
-  const headers = response?.headers;
-  const requestId = headers?.["seam-request-id"] ?? "";
-  if (status == null)
-    throw err;
-  if (status === 401) {
-    throw new SeamHttpUnauthorizedError(requestId);
-  }
-  if (!isApiErrorResponse(response))
-    throw err;
-  const { type } = response.data.error;
-  const args = [response.data.error, status, requestId];
-  if (type === "invalid_input")
-    throw new SeamHttpInvalidInputError(...args);
-  throw new SeamHttpApiError(...args);
-};
-var isApiErrorResponse = (response) => {
-  if (response == null)
-    return false;
-  const { headers, data } = response;
-  if (headers == null)
-    return false;
-  const contentType = headers["content-type"];
-  if (typeof contentType === "string" && !contentType.startsWith("application/json")) {
-    return false;
-  }
-  if (typeof data === "object" && data != null) {
-    return "error" in data && typeof data.error === "object" && data.error != null && "type" in data.error && typeof data.error.type === "string";
-  }
-  return false;
-};
-
 // src/lib/seam/connect/options.ts
+var isSeamHttpMultiWorkspaceOptionsWithClient = (options) => isSeamHttpOptionsWithClient(options);
 var isSeamHttpOptionsWithClient = (options) => {
   if (!("client" in options))
     return false;
@@ -153,16 +71,11 @@ var isSeamHttpOptionsWithClientSessionToken = (options) => {
   }
   return true;
 };
-var isSeamHttpOptionsWithConsoleSessionToken = (options) => {
+var isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken = (options) => {
   if (!("consoleSessionToken" in options))
     return false;
   if (options.consoleSessionToken == null)
     return false;
-  if (!("workspaceId" in options) || options.workspaceId == null) {
-    throw new SeamHttpInvalidOptionsError(
-      "Must pass a workspaceId when using a consoleSessionToken"
-    );
-  }
   if ("apiKey" in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
       "The apiKey option cannot be used with the consoleSessionToken option"
@@ -180,16 +93,22 @@ var isSeamHttpOptionsWithConsoleSessionToken = (options) => {
   }
   return true;
 };
-var isSeamHttpOptionsWithPersonalAccessToken = (options) => {
-  if (!("personalAccessToken" in options))
-    return false;
-  if (options.personalAccessToken == null)
+var isSeamHttpOptionsWithConsoleSessionToken = (options) => {
+  if (!isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken(options)) {
     return false;
+  }
   if (!("workspaceId" in options) || options.workspaceId == null) {
     throw new SeamHttpInvalidOptionsError(
-      "Must pass a workspaceId when using a personalAccessToken"
+      "Must pass a workspaceId when using a consoleSessionToken"
     );
   }
+  return true;
+};
+var isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken = (options) => {
+  if (!("personalAccessToken" in options))
+    return false;
+  if (options.personalAccessToken == null)
+    return false;
   if ("apiKey" in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
       "The apiKey option cannot be used with the personalAccessToken option"
@@ -207,6 +126,17 @@ var isSeamHttpOptionsWithPersonalAccessToken = (options) => {
   }
   return true;
 };
+var isSeamHttpOptionsWithPersonalAccessToken = (options) => {
+  if (!isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken(options)) {
+    return false;
+  }
+  if (!("workspaceId" in options) || options.workspaceId == null) {
+    throw new SeamHttpInvalidOptionsError(
+      "Must pass a workspaceId when using a personalAccessToken"
+    );
+  }
+  return true;
+};
 var SeamHttpInvalidOptionsError = class extends Error {
   constructor(message) {
     super(`SeamHttp received invalid options: ${message}`);
@@ -214,6 +144,8 @@ var SeamHttpInvalidOptionsError = class extends Error {
     Error.captureStackTrace(this, this.constructor);
   }
 };
+var SeamHttpMultiWorkspaceInvalidOptionsError = class extends SeamHttpInvalidOptionsError {
+};
 
 // src/lib/seam/connect/auth.ts
 var getAuthHeaders = (options) => {
@@ -226,10 +158,10 @@ var getAuthHeaders = (options) => {
   if (isSeamHttpOptionsWithClientSessionToken(options)) {
     return getAuthHeadersForClientSessionToken(options);
   }
-  if (isSeamHttpOptionsWithConsoleSessionToken(options)) {
+  if (isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken(options) || isSeamHttpOptionsWithConsoleSessionToken(options)) {
     return getAuthHeadersForConsoleSessionToken(options);
   }
-  if (isSeamHttpOptionsWithPersonalAccessToken(options)) {
+  if (isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken(options) || isSeamHttpOptionsWithPersonalAccessToken(options)) {
     return getAuthHeadersForPersonalAccessToken(options);
   }
   throw new SeamHttpInvalidOptionsError(
@@ -238,8 +170,8 @@ var getAuthHeaders = (options) => {
       "an apiKey,",
       "clientSessionToken,",
       "publishableKey,",
-      "consoleSessionToken with a workspaceId",
-      "or personalAccessToken with a workspaceId"
+      "consoleSessionToken",
+      "or personalAccessToken"
     ].join(" ")
   );
 };
@@ -303,8 +235,9 @@ var getAuthHeadersForClientSessionToken = ({
 };
 var getAuthHeadersForConsoleSessionToken = ({
   consoleSessionToken,
-  workspaceId
+  ...options
 }) => {
+  const workspaceId = "workspaceId" in options ? options.workspaceId : void 0;
   if (isAccessToken(consoleSessionToken)) {
     throw new SeamHttpInvalidTokenError(
       "An Access Token cannot be used as a consoleSessionToken"
@@ -327,13 +260,14 @@ var getAuthHeadersForConsoleSessionToken = ({
   }
   return {
     authorization: `Bearer ${consoleSessionToken}`,
-    "seam-workspace-id": workspaceId
+    ...workspaceId != null ? { "seam-workspace-id": workspaceId } : {}
   };
 };
 var getAuthHeadersForPersonalAccessToken = ({
   personalAccessToken,
-  workspaceId
+  ...options
 }) => {
+  const workspaceId = "workspaceId" in options ? options.workspaceId : void 0;
   if (isJwt(personalAccessToken)) {
     throw new SeamHttpInvalidTokenError(
       "A JWT cannot be used as a personalAccessToken"
@@ -356,7 +290,7 @@ var getAuthHeadersForPersonalAccessToken = ({
   }
   return {
     authorization: `Bearer ${personalAccessToken}`,
-    "seam-workspace-id": workspaceId
+    ...workspaceId != null ? { "seam-workspace-id": workspaceId } : {}
   };
 };
 var getAuthHeadersForPublishableKey = (publishableKey) => {
@@ -416,6 +350,87 @@ var isSeamToken = (token) => token.startsWith(tokenPrefix);
 var isPublishableKey = (token) => token.startsWith(publishableKeyTokenPrefix);
 var isEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
 
+// src/lib/seam/connect/seam-http-error.ts
+var SeamHttpApiError = class extends Error {
+  constructor(error, statusCode, requestId) {
+    const { type, message, data } = error;
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    this.code = type;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    if (data != null)
+      this.data = data;
+  }
+};
+var isSeamHttpApiError = (error) => {
+  return error instanceof SeamHttpApiError;
+};
+var SeamHttpUnauthorizedError = class extends SeamHttpApiError {
+  constructor(requestId) {
+    const type = "unauthorized";
+    const status = 401;
+    super({ type, message: "Unauthorized" }, status, requestId);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    this.code = type;
+    this.statusCode = status;
+    this.requestId = requestId;
+  }
+};
+var isSeamHttpUnauthorizedError = (error) => {
+  return error instanceof SeamHttpUnauthorizedError;
+};
+var SeamHttpInvalidInputError = class extends SeamHttpApiError {
+  constructor(error, statusCode, requestId) {
+    super(error, statusCode, requestId);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    this.code = "invalid_input";
+  }
+};
+var isSeamHttpInvalidInputError = (error) => {
+  return error instanceof SeamHttpInvalidInputError;
+};
+
+// src/lib/seam/connect/error-interceptor.ts
+var errorInterceptor = async (err) => {
+  if (!axios.isAxiosError(err))
+    throw err;
+  const { response } = err;
+  const status = response?.status;
+  const headers = response?.headers;
+  const requestId = headers?.["seam-request-id"] ?? "";
+  if (status == null)
+    throw err;
+  if (status === 401) {
+    throw new SeamHttpUnauthorizedError(requestId);
+  }
+  if (!isApiErrorResponse(response))
+    throw err;
+  const { type } = response.data.error;
+  const args = [response.data.error, status, requestId];
+  if (type === "invalid_input")
+    throw new SeamHttpInvalidInputError(...args);
+  throw new SeamHttpApiError(...args);
+};
+var isApiErrorResponse = (response) => {
+  if (response == null)
+    return false;
+  const { headers, data } = response;
+  if (headers == null)
+    return false;
+  const contentType = headers["content-type"];
+  if (typeof contentType === "string" && !contentType.startsWith("application/json")) {
+    return false;
+  }
+  if (typeof data === "object" && data != null) {
+    return "error" in data && typeof data.error === "object" && data.error != null && "type" in data.error && typeof data.error.type === "string";
+  }
+  return false;
+};
+
 // src/lib/params-serializer.ts
 var paramsSerializer = (params) => {
   const searchParams = new URLSearchParams();
@@ -497,6 +512,8 @@ var parseOptions = (apiKeyOrOptions) => {
   const options = getNormalizedOptions(apiKeyOrOptions);
   if (isSeamHttpOptionsWithClient(options))
     return options;
+  if (isSeamHttpMultiWorkspaceOptionsWithClient(options))
+    return options;
   return {
     axiosOptions: {
       baseURL: options.endpoint ?? getEndpointFromEnv() ?? defaultEndpoint,
@@ -635,6 +652,13 @@ var SeamHttpClientSessions = class _SeamHttpClientSessions {
     });
     return data.client_sessions;
   }
+  async revoke(body) {
+    await this.client.request({
+      url: "/client_sessions/revoke",
+      method: "post",
+      data: body
+    });
+  }
 };
 
 // src/lib/seam/connect/routes/access-codes-unmanaged.ts
@@ -919,21 +943,6 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
       data: body
     });
   }
-  async create(body) {
-    const { data } = await this.client.request({
-      url: "/acs/access_groups/create",
-      method: "post",
-      data: body
-    });
-    return data.acs_access_group;
-  }
-  async delete(body) {
-    await this.client.request({
-      url: "/acs/access_groups/delete",
-      method: "post",
-      data: body
-    });
-  }
   async get(body) {
     const { data } = await this.client.request({
       url: "/acs/access_groups/get",
@@ -965,13 +974,6 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
       data: body
     });
   }
-  async update(body) {
-    await this.client.request({
-      url: "/acs/access_groups/update",
-      method: "post",
-      data: body
-    });
-  }
 };
 
 // src/lib/seam/connect/routes/acs-credentials.ts
@@ -1029,6 +1031,13 @@ var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
     }
     return new _SeamHttpAcsCredentials(constructorOptions);
   }
+  async assign(body) {
+    await this.client.request({
+      url: "/acs/credentials/assign",
+      method: "post",
+      data: body
+    });
+  }
   async create(body) {
     const { data } = await this.client.request({
       url: "/acs/credentials/create",
@@ -1060,6 +1069,13 @@ var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
     });
     return data.acs_credentials;
   }
+  async unassign(body) {
+    await this.client.request({
+      url: "/acs/credentials/unassign",
+      method: "post",
+      data: body
+    });
+  }
 };
 
 // src/lib/seam/connect/routes/acs-systems.ts
@@ -2296,6 +2312,123 @@ var SeamHttpThermostats = class _SeamHttpThermostats {
   }
 };
 
+// src/lib/seam/connect/routes/user-identities.ts
+var SeamHttpUserIdentities = class _SeamHttpUserIdentities {
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpUserIdentities.fromClientSessionToken(token, options);
+  }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  async addAcsUser(body) {
+    await this.client.request({
+      url: "/user_identities/add_acs_user",
+      method: "post",
+      data: body
+    });
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/create",
+      method: "post",
+      data: body
+    });
+    return data.user_identity;
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/get",
+      method: "post",
+      data: body
+    });
+    return data.user_identity;
+  }
+  async grantAccessToDevice(body) {
+    await this.client.request({
+      url: "/user_identities/grant_access_to_device",
+      method: "post",
+      data: body
+    });
+  }
+  async listAccessibleDevices(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/list_accessible_devices",
+      method: "post",
+      data: body
+    });
+    return data.accessible_devices;
+  }
+  async listAcsUsers(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/list_acs_users",
+      method: "post",
+      data: body
+    });
+    return data.acs_users;
+  }
+  async removeAcsUser(body) {
+    await this.client.request({
+      url: "/user_identities/remove_acs_user",
+      method: "post",
+      data: body
+    });
+  }
+  async revokeAccessToDevice(body) {
+    await this.client.request({
+      url: "/user_identities/revoke_access_to_device",
+      method: "post",
+      data: body
+    });
+  }
+};
+
 // src/lib/seam/connect/routes/webhooks.ts
 var SeamHttpWebhooks = class _SeamHttpWebhooks {
   constructor(apiKeyOrOptions = {}) {
@@ -2552,6 +2685,9 @@ var SeamHttp = class _SeamHttp {
   get thermostats() {
     return SeamHttpThermostats.fromClient(this.client);
   }
+  get userIdentities() {
+    return SeamHttpUserIdentities.fromClient(this.client);
+  }
   get webhooks() {
     return SeamHttpWebhooks.fromClient(this.client);
   }
@@ -2560,6 +2696,46 @@ var SeamHttp = class _SeamHttp {
   }
 };
 
+// src/lib/seam/connect/seam-http-multi-workspace.ts
+var SeamHttpMultiWorkspace = class _SeamHttpMultiWorkspace {
+  constructor(options) {
+    const clientOptions = parseOptions(options);
+    this.client = createClient(clientOptions);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpMultiWorkspaceOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpMultiWorkspace(constructorOptions);
+  }
+  static fromConsoleSessionToken(consoleSessionToken, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken };
+    if (!isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken(
+      constructorOptions
+    )) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError(
+        "Missing consoleSessionToken"
+      );
+    }
+    return new _SeamHttpMultiWorkspace(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken };
+    if (!isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken(
+      constructorOptions
+    )) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError(
+        "Missing personalAccessToken"
+      );
+    }
+    return new _SeamHttpMultiWorkspace(constructorOptions);
+  }
+  get workspaces() {
+    return SeamHttpWorkspaces.fromClient(this.client);
+  }
+};
+
 exports.SeamHttp = SeamHttp;
 exports.SeamHttpAccessCodes = SeamHttpAccessCodes;
 exports.SeamHttpAccessCodesUnmanaged = SeamHttpAccessCodesUnmanaged;
@@ -2578,18 +2754,25 @@ exports.SeamHttpDevicesUnmanaged = SeamHttpDevicesUnmanaged;
 exports.SeamHttpEvents = SeamHttpEvents;
 exports.SeamHttpInvalidInputError = SeamHttpInvalidInputError;
 exports.SeamHttpInvalidOptionsError = SeamHttpInvalidOptionsError;
+exports.SeamHttpInvalidTokenError = SeamHttpInvalidTokenError;
 exports.SeamHttpLocks = SeamHttpLocks;
+exports.SeamHttpMultiWorkspace = SeamHttpMultiWorkspace;
+exports.SeamHttpMultiWorkspaceInvalidOptionsError = SeamHttpMultiWorkspaceInvalidOptionsError;
 exports.SeamHttpNoiseSensors = SeamHttpNoiseSensors;
 exports.SeamHttpNoiseSensorsNoiseThresholds = SeamHttpNoiseSensorsNoiseThresholds;
 exports.SeamHttpThermostats = SeamHttpThermostats;
 exports.SeamHttpThermostatsClimateSettingSchedules = SeamHttpThermostatsClimateSettingSchedules;
 exports.SeamHttpUnauthorizedError = SeamHttpUnauthorizedError;
+exports.SeamHttpUserIdentities = SeamHttpUserIdentities;
 exports.SeamHttpWebhooks = SeamHttpWebhooks;
 exports.SeamHttpWorkspaces = SeamHttpWorkspaces;
 exports.UnserializableParamError = UnserializableParamError;
 exports.errorInterceptor = errorInterceptor;
 exports.isSeamHttpApiError = isSeamHttpApiError;
 exports.isSeamHttpInvalidInputError = isSeamHttpInvalidInputError;
+exports.isSeamHttpMultiWorkspaceOptionsWithClient = isSeamHttpMultiWorkspaceOptionsWithClient;
+exports.isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken = isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken;
+exports.isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken = isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken;
 exports.isSeamHttpOptionsWithApiKey = isSeamHttpOptionsWithApiKey;
 exports.isSeamHttpOptionsWithClient = isSeamHttpOptionsWithClient;
 exports.isSeamHttpOptionsWithClientSessionToken = isSeamHttpOptionsWithClientSessionToken;