@lucern/sdk 1.0.10 → 1.0.12

package/dist/authContext.d.ts

@@ -1,11 +1,7 @@
-import { SessionPrincipalType, SessionAuthMode, SessionDelegationHop } from './contracts/auth-session.contract.js';
-import { JsonObject } from './types.js';
-import './contracts/workflow-runtime.contract.js';
-import './contracts/lens-workflow.contract.js';
-import './contracts/lens-filter.contract.js';
-
-type LucernSdkAuthFailureReason = "principal_missing" | "tenant_missing" | "membership_missing" | "workspace_missing" | "clerk_alias_missing" | "clerk_alias_unrecognized" | "policy_denied" | "policy_unavailable" | "policy_unknown";
-type PermitReadyAuthContext = {
+import type { SessionAuthMode, SessionDelegationHop, SessionPrincipalType } from "./contracts/auth-session.contract";
+import type { JsonObject } from "./types";
+export type LucernSdkAuthFailureReason = "principal_missing" | "tenant_missing" | "membership_missing" | "workspace_missing" | "clerk_alias_missing" | "clerk_alias_unrecognized" | "policy_denied" | "policy_unavailable" | "policy_unknown";
+export type PermitReadyAuthContext = {
     subject: string;
     tenant: string;
     workspace: string;
@@ -14,8 +10,8 @@ type PermitReadyAuthContext = {
     relation?: string;
     context?: JsonObject;
 };
-type LucernSdkAuthPolicyDecision = "allow" | "deny" | "unknown";
-type LucernSdkAuthContextInput = {
+export type LucernSdkAuthPolicyDecision = "allow" | "deny" | "unknown";
+export type LucernSdkAuthContextInput = {
     clerkId?: string;
     principalId?: string;
     tenantId?: string;
@@ -31,7 +27,7 @@ type LucernSdkAuthContextInput = {
     policyDecision?: LucernSdkAuthPolicyDecision;
     permit?: Partial<PermitReadyAuthContext>;
 };
-type CanonicalLucernSdkAuthContext = {
+export type CanonicalLucernSdkAuthContext = {
     clerkId?: string;
     principalId: string;
     tenantId: string;
@@ -46,11 +42,10 @@ type CanonicalLucernSdkAuthContext = {
     membershipId?: string;
     permit: PermitReadyAuthContext;
 };
-declare class LucernSdkAuthContextError extends Error {
+export declare class LucernSdkAuthContextError extends Error {
     readonly reason: LucernSdkAuthFailureReason;
     constructor(reason: LucernSdkAuthFailureReason, message: string);
 }
-declare function normalizeCanonicalLucernAuthContext(input: LucernSdkAuthContextInput | undefined): CanonicalLucernSdkAuthContext;
-declare function createCanonicalAuthHeaders(authContext: CanonicalLucernSdkAuthContext): Record<string, string>;
-
-export { type CanonicalLucernSdkAuthContext, LucernSdkAuthContextError, type LucernSdkAuthContextInput, type LucernSdkAuthFailureReason, type LucernSdkAuthPolicyDecision, type PermitReadyAuthContext, createCanonicalAuthHeaders, normalizeCanonicalLucernAuthContext };
+export declare function normalizeCanonicalLucernAuthContext(input: LucernSdkAuthContextInput | undefined): CanonicalLucernSdkAuthContext;
+export declare function createCanonicalAuthHeaders(authContext: CanonicalLucernSdkAuthContext): Record<string, string>;
+//# sourceMappingURL=authContext.d.ts.map

package/dist/authContext.js

@@ -1,170 +1,138 @@
-// src/authContext.ts
-var LucernSdkAuthContextError = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "LucernSdkAuthContextError";
-    this.reason = reason;
-  }
-};
+export class LucernSdkAuthContextError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.name = "LucernSdkAuthContextError";
+        this.reason = reason;
+    }
+}
 function cleanString(value) {
-  const normalized = value?.trim();
-  return normalized ? normalized : void 0;
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
 }
 function cleanStringList(values) {
-  if (!values) {
-    return [];
-  }
-  return values.map((value) => value.trim()).filter(
-    (value, index, list) => value.length > 0 && list.indexOf(value) === index
-  );
+    if (!values) {
+        return [];
+    }
+    return values
+        .map((value) => value.trim())
+        .filter((value, index, list) => value.length > 0 && list.indexOf(value) === index);
 }
 function requireString(value, reason, label) {
-  const normalized = cleanString(value);
-  if (!normalized) {
-    throw new LucernSdkAuthContextError(
-      reason,
-      `Canonical Lucern SDK auth context is missing ${label}.`
-    );
-  }
-  return normalized;
+    const normalized = cleanString(value);
+    if (!normalized) {
+        throw new LucernSdkAuthContextError(reason, `Canonical Lucern SDK auth context is missing ${label}.`);
+    }
+    return normalized;
 }
 function requirePrincipalType(principalType) {
-  if (!principalType) {
-    throw new LucernSdkAuthContextError(
-      "principal_missing",
-      "Canonical Lucern SDK auth context is missing principalType."
-    );
-  }
-  return principalType;
+    if (!principalType) {
+        throw new LucernSdkAuthContextError("principal_missing", "Canonical Lucern SDK auth context is missing principalType.");
+    }
+    return principalType;
 }
 function requireAuthMode(authMode) {
-  if (!authMode) {
-    throw new LucernSdkAuthContextError(
-      "principal_missing",
-      "Canonical Lucern SDK auth context is missing authMode."
-    );
-  }
-  return authMode;
+    if (!authMode) {
+        throw new LucernSdkAuthContextError("principal_missing", "Canonical Lucern SDK auth context is missing authMode.");
+    }
+    return authMode;
 }
 function ensurePermitMatch(args) {
-  const actual = cleanString(args.actual);
-  if (actual && actual !== args.expected) {
-    throw new LucernSdkAuthContextError(
-      "policy_denied",
-      `Canonical Lucern SDK auth context has conflicting Permit ${args.field}.`
-    );
-  }
+    const actual = cleanString(args.actual);
+    if (actual && actual !== args.expected) {
+        throw new LucernSdkAuthContextError("policy_denied", `Canonical Lucern SDK auth context has conflicting Permit ${args.field}.`);
+    }
 }
-function normalizeCanonicalLucernAuthContext(input) {
-  if (!input) {
-    throw new LucernSdkAuthContextError(
-      "principal_missing",
-      "Canonical Lucern SDK auth context is required."
-    );
-  }
-  if (input.policyDecision === "deny") {
-    throw new LucernSdkAuthContextError(
-      "policy_denied",
-      "Canonical Lucern SDK auth context carries a denied policy decision."
-    );
-  }
-  const principalId = requireString(
-    input.principalId,
-    "principal_missing",
-    "principalId"
-  );
-  const tenantId = requireString(input.tenantId, "tenant_missing", "tenantId");
-  const workspaceId = requireString(
-    input.workspaceId,
-    "workspace_missing",
-    "workspaceId"
-  );
-  const roles = cleanStringList(input.roles);
-  const scopes = cleanStringList(input.scopes);
-  const principalType = requirePrincipalType(input.principalType);
-  const authMode = requireAuthMode(input.authMode);
-  const roleBasedInteractiveAuth = authMode === "interactive_user" && roles.length > 0;
-  if (roles.length === 0 || scopes.length === 0 && !roleBasedInteractiveAuth) {
-    throw new LucernSdkAuthContextError(
-      "membership_missing",
-      "Canonical Lucern SDK auth context requires non-empty roles and scopes."
-    );
-  }
-  const subject = cleanString(input.permit?.subject) ?? principalId;
-  const tenant = cleanString(input.permit?.tenant) ?? tenantId;
-  const workspace = cleanString(input.permit?.workspace) ?? workspaceId;
-  ensurePermitMatch({
-    field: "subject",
-    expected: principalId,
-    actual: subject
-  });
-  ensurePermitMatch({ field: "tenant", expected: tenantId, actual: tenant });
-  ensurePermitMatch({
-    field: "workspace",
-    expected: workspaceId,
-    actual: workspace
-  });
-  const context = input.permit?.context ? { ...input.permit.context } : void 0;
-  return {
-    clerkId: cleanString(input.clerkId),
-    principalId,
-    tenantId,
-    workspaceId,
-    principalType,
-    authMode,
-    roles,
-    scopes,
-    delegationChain: input.delegationChain ? [...input.delegationChain] : [],
-    policyTraceId: cleanString(input.policyTraceId),
-    correlationId: cleanString(input.correlationId),
-    membershipId: cleanString(input.membershipId),
-    permit: {
-      subject,
-      tenant,
-      workspace,
-      resource: cleanString(input.permit?.resource),
-      action: cleanString(input.permit?.action),
-      relation: cleanString(input.permit?.relation),
-      context
+export function normalizeCanonicalLucernAuthContext(input) {
+    if (!input) {
+        throw new LucernSdkAuthContextError("principal_missing", "Canonical Lucern SDK auth context is required.");
     }
-  };
+    if (input.policyDecision === "deny") {
+        throw new LucernSdkAuthContextError("policy_denied", "Canonical Lucern SDK auth context carries a denied policy decision.");
+    }
+    const principalId = requireString(input.principalId, "principal_missing", "principalId");
+    const tenantId = requireString(input.tenantId, "tenant_missing", "tenantId");
+    const workspaceId = requireString(input.workspaceId, "workspace_missing", "workspaceId");
+    const roles = cleanStringList(input.roles);
+    const scopes = cleanStringList(input.scopes);
+    const principalType = requirePrincipalType(input.principalType);
+    const authMode = requireAuthMode(input.authMode);
+    const roleBasedInteractiveAuth = authMode === "interactive_user" && roles.length > 0;
+    if (roles.length === 0 ||
+        (scopes.length === 0 && !roleBasedInteractiveAuth)) {
+        throw new LucernSdkAuthContextError("membership_missing", "Canonical Lucern SDK auth context requires non-empty roles and scopes.");
+    }
+    const subject = cleanString(input.permit?.subject) ?? principalId;
+    const tenant = cleanString(input.permit?.tenant) ?? tenantId;
+    const workspace = cleanString(input.permit?.workspace) ?? workspaceId;
+    ensurePermitMatch({
+        field: "subject",
+        expected: principalId,
+        actual: subject,
+    });
+    ensurePermitMatch({ field: "tenant", expected: tenantId, actual: tenant });
+    ensurePermitMatch({
+        field: "workspace",
+        expected: workspaceId,
+        actual: workspace,
+    });
+    const context = input.permit?.context
+        ? { ...input.permit.context }
+        : undefined;
+    return {
+        clerkId: cleanString(input.clerkId),
+        principalId,
+        tenantId,
+        workspaceId,
+        principalType,
+        authMode,
+        roles,
+        scopes,
+        delegationChain: input.delegationChain ? [...input.delegationChain] : [],
+        policyTraceId: cleanString(input.policyTraceId),
+        correlationId: cleanString(input.correlationId),
+        membershipId: cleanString(input.membershipId),
+        permit: {
+            subject,
+            tenant,
+            workspace,
+            resource: cleanString(input.permit?.resource),
+            action: cleanString(input.permit?.action),
+            relation: cleanString(input.permit?.relation),
+            context,
+        },
+    };
 }
-function createCanonicalAuthHeaders(authContext) {
-  const headers = {
-    "x-lucern-principal-id": authContext.principalId,
-    "x-lucern-principal-type": authContext.principalType,
-    "x-lucern-tenant": authContext.tenantId,
-    "x-lucern-tenant-id": authContext.tenantId,
-    "x-lucern-workspace": authContext.workspaceId,
-    "x-lucern-workspace-id": authContext.workspaceId,
-    "x-lucern-auth-mode": authContext.authMode,
-    "x-lucern-roles": authContext.roles.join(","),
-    "x-lucern-scopes": authContext.scopes.join(","),
-    "x-lucern-permit-context": JSON.stringify(authContext.permit)
-  };
-  if (authContext.clerkId) {
-    headers["x-lucern-clerk-id"] = authContext.clerkId;
-    headers["x-lucern-user-id"] = authContext.clerkId;
-  }
-  if (authContext.delegationChain.length > 0) {
-    headers["x-lucern-delegation-chain"] = JSON.stringify(
-      authContext.delegationChain
-    );
-  }
-  if (authContext.policyTraceId) {
-    headers["x-lucern-policy-trace-id"] = authContext.policyTraceId;
-  }
-  if (authContext.correlationId) {
-    headers["x-correlation-id"] = authContext.correlationId;
-    headers["x-lucern-correlation-id"] = authContext.correlationId;
-  }
-  if (authContext.membershipId) {
-    headers["x-lucern-membership-id"] = authContext.membershipId;
-  }
-  return headers;
+export function createCanonicalAuthHeaders(authContext) {
+    const headers = {
+        "x-lucern-principal-id": authContext.principalId,
+        "x-lucern-principal-type": authContext.principalType,
+        "x-lucern-tenant": authContext.tenantId,
+        "x-lucern-tenant-id": authContext.tenantId,
+        "x-lucern-workspace": authContext.workspaceId,
+        "x-lucern-workspace-id": authContext.workspaceId,
+        "x-lucern-auth-mode": authContext.authMode,
+        "x-lucern-roles": authContext.roles.join(","),
+        "x-lucern-scopes": authContext.scopes.join(","),
+        "x-lucern-permit-context": JSON.stringify(authContext.permit),
+    };
+    if (authContext.clerkId) {
+        headers["x-lucern-clerk-id"] = authContext.clerkId;
+        headers["x-lucern-user-id"] = authContext.clerkId;
+    }
+    if (authContext.delegationChain.length > 0) {
+        headers["x-lucern-delegation-chain"] = JSON.stringify(authContext.delegationChain);
+    }
+    if (authContext.policyTraceId) {
+        headers["x-lucern-policy-trace-id"] = authContext.policyTraceId;
+    }
+    if (authContext.correlationId) {
+        headers["x-correlation-id"] = authContext.correlationId;
+        headers["x-lucern-correlation-id"] = authContext.correlationId;
+    }
+    if (authContext.membershipId) {
+        headers["x-lucern-membership-id"] = authContext.membershipId;
+    }
+    return headers;
 }
-
-export { LucernSdkAuthContextError, createCanonicalAuthHeaders, normalizeCanonicalLucernAuthContext };
-//# sourceMappingURL=authContext.js.map
 //# sourceMappingURL=authContext.js.map

package/dist/authDeviceClient.d.ts

@@ -1,17 +1,9 @@
-import { GatewayClientConfig } from './coreClient.js';
-import '@lucern/transport-core';
-import './authContext.js';
-import './contracts/auth-session.contract.js';
-import './types.js';
-import './contracts/workflow-runtime.contract.js';
-import './contracts/lens-workflow.contract.js';
-import './contracts/lens-filter.contract.js';
-
-type DeviceCodeInput = {
+import type { GatewayClientConfig } from "./coreClient";
+export type DeviceCodeInput = {
     clientId?: string;
     scope?: string;
 };
-type DeviceCodeResponse = {
+export type DeviceCodeResponse = {
     device_code: string;
     user_code: string;
     verification_uri: string;
@@ -19,7 +11,7 @@ type DeviceCodeResponse = {
     expires_in: number;
     interval: number;
 };
-type DeviceTokenResponse = {
+export type DeviceTokenResponse = {
     access_token: string;
     token_type: "Bearer";
     expires_in: number;
@@ -32,8 +24,8 @@ type DeviceTokenResponse = {
         principalId: string;
     };
 };
-type DeviceTokenErrorCode = "authorization_pending" | "slow_down" | "access_denied" | "expired_token" | "invalid_grant" | "invalid_request";
-declare class DeviceAuthorizationError extends Error {
+export type DeviceTokenErrorCode = "authorization_pending" | "slow_down" | "access_denied" | "expired_token" | "invalid_grant" | "invalid_request";
+export declare class DeviceAuthorizationError extends Error {
     readonly error: DeviceTokenErrorCode;
     readonly interval?: number;
     constructor(args: {
@@ -42,9 +34,8 @@ declare class DeviceAuthorizationError extends Error {
         interval?: number;
     });
 }
-declare function createAuthDeviceClient(config?: GatewayClientConfig): {
+export declare function createAuthDeviceClient(config?: GatewayClientConfig): {
     createDeviceCode(input?: DeviceCodeInput): Promise<DeviceCodeResponse>;
     pollDeviceToken(deviceCode: string): Promise<DeviceTokenResponse>;
 };
-
-export { DeviceAuthorizationError, type DeviceCodeInput, type DeviceCodeResponse, type DeviceTokenErrorCode, type DeviceTokenResponse, createAuthDeviceClient };
+//# sourceMappingURL=authDeviceClient.d.ts.map

package/dist/authDeviceClient.js

@@ -1,121 +1,132 @@
-// src/authDeviceClient.ts
-var DeviceAuthorizationError = class extends Error {
-  error;
-  interval;
-  constructor(args) {
-    super(args.description ?? args.error);
-    this.name = "DeviceAuthorizationError";
-    this.error = args.error;
-    this.interval = args.interval;
-  }
-};
+export class DeviceAuthorizationError extends Error {
+    error;
+    interval;
+    constructor(args) {
+        super(args.description ?? args.error);
+        this.name = "DeviceAuthorizationError";
+        this.error = args.error;
+        this.interval = args.interval;
+    }
+}
 function authBaseUrl(config) {
-  return config.baseUrl?.replace(/\/+$/, "") ?? "";
+    return config.baseUrl?.replace(/\/+$/, "") ?? "";
 }
 async function readJson(response) {
-  try {
-    const payload = await response.json();
-    return isRecord(payload) ? payload : {};
-  } catch (error) {
-    return unreadableJsonBodyFallback();
-  }
+    try {
+        const payload = (await response.json());
+        return isRecord(payload) ? payload : {};
+    }
+    catch (error) {
+        return unreadableJsonBodyFallback(error);
+    }
 }
 function unreadableJsonBodyFallback(_error) {
-  return {};
+    return {};
 }
 function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+    return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function readString(value) {
-  const normalized = typeof value === "string" ? value.trim() : "";
-  return normalized || void 0;
+    const normalized = typeof value === "string" ? value.trim() : "";
+    return normalized || undefined;
 }
 function assertDeviceCodeResponse(payload) {
-  const deviceCode = readString(payload.device_code);
-  const userCode = readString(payload.user_code);
-  const verificationUri = readString(payload.verification_uri);
-  const verificationUriComplete = readString(payload.verification_uri_complete);
-  const expiresIn = payload.expires_in;
-  const interval = payload.interval;
-  if (!deviceCode || !userCode || !verificationUri || !verificationUriComplete || typeof expiresIn !== "number" || typeof interval !== "number") {
-    throw new Error("Gateway returned an invalid device-code response.");
-  }
-  return {
-    device_code: deviceCode,
-    user_code: userCode,
-    verification_uri: verificationUri,
-    verification_uri_complete: verificationUriComplete,
-    expires_in: expiresIn,
-    interval
-  };
+    const deviceCode = readString(payload.device_code);
+    const userCode = readString(payload.user_code);
+    const verificationUri = readString(payload.verification_uri);
+    const verificationUriComplete = readString(payload.verification_uri_complete);
+    const expiresIn = payload.expires_in;
+    const interval = payload.interval;
+    if (!deviceCode ||
+        !userCode ||
+        !verificationUri ||
+        !verificationUriComplete ||
+        typeof expiresIn !== "number" ||
+        typeof interval !== "number") {
+        throw new Error("Gateway returned an invalid device-code response.");
+    }
+    return {
+        device_code: deviceCode,
+        user_code: userCode,
+        verification_uri: verificationUri,
+        verification_uri_complete: verificationUriComplete,
+        expires_in: expiresIn,
+        interval,
+    };
 }
 function assertDeviceTokenResponse(payload) {
-  const accessToken = readString(payload.access_token);
-  const tokenType = readString(payload.token_type);
-  const scope = readString(payload.scope);
-  const tenantId = readString(payload.tenant_id);
-  const principalId = readString(payload.principal_id);
-  if (!accessToken || tokenType !== "Bearer" || typeof payload.expires_in !== "number" || !scope || !tenantId || !principalId) {
-    throw new Error("Gateway returned an invalid device token response.");
-  }
-  return {
-    access_token: accessToken,
-    token_type: "Bearer",
-    expires_in: payload.expires_in,
-    scope,
-    tenant_id: tenantId,
-    workspace_id: readString(payload.workspace_id),
-    principal_id: principalId,
-    user: isRecord(payload.user) && typeof payload.user.id === "string" && typeof payload.user.principalId === "string" ? {
-      id: payload.user.id,
-      principalId: payload.user.principalId
-    } : void 0
-  };
+    const accessToken = readString(payload.access_token);
+    const tokenType = readString(payload.token_type);
+    const scope = readString(payload.scope);
+    const tenantId = readString(payload.tenant_id);
+    const principalId = readString(payload.principal_id);
+    if (!accessToken ||
+        tokenType !== "Bearer" ||
+        typeof payload.expires_in !== "number" ||
+        !scope ||
+        !tenantId ||
+        !principalId) {
+        throw new Error("Gateway returned an invalid device token response.");
+    }
+    return {
+        access_token: accessToken,
+        token_type: "Bearer",
+        expires_in: payload.expires_in,
+        scope,
+        tenant_id: tenantId,
+        workspace_id: readString(payload.workspace_id),
+        principal_id: principalId,
+        user: isRecord(payload.user) &&
+            typeof payload.user.id === "string" &&
+            typeof payload.user.principalId === "string"
+            ? {
+                id: payload.user.id,
+                principalId: payload.user.principalId,
+            }
+            : undefined,
+    };
 }
 function maybeThrowDeviceError(payload) {
-  const error = readString(payload.error);
-  throw new DeviceAuthorizationError({
-    error: error ?? "invalid_request",
-    description: readString(payload.error_description),
-    interval: typeof payload.interval === "number" ? payload.interval : void 0
-  });
-}
-function createAuthDeviceClient(config = {}) {
-  const fetchImpl = config.fetchImpl ?? fetch;
-  const baseUrl = authBaseUrl(config);
-  async function post(path, body) {
-    return fetchImpl(`${baseUrl}${path}`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(body)
+    const error = readString(payload.error);
+    throw new DeviceAuthorizationError({
+        error: error ?? "invalid_request",
+        description: readString(payload.error_description),
+        interval: typeof payload.interval === "number" ? payload.interval : undefined,
     });
-  }
-  return {
-    async createDeviceCode(input = {}) {
-      const response = await post("/api/platform/v1/auth/device/code", {
-        client_id: input.clientId ?? "lucern-cli",
-        scope: input.scope ?? "graph.read graph.write"
-      });
-      const payload = await readJson(response);
-      if (!response.ok) {
-        maybeThrowDeviceError(payload);
-      }
-      return assertDeviceCodeResponse(payload);
-    },
-    async pollDeviceToken(deviceCode) {
-      const response = await post("/api/platform/v1/auth/device/token", {
-        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-        device_code: deviceCode
-      });
-      const payload = await readJson(response);
-      if (!response.ok) {
-        maybeThrowDeviceError(payload);
-      }
-      return assertDeviceTokenResponse(payload);
+}
+export function createAuthDeviceClient(config = {}) {
+    const fetchImpl = config.fetchImpl ?? fetch;
+    const baseUrl = authBaseUrl(config);
+    async function post(path, body) {
+        return fetchImpl(`${baseUrl}${path}`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
     }
-  };
+    return {
+        async createDeviceCode(input = {}) {
+            const response = await post("/api/platform/v1/auth/device/code", {
+                client_id: input.clientId ?? "lucern-cli",
+                scope: input.scope ?? "graph.read graph.write",
+            });
+            const payload = await readJson(response);
+            if (!response.ok) {
+                maybeThrowDeviceError(payload);
+            }
+            return assertDeviceCodeResponse(payload);
+        },
+        async pollDeviceToken(deviceCode) {
+            const response = await post("/api/platform/v1/auth/device/token", {
+                grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                device_code: deviceCode,
+            });
+            const payload = await readJson(response);
+            if (!response.ok) {
+                maybeThrowDeviceError(payload);
+            }
+            return assertDeviceTokenResponse(payload);
+        },
+    };
 }
-
-export { DeviceAuthorizationError, createAuthDeviceClient };
-//# sourceMappingURL=authDeviceClient.js.map
 //# sourceMappingURL=authDeviceClient.js.map