@ariestools/cli 0.1.8 → 0.1.10

package/dist/node/datalake.d.ts

@@ -0,0 +1,220 @@
+/** Programmatic datalake client API shipped with @ariestools/cli (bundled). */
+
+export type AuthTokenSource = string | (() => string | Promise<string>)
+export type PayloadsAuthTokenSource = AuthTokenSource
+
+export type DatalakeRole = 'viewer' | 'runner'
+export type DatalakePrincipal = string
+export type DatalakeTier = 'small' | 'medium' | 'large' | 'archive'
+export type DatalakeRegion = 'us-west-2' | 'us-east-1' | 'eu-west-1'
+export type DatalakeStatus =
+  | 'pending'
+  | 'provisioning'
+  | 'ready'
+  | 'resizing'
+  | 'deprovisioning'
+  | 'deleted'
+  | 'error'
+
+export interface RateLimitOverrides {
+  anonymousPerMinute?: number
+  authenticatedPerMinute?: number
+  burstFactor?: number
+}
+
+export interface DatalakeConfig {
+  allowedSchemas?: string[]
+  disallowedSchemas?: string[]
+  iops?: number
+  rateLimits?: RateLimitOverrides
+  region?: DatalakeRegion
+  retentionDays?: number | null
+  sizeBytes?: number
+  tier: DatalakeTier
+  /** @deprecated No-op; archivist recomputes hashes trustlessly. */
+  verifyHashes?: boolean
+}
+
+export interface AclEntry {
+  grantedAt: string
+  grantedBy?: string
+  principal: DatalakePrincipal
+  role: DatalakeRole
+}
+
+export interface DatalakeUsage {
+  bytesStored: number
+  bytesStoredLimit: number
+  payloadCount: number
+  readsLast24h: number
+  writesLast24h: number
+}
+
+export interface DatalakeDescriptor {
+  acl: AclEntry[]
+  config: DatalakeConfig
+  createdAt: string
+  errorMessage?: string
+  id: string
+  name: string
+  ownerId: string
+  status: DatalakeStatus
+  updatedAt: string
+  url?: string
+  usage?: DatalakeUsage
+}
+
+export interface DatalakeToken {
+  datalakeId: string
+  expiresAt: string
+  role: DatalakeRole
+  token: string
+  url: string
+}
+
+export interface CreateDatalakeRequest {
+  config: DatalakeConfig
+  name: string
+}
+
+export interface GrantRequest {
+  datalakeId: string
+  principal: DatalakePrincipal
+  role: DatalakeRole
+}
+
+export interface RevokeRequest {
+  datalakeId: string
+  principal: DatalakePrincipal
+}
+
+export interface TokenRequest {
+  datalakeId: string
+  role: DatalakeRole
+  ttlSeconds?: number
+}
+
+export interface StoredCredentials {
+  authToken: string
+  baseUrl: string
+  userId?: string
+}
+
+export interface WalletJwtCredentials {
+  baseUrl: string
+  walletJwt: true
+  userId?: string
+}
+
+export interface CreateDatalakeClientOptions {
+  authToken?: AuthTokenSource
+  baseUrl?: string
+  driver?: 'local' | 'rest'
+}
+
+export interface RestDatalakeClientOptions {
+  authToken: AuthTokenSource
+  baseUrl: string
+  fetchImpl?: typeof fetch
+}
+
+export interface RestPayloadsClientOptions {
+  authToken: PayloadsAuthTokenSource
+  baseUrl: string
+  datalakeId: string
+  fetchImpl?: typeof fetch
+}
+
+export interface DatalakeInsertSummary {
+  duplicates: number
+  rejected: string[]
+}
+
+/** Result of PayloadsClient.insert — matches RestPayloadsClient runtime. */
+export interface InsertPayloadsResult {
+  inserted: unknown[]
+  summary: DatalakeInsertSummary
+}
+
+export interface NextPayloadsResult {
+  nextCursor?: string
+  payloads: unknown[]
+}
+
+export interface DatalakeUsageReport {
+  datalakeId: string
+  payloadCount: number
+  rateLimits?: {
+    anonymous?: { limit: number; remaining: number }
+    authenticated?: { limit: number; remaining: number }
+  }
+}
+
+export interface PayloadsClient {
+  clear(): Promise<{ removed: number }>
+  delete(hash: string): Promise<void>
+  get(hash: string): Promise<unknown>
+  getMany(hashes: string[]): Promise<unknown[]>
+  insert(payloads: unknown[]): Promise<InsertPayloadsResult>
+  next(options?: {
+    cursor?: string
+    limit?: number
+    order?: 'asc' | 'desc'
+    schemas?: string[]
+  }): Promise<NextPayloadsResult>
+  usage(): Promise<DatalakeUsageReport>
+}
+
+export interface DatalakeClient {
+  create(request: CreateDatalakeRequest): Promise<DatalakeDescriptor>
+  describe(idOrName: string): Promise<DatalakeDescriptor>
+  destroy(idOrName: string): Promise<void>
+  grant(request: GrantRequest): Promise<DatalakeDescriptor>
+  list(): Promise<DatalakeDescriptor[]>
+  mintToken(request: TokenRequest): Promise<DatalakeToken>
+  revoke(request: RevokeRequest): Promise<DatalakeDescriptor>
+}
+
+export declare function createDatalakeClient(options?: CreateDatalakeClientOptions): DatalakeClient
+export declare class LocalDatalakeClient implements DatalakeClient {
+  create(request: CreateDatalakeRequest): Promise<DatalakeDescriptor>
+  describe(idOrName: string): Promise<DatalakeDescriptor>
+  destroy(idOrName: string): Promise<void>
+  grant(request: GrantRequest): Promise<DatalakeDescriptor>
+  list(): Promise<DatalakeDescriptor[]>
+  mintToken(request: TokenRequest): Promise<DatalakeToken>
+  revoke(request: RevokeRequest): Promise<DatalakeDescriptor>
+}
+export declare class RestDatalakeClient implements DatalakeClient {
+  constructor(options: RestDatalakeClientOptions)
+  create(request: CreateDatalakeRequest): Promise<DatalakeDescriptor>
+  describe(idOrName: string): Promise<DatalakeDescriptor>
+  destroy(idOrName: string): Promise<void>
+  grant(request: GrantRequest): Promise<DatalakeDescriptor>
+  list(): Promise<DatalakeDescriptor[]>
+  mintToken(request: TokenRequest): Promise<DatalakeToken>
+  revoke(request: RevokeRequest): Promise<DatalakeDescriptor>
+}
+export declare class RestPayloadsClient implements PayloadsClient {
+  constructor(options: RestPayloadsClientOptions)
+  clear(): Promise<{ removed: number }>
+  delete(hash: string): Promise<void>
+  get(hash: string): Promise<unknown>
+  getMany(hashes: string[]): Promise<unknown[]>
+  insert(payloads: unknown[]): Promise<InsertPayloadsResult>
+  next(options?: {
+    cursor?: string
+    limit?: number
+    order?: 'asc' | 'desc'
+    schemas?: string[]
+  }): Promise<NextPayloadsResult>
+  usage(): Promise<DatalakeUsageReport>
+}
+
+export declare function loadCredentials(): StoredCredentials | WalletJwtCredentials | undefined
+export declare function saveCredentials(credentials: StoredCredentials | WalletJwtCredentials): void
+export declare function clearCredentials(): void
+export declare function getCredentialsLocation(): string
+export declare function getDefaultDatalake(): string | undefined
+export declare function setDefaultDatalake(id: string): void
+export declare function clearDefaultDatalake(): void

package/dist/node/datalake.mjs

@@ -0,0 +1,475 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+//#region ../datalake-core/dist/node/index.mjs
+var DatalakeApiError = class extends Error {
+	code;
+	requestId;
+	status;
+	constructor(status, body) {
+		super(body.message);
+		this.name = "DatalakeApiError";
+		this.code = body.code;
+		this.status = status;
+		this.requestId = body.requestId;
+	}
+};
+function datalakeCollectionPath() {
+	return `/v1/datalakes`;
+}
+function datalakeResourcePath(idOrName) {
+	return `${datalakeCollectionPath()}/${encodeURIComponent(idOrName)}`;
+}
+function datalakeGrantsPath(idOrName) {
+	return `${datalakeResourcePath(idOrName)}/grants`;
+}
+function datalakeGrantPath(idOrName, principal) {
+	return `${datalakeGrantsPath(idOrName)}/${encodeURIComponent(principal)}`;
+}
+function datalakeTokensPath(idOrName) {
+	return `${datalakeResourcePath(idOrName)}/tokens`;
+}
+var DATALAKE_HEADER_DUPLICATES = "x-datalake-duplicates";
+var DATALAKE_HEADER_REJECTED = "x-datalake-rejected";
+function datalakePlaneResourcePath(id) {
+	return `/v1/datalakes/${encodeURIComponent(id)}`;
+}
+function datalakePlaneInsertPath(id) {
+	return `${datalakePlaneResourcePath(id)}/insert`;
+}
+function datalakePlaneGetPath(id, hash) {
+	return `${datalakePlaneResourcePath(id)}/get/${encodeURIComponent(hash)}`;
+}
+function datalakePlaneGetManyPath(id) {
+	return `${datalakePlaneResourcePath(id)}/get`;
+}
+function datalakePlaneNextPath(id) {
+	return `${datalakePlaneResourcePath(id)}/next`;
+}
+function datalakePlaneDeletePath(id, hash) {
+	return `${datalakePlaneResourcePath(id)}/delete/${encodeURIComponent(hash)}`;
+}
+function datalakePlaneClearPath(id) {
+	return `${datalakePlaneResourcePath(id)}/clear`;
+}
+function datalakePlaneUsagePath(id) {
+	return `${datalakePlaneResourcePath(id)}/usage`;
+}
+//#endregion
+//#region ../datalake-client/dist/node/index.mjs
+function getAriesHome() {
+	return process.env.ARIES_HOME ?? path.join(homedir(), ".aries");
+}
+function getDatalakeStoreDir() {
+	return path.join(getAriesHome(), "datalakes");
+}
+function getLocalDatalakeStorePath() {
+	return path.join(getDatalakeStoreDir(), "local-store.json");
+}
+function getCredentialsPath() {
+	return path.join(getAriesHome(), "credentials.json");
+}
+function getDefaultDatalakePath() {
+	return path.join(getAriesHome(), "datalake-default.json");
+}
+function saveCredentials(credentials) {
+	const home = getAriesHome();
+	if (!existsSync(home)) mkdirSync(home, { recursive: true });
+	const filePath = getCredentialsPath();
+	writeFileSync(filePath, JSON.stringify(credentials, void 0, 2), "utf8");
+	try {
+		chmodSync(filePath, 384);
+	} catch {}
+}
+function loadCredentials() {
+	const filePath = getCredentialsPath();
+	if (!existsSync(filePath)) return void 0;
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return;
+	}
+}
+function clearCredentials() {
+	const filePath = getCredentialsPath();
+	if (existsSync(filePath)) unlinkSync(filePath);
+}
+function getCredentialsLocation() {
+	return path.resolve(getCredentialsPath());
+}
+var LOCAL_OWNER_ID = "local-user";
+var TIER_SIZE_DEFAULTS = {
+	small: 10 * 1024 * 1024 * 1024,
+	medium: 100 * 1024 * 1024 * 1024,
+	large: 1024 * 1024 * 1024 * 1024,
+	archive: 10 * 1024 * 1024 * 1024 * 1024
+};
+var TIER_IOPS_DEFAULTS = {
+	small: 500,
+	medium: 2e3,
+	large: 1e4,
+	archive: 0
+};
+function readStore() {
+	const filePath = getLocalDatalakeStorePath();
+	if (!existsSync(filePath)) return { datalakes: [] };
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return { datalakes: [] };
+	}
+}
+function writeStore(store) {
+	const dir = getDatalakeStoreDir();
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(getLocalDatalakeStorePath(), JSON.stringify(store, void 0, 2), "utf8");
+}
+function generateId() {
+	return `dl_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+}
+function findDatalake(store, idOrName) {
+	return store.datalakes.find((dl) => dl.id === idOrName || dl.name === idOrName);
+}
+function requireDatalake(store, idOrName) {
+	const found = findDatalake(store, idOrName);
+	if (!found) throw new Error(`Datalake not found: ${idOrName}`);
+	return found;
+}
+var LocalDatalakeClient = class {
+	async create(request) {
+		const store = readStore();
+		if (store.datalakes.some((dl) => dl.name === request.name)) throw new Error(`Datalake already exists: ${request.name}`);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const tier = request.config.tier;
+		const descriptor = {
+			id: generateId(),
+			name: request.name,
+			ownerId: LOCAL_OWNER_ID,
+			config: {
+				tier,
+				sizeBytes: request.config.sizeBytes ?? TIER_SIZE_DEFAULTS[tier],
+				iops: request.config.iops ?? TIER_IOPS_DEFAULTS[tier],
+				retentionDays: request.config.retentionDays ?? 30,
+				region: request.config.region ?? "us-west-2",
+				allowedSchemas: request.config.allowedSchemas ?? [],
+				disallowedSchemas: request.config.disallowedSchemas ?? []
+			},
+			status: "ready",
+			url: `http://localhost:8080/datalakes/${request.name}`,
+			acl: [],
+			usage: {
+				payloadCount: 0,
+				bytesStored: 0,
+				bytesStoredLimit: request.config.sizeBytes ?? TIER_SIZE_DEFAULTS[tier],
+				readsLast24h: 0,
+				writesLast24h: 0
+			},
+			createdAt: now,
+			updatedAt: now
+		};
+		store.datalakes.push(descriptor);
+		writeStore(store);
+		return descriptor;
+	}
+	async describe(idOrName) {
+		return requireDatalake(readStore(), idOrName);
+	}
+	async destroy(idOrName) {
+		const store = readStore();
+		const found = findDatalake(store, idOrName);
+		if (!found) throw new Error(`Datalake not found: ${idOrName}`);
+		store.datalakes = store.datalakes.filter((dl) => dl.id !== found.id);
+		writeStore(store);
+	}
+	async grant(request) {
+		const store = readStore();
+		const datalake = requireDatalake(store, request.datalakeId);
+		const existing = datalake.acl.findIndex((entry2) => entry2.principal === request.principal);
+		const entry = {
+			principal: request.principal,
+			role: request.role,
+			grantedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			grantedBy: LOCAL_OWNER_ID
+		};
+		if (existing === -1) datalake.acl.push(entry);
+		else datalake.acl[existing] = entry;
+		datalake.updatedAt = entry.grantedAt;
+		writeStore(store);
+		return datalake;
+	}
+	async list() {
+		return readStore().datalakes;
+	}
+	async mintToken(request) {
+		const datalake = requireDatalake(readStore(), request.datalakeId);
+		const ttl = request.ttlSeconds ?? 3600;
+		return {
+			token: `local.${Buffer.from(JSON.stringify({
+				dl: datalake.id,
+				role: request.role,
+				exp: Math.floor(Date.now() / 1e3) + ttl
+			})).toString("base64url")}`,
+			datalakeId: datalake.id,
+			role: request.role,
+			expiresAt: new Date(Date.now() + ttl * 1e3).toISOString(),
+			url: datalake.url ?? `http://localhost:8080/datalakes/${datalake.name}`
+		};
+	}
+	async revoke(request) {
+		const store = readStore();
+		const datalake = requireDatalake(store, request.datalakeId);
+		datalake.acl = datalake.acl.filter((entry) => entry.principal !== request.principal);
+		datalake.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		writeStore(store);
+		return datalake;
+	}
+};
+var RestDatalakeClient = class {
+	authToken;
+	baseUrl;
+	fetchImpl;
+	constructor(options) {
+		this.baseUrl = options.baseUrl.replace(/\/$/, "");
+		this.authToken = options.authToken;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+	}
+	async create(request) {
+		const body = {
+			name: request.name,
+			config: request.config
+		};
+		return this.request(datalakeCollectionPath(), {
+			method: "POST",
+			body
+		});
+	}
+	async describe(idOrName) {
+		return this.request(datalakeResourcePath(idOrName));
+	}
+	async destroy(idOrName) {
+		await this.request(datalakeResourcePath(idOrName), { method: "DELETE" });
+	}
+	async grant(request) {
+		const body = {
+			principal: request.principal,
+			role: request.role
+		};
+		return this.request(datalakeGrantsPath(request.datalakeId), {
+			method: "POST",
+			body
+		});
+	}
+	async list() {
+		return this.request(datalakeCollectionPath());
+	}
+	async mintToken(request) {
+		const body = {
+			role: request.role,
+			ttlSeconds: request.ttlSeconds
+		};
+		return this.request(datalakeTokensPath(request.datalakeId), {
+			method: "POST",
+			body
+		});
+	}
+	async revoke(request) {
+		return this.request(datalakeGrantPath(request.datalakeId, request.principal), { method: "DELETE" });
+	}
+	async request(path4, options = {}) {
+		const url = `${this.baseUrl}${path4}`;
+		const method = options.method ?? "GET";
+		const headers = {
+			accept: "application/json",
+			authorization: `Bearer ${await this.resolveAuthToken()}`
+		};
+		const init = {
+			method,
+			headers
+		};
+		if (options.body !== void 0) {
+			headers["content-type"] = "application/json";
+			init.body = JSON.stringify(options.body);
+		}
+		const response = await this.fetchImpl(url, init);
+		if (response.status === 204) return;
+		const text = await response.text();
+		const payload = text.length > 0 ? JSON.parse(text) : void 0;
+		if (!response.ok) {
+			const errorBody = isApiErrorBody(payload) ? payload : {
+				code: "internal",
+				message: `Unexpected ${response.status} response from ${method} ${path4}`
+			};
+			throw new DatalakeApiError(response.status, errorBody);
+		}
+		return payload;
+	}
+	async resolveAuthToken() {
+		return typeof this.authToken === "function" ? await this.authToken() : this.authToken;
+	}
+};
+function isApiErrorBody(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	return typeof maybe.code === "string" && typeof maybe.message === "string";
+}
+function createDatalakeClient(options = {}) {
+	const envBaseUrl = process.env.ARIES_DATALAKE_API;
+	const credentials = loadCredentials();
+	const baseUrl = options.baseUrl ?? envBaseUrl ?? credentials?.baseUrl;
+	const authToken = options.authToken ?? credentials?.authToken;
+	if ((options.driver ?? (baseUrl && authToken ? "rest" : "local")) === "rest") {
+		if (!baseUrl || !authToken) throw new Error("REST driver requires a baseUrl and authToken. Run `aries datalake login` or set ARIES_DATALAKE_API and sign in.");
+		return new RestDatalakeClient({
+			baseUrl,
+			authToken
+		});
+	}
+	return new LocalDatalakeClient();
+}
+function setDefaultDatalake(name, id) {
+	const home = getAriesHome();
+	if (!existsSync(home)) mkdirSync(home, { recursive: true });
+	const payload = {
+		name,
+		id,
+		setAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writeFileSync(getDefaultDatalakePath(), JSON.stringify(payload, void 0, 2), "utf8");
+}
+function getDefaultDatalake() {
+	const filePath = getDefaultDatalakePath();
+	if (!existsSync(filePath)) return void 0;
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		return JSON.parse(raw).name;
+	} catch {
+		return;
+	}
+}
+function clearDefaultDatalake() {
+	const filePath = getDefaultDatalakePath();
+	if (existsSync(filePath)) unlinkSync(filePath);
+}
+function extractOrigin(urlWithPossiblePath) {
+	try {
+		const parsed = new URL(urlWithPossiblePath);
+		return `${parsed.protocol}//${parsed.host}`;
+	} catch {
+		return urlWithPossiblePath.replace(/\/$/, "");
+	}
+}
+var RestPayloadsClient = class {
+	authToken;
+	datalakeId;
+	fetchImpl;
+	origin;
+	constructor(options) {
+		this.origin = extractOrigin(options.baseUrl);
+		this.datalakeId = options.datalakeId;
+		this.authToken = options.authToken;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+	}
+	async clear() {
+		return this.request(datalakePlaneClearPath(this.datalakeId), { method: "POST" });
+	}
+	async delete(hash) {
+		await this.request(datalakePlaneDeletePath(this.datalakeId, hash), { method: "DELETE" });
+	}
+	async get(hash) {
+		return this.request(datalakePlaneGetPath(this.datalakeId, hash));
+	}
+	async getMany(hashes) {
+		if (hashes.length === 0) return [];
+		return this.request(datalakePlaneGetManyPath(this.datalakeId), {
+			method: "POST",
+			body: hashes
+		});
+	}
+	async insert(payloads) {
+		const body = payloads;
+		const { data, headers } = await this.requestWithHeaders(datalakePlaneInsertPath(this.datalakeId), {
+			method: "POST",
+			body
+		});
+		return {
+			inserted: data,
+			summary: readInsertSummary(headers)
+		};
+	}
+	async next(options = {}) {
+		const params = new URLSearchParams();
+		if (options.limit !== void 0) params.set("limit", String(options.limit));
+		if (options.cursor) params.set("cursor", options.cursor);
+		if (options.schemas && options.schemas.length > 0) params.set("schemas", options.schemas.join(","));
+		if (options.order) params.set("order", options.order);
+		const suffix = params.toString();
+		const path4 = suffix ? `${datalakePlaneNextPath(this.datalakeId)}?${suffix}` : datalakePlaneNextPath(this.datalakeId);
+		const { data, headers } = await this.requestWithHeaders(path4);
+		return {
+			payloads: data,
+			nextCursor: headers.get("x-datalake-next-cursor") ?? void 0
+		};
+	}
+	async usage() {
+		return this.request(datalakePlaneUsagePath(this.datalakeId));
+	}
+	async request(path4, options = {}) {
+		const { data } = await this.requestWithHeaders(path4, options);
+		return data;
+	}
+	async requestWithHeaders(path4, options = {}) {
+		const method = options.method ?? "GET";
+		const headers = {
+			accept: "application/json",
+			authorization: `Bearer ${await this.resolveAuthToken()}`
+		};
+		const init = {
+			method,
+			headers
+		};
+		if (options.body !== void 0) {
+			headers["content-type"] = "application/json";
+			init.body = JSON.stringify(options.body);
+		}
+		const response = await this.fetchImpl(`${this.origin}${path4}`, init);
+		if (response.status === 204) return {
+			data: void 0,
+			headers: response.headers
+		};
+		const text = await response.text();
+		const payload = text.length > 0 ? JSON.parse(text) : void 0;
+		if (!response.ok) {
+			const errorBody = isApiErrorBody2(payload) ? payload : {
+				code: "internal",
+				message: `Unexpected ${response.status} response from ${method} ${path4}`
+			};
+			throw new DatalakeApiError(response.status, errorBody);
+		}
+		return {
+			data: payload,
+			headers: response.headers
+		};
+	}
+	async resolveAuthToken() {
+		return typeof this.authToken === "function" ? await this.authToken() : this.authToken;
+	}
+};
+function readInsertSummary(headers) {
+	const duplicatesRaw = headers.get(DATALAKE_HEADER_DUPLICATES);
+	const duplicates = duplicatesRaw === null ? 0 : Number.parseInt(duplicatesRaw, 10);
+	const rejectedRaw = headers.get(DATALAKE_HEADER_REJECTED);
+	const rejected = rejectedRaw === null || rejectedRaw.length === 0 ? [] : rejectedRaw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+	return {
+		duplicates: Number.isFinite(duplicates) ? duplicates : 0,
+		rejected
+	};
+}
+function isApiErrorBody2(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	return typeof maybe.code === "string" && typeof maybe.message === "string";
+}
+//#endregion
+export { LocalDatalakeClient, RestDatalakeClient, RestPayloadsClient, clearCredentials, clearDefaultDatalake, createDatalakeClient, getCredentialsLocation, getDefaultDatalake, loadCredentials, saveCredentials, setDefaultDatalake };