@seamapi/http 1.101.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
@@ -6342,8 +6571,8 @@ var SeamHttpSeamCustomerV1Automations = class _SeamHttpSeamCustomerV1Automations
   }
 };
 
-// src/lib/seam/connect/routes/seam/customer/v1/connectors/connectors.ts
-var SeamHttpSeamCustomerV1Connectors = class _SeamHttpSeamCustomerV1Connectors {
+// src/lib/seam/connect/routes/seam/customer/v1/connector-customers/connector-customers.ts
+var SeamHttpSeamCustomerV1ConnectorCustomers = class _SeamHttpSeamCustomerV1ConnectorCustomers {
   client;
   defaults;
   ltsVersion = seamApiLtsVersion;
@@ -6363,28 +6592,28 @@ var SeamHttpSeamCustomerV1Connectors = class _SeamHttpSeamCustomerV1Connectors {
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamCustomerV1Connectors(constructorOptions);
+    return new _SeamHttpSeamCustomerV1ConnectorCustomers(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamCustomerV1Connectors(constructorOptions);
+    return new _SeamHttpSeamCustomerV1ConnectorCustomers(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamCustomerV1Connectors(constructorOptions);
+    return new _SeamHttpSeamCustomerV1ConnectorCustomers(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 SeamHttpSeamCustomerV1Connectors.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1ConnectorCustomers.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -6392,7 +6621,7 @@ var SeamHttpSeamCustomerV1Connectors = class _SeamHttpSeamCustomerV1Connectors {
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamCustomerV1Connectors.fromClientSessionToken(
+    return _SeamHttpSeamCustomerV1ConnectorCustomers.fromClientSessionToken(
       token,
       options
     );
@@ -6404,7 +6633,7 @@ var SeamHttpSeamCustomerV1Connectors = class _SeamHttpSeamCustomerV1Connectors {
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Connectors(constructorOptions);
+    return new _SeamHttpSeamCustomerV1ConnectorCustomers(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -6413,7 +6642,7 @@ var SeamHttpSeamCustomerV1Connectors = class _SeamHttpSeamCustomerV1Connectors {
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Connectors(constructorOptions);
+    return new _SeamHttpSeamCustomerV1ConnectorCustomers(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -6434,47 +6663,155 @@ var SeamHttpSeamCustomerV1Connectors = class _SeamHttpSeamCustomerV1Connectors {
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
-  authorize(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/connectors/authorize",
+      pathname: "/seam/customer/v1/connector_customers/list",
       method: "POST",
       body: parameters,
-      responseKey: "connector_authorize",
+      responseKey: "connector_customers",
       options
     });
   }
-  connectorTypes(parameters, options = {}) {
-    if (!this.defaults.isUndocumentedApiEnabled) {
+};
+
+// src/lib/seam/connect/routes/seam/customer/v1/connectors/connectors.ts
+var SeamHttpSeamCustomerV1Connectors = class _SeamHttpSeamCustomerV1Connectors {
+  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"
       );
     }
-    return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/connectors/connector_types",
-      method: "GET",
-      params: parameters,
-      responseKey: "connector_types",
-      options
-    });
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
-  create(parameters, options = {}) {
-    if (!this.defaults.isUndocumentedApiEnabled) {
-      throw new Error(
-        "Cannot use undocumented API without isUndocumentedApiEnabled"
-      );
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/connectors/create",
-      method: "POST",
-      body: parameters,
-      responseKey: "connector",
-      options
-    });
+    return new _SeamHttpSeamCustomerV1Connectors(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpSeamCustomerV1Connectors(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpSeamCustomerV1Connectors(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 SeamHttpSeamCustomerV1Connectors.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpSeamCustomerV1Connectors.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 _SeamHttpSeamCustomerV1Connectors(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpSeamCustomerV1Connectors(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();
+  }
+  authorize(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/connectors/authorize",
+      method: "POST",
+      body: parameters,
+      responseKey: "connector_authorize",
+      options
+    });
+  }
+  connectorTypes(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/connectors/connector_types",
+      method: "GET",
+      params: parameters,
+      responseKey: "connector_types",
+      options
+    });
+  }
+  create(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/connectors/create",
+      method: "POST",
+      body: parameters,
+      responseKey: "connector",
+      options
+    });
   }
   delete(parameters, options = {}) {
     if (!this.defaults.isUndocumentedApiEnabled) {
@@ -6542,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);
   }
@@ -6640,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(
@@ -6656,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;
@@ -6677,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);
@@ -6706,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 };
@@ -6715,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 };
@@ -6724,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);
@@ -6752,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;
@@ -6782,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);
@@ -6811,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 };
@@ -6820,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 };
@@ -6829,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);
@@ -6850,24 +7191,24 @@ 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;
@@ -6887,28 +7228,28 @@ var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservatio
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
+    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 SeamHttpSeamCustomerV1Reservations.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1Portals.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -6916,10 +7257,7 @@ var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservatio
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamCustomerV1Reservations.fromClientSessionToken(
-      token,
-      options
-    );
+    return _SeamHttpSeamCustomerV1Portals.fromClientSessionToken(token, options);
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -6928,7 +7266,7 @@ var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservatio
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -6937,7 +7275,7 @@ var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservatio
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Portals(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -6965,31 +7303,17 @@ var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservatio
       );
     }
     return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/reservations/get",
-      method: "POST",
-      body: parameters,
-      responseKey: "reservation",
-      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/reservations/list",
+      pathname: "/seam/customer/v1/portals/get",
       method: "POST",
       body: parameters,
-      responseKey: "reservations",
+      responseKey: "customer_portal",
       options
     });
   }
 };
 
-// src/lib/seam/connect/routes/seam/customer/v1/settings/settings.ts
-var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
+// src/lib/seam/connect/routes/seam/customer/v1/reservations/reservations.ts
+var SeamHttpSeamCustomerV1Reservations = class _SeamHttpSeamCustomerV1Reservations {
   client;
   defaults;
   ltsVersion = seamApiLtsVersion;
@@ -7009,28 +7333,28 @@ var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Reservations(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 SeamHttpSeamCustomerV1Settings.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1Reservations.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -7038,7 +7362,10 @@ var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamCustomerV1Settings.fromClientSessionToken(token, options);
+    return _SeamHttpSeamCustomerV1Reservations.fromClientSessionToken(
+      token,
+      options
+    );
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -7047,7 +7374,7 @@ var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -7056,7 +7383,7 @@ var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Reservations(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -7084,31 +7411,31 @@ var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
       );
     }
     return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/settings/get",
-      method: "GET",
-      params: parameters,
-      responseKey: "business_vertical",
+      pathname: "/seam/customer/v1/reservations/get",
+      method: "POST",
+      body: parameters,
+      responseKey: "reservation",
       options
     });
   }
-  update(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/settings/update",
-      method: "PATCH",
+      pathname: "/seam/customer/v1/reservations/list",
+      method: "POST",
       body: parameters,
-      responseKey: void 0,
+      responseKey: "reservations",
       options
     });
   }
 };
 
-// src/lib/seam/connect/routes/seam/customer/v1/spaces/spaces.ts
-var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
+// src/lib/seam/connect/routes/seam/customer/v1/settings/vertical-resource-aliases/vertical-resource-aliases.ts
+var SeamHttpSeamCustomerV1SettingsVerticalResourceAliases = class _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases {
   client;
   defaults;
   ltsVersion = seamApiLtsVersion;
@@ -7128,28 +7455,34 @@ var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
+    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 SeamHttpSeamCustomerV1Spaces.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1SettingsVerticalResourceAliases.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -7157,7 +7490,10 @@ var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamCustomerV1Spaces.fromClientSessionToken(token, options);
+    return _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases.fromClientSessionToken(
+      token,
+      options
+    );
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -7166,7 +7502,9 @@ var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -7175,7 +7513,9 @@ var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1SettingsVerticalResourceAliases(
+      constructorOptions
+    );
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -7196,52 +7536,24 @@ var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
-  create(parameters, options = {}) {
-    if (!this.defaults.isUndocumentedApiEnabled) {
-      throw new Error(
-        "Cannot use undocumented API without isUndocumentedApiEnabled"
-      );
-    }
-    return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/spaces/create",
-      method: "POST",
-      body: parameters,
-      responseKey: "space",
-      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/spaces/list",
-      method: "POST",
-      body: parameters,
-      responseKey: "spaces",
-      options
-    });
-  }
-  listReservations(parameters, options = {}) {
+  get(parameters, options = {}) {
     if (!this.defaults.isUndocumentedApiEnabled) {
       throw new Error(
         "Cannot use undocumented API without isUndocumentedApiEnabled"
       );
     }
     return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/spaces/list_reservations",
+      pathname: "/seam/customer/v1/settings/vertical_resource_aliases/get",
       method: "POST",
       body: parameters,
-      responseKey: "reservations",
+      responseKey: "vertical_resource_aliases",
       options
     });
   }
 };
 
-// src/lib/seam/connect/routes/seam/customer/v1/staff-members/staff-members.ts
-var SeamHttpSeamCustomerV1StaffMembers = class _SeamHttpSeamCustomerV1StaffMembers {
+// src/lib/seam/connect/routes/seam/customer/v1/settings/settings.ts
+var SeamHttpSeamCustomerV1Settings = class _SeamHttpSeamCustomerV1Settings {
   client;
   defaults;
   ltsVersion = seamApiLtsVersion;
@@ -7261,28 +7573,28 @@ var SeamHttpSeamCustomerV1StaffMembers = class _SeamHttpSeamCustomerV1StaffMembe
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Settings(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 SeamHttpSeamCustomerV1StaffMembers.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1Settings.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -7290,10 +7602,7 @@ var SeamHttpSeamCustomerV1StaffMembers = class _SeamHttpSeamCustomerV1StaffMembe
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamCustomerV1StaffMembers.fromClientSessionToken(
-      token,
-      options
-    );
+    return _SeamHttpSeamCustomerV1Settings.fromClientSessionToken(token, options);
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -7302,7 +7611,7 @@ var SeamHttpSeamCustomerV1StaffMembers = class _SeamHttpSeamCustomerV1StaffMembe
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -7311,7 +7620,7 @@ var SeamHttpSeamCustomerV1StaffMembers = class _SeamHttpSeamCustomerV1StaffMembe
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Settings(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -7332,6 +7641,12 @@ var SeamHttpSeamCustomerV1StaffMembers = class _SeamHttpSeamCustomerV1StaffMembe
     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(
@@ -7339,42 +7654,37 @@ var SeamHttpSeamCustomerV1StaffMembers = class _SeamHttpSeamCustomerV1StaffMembe
       );
     }
     return new SeamHttpRequest(this, {
-      pathname: "/seam/customer/v1/staff_members/get",
-      method: "POST",
-      body: parameters,
-      responseKey: "staff_member",
+      pathname: "/seam/customer/v1/settings/get",
+      method: "GET",
+      params: parameters,
+      responseKey: "business_vertical",
       options
     });
   }
-  list(parameters, 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/staff_members/list",
-      method: "POST",
+      pathname: "/seam/customer/v1/settings/update",
+      method: "PATCH",
       body: parameters,
-      responseKey: "staff_members",
+      responseKey: void 0,
       options
     });
   }
 };
 
-// src/lib/seam/connect/routes/seam/customer/v1/v1.ts
-var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
+// src/lib/seam/connect/routes/seam/customer/v1/spaces/spaces.ts
+var SeamHttpSeamCustomerV1Spaces = class _SeamHttpSeamCustomerV1Spaces {
   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);
   }
@@ -7383,28 +7693,28 @@ var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamCustomerV1(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamCustomerV1(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamCustomerV1(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Spaces(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 SeamHttpSeamCustomerV1.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1Spaces.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -7412,7 +7722,7 @@ var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamCustomerV1.fromClientSessionToken(token, options);
+    return _SeamHttpSeamCustomerV1Spaces.fromClientSessionToken(token, options);
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -7421,7 +7731,7 @@ var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -7430,7 +7740,7 @@ var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamCustomerV1(constructorOptions);
+    return new _SeamHttpSeamCustomerV1Spaces(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -7451,64 +7761,61 @@ var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
-  get accessGrants() {
-    return SeamHttpSeamCustomerV1AccessGrants.fromClient(
-      this.client,
-      this.defaults
-    );
-  }
-  get automationRuns() {
-    return SeamHttpSeamCustomerV1AutomationRuns.fromClient(
-      this.client,
-      this.defaults
-    );
-  }
-  get automations() {
-    return SeamHttpSeamCustomerV1Automations.fromClient(
-      this.client,
-      this.defaults
-    );
-  }
-  get connectors() {
-    return SeamHttpSeamCustomerV1Connectors.fromClient(
-      this.client,
-      this.defaults
-    );
-  }
-  get customers() {
-    return SeamHttpSeamCustomerV1Customers.fromClient(
-      this.client,
-      this.defaults
-    );
-  }
-  get events() {
-    return SeamHttpSeamCustomerV1Events.fromClient(this.client, this.defaults);
-  }
-  get portals() {
-    return SeamHttpSeamCustomerV1Portals.fromClient(this.client, this.defaults);
-  }
-  get reservations() {
-    return SeamHttpSeamCustomerV1Reservations.fromClient(
-      this.client,
-      this.defaults
-    );
+  create(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/spaces/create",
+      method: "POST",
+      body: parameters,
+      responseKey: "space",
+      options
+    });
   }
-  get settings() {
-    return SeamHttpSeamCustomerV1Settings.fromClient(this.client, this.defaults);
+  list(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/spaces/list",
+      method: "POST",
+      body: parameters,
+      responseKey: "spaces",
+      options
+    });
   }
-  get spaces() {
-    return SeamHttpSeamCustomerV1Spaces.fromClient(this.client, this.defaults);
+  listReservations(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return new SeamHttpRequest(this, {
+      pathname: "/seam/customer/v1/spaces/list_reservations",
+      method: "POST",
+      body: parameters,
+      responseKey: "reservations",
+      options
+    });
   }
-  get staffMembers() {
-    return SeamHttpSeamCustomerV1StaffMembers.fromClient(
-      this.client,
-      this.defaults
-    );
+  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/partner/v1/building-blocks/spaces/spaces.ts
-var SeamHttpSeamPartnerV1BuildingBlocksSpaces = class _SeamHttpSeamPartnerV1BuildingBlocksSpaces {
+// src/lib/seam/connect/routes/seam/customer/v1/staff-members/staff-members.ts
+var SeamHttpSeamCustomerV1StaffMembers = class _SeamHttpSeamCustomerV1StaffMembers {
   client;
   defaults;
   ltsVersion = seamApiLtsVersion;
@@ -7528,28 +7835,28 @@ var SeamHttpSeamPartnerV1BuildingBlocksSpaces = class _SeamHttpSeamPartnerV1Buil
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1StaffMembers(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 SeamHttpSeamPartnerV1BuildingBlocksSpaces.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1StaffMembers.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -7557,7 +7864,7 @@ var SeamHttpSeamPartnerV1BuildingBlocksSpaces = class _SeamHttpSeamPartnerV1Buil
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamPartnerV1BuildingBlocksSpaces.fromClientSessionToken(
+    return _SeamHttpSeamCustomerV1StaffMembers.fromClientSessionToken(
       token,
       options
     );
@@ -7569,7 +7876,7 @@ var SeamHttpSeamPartnerV1BuildingBlocksSpaces = class _SeamHttpSeamPartnerV1Buil
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -7578,7 +7885,7 @@ var SeamHttpSeamPartnerV1BuildingBlocksSpaces = class _SeamHttpSeamPartnerV1Buil
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
+    return new _SeamHttpSeamCustomerV1StaffMembers(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -7599,35 +7906,44 @@ var SeamHttpSeamPartnerV1BuildingBlocksSpaces = class _SeamHttpSeamPartnerV1Buil
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
-  autoMap(parameters, options = {}) {
+  get(parameters, options = {}) {
     if (!this.defaults.isUndocumentedApiEnabled) {
       throw new Error(
         "Cannot use undocumented API without isUndocumentedApiEnabled"
       );
     }
     return new SeamHttpRequest(this, {
-      pathname: "/seam/partner/v1/building_blocks/spaces/auto_map",
+      pathname: "/seam/customer/v1/staff_members/get",
       method: "POST",
       body: parameters,
-      responseKey: "spaces",
+      responseKey: "staff_member",
+      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/staff_members/list",
+      method: "POST",
+      body: parameters,
+      responseKey: "staff_members",
       options
     });
   }
 };
 
-// src/lib/seam/connect/routes/seam/partner/v1/building-blocks/building-blocks.ts
-var SeamHttpSeamPartnerV1BuildingBlocks = class _SeamHttpSeamPartnerV1BuildingBlocks {
+// src/lib/seam/connect/routes/seam/customer/v1/v1.ts
+var SeamHttpSeamCustomerV1 = class _SeamHttpSeamCustomerV1 {
   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);
   }
@@ -7636,28 +7952,28 @@ var SeamHttpSeamPartnerV1BuildingBlocks = class _SeamHttpSeamPartnerV1BuildingBl
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
+    return new _SeamHttpSeamCustomerV1(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
+    return new _SeamHttpSeamCustomerV1(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
+    return new _SeamHttpSeamCustomerV1(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 SeamHttpSeamPartnerV1BuildingBlocks.fromPublishableKey"
+        "The client option cannot be used with SeamHttpSeamCustomerV1.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -7665,10 +7981,7 @@ var SeamHttpSeamPartnerV1BuildingBlocks = class _SeamHttpSeamPartnerV1BuildingBl
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamPartnerV1BuildingBlocks.fromClientSessionToken(
-      token,
-      options
-    );
+    return _SeamHttpSeamCustomerV1.fromClientSessionToken(token, options);
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -7677,7 +7990,7 @@ var SeamHttpSeamPartnerV1BuildingBlocks = class _SeamHttpSeamPartnerV1BuildingBl
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
+    return new _SeamHttpSeamCustomerV1(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -7686,7 +7999,7 @@ var SeamHttpSeamPartnerV1BuildingBlocks = class _SeamHttpSeamPartnerV1BuildingBl
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
+    return new _SeamHttpSeamCustomerV1(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -7707,22 +8020,90 @@ var SeamHttpSeamPartnerV1BuildingBlocks = class _SeamHttpSeamPartnerV1BuildingBl
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
+  get accessGrants() {
+    return SeamHttpSeamCustomerV1AccessGrants.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
+  get accessMethods() {
+    return SeamHttpSeamCustomerV1AccessMethods.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
+  get automationRuns() {
+    return SeamHttpSeamCustomerV1AutomationRuns.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
+  get automations() {
+    return SeamHttpSeamCustomerV1Automations.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
+  get connectorCustomers() {
+    return SeamHttpSeamCustomerV1ConnectorCustomers.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
+  get connectors() {
+    return SeamHttpSeamCustomerV1Connectors.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
+  get customers() {
+    return SeamHttpSeamCustomerV1Customers.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
+  get encoders() {
+    return SeamHttpSeamCustomerV1Encoders.fromClient(this.client, this.defaults);
+  }
+  get events() {
+    return SeamHttpSeamCustomerV1Events.fromClient(this.client, this.defaults);
+  }
+  get portals() {
+    return SeamHttpSeamCustomerV1Portals.fromClient(this.client, this.defaults);
+  }
+  get reservations() {
+    return SeamHttpSeamCustomerV1Reservations.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
+  get settings() {
+    return SeamHttpSeamCustomerV1Settings.fromClient(this.client, this.defaults);
+  }
   get spaces() {
-    return SeamHttpSeamPartnerV1BuildingBlocksSpaces.fromClient(
+    return SeamHttpSeamCustomerV1Spaces.fromClient(this.client, this.defaults);
+  }
+  get staffMembers() {
+    return SeamHttpSeamCustomerV1StaffMembers.fromClient(
       this.client,
       this.defaults
     );
   }
 };
 
-// src/lib/seam/connect/routes/seam/v1/customers/customers.ts
-var SeamHttpSeamV1Customers = class _SeamHttpSeamV1Customers {
+// src/lib/seam/connect/routes/seam/partner/v1/building-blocks/spaces/spaces.ts
+var SeamHttpSeamPartnerV1BuildingBlocksSpaces = class _SeamHttpSeamPartnerV1BuildingBlocksSpaces {
   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);
   }
@@ -7731,28 +8112,28 @@ var SeamHttpSeamV1Customers = class _SeamHttpSeamV1Customers {
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(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"
+        "The client option cannot be used with SeamHttpSeamPartnerV1BuildingBlocksSpaces.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -7760,7 +8141,10 @@ var SeamHttpSeamV1Customers = class _SeamHttpSeamV1Customers {
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamV1Customers.fromClientSessionToken(token, options);
+    return _SeamHttpSeamPartnerV1BuildingBlocksSpaces.fromClientSessionToken(
+      token,
+      options
+    );
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -7769,7 +8153,7 @@ var SeamHttpSeamV1Customers = class _SeamHttpSeamV1Customers {
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -7778,7 +8162,7 @@ var SeamHttpSeamV1Customers = class _SeamHttpSeamV1Customers {
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamV1Customers(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocksSpaces(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -7799,25 +8183,35 @@ var SeamHttpSeamV1Customers = class _SeamHttpSeamV1Customers {
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
-  pushData(parameters, options = {}) {
+  autoMap(parameters, options = {}) {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
     return new SeamHttpRequest(this, {
-      pathname: "/seam/v1/customers/push_data",
+      pathname: "/seam/partner/v1/building_blocks/spaces/auto_map",
       method: "POST",
       body: parameters,
-      responseKey: void 0,
+      responseKey: "spaces",
       options
     });
   }
 };
 
-// src/lib/seam/connect/routes/seam/v1/v1.ts
-var SeamHttpSeamV1 = class _SeamHttpSeamV1 {
+// src/lib/seam/connect/routes/seam/partner/v1/building-blocks/building-blocks.ts
+var SeamHttpSeamPartnerV1BuildingBlocks = class _SeamHttpSeamPartnerV1BuildingBlocks {
   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);
   }
@@ -7826,28 +8220,28 @@ var SeamHttpSeamV1 = class _SeamHttpSeamV1 {
     if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpSeamV1(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
     const constructorOptions = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpSeamV1(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const constructorOptions = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpSeamV1(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocks(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"
+        "The client option cannot be used with SeamHttpSeamPartnerV1BuildingBlocks.fromPublishableKey"
       );
     }
     const client = createClient(clientOptions);
@@ -7855,7 +8249,10 @@ var SeamHttpSeamV1 = class _SeamHttpSeamV1 {
     const { token } = await clientSessions.getOrCreate({
       user_identifier_key: userIdentifierKey
     });
-    return _SeamHttpSeamV1.fromClientSessionToken(token, options);
+    return _SeamHttpSeamPartnerV1BuildingBlocks.fromClientSessionToken(
+      token,
+      options
+    );
   }
   static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, consoleSessionToken, workspaceId };
@@ -7864,7 +8261,7 @@ var SeamHttpSeamV1 = class _SeamHttpSeamV1 {
         "Missing consoleSessionToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamV1(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
   }
   static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
     const constructorOptions = { ...options, personalAccessToken, workspaceId };
@@ -7873,7 +8270,7 @@ var SeamHttpSeamV1 = class _SeamHttpSeamV1 {
         "Missing personalAccessToken or workspaceId"
       );
     }
-    return new _SeamHttpSeamV1(constructorOptions);
+    return new _SeamHttpSeamPartnerV1BuildingBlocks(constructorOptions);
   }
   createPaginator(request) {
     return new SeamPaginator(this, request);
@@ -7894,8 +8291,11 @@ var SeamHttpSeamV1 = class _SeamHttpSeamV1 {
     const clientSessions = SeamHttpClientSessions.fromClient(this.client);
     await clientSessions.get();
   }
-  get customers() {
-    return SeamHttpSeamV1Customers.fromClient(this.client, this.defaults);
+  get spaces() {
+    return SeamHttpSeamPartnerV1BuildingBlocksSpaces.fromClient(
+      this.client,
+      this.defaults
+    );
   }
 };
 
@@ -10109,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) {
@@ -10891,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) {
@@ -11209,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) {
@@ -11269,6 +11713,21 @@ var SeamHttpEndpoints = class _SeamHttpEndpoints {
       return seam.update(...args);
     };
   }
+  get "/seam/customer/v1/connector_customers/list"() {
+    const { client, defaults } = this;
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        "Cannot use undocumented API without isUndocumentedApiEnabled"
+      );
+    }
+    return function seamCustomerV1ConnectorCustomersList(...args) {
+      const seam = SeamHttpSeamCustomerV1ConnectorCustomers.fromClient(
+        client,
+        defaults
+      );
+      return seam.list(...args);
+    };
+  }
   get "/seam/customer/v1/connectors/authorize"() {
     const { client, defaults } = this;
     if (!this.defaults.isUndocumentedApiEnabled) {
@@ -11365,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) {
@@ -11377,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) {
@@ -11455,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) {
@@ -11491,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) {
@@ -11536,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) {
@@ -12330,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;
@@ -12354,20 +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;