@rstreamlabs/tunnels 1.0.11 → 3.0.0

package/dist/index.mjs

@@ -13,211 +13,13 @@ import {
   streamSummarySchema,
   streamTLSInfoSchema,
   tunnelFilterSchema,
-  tunnelSchema,
   webhookEventsSchema,
   wsEventsSchema
-} from "./chunk-NHUJ3FYM.mjs";
+} from "./chunk-UUZYVELQ.mjs";
 
 // src/auth-resource.ts
+import { createAuthTokenParamsSchema } from "@rstreamlabs/rstream/auth-token";
 import { createClientCredentialsToken } from "@rstreamlabs/rstream";
-
-// src/zod.ts
-import * as z from "zod";
-var StringFilter = z.union([
-  z.string(),
-  z.object({ exact: z.string() }).strict(),
-  z.object({ oneof: z.array(z.string()) }).strict(),
-  z.object({ regex: z.string() }).strict()
-]);
-function transform(field) {
-  if (field instanceof z.ZodOptional) {
-    return z.optional(transform(field.unwrap()));
-  }
-  if (field instanceof z.ZodString) {
-    return z.optional(StringFilter);
-  }
-  if (field instanceof z.ZodRecord) {
-    return z.optional(z.record(field.keyType, transform(field.valueType)));
-  }
-  return z.optional(field);
-}
-function filters(base) {
-  const entries = Object.entries(base.shape).map(([key, field]) => [
-    key,
-    transform(field)
-  ]);
-  const shape = Object.fromEntries(entries);
-  const node = z.lazy(
-    () => z.union([
-      z.object(shape).strict(),
-      z.object({ AND: z.array(node) }).strict(),
-      z.object({ OR: z.array(node) }).strict()
-    ])
-  );
-  return node;
-}
-function select(base) {
-  const entries = Object.entries(base.shape).map(([key]) => {
-    return [key, z.boolean().optional()];
-  });
-  const shape = Object.fromEntries(entries);
-  return z.object(shape).strict();
-}
-
-// src/auth.ts
-import * as z2 from "zod";
-var nonEmptyStringSchema = z2.string().trim().min(1);
-var authTokenPermissionsSchema = z2.array(z2.string());
-var authTokenTunnelsScopesSchema = z2.object({
-  // Scopes for creating tunnels
-  create: z2.union([
-    z2.boolean(),
-    z2.object({
-      filters: filters(
-        tunnelSchema.omit({
-          client_id: true,
-          user_id: true,
-          workspace_id: true,
-          project_id: true,
-          cluster_id: true,
-          plan: true,
-          provider: true,
-          region: true,
-          status: true,
-          id: true,
-          creation_date: true
-        })
-      ).optional()
-    }).strict()
-  ]).optional(),
-  // Scopes for connecting to tunnels
-  connect: z2.union([
-    z2.boolean(),
-    z2.object({
-      filters: filters(tunnelSchema).optional(),
-      params: filters(
-        z2.object({
-          path: z2.string().optional()
-        })
-      ).optional()
-    }).strict()
-  ]).optional(),
-  // Scopes for listing tunnels
-  list: z2.union([
-    z2.boolean(),
-    z2.object({
-      filters: filters(tunnelSchema).optional(),
-      select: select(tunnelSchema).optional()
-    }).strict()
-  ]).optional()
-}).strict().superRefine((scopes, ctx) => {
-  if (scopes.create === void 0 && scopes.connect === void 0 && scopes.list === void 0) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "At least one tunnel scope action is required."
-    });
-  }
-});
-var authTokenScopesSchema = z2.object({
-  tunnels: authTokenTunnelsScopesSchema.optional()
-  // Scopes related to tunnels
-}).strict().superRefine((scopes, ctx) => {
-  if (scopes.tunnels === void 0) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "Tunnel scopes are required.",
-      path: ["tunnels"]
-    });
-  }
-});
-var authTokenTunnelGrantLeafSchema = z2.object({
-  workspaces: z2.array(nonEmptyStringSchema).min(1).optional(),
-  projects: z2.array(nonEmptyStringSchema).min(1).optional(),
-  scopes: authTokenScopesSchema.optional()
-}).strict().superRefine((grant, ctx) => {
-  if (grant.workspaces !== void 0 && grant.projects !== void 0) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "A grant cannot target workspaces and projects at the same time.",
-      path: ["projects"]
-    });
-  }
-  if (grant.workspaces === void 0 && grant.projects === void 0 && grant.scopes === void 0) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "A grant must target workspaces, projects, or scopes.",
-      path: ["workspaces"]
-    });
-  }
-});
-var authTokenTunnelGrantSchema = z2.lazy(
-  () => z2.union([
-    authTokenTunnelGrantLeafSchema,
-    z2.object({ AND: z2.array(authTokenTunnelGrantSchema).min(1) }).strict(),
-    z2.object({ OR: z2.array(authTokenTunnelGrantSchema).min(1) }).strict()
-  ])
-);
-var authTokenCommonSchema = {
-  aud: z2.union([z2.string(), z2.array(z2.string())]).optional(),
-  exp: z2.number().optional(),
-  tunnelsGrants: authTokenTunnelGrantSchema.optional(),
-  iat: z2.number().optional(),
-  iss: z2.string().optional(),
-  jti: z2.string().optional(),
-  metadata: z2.object({
-    engine: z2.string().optional()
-  }).strict().optional(),
-  nbf: z2.number().optional(),
-  sub: z2.string().optional()
-};
-var authTokenSchema = z2.union([
-  z2.object({
-    type: z2.literal("auth"),
-    userId: z2.string(),
-    permissions: authTokenPermissionsSchema.nullable(),
-    ...authTokenCommonSchema
-  }).strict(),
-  z2.object({
-    type: z2.literal("pat"),
-    tokendpoint: z2.string().optional(),
-    token_endpoint: z2.string().optional(),
-    ...authTokenCommonSchema
-  }).strict(),
-  z2.object({
-    type: z2.literal("app"),
-    clientId: z2.string(),
-    permissions: authTokenPermissionsSchema.nullable(),
-    ...authTokenCommonSchema
-  }).strict()
-]);
-var tokenSchema = authTokenSchema;
-var createAuthTokenParamsSchema = z2.object({
-  expires_in: z2.number().int().min(1).max(3600).default(60),
-  scopes: authTokenScopesSchema.optional(),
-  tunnelsGrants: authTokenTunnelGrantSchema.optional(),
-  metadata: z2.unknown().optional()
-  // Additional metadata
-}).strict().superRefine((params, ctx) => {
-  if (params.scopes !== void 0 && params.tunnelsGrants !== void 0) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "Use either scopes or tunnelsGrants, not both.",
-      path: ["tunnelsGrants"]
-    });
-  }
-  if (params.scopes === void 0 && params.tunnelsGrants === void 0) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "Explicit scopes or tunnelsGrants are required.",
-      path: ["scopes"]
-    });
-  }
-});
-var createAuthTokenResponseSchema = z2.object({
-  token: z2.string()
-});
-
-// src/auth-resource.ts
 import { isClientCredentials } from "@rstreamlabs/rstream";
 var RstreamAuthResource = class {
   client;
@@ -246,7 +48,7 @@ var RstreamAuthResource = class {
     if (options?.projectId !== void 0 || options?.workspaceId !== void 0) {
       return options;
     }
-    if (tokenParams.scopes === void 0 && !tunnelGrantsNeedDefaultTarget(tokenParams.tunnelsGrants)) {
+    if (!tunnelResourcesNeedDefaultTarget(tokenParams.resources?.tunnels)) {
       return options ?? {};
     }
     const target = await this.client.getEngineAuthTokenTarget();
@@ -263,8 +65,8 @@ function createAuthTokenFromClientCredentials(credentials, params, options) {
     metadata: {
       engine: options?.engine
     },
-    tunnelsGrants: normalizeAuthTokenTunnelGrants(tokenParams, options),
-    permissions: null
+    permissions: null,
+    resources: normalizeAuthTokenResources(tokenParams, options)
   };
   const { token } = createClientCredentialsToken(credentials, {
     claims: payload,
@@ -272,70 +74,73 @@ function createAuthTokenFromClientCredentials(credentials, params, options) {
   });
   return { token };
 }
-function normalizeAuthTokenTunnelGrants(params, options) {
-  const tunnelsGrants = params.tunnelsGrants;
-  if (tunnelsGrants !== void 0) {
-    return applyDefaultTunnelGrantTarget(tunnelsGrants, options);
-  }
-  if (params.scopes) {
-    return { ...normalizeTunnelGrantTarget(options), scopes: params.scopes };
-  }
-  return void 0;
+function normalizeAuthTokenResources(params, options) {
+  return {
+    tunnels: applyDefaultTunnelResourceTarget(
+      requireTunnelResource(params),
+      options
+    )
+  };
 }
-function applyDefaultTunnelGrantTarget(grants, options, inheritedTarget = false) {
+function requireTunnelResource(params) {
+  const tunnels = params.resources?.tunnels;
+  if (tunnels !== void 0) return tunnels;
+  throw new Error("Explicit resources.tunnels is required.");
+}
+function applyDefaultTunnelResourceTarget(resource, options, inheritedTarget = false) {
   if (options?.projectScoped === false) {
-    return grants;
+    return resource;
   }
-  if ("AND" in grants) {
-    const branchHasTarget = inheritedTarget || grants.AND.some((grant) => tunnelGrantTreeHasTarget(grant));
+  if ("AND" in resource) {
+    const branchHasTarget = inheritedTarget || resource.AND.some((child) => tunnelResourceTreeHasTarget(child));
     return {
-      AND: grants.AND.map(
-        (grant) => applyDefaultTunnelGrantTarget(grant, options, branchHasTarget)
+      AND: resource.AND.map(
+        (child) => applyDefaultTunnelResourceTarget(child, options, branchHasTarget)
       )
     };
   }
-  if ("OR" in grants) {
+  if ("OR" in resource) {
     return {
-      OR: grants.OR.map(
-        (grant) => applyDefaultTunnelGrantTarget(grant, options, inheritedTarget)
+      OR: resource.OR.map(
+        (child) => applyDefaultTunnelResourceTarget(child, options, inheritedTarget)
       )
     };
   }
-  if (grants.scopes === void 0 || tunnelGrantHasTarget(grants) || inheritedTarget) {
-    return grants;
+  if (resource.scopes === void 0 || tunnelResourceHasTarget(resource) || inheritedTarget) {
+    return resource;
   }
-  return { ...normalizeTunnelGrantTarget(options), scopes: grants.scopes };
+  return { ...normalizeTunnelResourceTarget(options), scopes: resource.scopes };
 }
-function tunnelGrantsNeedDefaultTarget(grants, inheritedTarget = false) {
-  if (grants === void 0) {
+function tunnelResourcesNeedDefaultTarget(resource, inheritedTarget = false) {
+  if (resource === void 0) {
     return false;
   }
-  if ("AND" in grants) {
-    const branchHasTarget = inheritedTarget || grants.AND.some((grant) => tunnelGrantTreeHasTarget(grant));
-    return grants.AND.some(
-      (grant) => tunnelGrantsNeedDefaultTarget(grant, branchHasTarget)
+  if ("AND" in resource) {
+    const branchHasTarget = inheritedTarget || resource.AND.some((child) => tunnelResourceTreeHasTarget(child));
+    return resource.AND.some(
+      (child) => tunnelResourcesNeedDefaultTarget(child, branchHasTarget)
     );
   }
-  if ("OR" in grants) {
-    return grants.OR.some(
-      (grant) => tunnelGrantsNeedDefaultTarget(grant, inheritedTarget)
+  if ("OR" in resource) {
+    return resource.OR.some(
+      (child) => tunnelResourcesNeedDefaultTarget(child, inheritedTarget)
     );
   }
-  return grants.scopes !== void 0 && !tunnelGrantHasTarget(grants) && !inheritedTarget;
+  return resource.scopes !== void 0 && !tunnelResourceHasTarget(resource) && !inheritedTarget;
 }
-function tunnelGrantHasTarget(grant) {
-  return grant.projects !== void 0 || grant.workspaces !== void 0;
+function tunnelResourceHasTarget(resource) {
+  return resource.projects !== void 0 || resource.workspaces !== void 0;
 }
-function tunnelGrantTreeHasTarget(grants) {
-  if ("AND" in grants) {
-    return grants.AND.some((grant) => tunnelGrantTreeHasTarget(grant));
+function tunnelResourceTreeHasTarget(resource) {
+  if ("AND" in resource) {
+    return resource.AND.some((child) => tunnelResourceTreeHasTarget(child));
   }
-  if ("OR" in grants) {
-    return grants.OR.some((grant) => tunnelGrantTreeHasTarget(grant));
+  if ("OR" in resource) {
+    return resource.OR.some((child) => tunnelResourceTreeHasTarget(child));
   }
-  return tunnelGrantHasTarget(grants);
+  return tunnelResourceHasTarget(resource);
 }
-function normalizeTunnelGrantTarget(options) {
+function normalizeTunnelResourceTarget(options) {
   const projectId = normalizeOptionalString(options?.projectId);
   const workspaceId = normalizeOptionalString(options?.workspaceId);
   if (projectId !== void 0 && workspaceId !== void 0) {
@@ -351,7 +156,7 @@ function normalizeTunnelGrantTarget(options) {
     return {};
   }
   throw new Error(
-    "Project ID or workspace ID is required when using scope-only tunnel grants."
+    "Project ID or workspace ID is required when using scope-only tunnel resources."
   );
 }
 function normalizeOptionalString(value) {
@@ -508,6 +313,7 @@ async function resolveManagedTunnelsProject(config) {
 }
 
 // src/tunnels-resource.ts
+import { tunnelSchema } from "@rstreamlabs/rstream/tunnel";
 function tunnelPathId(id) {
   const normalized = id.trim();
   if (!normalized) {
@@ -547,21 +353,21 @@ import { readEnvironment as readEnvironment2 } from "@rstreamlabs/rstream";
 import { isClientCredentials as isClientCredentials2 } from "@rstreamlabs/rstream";
 import { isTokenCredentials as isTokenCredentials2 } from "@rstreamlabs/rstream";
 import { RstreamClient as RstreamClient2 } from "@rstreamlabs/rstream";
-import { turnCredentialsSchema } from "@rstreamlabs/rstream";
-import * as z3 from "zod";
+import { turnCredentialsSchema } from "@rstreamlabs/rstream/turn";
+import * as z from "zod";
 import crypto from "crypto";
 var defaultTURNPort = 3478;
 var defaultTURNSPort = 5349;
 var defaultTURNCredentialTTLSeconds = 10 * 60;
 var maxTURNCredentialTTLSeconds = 60 * 60;
-var turnTokenClaimsSchema = z3.object({
-  exp: z3.number().int().optional(),
-  iat: z3.number().int().optional(),
-  token_endpoint: z3.string().regex(/^[0-9a-f]{8}$/i).optional(),
-  tokendpoint: z3.string().regex(/^[0-9a-f]{8}$/i).optional(),
-  type: z3.enum(["app", "auth", "pat"])
+var turnTokenClaimsSchema = z.object({
+  exp: z.number().int().optional(),
+  iat: z.number().int().optional(),
+  token_endpoint: z.string().regex(/^[0-9a-f]{8}$/i).optional(),
+  tokendpoint: z.string().regex(/^[0-9a-f]{8}$/i).optional(),
+  type: z.enum(["app", "auth", "pat"])
 });
-var turnCredentialModeSchema = z3.enum(["api", "app", "pat"]);
+var turnCredentialModeSchema = z.enum(["api", "app", "pat"]);
 function normalizeOptionalString2(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
@@ -587,6 +393,9 @@ function normalizeTTLSeconds(ttlSeconds) {
   }
   return ttl;
 }
+function createAPITURNCredentialsParams(ttlSeconds) {
+  return ttlSeconds === void 0 ? {} : { ttlSeconds: normalizeTTLSeconds(ttlSeconds) };
+}
 function normalizePort(port, fallback, name) {
   const normalized = port ?? fallback;
   if (!Number.isInteger(normalized) || normalized < 1 || normalized > 65535) {
@@ -616,19 +425,21 @@ function parseTURNTokenClaims(token) {
   if (!payloadPart) {
     throw new Error("Invalid token format.");
   }
-  let decoded;
-  try {
-    const payload = Buffer.from(payloadPart, "base64url").toString("utf8");
-    decoded = JSON.parse(payload);
-  } catch {
-    throw new Error("Invalid token format.");
-  }
+  const decoded = parseTURNTokenPayload(payloadPart);
   const parsed = turnTokenClaimsSchema.safeParse(decoded);
   if (!parsed.success) {
     throw new Error("Invalid token format.");
   }
   return parsed.data;
 }
+function parseTURNTokenPayload(payloadPart) {
+  try {
+    const payload = Buffer.from(payloadPart, "base64url").toString("utf8");
+    return JSON.parse(payload);
+  } catch {
+    throw new Error("Invalid token format.");
+  }
+}
 function requirePATExpiration(claims, now) {
   const exp = claims.exp;
   if (typeof exp !== "number") {
@@ -702,8 +513,12 @@ async function createAPITURNCredentials(options) {
     apiUrl: options.apiUrl,
     credentials: options.credentials
   });
+  const params = createAPITURNCredentialsParams(options.ttlSeconds);
   if (projectId) {
-    return await client.tunnels.projects.createTurnCredentials(projectId);
+    return await client.tunnels.projects.createTurnCredentials(
+      projectId,
+      params
+    );
   }
   if (!projectEndpoint) {
     throw new Error(
@@ -711,7 +526,8 @@ async function createAPITURNCredentials(options) {
     );
   }
   return await client.tunnels.projects.createTurnCredentialsByEndpoint(
-    projectEndpoint
+    projectEndpoint,
+    params
   );
 }
 function createPATTURNCredentials(options) {
@@ -829,7 +645,8 @@ async function createTURNCredentials(options) {
       apiUrl: options.apiUrl,
       credentials: controlPlaneCredentials,
       projectEndpoint,
-      projectId: options.projectId
+      projectId: options.projectId,
+      ttlSeconds: options.ttlSeconds
     });
   }
   const clusterDomain = normalizeClusterDomain(options.clusterDomain) ?? (projectEndpoint && options.engine ? deriveClusterDomainFromEngine(projectEndpoint, options.engine) : void 0);
@@ -1065,9 +882,11 @@ var RstreamTunnelsClient = class {
   async getEngineAuthTokenParams() {
     const target = await this.getEngineAuthTokenTarget();
     return {
-      tunnelsGrants: {
-        ...target,
-        scopes: engineAuthTokenScopes
+      resources: {
+        tunnels: {
+          ...target,
+          scopes: engineAuthTokenScopes
+        }
       }
     };
   }
@@ -1149,6 +968,7 @@ function normalizeOptionalString3(value) {
 }
 
 // src/watch.ts
+import { authTokenSchema } from "@rstreamlabs/rstream/auth-token";
 import jwt from "jsonwebtoken";
 var maxWatchTokenLifetimeSeconds = 3600;
 var watchTokenIssuedAtSkewSeconds = 300;
@@ -1176,37 +996,38 @@ function validateWatchQueryToken(token) {
       "Watch requires a token with a bounded lifetime of at most 3600 seconds."
     );
   }
-  if (!hasWatchOnlyTunnelGrants(parsed.data)) {
+  if (!hasWatchOnlyTunnelResources(parsed.data)) {
     throw new Error(
-      "Watch requires a fine-grained token limited to tunnel list grants for URL-based authentication."
+      "Watch requires a fine-grained token limited to tunnel list resources for URL-based authentication."
     );
   }
 }
-function hasWatchOnlyTunnelGrants(token) {
+function hasWatchOnlyTunnelResources(token) {
   if (!hasWatchOnlyPermissions(token.permissions)) {
     return false;
   }
-  if (token.tunnelsGrants === void 0) {
+  const resource = token.resources?.tunnels;
+  if (resource === void 0) {
     return false;
   }
-  return hasWatchOnlyTunnelGrant(token.tunnelsGrants);
+  return hasWatchOnlyTunnelResource(resource);
 }
-function hasWatchOnlyTunnelGrant(grant) {
-  return watchGrantBranches(grant).every(
+function hasWatchOnlyTunnelResource(resource) {
+  return watchResourceBranches(resource).every(
     (branch) => branch.hasList && !branch.hasMutationOrConnect
   );
 }
-function watchGrantBranches(grant) {
-  if ("AND" in grant) {
-    return grant.AND.reduce(
-      (branches, child) => combineWatchGrantBranches(branches, child),
+function watchResourceBranches(resource) {
+  if ("AND" in resource) {
+    return resource.AND.reduce(
+      (branches, child) => combineWatchResourceBranches(branches, child),
       [{ hasList: false, hasMutationOrConnect: false }]
     );
   }
-  if ("OR" in grant) {
-    return grant.OR.flatMap(watchGrantBranches);
+  if ("OR" in resource) {
+    return resource.OR.flatMap(watchResourceBranches);
   }
-  const tunnels = grant.scopes?.tunnels;
+  const tunnels = resource.scopes?.tunnels;
   if (tunnels === void 0) {
     return [{ hasList: false, hasMutationOrConnect: false }];
   }
@@ -1217,9 +1038,9 @@ function watchGrantBranches(grant) {
     }
   ];
 }
-function combineWatchGrantBranches(branches, child) {
+function combineWatchResourceBranches(branches, child) {
   return branches.flatMap(
-    (branch) => watchGrantBranches(child).map((childBranch) => ({
+    (branch) => watchResourceBranches(child).map((childBranch) => ({
       hasList: branch.hasList || childBranch.hasList,
       hasMutationOrConnect: branch.hasMutationOrConnect || childBranch.hasMutationOrConnect
     }))
@@ -1230,7 +1051,7 @@ function hasWatchOnlyPermissions(permissions) {
     return true;
   }
   return permissions.every(
-    (permission) => permission === "tunnels.resources.read-only" || permission === "network.resources.read-only"
+    (permission) => permission === "tunnels.resources.read-only"
   );
 }
 var Watch = class {
@@ -1315,7 +1136,7 @@ var Watch = class {
 };
 
 // src/webtty.ts
-import * as z4 from "zod";
+import * as z2 from "zod";
 var osFamilies = [
   "linux",
   "macos",
@@ -1324,25 +1145,25 @@ var osFamilies = [
   "openbsd",
   "freebsd"
 ];
-var webttyServerSchema = z4.object({
-  tunnel_id: z4.string(),
-  host: z4.string(),
-  token_auth: z4.boolean(),
-  os_family: z4.enum(osFamilies).optional(),
-  arch: z4.string().optional(),
-  os_id: z4.string().optional(),
+var webttyServerSchema = z2.object({
+  tunnel_id: z2.string(),
+  host: z2.string(),
+  token_auth: z2.boolean(),
+  os_family: z2.enum(osFamilies).optional(),
+  arch: z2.string().optional(),
+  os_id: z2.string().optional(),
   // /etc/os-release::ID (ubuntu, debian, rocky, etc.)
-  os_version_id: z4.string().optional(),
+  os_version_id: z2.string().optional(),
   // /etc/os-release::VERSION_ID (24.04, 22.04, 11, 10.0.19045, ...)
-  os_version_codename: z4.string().optional(),
+  os_version_codename: z2.string().optional(),
   // /etc/os-release::VERSION_CODENAME (jammy, noble...)
-  os_pretty_name: z4.string().optional(),
+  os_pretty_name: z2.string().optional(),
   // /etc/os-release::PRETTY_NAME
-  kernel_release: z4.string().optional(),
+  kernel_release: z2.string().optional(),
   // uname -r
-  hostname: z4.string().optional(),
+  hostname: z2.string().optional(),
   // uname -n
-  labels: z4.record(z4.string(), z4.string().optional()).optional()
+  labels: z2.record(z2.string(), z2.string().optional()).optional()
 });
 function parser(tunnel) {
   if (tunnel.status !== "online") return null;
@@ -1394,18 +1215,11 @@ export {
   RstreamWebhookResource as RstreamWebhookRessource,
   RstreamTunnelsClient as Tunnels,
   Watch,
-  authTokenPermissionsSchema,
-  authTokenSchema,
-  authTokenScopesSchema,
-  authTokenTunnelGrantSchema,
-  authTokenTunnelsScopesSchema,
   clientFilterSchema,
   clientSchema,
   createAPITURNCredentials,
   createAPPTURNCredentials,
   createAuthTokenFromClientCredentials,
-  createAuthTokenParamsSchema,
-  createAuthTokenResponseSchema,
   createPATTURNCredentials,
   createTURNCredentials,
   engineOpenApiDocument,
@@ -1426,9 +1240,7 @@ export {
   streamEndpointSchema,
   streamSummarySchema,
   streamTLSInfoSchema,
-  tokenSchema,
   tunnelFilterSchema,
-  tunnelSchema,
   turnCredentialModeSchema,
   webhookEventsSchema,
   webttyServerSchema,