@feelflow/ffid-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+var chunkYCMQXJOS_cjs = require('./chunk-YCMQXJOS.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function withFFIDAuth(Component, options = {}) {
+  const WrappedComponent = (props) => {
+    const { isLoading, isAuthenticated, login } = chunkYCMQXJOS_cjs.useFFIDContext();
+    const hasRedirected = react.useRef(false);
+    react.useEffect(() => {
+      if (!isLoading && !isAuthenticated && options.redirectToLogin && !hasRedirected.current) {
+        hasRedirected.current = true;
+        login();
+      }
+    }, [isLoading, isAuthenticated, login]);
+    if (isLoading) {
+      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: options.loading ?? null });
+    }
+    if (!isAuthenticated) {
+      if (options.redirectToLogin) {
+        return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: options.loading ?? null });
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: options.fallback ?? null });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(Component, { ...props });
+  };
+  WrappedComponent.displayName = `withFFIDAuth(${Component.displayName ?? Component.name ?? "Component"})`;
+  return WrappedComponent;
+}
+
+Object.defineProperty(exports, "DEFAULT_API_BASE_URL", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.DEFAULT_API_BASE_URL; }
+});
+Object.defineProperty(exports, "FFIDLoginButton", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.FFIDLoginButton; }
+});
+Object.defineProperty(exports, "FFIDOrganizationSwitcher", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.FFIDOrganizationSwitcher; }
+});
+Object.defineProperty(exports, "FFIDProvider", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.FFIDProvider; }
+});
+Object.defineProperty(exports, "FFIDSubscriptionBadge", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.FFIDSubscriptionBadge; }
+});
+Object.defineProperty(exports, "FFIDUserMenu", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.FFIDUserMenu; }
+});
+Object.defineProperty(exports, "useFFID", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.useFFID; }
+});
+Object.defineProperty(exports, "useSubscription", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.useSubscription; }
+});
+Object.defineProperty(exports, "withSubscription", {
+  enumerable: true,
+  get: function () { return chunkYCMQXJOS_cjs.withSubscription; }
+});
+exports.withFFIDAuth = withFFIDAuth;

package/dist/index.d.cts

@@ -0,0 +1,181 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, ComponentType, FC } from 'react';
+import { F as FFIDConfig, a as FFIDUser, b as FFIDOrganization, c as FFIDError, d as FFIDSubscriptionContextValue } from './index-CtBBLbTn.cjs';
+export { e as FFIDApiResponse, f as FFIDContextValue, g as FFIDLogger, h as FFIDLoginButton, i as FFIDOrganizationSwitcher, j as FFIDSessionResponse, k as FFIDSubscription, l as FFIDSubscriptionBadge, m as FFIDUserMenu } from './index-CtBBLbTn.cjs';
+
+/**
+ * FFID SDK Shared Constants
+ *
+ * Constants shared across all SDK entry points (main client + legal client).
+ * Centralizing these prevents drift during domain/URL changes.
+ */
+/** Default FFID API base URL (production) */
+declare const DEFAULT_API_BASE_URL = "https://id.feelflow.co.jp";
+
+/**
+ * Props for FFIDProvider component
+ */
+interface FFIDProviderProps extends FFIDConfig {
+    /** Child components */
+    children: ReactNode;
+}
+/**
+ * FFIDProvider - Wrap your app to enable FFID authentication
+ *
+ * This provider handles:
+ * - Session management
+ * - User authentication state
+ * - Organization switching
+ * - Automatic session refresh
+ */
+declare function FFIDProvider({ children, serviceCode, apiBaseUrl, debug, logger, refreshInterval, onAuthStateChange, onError, }: FFIDProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Return type for useFFID hook
+ */
+interface UseFFIDReturn {
+    /** Current authenticated user (null if not logged in) */
+    user: FFIDUser | null;
+    /** List of user's organizations */
+    organizations: FFIDOrganization[];
+    /** Currently selected organization */
+    currentOrganization: FFIDOrganization | null;
+    /** Whether session is being loaded */
+    isLoading: boolean;
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Any authentication error that occurred */
+    error: FFIDError | null;
+    /** Redirect to login page */
+    login: () => void;
+    /** Sign out */
+    logout: () => Promise<void>;
+    /** Switch current organization */
+    switchOrganization: (organizationId: string) => void;
+    /** Refresh session data */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook to access FFID authentication and user data
+ *
+ * Must be used within FFIDProvider
+ */
+declare function useFFID(): UseFFIDReturn;
+
+/**
+ * useSubscription Hook
+ *
+ * Access subscription/contract information for the current service
+ *
+ * @example
+ * ```tsx
+ * import { useSubscription } from '@feelflow/ffid-sdk'
+ *
+ * function PremiumFeature() {
+ *   const { isActive, hasPlan, planCode } = useSubscription()
+ *
+ *   if (!isActive) {
+ *     return <div>契約が必要です</div>
+ *   }
+ *
+ *   if (!hasPlan(['pro', 'enterprise'])) {
+ *     return <div>プロプラン以上が必要です</div>
+ *   }
+ *
+ *   return <div>Premium Content</div>
+ * }
+ * ```
+ */
+
+/**
+ * Hook to access subscription information
+ *
+ * Must be used within FFIDProvider
+ */
+declare function useSubscription(): FFIDSubscriptionContextValue;
+/**
+ * HOC to require subscription for a component
+ *
+ * @example
+ * ```tsx
+ * import { withSubscription } from '@feelflow/ffid-sdk'
+ *
+ * const PremiumDashboard = withSubscription(Dashboard, {
+ *   plans: ['pro', 'enterprise'],
+ *   fallback: <UpgradePrompt />,
+ * })
+ * ```
+ */
+interface WithSubscriptionOptions {
+    /** Required plans (any of these) */
+    plans?: string[];
+    /** Component to show when subscription check fails */
+    fallback?: ReactNode;
+    /** Component to show while loading */
+    loading?: ReactNode;
+}
+declare function withSubscription<P extends object>(Component: ComponentType<P>, options?: WithSubscriptionOptions): FC<P>;
+
+/**
+ * withFFIDAuth HOC
+ *
+ * Wrap a component to require FFID authentication.
+ * Renders the wrapped component only when the user is authenticated.
+ *
+ * @example
+ * ```tsx
+ * import { withFFIDAuth } from '@feelflow/ffid-sdk'
+ *
+ * function Dashboard() {
+ *   return <div>Protected Dashboard</div>
+ * }
+ *
+ * // Basic usage - renders nothing when not authenticated
+ * export default withFFIDAuth(Dashboard)
+ *
+ * // With redirect to login
+ * export default withFFIDAuth(Dashboard, {
+ *   redirectToLogin: true,
+ *   loading: <div>認証確認中...</div>,
+ * })
+ *
+ * // With fallback component
+ * export default withFFIDAuth(Dashboard, {
+ *   fallback: <div>ログインが必要です</div>,
+ * })
+ * ```
+ */
+
+/**
+ * Options for withFFIDAuth HOC
+ */
+interface WithFFIDAuthOptions {
+    /** Automatically redirect to FFID login page when not authenticated (default: false) */
+    redirectToLogin?: boolean;
+    /** Component to show while authentication is being checked */
+    loading?: ReactNode;
+    /** Component to show when user is not authenticated (ignored if redirectToLogin is true) */
+    fallback?: ReactNode;
+}
+/**
+ * HOC to require FFID authentication for a component
+ *
+ * Renders the wrapped component only when the user is authenticated.
+ * While authentication is loading, shows the loading component (if provided).
+ * When not authenticated, either redirects to login or shows fallback.
+ *
+ * @example
+ * ```tsx
+ * // Redirect to login on unauthenticated
+ * const ProtectedPage = withFFIDAuth(MyPage, { redirectToLogin: true })
+ *
+ * // Show custom fallback
+ * const ProtectedPage = withFFIDAuth(MyPage, {
+ *   fallback: <LoginPrompt />,
+ *   loading: <Spinner />,
+ * })
+ * ```
+ */
+declare function withFFIDAuth<P extends object>(Component: ComponentType<P>, options?: WithFFIDAuthOptions): FC<P>;
+
+export { DEFAULT_API_BASE_URL, FFIDConfig, FFIDError, FFIDOrganization, FFIDProvider, type FFIDProviderProps, FFIDSubscriptionContextValue, FFIDUser, type UseFFIDReturn, type WithFFIDAuthOptions, type WithSubscriptionOptions, useFFID, useSubscription, withFFIDAuth, withSubscription };

package/dist/index.d.ts

@@ -0,0 +1,181 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, ComponentType, FC } from 'react';
+import { F as FFIDConfig, a as FFIDUser, b as FFIDOrganization, c as FFIDError, d as FFIDSubscriptionContextValue } from './index-CtBBLbTn.js';
+export { e as FFIDApiResponse, f as FFIDContextValue, g as FFIDLogger, h as FFIDLoginButton, i as FFIDOrganizationSwitcher, j as FFIDSessionResponse, k as FFIDSubscription, l as FFIDSubscriptionBadge, m as FFIDUserMenu } from './index-CtBBLbTn.js';
+
+/**
+ * FFID SDK Shared Constants
+ *
+ * Constants shared across all SDK entry points (main client + legal client).
+ * Centralizing these prevents drift during domain/URL changes.
+ */
+/** Default FFID API base URL (production) */
+declare const DEFAULT_API_BASE_URL = "https://id.feelflow.co.jp";
+
+/**
+ * Props for FFIDProvider component
+ */
+interface FFIDProviderProps extends FFIDConfig {
+    /** Child components */
+    children: ReactNode;
+}
+/**
+ * FFIDProvider - Wrap your app to enable FFID authentication
+ *
+ * This provider handles:
+ * - Session management
+ * - User authentication state
+ * - Organization switching
+ * - Automatic session refresh
+ */
+declare function FFIDProvider({ children, serviceCode, apiBaseUrl, debug, logger, refreshInterval, onAuthStateChange, onError, }: FFIDProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Return type for useFFID hook
+ */
+interface UseFFIDReturn {
+    /** Current authenticated user (null if not logged in) */
+    user: FFIDUser | null;
+    /** List of user's organizations */
+    organizations: FFIDOrganization[];
+    /** Currently selected organization */
+    currentOrganization: FFIDOrganization | null;
+    /** Whether session is being loaded */
+    isLoading: boolean;
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Any authentication error that occurred */
+    error: FFIDError | null;
+    /** Redirect to login page */
+    login: () => void;
+    /** Sign out */
+    logout: () => Promise<void>;
+    /** Switch current organization */
+    switchOrganization: (organizationId: string) => void;
+    /** Refresh session data */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook to access FFID authentication and user data
+ *
+ * Must be used within FFIDProvider
+ */
+declare function useFFID(): UseFFIDReturn;
+
+/**
+ * useSubscription Hook
+ *
+ * Access subscription/contract information for the current service
+ *
+ * @example
+ * ```tsx
+ * import { useSubscription } from '@feelflow/ffid-sdk'
+ *
+ * function PremiumFeature() {
+ *   const { isActive, hasPlan, planCode } = useSubscription()
+ *
+ *   if (!isActive) {
+ *     return <div>契約が必要です</div>
+ *   }
+ *
+ *   if (!hasPlan(['pro', 'enterprise'])) {
+ *     return <div>プロプラン以上が必要です</div>
+ *   }
+ *
+ *   return <div>Premium Content</div>
+ * }
+ * ```
+ */
+
+/**
+ * Hook to access subscription information
+ *
+ * Must be used within FFIDProvider
+ */
+declare function useSubscription(): FFIDSubscriptionContextValue;
+/**
+ * HOC to require subscription for a component
+ *
+ * @example
+ * ```tsx
+ * import { withSubscription } from '@feelflow/ffid-sdk'
+ *
+ * const PremiumDashboard = withSubscription(Dashboard, {
+ *   plans: ['pro', 'enterprise'],
+ *   fallback: <UpgradePrompt />,
+ * })
+ * ```
+ */
+interface WithSubscriptionOptions {
+    /** Required plans (any of these) */
+    plans?: string[];
+    /** Component to show when subscription check fails */
+    fallback?: ReactNode;
+    /** Component to show while loading */
+    loading?: ReactNode;
+}
+declare function withSubscription<P extends object>(Component: ComponentType<P>, options?: WithSubscriptionOptions): FC<P>;
+
+/**
+ * withFFIDAuth HOC
+ *
+ * Wrap a component to require FFID authentication.
+ * Renders the wrapped component only when the user is authenticated.
+ *
+ * @example
+ * ```tsx
+ * import { withFFIDAuth } from '@feelflow/ffid-sdk'
+ *
+ * function Dashboard() {
+ *   return <div>Protected Dashboard</div>
+ * }
+ *
+ * // Basic usage - renders nothing when not authenticated
+ * export default withFFIDAuth(Dashboard)
+ *
+ * // With redirect to login
+ * export default withFFIDAuth(Dashboard, {
+ *   redirectToLogin: true,
+ *   loading: <div>認証確認中...</div>,
+ * })
+ *
+ * // With fallback component
+ * export default withFFIDAuth(Dashboard, {
+ *   fallback: <div>ログインが必要です</div>,
+ * })
+ * ```
+ */
+
+/**
+ * Options for withFFIDAuth HOC
+ */
+interface WithFFIDAuthOptions {
+    /** Automatically redirect to FFID login page when not authenticated (default: false) */
+    redirectToLogin?: boolean;
+    /** Component to show while authentication is being checked */
+    loading?: ReactNode;
+    /** Component to show when user is not authenticated (ignored if redirectToLogin is true) */
+    fallback?: ReactNode;
+}
+/**
+ * HOC to require FFID authentication for a component
+ *
+ * Renders the wrapped component only when the user is authenticated.
+ * While authentication is loading, shows the loading component (if provided).
+ * When not authenticated, either redirects to login or shows fallback.
+ *
+ * @example
+ * ```tsx
+ * // Redirect to login on unauthenticated
+ * const ProtectedPage = withFFIDAuth(MyPage, { redirectToLogin: true })
+ *
+ * // Show custom fallback
+ * const ProtectedPage = withFFIDAuth(MyPage, {
+ *   fallback: <LoginPrompt />,
+ *   loading: <Spinner />,
+ * })
+ * ```
+ */
+declare function withFFIDAuth<P extends object>(Component: ComponentType<P>, options?: WithFFIDAuthOptions): FC<P>;
+
+export { DEFAULT_API_BASE_URL, FFIDConfig, FFIDError, FFIDOrganization, FFIDProvider, type FFIDProviderProps, FFIDSubscriptionContextValue, FFIDUser, type UseFFIDReturn, type WithFFIDAuthOptions, type WithSubscriptionOptions, useFFID, useSubscription, withFFIDAuth, withSubscription };

package/dist/index.js

@@ -0,0 +1,31 @@
+import { useFFIDContext } from './chunk-A63MX52D.js';
+export { DEFAULT_API_BASE_URL, FFIDLoginButton, FFIDOrganizationSwitcher, FFIDProvider, FFIDSubscriptionBadge, FFIDUserMenu, useFFID, useSubscription, withSubscription } from './chunk-A63MX52D.js';
+import { useRef, useEffect } from 'react';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+function withFFIDAuth(Component, options = {}) {
+  const WrappedComponent = (props) => {
+    const { isLoading, isAuthenticated, login } = useFFIDContext();
+    const hasRedirected = useRef(false);
+    useEffect(() => {
+      if (!isLoading && !isAuthenticated && options.redirectToLogin && !hasRedirected.current) {
+        hasRedirected.current = true;
+        login();
+      }
+    }, [isLoading, isAuthenticated, login]);
+    if (isLoading) {
+      return /* @__PURE__ */ jsx(Fragment, { children: options.loading ?? null });
+    }
+    if (!isAuthenticated) {
+      if (options.redirectToLogin) {
+        return /* @__PURE__ */ jsx(Fragment, { children: options.loading ?? null });
+      }
+      return /* @__PURE__ */ jsx(Fragment, { children: options.fallback ?? null });
+    }
+    return /* @__PURE__ */ jsx(Component, { ...props });
+  };
+  WrappedComponent.displayName = `withFFIDAuth(${Component.displayName ?? Component.name ?? "Component"})`;
+  return WrappedComponent;
+}
+
+export { withFFIDAuth };

package/dist/legal/index.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+// src/constants.ts
+var DEFAULT_API_BASE_URL = "https://id.feelflow.co.jp";
+
+// src/legal/ffid-legal-client.ts
+var API_PREFIX = "/api/v1/legal/ext";
+var SDK_LOG_PREFIX = "[FFID Legal SDK]";
+var NO_CONTENT_STATUS = 204;
+var FFID_LEGAL_ERROR_CODES = {
+  /** API key is missing */
+  MISSING_API_KEY: "MISSING_API_KEY",
+  /** Network request failed (fetch threw) */
+  NETWORK_ERROR: "NETWORK_ERROR",
+  /** Server returned non-JSON response */
+  PARSE_ERROR: "PARSE_ERROR",
+  /** Server returned error without structured error body */
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  /** Input validation failed (empty required parameters) */
+  VALIDATION_ERROR: "VALIDATION_ERROR"
+};
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: (...args) => console.error(SDK_LOG_PREFIX, ...args)
+};
+var consoleLogger = {
+  debug: (...args) => console.debug(SDK_LOG_PREFIX, ...args),
+  info: (...args) => console.info(SDK_LOG_PREFIX, ...args),
+  warn: (...args) => console.warn(SDK_LOG_PREFIX, ...args),
+  error: (...args) => console.error(SDK_LOG_PREFIX, ...args)
+};
+function createFFIDLegalClient(config) {
+  if (!config.apiKey) {
+    throw new Error("FFID Legal Client: apiKey \u304C\u672A\u8A2D\u5B9A\u3067\u3059");
+  }
+  const baseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+  const logger = config.logger ?? (config.debug ? consoleLogger : noopLogger);
+  async function fetchWithApiKey(endpoint, options = {}) {
+    const url = `${baseUrl}${API_PREFIX}${endpoint}`;
+    logger.debug("Fetching:", url);
+    let response;
+    try {
+      response = await fetch(url, {
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Service-Api-Key": config.apiKey,
+          ...options.headers
+        }
+      });
+    } catch (error) {
+      logger.error("Network error:", { url, error });
+      return {
+        error: {
+          code: FFID_LEGAL_ERROR_CODES.NETWORK_ERROR,
+          message: error instanceof Error ? error.message : "\u30CD\u30C3\u30C8\u30EF\u30FC\u30AF\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F"
+        }
+      };
+    }
+    if (response.status === NO_CONTENT_STATUS) {
+      logger.debug("Response: 204 No Content (unexpected)", { url });
+      return {
+        error: {
+          code: FFID_LEGAL_ERROR_CODES.UNKNOWN_ERROR,
+          message: "\u4E88\u671F\u3057\u306A\u3044\u30EC\u30B9\u30DD\u30F3\u30B9: \u30B5\u30FC\u30D0\u30FC\u304B\u3089\u30B3\u30F3\u30C6\u30F3\u30C4\u304C\u8FD4\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F"
+        }
+      };
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch (parseError) {
+      logger.error("Parse error:", { url, status: response.status, parseError });
+      return {
+        error: {
+          code: FFID_LEGAL_ERROR_CODES.PARSE_ERROR,
+          message: `\u30B5\u30FC\u30D0\u30FC\u304B\u3089\u4E0D\u6B63\u306A\u30EC\u30B9\u30DD\u30F3\u30B9\u3092\u53D7\u4FE1\u3057\u307E\u3057\u305F (status: ${response.status})`
+        }
+      };
+    }
+    logger.debug("Response:", response.status, data);
+    if (!response.ok || !data.success) {
+      return {
+        error: data.error ?? {
+          code: FFID_LEGAL_ERROR_CODES.UNKNOWN_ERROR,
+          message: "\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F"
+        }
+      };
+    }
+    if (data.data === void 0) {
+      return {
+        error: {
+          code: FFID_LEGAL_ERROR_CODES.UNKNOWN_ERROR,
+          message: "\u30B5\u30FC\u30D0\u30FC\u304B\u3089\u30C7\u30FC\u30BF\u304C\u8FD4\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F"
+        }
+      };
+    }
+    return { data: data.data };
+  }
+  async function getDocuments() {
+    return fetchWithApiKey("/documents");
+  }
+  async function getDocument(documentId) {
+    if (!documentId) {
+      return {
+        error: {
+          code: FFID_LEGAL_ERROR_CODES.VALIDATION_ERROR,
+          message: "documentId is required"
+        }
+      };
+    }
+    return fetchWithApiKey(`/documents/${encodeURIComponent(documentId)}`);
+  }
+  async function recordAgreement(request) {
+    if (!request.externalUserId || !request.documentId) {
+      return {
+        error: {
+          code: FFID_LEGAL_ERROR_CODES.VALIDATION_ERROR,
+          message: "externalUserId and documentId are required"
+        }
+      };
+    }
+    return fetchWithApiKey("/agreements", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async function checkAgreement(externalUserId, documentId) {
+    if (!externalUserId || !documentId) {
+      return {
+        error: {
+          code: FFID_LEGAL_ERROR_CODES.VALIDATION_ERROR,
+          message: "externalUserId and documentId are required"
+        }
+      };
+    }
+    const params = new URLSearchParams({
+      externalUserId,
+      documentId
+    });
+    return fetchWithApiKey(`/agreements/check?${params.toString()}`);
+  }
+  async function getPendingAgreements(externalUserId) {
+    if (!externalUserId) {
+      return {
+        error: {
+          code: FFID_LEGAL_ERROR_CODES.VALIDATION_ERROR,
+          message: "externalUserId is required"
+        }
+      };
+    }
+    const params = new URLSearchParams({ externalUserId });
+    return fetchWithApiKey(`/agreements/pending?${params.toString()}`);
+  }
+  return {
+    /** Get all legal documents available to this service */
+    getDocuments,
+    /** Get a specific legal document by ID */
+    getDocument,
+    /** Record a user's agreement to a legal document */
+    recordAgreement,
+    /** Check if a user has agreed to a specific document */
+    checkAgreement,
+    /** Get all documents that a user has not yet agreed to */
+    getPendingAgreements,
+    /** Resolved logger instance */
+    logger,
+    /** API base URL */
+    baseUrl
+  };
+}
+
+exports.DEFAULT_API_BASE_URL = DEFAULT_API_BASE_URL;
+exports.FFID_LEGAL_ERROR_CODES = FFID_LEGAL_ERROR_CODES;
+exports.createFFIDLegalClient = createFFIDLegalClient;