@serve.zone/dcrouter 14.3.1 → 15.0.0

package/ts/config/classes.route-config-manager.ts

@@ -491,19 +491,14 @@ export class RouteConfigManager {
       lastResolvedAt: typeof metadata.lastResolvedAt === 'number' && Number.isFinite(metadata.lastResolvedAt)
         ? metadata.lastResolvedAt
         : undefined,
-      ownerType: metadata.ownerType === 'gatewayClient' || metadata.ownerType === 'workhoster' || metadata.ownerType === 'operator' || metadata.ownerType === 'system'
+      ownerType: metadata.ownerType === 'gatewayClient' || metadata.ownerType === 'operator' || metadata.ownerType === 'system'
         ? metadata.ownerType
         : undefined,
       gatewayClientType: metadata.gatewayClientType === 'onebox' || metadata.gatewayClientType === 'cloudly' || metadata.gatewayClientType === 'custom'
         ? metadata.gatewayClientType
-        : metadata.workHosterType,
-      gatewayClientId: normalizeString(metadata.gatewayClientId || metadata.workHosterId),
-      gatewayClientAppId: normalizeString(metadata.gatewayClientAppId || metadata.workAppId),
-      workHosterType: metadata.workHosterType === 'onebox' || metadata.workHosterType === 'cloudly' || metadata.workHosterType === 'custom'
-        ? metadata.workHosterType
-        : metadata.gatewayClientType,
-      workHosterId: normalizeString(metadata.workHosterId || metadata.gatewayClientId),
-      workAppId: normalizeString(metadata.workAppId || metadata.gatewayClientAppId),
+        : undefined,
+      gatewayClientId: normalizeString(metadata.gatewayClientId),
+      gatewayClientAppId: normalizeString(metadata.gatewayClientAppId),
       externalKey: normalizeString(metadata.externalKey),
     };
 
@@ -513,19 +508,11 @@ export class RouteConfigManager {
     if (!normalized.sourceBindings && !normalized.networkTargetRef) {
       normalized.lastResolvedAt = undefined;
     }
-    if (normalized.ownerType !== 'gatewayClient' && normalized.ownerType !== 'workhoster') {
+    if (normalized.ownerType !== 'gatewayClient') {
       normalized.gatewayClientType = undefined;
       normalized.gatewayClientId = undefined;
       normalized.gatewayClientAppId = undefined;
-      normalized.workHosterType = undefined;
-      normalized.workHosterId = undefined;
-      normalized.workAppId = undefined;
       normalized.externalKey = undefined;
-    } else {
-      normalized.ownerType = 'gatewayClient';
-      normalized.workHosterType = normalized.gatewayClientType;
-      normalized.workHosterId = normalized.gatewayClientId;
-      normalized.workAppId = normalized.gatewayClientAppId;
     }
 
     if (Object.values(normalized).every((value) => value === undefined)) {
@@ -825,9 +812,7 @@ export class RouteConfigManager {
       return false;
     }
     return metadata.ownerType === 'gatewayClient'
-      || metadata.ownerType === 'workhoster'
       || Boolean(metadata.gatewayClientId)
-      || Boolean(metadata.workHosterId)
       || Boolean(metadata.externalKey);
   }
 

package/ts/email/classes.workapp-mail-manager.ts

@@ -5,7 +5,17 @@ import type {
 import * as plugins from '../plugins.js';
 import type * as interfaces from '../../ts_interfaces/index.js';
 
-type TSyncRequest = interfaces.requests.IReq_SyncWorkAppMailIdentity['request'];
+type TSyncRequest = {
+  ownership: interfaces.data.IWorkAppMailOwnership;
+  localPart: string;
+  domain: string;
+  displayName?: string;
+  inbound?: interfaces.data.IWorkAppMailInboundRoute;
+  enabled?: boolean;
+  smtpEnabled?: boolean;
+  resetSmtpPassword?: boolean;
+  delete?: boolean;
+};
 type TMailResourceOwner = plugins.servezoneInterfaces.data.IMailResourceOwner;
 type TMailAddressBinding = plugins.servezoneInterfaces.data.IMailAddressBinding;
 type TMailAddressBindingSync = plugins.servezoneInterfaces.requests.mail.TMailAddressBindingSync;

package/ts/opsserver/classes.opsserver.ts

@@ -38,7 +38,7 @@ export class OpsServer {
   private dnsRecordHandler!: handlers.DnsRecordHandler;
   private acmeConfigHandler!: handlers.AcmeConfigHandler;
   private emailDomainHandler!: handlers.EmailDomainHandler;
-  private workHosterHandler!: handlers.WorkHosterHandler;
+  private gatewayClientHandler!: handlers.GatewayClientHandler;
 
   constructor(dcRouterRefArg: DcRouter) {
     this.dcRouterRef = dcRouterRefArg;
@@ -98,7 +98,7 @@ export class OpsServer {
     this.dnsRecordHandler = new handlers.DnsRecordHandler(this);
     this.acmeConfigHandler = new handlers.AcmeConfigHandler(this);
     this.emailDomainHandler = new handlers.EmailDomainHandler(this);
-    this.workHosterHandler = new handlers.WorkHosterHandler(this);
+    this.gatewayClientHandler = new handlers.GatewayClientHandler(this);
 
     console.log('✅ OpsServer TypedRequest handlers initialized');
   }

package/ts/opsserver/handlers/certificate.handler.ts

@@ -85,7 +85,7 @@ export class CertificateHandler {
 
     // Export certificate
     router.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_ExportCertificate>(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.gateway.IReq_ExportCertificate>(
         'exportCertificate',
         async (dataArg) => {
           await this.requireAuth(dataArg, 'certificates:read');
@@ -96,7 +96,7 @@ export class CertificateHandler {
 
     // Import certificate
     router.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_ImportCertificate>(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.gateway.IReq_ImportCertificate>(
         'importCertificate',
         async (dataArg) => {
           await this.requireAuth(dataArg, 'certificates:write');

package/ts/opsserver/handlers/{workhoster.handler.ts → gatewayclient.handler.ts}

@@ -9,7 +9,7 @@ type TAuthContext = {
   token?: interfaces.data.IStoredApiToken;
 };
 
-export class WorkHosterHandler {
+export class GatewayClientHandler {
   public typedrouter = new plugins.typedrequest.TypedRouter();
 
   constructor(private opsServerRef: OpsServer) {
@@ -42,7 +42,7 @@ export class WorkHosterHandler {
 
   private registerHandlers(): void {
     this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetGatewayCapabilities>(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.gateway.IReq_GetGatewayCapabilities>(
         'getGatewayCapabilities',
         async (dataArg) => {
           await this.requireAuth(dataArg, 'gateway-clients:read');
@@ -52,7 +52,7 @@ export class WorkHosterHandler {
     );
 
     this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetGatewayClientContext>(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.gateway.IReq_GetGatewayClientContext>(
         'getGatewayClientContext',
         async (dataArg) => {
           const auth = await this.requireAuth(dataArg, 'gateway-clients:read');
@@ -168,7 +168,7 @@ export class WorkHosterHandler {
     );
 
     this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetGatewayClientDomains>(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.gateway.IReq_GetGatewayClientDomains>(
         'getGatewayClientDomains',
         async (dataArg) => {
           const auth = await this.requireAuth(dataArg, 'gateway-clients:read');
@@ -179,7 +179,7 @@ export class WorkHosterHandler {
     );
 
     this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetGatewayClientDnsRecords>(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.gateway.IReq_GetGatewayClientDnsRecords>(
         'getGatewayClientDnsRecords',
         async (dataArg) => {
           const auth = await this.requireAuth(dataArg, 'gateway-clients:read');
@@ -189,19 +189,9 @@ export class WorkHosterHandler {
       ),
     );
 
-    this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetWorkHosterDomains>(
-        'getWorkHosterDomains',
-        async (dataArg) => {
-          const auth = await this.requireAuth(dataArg, 'workhosters:read');
-          this.assertCapability(auth, 'readDomains');
-          return { domains: await this.listGatewayClientDomains(auth) };
-        },
-      ),
-    );
 
     this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_SyncGatewayClientRoute>(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.gateway.IReq_SyncGatewayClientRoute>(
         'syncGatewayClientRoute',
         async (dataArg) => {
           const auth = await this.requireAuth(dataArg, 'gateway-clients:write');
@@ -211,52 +201,8 @@ export class WorkHosterHandler {
       ),
     );
 
-    this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_SyncWorkAppRoute>(
-        'syncWorkAppRoute',
-        async (dataArg) => {
-          const auth = await this.requireAuth(dataArg, 'workhosters:write');
-          this.assertCapability(auth, 'syncRoutes');
-          const ownership: interfaces.data.IGatewayClientOwnership = {
-            gatewayClientType: dataArg.ownership.workHosterType,
-            gatewayClientId: dataArg.ownership.workHosterId,
-            appId: dataArg.ownership.workAppId,
-            hostname: dataArg.ownership.hostname,
-          };
-          return await this.syncGatewayClientRoute(auth, ownership, dataArg.route, dataArg.enabled, dataArg.delete);
-        },
-      ),
-    );
 
-    this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetWorkAppMailIdentities>(
-        'getWorkAppMailIdentities',
-        async (dataArg) => {
-          await this.requireAuth(dataArg, 'workhosters:read');
-          const manager = this.opsServerRef.dcRouterRef.workAppMailManager;
-          if (!manager) return { identities: [] };
-          return { identities: await manager.listMailIdentities(dataArg.ownership) };
-        },
-      ),
-    );
 
-    this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_SyncWorkAppMailIdentity>(
-        'syncWorkAppMailIdentity',
-        async (dataArg) => {
-          const auth = await this.requireAuth(dataArg, 'workhosters:write');
-          const manager = this.opsServerRef.dcRouterRef.workAppMailManager;
-          if (!manager) {
-            return { success: false, message: 'WorkApp mail manager not initialized' };
-          }
-          try {
-            return await manager.syncMailIdentity(dataArg, auth.userId);
-          } catch (error) {
-            return { success: false, message: (error as Error).message };
-          }
-        },
-      ),
-    );
 
     this.typedrouter.addTypedHandler(
       new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.mail.IReq_ListMailAddressBindings>(
@@ -336,7 +282,7 @@ export class WorkHosterHandler {
     );
   }
 
-  private getGatewayCapabilities(): interfaces.data.IGatewayCapabilities {
+  private getGatewayCapabilities(): plugins.servezoneInterfaces.data.IGatewayCapabilities {
     const dcRouter = this.opsServerRef.dcRouterRef;
     return {
       routes: {
@@ -371,7 +317,7 @@ export class WorkHosterHandler {
     };
   }
 
-  private getGatewayClientContext(auth: TAuthContext): interfaces.data.IGatewayClientContext {
+  private getGatewayClientContext(auth: TAuthContext): plugins.servezoneInterfaces.data.IGatewayClientContext {
     const policy = auth.token?.policy;
     const role = auth.isAdmin ? 'admin' : policy?.role || 'operator';
     return {
@@ -395,14 +341,6 @@ export class WorkHosterHandler {
     }));
   }
 
-  private buildExternalKey(ownership: interfaces.data.IWorkAppRouteOwnership): string {
-    return [
-      ownership.workHosterType,
-      ownership.workHosterId,
-      ownership.workAppId,
-      ownership.hostname,
-    ].map((part) => part.trim()).join(':');
-  }
 
   private assertCapability(
     auth: TAuthContext,
@@ -426,8 +364,8 @@ export class WorkHosterHandler {
 
   private resolveGatewayClientOwnership(
     auth: TAuthContext,
-    ownership: interfaces.data.IGatewayClientOwnership,
-  ): Required<interfaces.data.IGatewayClientOwnership> {
+    ownership: plugins.servezoneInterfaces.data.IGatewayClientOwnership,
+  ): Required<plugins.servezoneInterfaces.data.IGatewayClientOwnership> {
     const policy = auth.token?.policy;
     if (policy?.role === 'gatewayClient') {
       if (!policy.gatewayClient) {
@@ -450,7 +388,7 @@ export class WorkHosterHandler {
     if (!ownership.gatewayClientType || !ownership.gatewayClientId) {
       throw new plugins.typedrequest.TypedResponseError('gateway client ownership is missing type or id');
     }
-    return ownership as Required<interfaces.data.IGatewayClientOwnership>;
+    return ownership as Required<plugins.servezoneInterfaces.data.IGatewayClientOwnership>;
   }
 
   private resolveMailOwnerFilter(
@@ -486,7 +424,7 @@ export class WorkHosterHandler {
     return resolvedOwner as plugins.servezoneInterfaces.data.IMailResourceOwner;
   }
 
-  private assertGatewayClientOwnership(auth: TAuthContext, ownership: Required<interfaces.data.IGatewayClientOwnership>): void {
+  private assertGatewayClientOwnership(auth: TAuthContext, ownership: Required<plugins.servezoneInterfaces.data.IGatewayClientOwnership>): void {
     const policy = auth.token?.policy;
     if (!policy || policy.role !== 'gatewayClient') return;
     if (!this.matchesHostnamePatterns(ownership.hostname, policy.hostnamePatterns || [])) {
@@ -568,18 +506,15 @@ export class WorkHosterHandler {
     return manager.getMergedRoutes().routes.filter((route) => {
       const metadata = route.metadata;
       if (!metadata) return false;
-      const ownerType = metadata.ownerType;
-      const isGatewayOwned = ownerType === 'gatewayClient' || ownerType === 'workhoster';
-      if (!isGatewayOwned) return false;
-      const routeGatewayClientId = metadata.gatewayClientId || metadata.workHosterId;
-      return gatewayClientId ? routeGatewayClientId === gatewayClientId : true;
+      if (metadata.ownerType !== 'gatewayClient') return false;
+      return gatewayClientId ? metadata.gatewayClientId === gatewayClientId : true;
     });
   }
 
   private async listGatewayClientDomains(
     auth: TAuthContext,
     requestedGatewayClientId?: string,
-  ): Promise<interfaces.data.IGatewayClientDomain[]> {
+  ): Promise<plugins.servezoneInterfaces.data.IGatewayDomain[]> {
     const dnsManager = this.opsServerRef.dcRouterRef.dnsManager;
     if (!dnsManager) return [];
     const gatewayClientId = this.resolveGatewayClientId(auth, requestedGatewayClientId);
@@ -606,27 +541,27 @@ export class WorkHosterHandler {
             canIssueCertificates: Boolean(this.opsServerRef.dcRouterRef.smartProxy),
             canHostEmail: Boolean(this.opsServerRef.dcRouterRef.emailDomainManager),
           },
-        } satisfies interfaces.data.IGatewayClientDomain;
+        } satisfies plugins.servezoneInterfaces.data.IGatewayDomain;
       });
   }
 
   private async listGatewayClientDnsRecords(
     auth: TAuthContext,
     requestedGatewayClientId?: string,
-  ): Promise<interfaces.data.IGatewayClientDnsRecord[]> {
+  ): Promise<plugins.servezoneInterfaces.data.IGatewayDnsRecord[]> {
     const dnsManager = this.opsServerRef.dcRouterRef.dnsManager;
     if (!dnsManager) return [];
     const gatewayClientId = this.resolveGatewayClientId(auth, requestedGatewayClientId);
     const ownedRoutes = this.getOwnedRoutes(gatewayClientId);
     const domains = await dnsManager.listDomains();
-    const records: interfaces.data.IGatewayClientDnsRecord[] = [];
+    const records: plugins.servezoneInterfaces.data.IGatewayDnsRecord[] = [];
 
     for (const route of ownedRoutes) {
       const metadata = route.metadata;
       if (!metadata) continue;
-      const gatewayClientType = metadata.gatewayClientType || metadata.workHosterType || 'custom';
-      const routeGatewayClientId = metadata.gatewayClientId || metadata.workHosterId || '';
-      const appId = metadata.gatewayClientAppId || metadata.workAppId || '';
+      const gatewayClientType = metadata.gatewayClientType || 'custom';
+      const routeGatewayClientId = metadata.gatewayClientId || '';
+      const appId = metadata.gatewayClientAppId || '';
 
       for (const hostname of this.getRouteHostnames(route.route)) {
         if (auth.token?.policy?.role === 'gatewayClient' && !this.matchesHostnamePatterns(hostname, auth.token.policy.hostnamePatterns || [])) {
@@ -686,11 +621,11 @@ export class WorkHosterHandler {
 
   private async syncGatewayClientRoute(
     auth: TAuthContext,
-    ownership: interfaces.data.IGatewayClientOwnership,
-    route?: interfaces.data.IDcRouterRouteConfig,
+    ownership: plugins.servezoneInterfaces.data.IGatewayClientOwnership,
+    route?: plugins.servezoneInterfaces.data.IGatewayRouteConfig,
     enabled?: boolean,
     deleteRoute?: boolean,
-  ): Promise<interfaces.data.IGatewayClientRouteSyncResult> {
+  ): Promise<plugins.servezoneInterfaces.data.IGatewayRouteSyncResult> {
     const resolvedOwnership = this.resolveGatewayClientOwnership(auth, ownership);
     this.assertGatewayClientOwnership(auth, resolvedOwnership);
     this.assertRouteTargetsAllowed(auth, route);
@@ -728,9 +663,6 @@ export class WorkHosterHandler {
       gatewayClientType: resolvedOwnership.gatewayClientType,
       gatewayClientId: resolvedOwnership.gatewayClientId,
       gatewayClientAppId: resolvedOwnership.appId,
-      workHosterType: resolvedOwnership.gatewayClientType,
-      workHosterId: resolvedOwnership.gatewayClientId,
-      workAppId: resolvedOwnership.appId,
       externalKey,
     };
     const normalizedRoute = this.normalizeGatewayClientRoute(route, resolvedOwnership, externalKey);
@@ -752,7 +684,7 @@ export class WorkHosterHandler {
     return { success: true, action: 'created', routeId };
   }
 
-  private buildGatewayClientExternalKey(ownership: Required<interfaces.data.IGatewayClientOwnership>): string {
+  private buildGatewayClientExternalKey(ownership: Required<plugins.servezoneInterfaces.data.IGatewayClientOwnership>): string {
     return [
       ownership.gatewayClientType,
       ownership.gatewayClientId,
@@ -761,21 +693,10 @@ export class WorkHosterHandler {
     ].map((part) => part.trim()).join(':');
   }
 
-  private normalizeWorkAppRoute(
-    route: interfaces.data.IDcRouterRouteConfig,
-    ownership: interfaces.data.IWorkAppRouteOwnership,
-    externalKey: string,
-  ): interfaces.data.IDcRouterRouteConfig {
-    const normalizedRoute = { ...route };
-    if (!normalizedRoute.name) {
-      normalizedRoute.name = `workapp-${externalKey.replace(/[^a-zA-Z0-9-]+/g, '-').slice(0, 80)}`;
-    }
-    return normalizedRoute;
-  }
 
   private normalizeGatewayClientRoute(
     route: interfaces.data.IDcRouterRouteConfig,
-    ownership: Required<interfaces.data.IGatewayClientOwnership>,
+    ownership: Required<plugins.servezoneInterfaces.data.IGatewayClientOwnership>,
     externalKey: string,
   ): interfaces.data.IDcRouterRouteConfig {
     const normalizedRoute = structuredClone(route);

package/ts/opsserver/handlers/index.ts

@@ -20,4 +20,4 @@ export * from './domain.handler.js';
 export * from './dns-record.handler.js';
 export * from './acme-config.handler.js';
 export * from './email-domain.handler.js';
-export * from './workhoster.handler.js';
+export * from './gatewayclient.handler.js';

package/ts_apiclient/classes.certificate.ts

@@ -1,3 +1,4 @@
+import type * as servezoneInterfaces from '@serve.zone/interfaces';
 import * as interfaces from '../ts_interfaces/index.js';
 import type { DcRouterApiClient } from './classes.dcrouterapiclient.js';
 
@@ -65,7 +66,7 @@ export class Certificate {
     publicKey: string;
     csr: string;
   } | undefined> {
-    const response = await this.clientRef.request<interfaces.requests.IReq_ExportCertificate>(
+    const response = await this.clientRef.request<servezoneInterfaces.requests.gateway.IReq_ExportCertificate>(
       'exportCertificate',
       this.clientRef.buildRequestPayload({ domain: this.domain }) as any,
     );
@@ -112,7 +113,7 @@ export class CertificateManager {
     publicKey: string;
     csr: string;
   }): Promise<void> {
-    const response = await this.clientRef.request<interfaces.requests.IReq_ImportCertificate>(
+    const response = await this.clientRef.request<servezoneInterfaces.requests.gateway.IReq_ImportCertificate>(
       'importCertificate',
       this.clientRef.buildRequestPayload({ cert }) as any,
     );

package/ts_apiclient/classes.dcrouterapiclient.ts

@@ -10,7 +10,7 @@ import { ConfigManager } from './classes.config.js';
 import { LogManager } from './classes.logs.js';
 import { EmailManager } from './classes.email.js';
 import { RadiusManager } from './classes.radius.js';
-import { WorkHosterManager } from './classes.workhoster.js';
+import { GatewayClientApi } from './classes.gatewayclient.js';
 
 export interface IDcRouterApiClientOptions {
   baseUrl: string;
@@ -32,7 +32,7 @@ export class DcRouterApiClient {
   public logs: LogManager;
   public emails: EmailManager;
   public radius: RadiusManager;
-  public workHosters: WorkHosterManager;
+  public gatewayClients: GatewayClientApi;
 
   constructor(options: IDcRouterApiClientOptions) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, '');
@@ -47,7 +47,7 @@ export class DcRouterApiClient {
     this.logs = new LogManager(this);
     this.emails = new EmailManager(this);
     this.radius = new RadiusManager(this);
-    this.workHosters = new WorkHosterManager(this);
+    this.gatewayClients = new GatewayClientApi(this);
   }
 
   // =====================

package/ts_apiclient/classes.gatewayclient.ts

@@ -0,0 +1,65 @@
+import type * as servezoneInterfaces from '@serve.zone/interfaces';
+import type { DcRouterApiClient } from './classes.dcrouterapiclient.js';
+
+export class GatewayClientApi {
+  constructor(private clientRef: DcRouterApiClient) {}
+
+  public async getCapabilities(): Promise<servezoneInterfaces.data.IGatewayCapabilities> {
+    const response = await this.clientRef.request<servezoneInterfaces.requests.gateway.IReq_GetGatewayCapabilities>(
+      'getGatewayCapabilities',
+      this.clientRef.buildRequestPayload() as any,
+    );
+    return response.capabilities;
+  }
+
+  public async getGatewayClientContext(): Promise<servezoneInterfaces.data.IGatewayClientContext> {
+    const response = await this.clientRef.request<servezoneInterfaces.requests.gateway.IReq_GetGatewayClientContext>(
+      'getGatewayClientContext',
+      this.clientRef.buildRequestPayload() as any,
+    );
+    return response.context;
+  }
+
+  public async getDomains(): Promise<servezoneInterfaces.data.IGatewayDomain[]> {
+    const response = await this.clientRef.request<servezoneInterfaces.requests.gateway.IReq_GetGatewayClientDomains>(
+      'getGatewayClientDomains',
+      this.clientRef.buildRequestPayload() as any,
+    );
+    return response.domains;
+  }
+
+  public async getDnsRecords(): Promise<servezoneInterfaces.data.IGatewayDnsRecord[]> {
+    const response = await this.clientRef.request<servezoneInterfaces.requests.gateway.IReq_GetGatewayClientDnsRecords>(
+      'getGatewayClientDnsRecords',
+      this.clientRef.buildRequestPayload() as any,
+    );
+    return response.records;
+  }
+
+  public async syncRoute(options: {
+    ownership: servezoneInterfaces.data.IGatewayClientOwnership;
+    route: servezoneInterfaces.data.IGatewayRouteConfig;
+    enabled?: boolean;
+  }): Promise<servezoneInterfaces.data.IGatewayRouteSyncResult> {
+    return this.clientRef.request<servezoneInterfaces.requests.gateway.IReq_SyncGatewayClientRoute>(
+      'syncGatewayClientRoute',
+      this.clientRef.buildRequestPayload({
+        ownership: options.ownership,
+        route: options.route,
+        enabled: options.enabled,
+      }) as any,
+    );
+  }
+
+  public async deleteRoute(
+    ownership: servezoneInterfaces.data.IGatewayClientOwnership,
+  ): Promise<servezoneInterfaces.data.IGatewayRouteSyncResult> {
+    return this.clientRef.request<servezoneInterfaces.requests.gateway.IReq_SyncGatewayClientRoute>(
+      'syncGatewayClientRoute',
+      this.clientRef.buildRequestPayload({
+        ownership,
+        delete: true,
+      }) as any,
+    );
+  }
+}

package/ts_apiclient/index.ts

@@ -7,7 +7,7 @@ export { Certificate, CertificateManager, type ICertificateSummary } from './cla
 export { ApiToken, ApiTokenBuilder, ApiTokenManager } from './classes.apitoken.js';
 export { RemoteIngress, RemoteIngressBuilder, RemoteIngressManager } from './classes.remoteingress.js';
 export { Email, EmailManager } from './classes.email.js';
-export { WorkHosterManager } from './classes.workhoster.js';
+export { GatewayClientApi } from './classes.gatewayclient.js';
 
 // Read-only managers
 export { StatsManager } from './classes.stats.js';

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '14.3.1',
+  version: '15.0.0',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }

package/ts_web/appstate.ts

@@ -1,4 +1,5 @@
 import * as plugins from './plugins.js';
+import type * as servezoneInterfaces from '@serve.zone/interfaces';
 import * as interfaces from '../ts_interfaces/index.js';
 
 // Create main app state instance
@@ -1037,7 +1038,7 @@ export const importCertificateAction = certificateStatePart.createAction<{
 
     try {
       const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
-        interfaces.requests.IReq_ImportCertificate
+        servezoneInterfaces.requests.gateway.IReq_ImportCertificate
       >('/typedrequest', 'importCertificate');
 
       await request.fire({
@@ -1059,7 +1060,7 @@ export const importCertificateAction = certificateStatePart.createAction<{
 export async function fetchCertificateExport(domain: string) {
   const context = getActionContext();
   const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
-    interfaces.requests.IReq_ExportCertificate
+    servezoneInterfaces.requests.gateway.IReq_ExportCertificate
   >('/typedrequest', 'exportCertificate');
 
   return request.fire({