@seamapi/http 1.102.0 → 1.105.1

package/dist/connect.cjs

@@ -1345,6 +1345,15 @@ var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
       options
     });
   }
+  getTimeline(parameters, options = {}) {
+    return new SeamHttpRequest(this, {
+      pathname: "/access_codes/get_timeline",
+      method: "POST",
+      body: parameters,
+      responseKey: "timeline_events",
+      options
+    });
+  }
   list(parameters, options = {}) {
     return new SeamHttpRequest(this, {
       pathname: "/access_codes/list",
@@ -1851,8 +1860,8 @@ var SeamHttpAccessMethods = class _SeamHttpAccessMethods {
   delete(parameters, options = {}) {
     return new SeamHttpRequest(this, {
       pathname: "/access_methods/delete",
-      method: "POST",
-      body: parameters,
+      method: "DELETE",
+      params: parameters,
       responseKey: void 0,
       options
     });
@@ -4176,6 +4185,101 @@ var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
   }
 };
 
+// src/lib/seam/connect/routes/customers/reservations/reservations.ts
+var SeamHttpCustomersReservations = class _SeamHttpCustomersReservations {
+  client;
+  defaults;
+  ltsVersion = seamApiLtsVersion;
+  static ltsVersion = seamApiLtsVersion;
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpCustomersReservations(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpCustomersReservations(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpCustomersReservations(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttpCustomersReservations.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpCustomersReservations.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 _SeamHttpCustomersReservations(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpCustomersReservations(constructorOptions);
+  }
+  createPaginator(request) {
+    return new SeamPaginator(this, request);
+  }
+  async updateClientSessionToken(clientSessionToken) {
+    const { headers } = this.client.defaults;
+    const authHeaders = getAuthHeadersForClientSessionToken({
+      clientSessionToken
+    });
+    for (const key of Object.keys(authHeaders)) {
+      if (headers[key] == null) {
+        throw new Error(
+          "Cannot update a clientSessionToken on a client created without a clientSessionToken"
+        );
+      }
+    }
+    this.client.defaults.headers = { ...headers, ...authHeaders };
+    const clientSessions = SeamHttpClientSessions.fromClient(this.client);
+    await clientSessions.get();
+  }
+  createDeepLink(parameters, options = {}) {
+    return new SeamHttpRequest(this, {
+      pathname: "/customers/reservations/create_deep_link",
+      method: "POST",
+      body: parameters,
+      responseKey: "deep_link",
+      options
+    });
+  }
+};
+
 // src/lib/seam/connect/routes/customers/customers.ts
 var SeamHttpCustomers = class _SeamHttpCustomers {
   client;
@@ -4260,6 +4364,9 @@ var SeamHttpCustomers = class _SeamHttpCustomers {
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
+  get reservations() {
+    return SeamHttpCustomersReservations.fromClient(this.client, this.defaults);
+  }
   createPortal(parameters, options = {}) {
     return new SeamHttpRequest(this, {
       pathname: "/customers/create_portal",
@@ -6096,6 +6203,128 @@ var SeamHttpSeamCustomerV1AccessGrants = class _SeamHttpSeamCustomerV1AccessGran
       options
     });
   }
+  update(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/access_grants/update",
+      method: "PATCH",
+      body: parameters,
+      responseKey: void 0,
+      options
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/seam/customer/v1/access-methods/access-methods.ts
+var SeamHttpSeamCustomerV1AccessMethods = class _SeamHttpSeamCustomerV1AccessMethods {
+  client;
+  defaults;
+  ltsVersion = seamApiLtsVersion;
+  static ltsVersion = seamApiLtsVersion;
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    if (!options.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpSeamCustomerV1AccessMethods(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpSeamCustomerV1AccessMethods(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpSeamCustomerV1AccessMethods(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttpSeamCustomerV1AccessMethods.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpSeamCustomerV1AccessMethods.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 _SeamHttpSeamCustomerV1AccessMethods(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpSeamCustomerV1AccessMethods(constructorOptions);
+  }
+  createPaginator(request) {
+    return new SeamPaginator(this, request);
+  }
+  async updateClientSessionToken(clientSessionToken) {
+    const { headers } = this.client.defaults;
+    const authHeaders = getAuthHeadersForClientSessionToken({
+      clientSessionToken
+    });
+    for (const key of Object.keys(authHeaders)) {
+      if (headers[key] == null) {
+        throw new Error(
+          "Cannot update a clientSessionToken on a client created without a clientSessionToken"
+        );
+      }
+    }
+    this.client.defaults.headers = { ...headers, ...authHeaders };
+    const clientSessions = SeamHttpClientSessions.fromClient(this.client);
+    await clientSessions.get();
+  }
+  encode(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/access_methods/encode",
+      method: "POST",
+      body: parameters,
+      responseKey: "action_attempt",
+      options
+    });
+  }
 };
 
 // src/lib/seam/connect/routes/seam/customer/v1/automation-runs/automation-runs.ts
@@ -6650,11 +6879,6 @@ var SeamHttpSeamCustomerV1Customers = class _SeamHttpSeamCustomerV1Customers {
   static ltsVersion = seamApiLtsVersion;
   constructor(apiKeyOrOptions = {}) {
     const options = parseOptions(apiKeyOrOptions);
-    if (!options.isUndocumentedApiEnabled) {
-      throw new Error(
-        "Cannot use undocumented API without isUndocumentedApiEnabled"
-      );
-    }
     this.client = "client" in options ? options.client : createClient(options);
     this.defaults = limitToSeamHttpRequestOptions(options);
   }
@@ -6748,6 +6972,15 @@ var SeamHttpSeamCustomerV1Customers = class _SeamHttpSeamCustomerV1Customers {
       options
     });
   }
+  me(parameters, options = {}) {
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/customers/me",
+      method: "GET",
+      params: parameters,
+      responseKey: void 0,
+      options
+    });
+  }
   openPortal(parameters, options = {}) {
     if (!this.defaults.isUndocumentedApiEnabled) {
       throw new Error(
@@ -6764,8 +6997,8 @@ var SeamHttpSeamCustomerV1Customers = class _SeamHttpSeamCustomerV1Customers {
   }
 };
 
-// src/lib/seam/connect/routes/seam/customer/v1/events/events.ts
-var SeamHttpSeamCustomerV1Events = class _SeamHttpSeamCustomerV1Events {
+// src/lib/seam/connect/routes/seam/customer/v1/encoders/encoders.ts
+var SeamHttpSeamCustomerV1Encoders = class _SeamHttpSeamCustomerV1Encoders {
   client;
   defaults;
   ltsVersion = seamApiLtsVersion;
@@ -6785,28 +7018,28 @@ var SeamHttpSeamCustomerV1Events = class _SeamHttpSeamCustomerV1Events {
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Encoders(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Encoders(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Encoders(constructorOptions);
   }
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
     if (isSeamHttpOptionsWithClient(clientOptions)) {
       throw new SeamHttpInvalidOptionsError(
-        "The client option cannot be used with SeamHttpSeamCustomerV1Events.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1Encoders.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -6814,7 +7047,7 @@ var SeamHttpSeamCustomerV1Events = class _SeamHttpSeamCustomerV1Events {
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamCustomerV1Events.fromClientSessionToken(token, options);
+    return _SeamHttpSeamCustomerV1Encoders.fromClientSessionToken(token, options);
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -6823,7 +7056,7 @@ var SeamHttpSeamCustomerV1Events = class _SeamHttpSeamCustomerV1Events {
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Encoders(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -6832,7 +7065,7 @@ var SeamHttpSeamCustomerV1Events = class _SeamHttpSeamCustomerV1Events {
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Encoders(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -6860,17 +7093,17 @@ var SeamHttpSeamCustomerV1Events = class _SeamHttpSeamCustomerV1Events {
       );
     }
     return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/events/list",
+      pathname: "/seam/customer/v1/encoders/list",
       method: "POST",
       body: parameters,
-      responseKey: "events",
+      responseKey: "encoders",
       options
     });
   }
 };
 
-// src/lib/seam/connect/routes/seam/customer/v1/portals/portals.ts
-var SeamHttpSeamCustomerV1Portals = class _SeamHttpSeamCustomerV1Portals {
+// src/lib/seam/connect/routes/seam/customer/v1/events/events.ts
+var SeamHttpSeamCustomerV1Events = class _SeamHttpSeamCustomerV1Events {
   client;
   defaults;
   ltsVersion = seamApiLtsVersion;
@@ -6890,28 +7123,28 @@ var SeamHttpSeamCustomerV1Portals = class _SeamHttpSeamCustomerV1Portals {
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
   }
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
     if (isSeamHttpOptionsWithClient(clientOptions)) {
       throw new SeamHttpInvalidOptionsError(
-        "The client option cannot be used with SeamHttpSeamCustomerV1Portals.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1Events.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -6919,7 +7152,7 @@ var SeamHttpSeamCustomerV1Portals = class _SeamHttpSeamCustomerV1Portals {
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamCustomerV1Portals.fromClientSessionToken(token, options);
+    return _SeamHttpSeamCustomerV1Events.fromClientSessionToken(token, options);
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -6928,7 +7161,7 @@ var SeamHttpSeamCustomerV1Portals = class _SeamHttpSeamCustomerV1Portals {
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -6937,7 +7170,7 @@ var SeamHttpSeamCustomerV1Portals = class _SeamHttpSeamCustomerV1Portals {
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Events(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -6958,24 +7191,129 @@ var SeamHttpSeamCustomerV1Portals = class _SeamHttpSeamCustomerV1Portals {
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
-  get(parameters, options = {}) {
+  list(parameters, options = {}) {
     if (!this.defaults.isUndocumentedApiEnabled) {
       throw new Error(
         "Cannot use undocumented API without isUndocumentedApiEnabled"
       );
     }
     return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/portals/get",
+      pathname: "/seam/customer/v1/events/list",
       method: "POST",
       body: parameters,
-      responseKey: "customer_portal",
+      responseKey: "events",
       options
     });
   }
 };
 
-// src/lib/seam/connect/routes/seam/customer/v1/reservations/reservations.ts
-var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservations {
+// src/lib/seam/connect/routes/seam/customer/v1/portals/portals.ts
+var SeamHttpSeamCustomerV1Portals = class _SeamHttpSeamCustomerV1Portals {
+  client;
+  defaults;
+  ltsVersion = seamApiLtsVersion;
+  static ltsVersion = seamApiLtsVersion;
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    if (!options.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttpSeamCustomerV1Portals.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpSeamCustomerV1Portals.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 _SeamHttpSeamCustomerV1Portals(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
+  }
+  createPaginator(request) {
+    return new SeamPaginator(this, request);
+  }
+  async updateClientSessionToken(clientSessionToken) {
+    const { headers } = this.client.defaults;
+    const authHeaders = getAuthHeadersForClientSessionToken({
+      clientSessionToken
+    });
+    for (const key of Object.keys(authHeaders)) {
+      if (headers[key] == null) {
+        throw new Error(
+          "Cannot update a clientSessionToken on a client created without a clientSessionToken"
+        );
+      }
+    }
+    this.client.defaults.headers = { ...headers, ...authHeaders };
+    const clientSessions = SeamHttpClientSessions.fromClient(this.client);
+    await clientSessions.get();
+  }
+  get(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/portals/get",
+      method: "POST",
+      body: parameters,
+      responseKey: "customer_portal",
+      options
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/seam/customer/v1/reservations/reservations.ts
+var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservations {
   client;
   defaults;
   ltsVersion = seamApiLtsVersion;
@@ -7096,6 +7434,124 @@ var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservatio
   }
 };
 
+// src/lib/seam/connect/routes/seam/customer/v1/settings/vertical-resource-aliases/vertical-resource-aliases.ts
+var SeamHttpSeamCustomerV1SettingsVerticalResourceAliases = class _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases {
+  client;
+  defaults;
+  ltsVersion = seamApiLtsVersion;
+  static ltsVersion = seamApiLtsVersion;
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    if (!options.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttpSeamCustomerV1SettingsVerticalResourceAliases.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases.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 _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
+  }
+  createPaginator(request) {
+    return new SeamPaginator(this, request);
+  }
+  async updateClientSessionToken(clientSessionToken) {
+    const { headers } = this.client.defaults;
+    const authHeaders = getAuthHeadersForClientSessionToken({
+      clientSessionToken
+    });
+    for (const key of Object.keys(authHeaders)) {
+      if (headers[key] == null) {
+        throw new Error(
+          "Cannot update a clientSessionToken on a client created without a clientSessionToken"
+        );
+      }
+    }
+    this.client.defaults.headers = { ...headers, ...authHeaders };
+    const clientSessions = SeamHttpClientSessions.fromClient(this.client);
+    await clientSessions.get();
+  }
+  get(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/settings/vertical_resource_aliases/get",
+      method: "POST",
+      body: parameters,
+      responseKey: "vertical_resource_aliases",
+      options
+    });
+  }
+};
+
 // src/lib/seam/connect/routes/seam/customer/v1/settings/settings.ts
 var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
   client;
@@ -7185,6 +7641,12 @@ var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
+  get verticalResourceAliases() {
+    return SeamHttpSeamCustomerV1SettingsVerticalResourceAliases.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
   get(parameters, options = {}) {
     if (!this.defaults.isUndocumentedApiEnabled) {
       throw new Error(
@@ -7223,11 +7685,6 @@ var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
   static ltsVersion = seamApiLtsVersion;
   constructor(apiKeyOrOptions = {}) {
     const options = parseOptions(apiKeyOrOptions);
-    if (!options.isUndocumentedApiEnabled) {
-      throw new Error(
-        "Cannot use undocumented API without isUndocumentedApiEnabled"
-      );
-    }
     this.client = "client" in options ? options.client : createClient(options);
     this.defaults = limitToSeamHttpRequestOptions(options);
   }
@@ -7346,6 +7803,15 @@ var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
       options
     });
   }
+  pushCommonAreas(parameters, options = {}) {
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/spaces/push_common_areas",
+      method: "POST",
+      body: parameters,
+      responseKey: void 0,
+      options
+    });
+  }
 };
 
 // src/lib/seam/connect/routes/seam/customer/v1/staff-members/staff-members.ts
@@ -7478,11 +7944,6 @@ var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
   static ltsVersion = seamApiLtsVersion;
   constructor(apiKeyOrOptions = {}) {
     const options = parseOptions(apiKeyOrOptions);
-    if (!options.isUndocumentedApiEnabled) {
-      throw new Error(
-        "Cannot use undocumented API without isUndocumentedApiEnabled"
-      );
-    }
     this.client = "client" in options ? options.client : createClient(options);
     this.defaults = limitToSeamHttpRequestOptions(options);
   }
@@ -7565,6 +8026,12 @@ var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
       this.defaults
     );
   }
+  get accessMethods() {
+    return SeamHttpSeamCustomerV1AccessMethods.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
   get automationRuns() {
     return SeamHttpSeamCustomerV1AutomationRuns.fromClient(
       this.client,
@@ -7595,6 +8062,9 @@ var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
       this.defaults
     );
   }
+  get encoders() {
+    return SeamHttpSeamCustomerV1Encoders.fromClient(this.client, this.defaults);
+  }
   get events() {
     return SeamHttpSeamCustomerV1Events.fromClient(this.client, this.defaults);
   }
@@ -7829,190 +8299,6 @@ var SeamHttpSeamPartnerV1BuildingBlocks = class _SeamHttpSeamPartnerV1BuildingBl
   }
 };
 
-// src/lib/seam/connect/routes/seam/v1/customers/customers.ts
-var SeamHttpSeamV1Customers = class _SeamHttpSeamV1Customers {
-  client;
-  defaults;
-  ltsVersion = seamApiLtsVersion;
-  static ltsVersion = seamApiLtsVersion;
-  constructor(apiKeyOrOptions = {}) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = "client" in options ? options.client : createClient(options);
-    this.defaults = limitToSeamHttpRequestOptions(options);
-  }
-  static fromClient(client, options = {}) {
-    const constructorOptions = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError("Missing client");
-    }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
-  }
-  static fromApiKey(apiKey, options = {}) {
-    const constructorOptions = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError("Missing apiKey");
-    }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
-  }
-  static fromClientSessionToken(clientSessionToken, options = {}) {
-    const constructorOptions = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
-    }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
-  }
-  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
-    warnOnInsecureuserIdentifierKey(userIdentifierKey);
-    const clientOptions = parseOptions({ ...options, publishableKey });
-    if (isSeamHttpOptionsWithClient(clientOptions)) {
-      throw new SeamHttpInvalidOptionsError(
-        "The client option cannot be used with SeamHttpSeamV1Customers.fromPublishableKey"
-      );
-    }
-    const client = createClient(clientOptions);
-    const clientSessions = SeamHttpClientSessions.fromClient(client);
-    const { token } = await clientSessions.getOrCreate({
-      user_identifier_key: userIdentifierKey
-    });
-    return _SeamHttpSeamV1Customers.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 _SeamHttpSeamV1Customers(constructorOptions);
-  }
-  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
-    const constructorOptions = { ...options, personalAccessToken, workspaceId };
-    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError(
-        "Missing personalAccessToken or workspaceId"
-      );
-    }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
-  }
-  createPaginator(request) {
-    return new SeamPaginator(this, request);
-  }
-  async updateClientSessionToken(clientSessionToken) {
-    const { headers } = this.client.defaults;
-    const authHeaders = getAuthHeadersForClientSessionToken({
-      clientSessionToken
-    });
-    for (const key of Object.keys(authHeaders)) {
-      if (headers[key] == null) {
-        throw new Error(
-          "Cannot update a clientSessionToken on a client created without a clientSessionToken"
-        );
-      }
-    }
-    this.client.defaults.headers = { ...headers, ...authHeaders };
-    const clientSessions = SeamHttpClientSessions.fromClient(this.client);
-    await clientSessions.get();
-  }
-  pushData(parameters, options = {}) {
-    return new SeamHttpRequest(this, {
-      pathname: "/seam/v1/customers/push_data",
-      method: "POST",
-      body: parameters,
-      responseKey: void 0,
-      options
-    });
-  }
-};
-
-// src/lib/seam/connect/routes/seam/v1/v1.ts
-var SeamHttpSeamV1 = class _SeamHttpSeamV1 {
-  client;
-  defaults;
-  ltsVersion = seamApiLtsVersion;
-  static ltsVersion = seamApiLtsVersion;
-  constructor(apiKeyOrOptions = {}) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = "client" in options ? options.client : createClient(options);
-    this.defaults = limitToSeamHttpRequestOptions(options);
-  }
-  static fromClient(client, options = {}) {
-    const constructorOptions = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError("Missing client");
-    }
-    return new _SeamHttpSeamV1(constructorOptions);
-  }
-  static fromApiKey(apiKey, options = {}) {
-    const constructorOptions = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError("Missing apiKey");
-    }
-    return new _SeamHttpSeamV1(constructorOptions);
-  }
-  static fromClientSessionToken(clientSessionToken, options = {}) {
-    const constructorOptions = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
-    }
-    return new _SeamHttpSeamV1(constructorOptions);
-  }
-  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
-    warnOnInsecureuserIdentifierKey(userIdentifierKey);
-    const clientOptions = parseOptions({ ...options, publishableKey });
-    if (isSeamHttpOptionsWithClient(clientOptions)) {
-      throw new SeamHttpInvalidOptionsError(
-        "The client option cannot be used with SeamHttpSeamV1.fromPublishableKey"
-      );
-    }
-    const client = createClient(clientOptions);
-    const clientSessions = SeamHttpClientSessions.fromClient(client);
-    const { token } = await clientSessions.getOrCreate({
-      user_identifier_key: userIdentifierKey
-    });
-    return _SeamHttpSeamV1.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 _SeamHttpSeamV1(constructorOptions);
-  }
-  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
-    const constructorOptions = { ...options, personalAccessToken, workspaceId };
-    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError(
-        "Missing personalAccessToken or workspaceId"
-      );
-    }
-    return new _SeamHttpSeamV1(constructorOptions);
-  }
-  createPaginator(request) {
-    return new SeamPaginator(this, request);
-  }
-  async updateClientSessionToken(clientSessionToken) {
-    const { headers } = this.client.defaults;
-    const authHeaders = getAuthHeadersForClientSessionToken({
-      clientSessionToken
-    });
-    for (const key of Object.keys(authHeaders)) {
-      if (headers[key] == null) {
-        throw new Error(
-          "Cannot update a clientSessionToken on a client created without a clientSessionToken"
-        );
-      }
-    }
-    this.client.defaults.headers = { ...headers, ...authHeaders };
-    const clientSessions = SeamHttpClientSessions.fromClient(this.client);
-    await clientSessions.get();
-  }
-  get customers() {
-    return SeamHttpSeamV1Customers.fromClient(this.client, this.defaults);
-  }
-};
-
 // src/lib/seam/connect/routes/spaces/spaces.ts
 var SeamHttpSpaces = class _SeamHttpSpaces {
   client;
@@ -10223,6 +10509,13 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.get(...args);
     };
   }
+  get "/access_codes/get_timeline"() {
+    const { client, defaults } = this;
+    return function accessCodesGetTimeline(...args) {
+      const seam = SeamHttpAccessCodes.fromClient(client, defaults);
+      return seam.getTimeline(...args);
+    };
+  }
   get "/access_codes/list"() {
     const { client, defaults } = this;
     return function accessCodesList(...args) {
@@ -11005,6 +11298,13 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.pushData(...args);
     };
   }
+  get "/customers/reservations/create_deep_link"() {
+    const { client, defaults } = this;
+    return function customersReservationsCreateDeepLink(...args) {
+      const seam = SeamHttpCustomersReservations.fromClient(client, defaults);
+      return seam.createDeepLink(...args);
+    };
+  }
   get "/devices/delete"() {
     const { client, defaults } = this;
     if (!this.defaults.isUndocumentedApiEnabled) {
@@ -11323,6 +11623,36 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.list(...args);
     };
   }
+  get "/seam/customer/v1/access_grants/update"() {
+    const { client, defaults } = this;
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return function seamCustomerV1AccessGrantsUpdate(...args) {
+      const seam = SeamHttpSeamCustomerV1AccessGrants.fromClient(
+        client,
+        defaults
+      );
+      return seam.update(...args);
+    };
+  }
+  get "/seam/customer/v1/access_methods/encode"() {
+    const { client, defaults } = this;
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return function seamCustomerV1AccessMethodsEncode(...args) {
+      const seam = SeamHttpSeamCustomerV1AccessMethods.fromClient(
+        client,
+        defaults
+      );
+      return seam.encode(...args);
+    };
+  }
   get "/seam/customer/v1/automation_runs/list"() {
     const { client, defaults } = this;
     if (!this.defaults.isUndocumentedApiEnabled) {
@@ -11494,6 +11824,13 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.list(...args);
     };
   }
+  get "/seam/customer/v1/customers/me"() {
+    const { client, defaults } = this;
+    return function seamCustomerV1CustomersMe(...args) {
+      const seam = SeamHttpSeamCustomerV1Customers.fromClient(client, defaults);
+      return seam.me(...args);
+    };
+  }
   get "/seam/customer/v1/customers/open_portal"() {
     const { client, defaults } = this;
     if (!this.defaults.isUndocumentedApiEnabled) {
@@ -11506,6 +11843,18 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.openPortal(...args);
     };
   }
+  get "/seam/customer/v1/encoders/list"() {
+    const { client, defaults } = this;
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return function seamCustomerV1EncodersList(...args) {
+      const seam = SeamHttpSeamCustomerV1Encoders.fromClient(client, defaults);
+      return seam.list(...args);
+    };
+  }
   get "/seam/customer/v1/events/list"() {
     const { client, defaults } = this;
     if (!this.defaults.isUndocumentedApiEnabled) {
@@ -11584,6 +11933,21 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.update(...args);
     };
   }
+  get "/seam/customer/v1/settings/vertical_resource_aliases/get"() {
+    const { client, defaults } = this;
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return function seamCustomerV1SettingsVerticalResourceAliasesGet(...args) {
+      const seam = SeamHttpSeamCustomerV1SettingsVerticalResourceAliases.fromClient(
+        client,
+        defaults
+      );
+      return seam.get(...args);
+    };
+  }
   get "/seam/customer/v1/spaces/create"() {
     const { client, defaults } = this;
     if (!this.defaults.isUndocumentedApiEnabled) {
@@ -11620,6 +11984,13 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.listReservations(...args);
     };
   }
+  get "/seam/customer/v1/spaces/push_common_areas"() {
+    const { client, defaults } = this;
+    return function seamCustomerV1SpacesPushCommonAreas(...args) {
+      const seam = SeamHttpSeamCustomerV1Spaces.fromClient(client, defaults);
+      return seam.pushCommonAreas(...args);
+    };
+  }
   get "/seam/customer/v1/staff_members/get"() {
     const { client, defaults } = this;
     if (!this.defaults.isUndocumentedApiEnabled) {
@@ -11665,13 +12036,6 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.autoMap(...args);
     };
   }
-  get "/seam/v1/customers/push_data"() {
-    const { client, defaults } = this;
-    return function seamV1CustomersPushData(...args) {
-      const seam = SeamHttpSeamV1Customers.fromClient(client, defaults);
-      return seam.pushData(...args);
-    };
-  }
   get "/spaces/add_acs_entrances"() {
     const { client, defaults } = this;
     return function spacesAddAcsEntrances(...args) {
@@ -12459,6 +12823,7 @@ exports.SeamHttpConnectWebviews = SeamHttpConnectWebviews;
 exports.SeamHttpConnectedAccounts = SeamHttpConnectedAccounts;
 exports.SeamHttpConnectedAccountsSimulate = SeamHttpConnectedAccountsSimulate;
 exports.SeamHttpCustomers = SeamHttpCustomers;
+exports.SeamHttpCustomersReservations = SeamHttpCustomersReservations;
 exports.SeamHttpDevices = SeamHttpDevices;
 exports.SeamHttpDevicesSimulate = SeamHttpDevicesSimulate;
 exports.SeamHttpDevicesUnmanaged = SeamHttpDevicesUnmanaged;
@@ -12483,21 +12848,22 @@ exports.SeamHttpSeamConsoleV1 = SeamHttpSeamConsoleV1;
 exports.SeamHttpSeamConsoleV1Timelines = SeamHttpSeamConsoleV1Timelines;
 exports.SeamHttpSeamCustomerV1 = SeamHttpSeamCustomerV1;
 exports.SeamHttpSeamCustomerV1AccessGrants = SeamHttpSeamCustomerV1AccessGrants;
+exports.SeamHttpSeamCustomerV1AccessMethods = SeamHttpSeamCustomerV1AccessMethods;
 exports.SeamHttpSeamCustomerV1AutomationRuns = SeamHttpSeamCustomerV1AutomationRuns;
 exports.SeamHttpSeamCustomerV1Automations = SeamHttpSeamCustomerV1Automations;
 exports.SeamHttpSeamCustomerV1ConnectorCustomers = SeamHttpSeamCustomerV1ConnectorCustomers;
 exports.SeamHttpSeamCustomerV1Connectors = SeamHttpSeamCustomerV1Connectors;
 exports.SeamHttpSeamCustomerV1Customers = SeamHttpSeamCustomerV1Customers;
+exports.SeamHttpSeamCustomerV1Encoders = SeamHttpSeamCustomerV1Encoders;
 exports.SeamHttpSeamCustomerV1Events = SeamHttpSeamCustomerV1Events;
 exports.SeamHttpSeamCustomerV1Portals = SeamHttpSeamCustomerV1Portals;
 exports.SeamHttpSeamCustomerV1Reservations = SeamHttpSeamCustomerV1Reservations;
 exports.SeamHttpSeamCustomerV1Settings = SeamHttpSeamCustomerV1Settings;
+exports.SeamHttpSeamCustomerV1SettingsVerticalResourceAliases = SeamHttpSeamCustomerV1SettingsVerticalResourceAliases;
 exports.SeamHttpSeamCustomerV1Spaces = SeamHttpSeamCustomerV1Spaces;
 exports.SeamHttpSeamCustomerV1StaffMembers = SeamHttpSeamCustomerV1StaffMembers;
 exports.SeamHttpSeamPartnerV1BuildingBlocks = SeamHttpSeamPartnerV1BuildingBlocks;
 exports.SeamHttpSeamPartnerV1BuildingBlocksSpaces = SeamHttpSeamPartnerV1BuildingBlocksSpaces;
-exports.SeamHttpSeamV1 = SeamHttpSeamV1;
-exports.SeamHttpSeamV1Customers = SeamHttpSeamV1Customers;
 exports.SeamHttpSpaces = SeamHttpSpaces;
 exports.SeamHttpThermostats = SeamHttpThermostats;
 exports.SeamHttpThermostatsDailyPrograms = SeamHttpThermostatsDailyPrograms;