@slates/profiles 1.0.0-rc.2

package/dist/index.cjs

@@ -0,0 +1,445 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SlatesCliStore: () => SlatesCliStore,
+  createSlatesClientFromProfile: () => createSlatesClientFromProfile,
+  openSlatesCliStore: () => openSlatesCliStore,
+  resolveSlatesCliDir: () => resolveSlatesCliDir,
+  resolveSlatesCliProfilesDir: () => resolveSlatesCliProfilesDir,
+  resolveSlatesCliRoot: () => resolveSlatesCliRoot
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_client = require("@slates/client");
+var import_path2 = __toESM(require("path"), 1);
+var import_url = require("url");
+
+// src/store.ts
+var import_child_process = require("child_process");
+var import_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_path = __toESM(require("path"), 1);
+var STORE_VERSION = 3;
+var CLI_DIR_NAME = ".slates-cli";
+var PROFILES_DIR_NAME = "profiles";
+var STORE_FILE_NAME = "store.json";
+var GITIGNORE_FILE_NAME = ".gitignore";
+var createEmptyStore = () => ({
+  version: STORE_VERSION,
+  currentProfileId: null,
+  profiles: {},
+  oauthCredentials: {}
+});
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var ensureDir = async (dirPath) => {
+  await (0, import_promises.mkdir)(dirPath, { recursive: true });
+};
+var ensureGitIgnore = async (dirPath) => {
+  let filePath = import_path.default.join(dirPath, GITIGNORE_FILE_NAME);
+  await (0, import_promises.writeFile)(filePath, "*\n!.gitignore\n", { encoding: "utf-8" }).catch(async (error) => {
+    if (error.code === "EEXIST") return;
+    throw error;
+  });
+};
+var resolveSlatesCliRoot = (cwd = process.cwd()) => {
+  try {
+    return (0, import_child_process.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return cwd;
+  }
+};
+var resolveSlatesCliDir = (cwd = process.cwd()) => import_path.default.join(resolveSlatesCliRoot(cwd), CLI_DIR_NAME);
+var resolveSlatesCliProfilesDir = (cwd = process.cwd()) => import_path.default.join(resolveSlatesCliDir(cwd), PROFILES_DIR_NAME);
+var normalizeScopeKey = (scopeKey) => import_path.default.posix.normalize(scopeKey.replace(/\\/g, "/")).replace(/^\.?\//, "");
+var splitScopeKey = (scopeKey) => normalizeScopeKey(scopeKey).split("/").filter(Boolean).filter((segment) => segment !== "." && segment !== "..");
+var resolveScopedStoreDir = (rootDir, scopeKey) => import_path.default.join(resolveSlatesCliProfilesDir(rootDir), ...splitScopeKey(scopeKey));
+var resolveScopedStorePath = (rootDir, scopeKey) => import_path.default.join(resolveScopedStoreDir(rootDir, scopeKey), STORE_FILE_NAME);
+var inferRootDirFromStorePath = (storePath) => {
+  let normalized = import_path.default.resolve(storePath);
+  let parts = normalized.split(import_path.default.sep).filter(Boolean);
+  let cliDirIndex = parts.lastIndexOf(CLI_DIR_NAME);
+  if (cliDirIndex === -1) {
+    throw new Error(`Could not infer Slates CLI root from store path: ${storePath}`);
+  }
+  let rootParts = parts.slice(0, cliDirIndex);
+  return import_path.default.join(import_path.default.sep, ...rootParts);
+};
+var resolveScopeKeyFromStorePath = (rootDir, storePath) => {
+  let profilesDir = resolveSlatesCliProfilesDir(rootDir);
+  let relativeDir = import_path.default.relative(profilesDir, import_path.default.dirname(storePath));
+  if (!relativeDir || relativeDir.startsWith("..") || import_path.default.isAbsolute(relativeDir)) {
+    return null;
+  }
+  return normalizeScopeKey(relativeDir);
+};
+var readStoreData = async (storePath) => {
+  try {
+    let raw = await (0, import_promises.readFile)(storePath, "utf-8");
+    if (!raw.trim()) {
+      return null;
+    }
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+var isProfileInScope = (rootDir, scopeKey, profile) => {
+  if (profile.target.type !== "local") {
+    return false;
+  }
+  let scopeDir = import_path.default.resolve(rootDir, ...splitScopeKey(scopeKey));
+  let entryPath = import_path.default.isAbsolute(profile.target.entry) ? profile.target.entry : import_path.default.resolve(rootDir, profile.target.entry);
+  let relative = import_path.default.relative(scopeDir, entryPath);
+  return relative !== "" && !relative.startsWith("..") && !import_path.default.isAbsolute(relative);
+};
+var loadMigratedLegacyStore = async (rootDir, scopeKey) => {
+  let legacyStorePath = import_path.default.join(resolveSlatesCliDir(rootDir), STORE_FILE_NAME);
+  let legacy = await readStoreData(legacyStorePath);
+  if (!legacy) {
+    return createEmptyStore();
+  }
+  let profiles = Object.fromEntries(
+    Object.entries(legacy.profiles ?? {}).filter(
+      ([, profile]) => isProfileInScope(rootDir, scopeKey, profile)
+    )
+  );
+  let currentProfileId = legacy.currentProfileId && profiles[legacy.currentProfileId] ? legacy.currentProfileId : null;
+  return {
+    version: STORE_VERSION,
+    currentProfileId,
+    profiles,
+    oauthCredentials: {}
+  };
+};
+var SlatesCliStore = class _SlatesCliStore {
+  constructor(rootDir, dirPath, storePath, scope, data) {
+    this.rootDir = rootDir;
+    this.dirPath = dirPath;
+    this.storePath = storePath;
+    this.scope = scope;
+    this.data = data;
+  }
+  rootDir;
+  dirPath;
+  storePath;
+  scope;
+  data;
+  static async open(opts = {}) {
+    let rootDir = opts.storePath ? inferRootDirFromStorePath(opts.storePath) : resolveSlatesCliRoot(opts.cwd);
+    let cliDir = resolveSlatesCliDir(rootDir);
+    let scopeKey = opts.storePath ? resolveScopeKeyFromStorePath(rootDir, opts.storePath) : opts.scope?.key ? normalizeScopeKey(opts.scope.key) : null;
+    let dirPath = opts.storePath ? import_path.default.dirname(opts.storePath) : scopeKey ? resolveScopedStoreDir(rootDir, scopeKey) : cliDir;
+    let storePath = opts.storePath ?? (scopeKey ? resolveScopedStorePath(rootDir, scopeKey) : import_path.default.join(cliDir, STORE_FILE_NAME));
+    await ensureDir(cliDir);
+    await ensureGitIgnore(cliDir);
+    await ensureDir(dirPath);
+    let parsed = await readStoreData(storePath);
+    let data = parsed ? {
+      version: STORE_VERSION,
+      currentProfileId: parsed.currentProfileId ?? null,
+      profiles: parsed.profiles ?? {},
+      oauthCredentials: parsed.oauthCredentials ?? {}
+    } : scopeKey ? await loadMigratedLegacyStore(rootDir, scopeKey) : createEmptyStore();
+    if (!parsed) {
+      await (0, import_promises.writeFile)(storePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    }
+    return new _SlatesCliStore(
+      rootDir,
+      dirPath,
+      storePath,
+      scopeKey ? { key: scopeKey, name: opts.scope?.name } : null,
+      data
+    );
+  }
+  async save() {
+    await ensureDir(this.dirPath);
+    await ensureDir(resolveSlatesCliDir(this.rootDir));
+    await ensureGitIgnore(resolveSlatesCliDir(this.rootDir));
+    await (0, import_promises.writeFile)(this.storePath, JSON.stringify(this.data, null, 2) + "\n", "utf-8");
+  }
+  listProfiles() {
+    return Object.values(this.data.profiles).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  listOAuthCredentials(authMethodId) {
+    return Object.values(this.data.oauthCredentials).filter((credential) => !authMethodId || credential.authMethodId === authMethodId).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  getOAuthCredential(credentialId, authMethodId) {
+    if (credentialId) {
+      let direct = this.data.oauthCredentials[credentialId];
+      if (direct && (!authMethodId || direct.authMethodId === authMethodId)) {
+        return direct;
+      }
+      let matches = this.listOAuthCredentials(authMethodId ?? void 0).filter(
+        (credential) => credential.name === credentialId
+      );
+      if (matches.length === 1) {
+        return matches[0];
+      }
+    }
+    return this.listOAuthCredentials(authMethodId ?? void 0)[0] ?? null;
+  }
+  getProfile(profileId) {
+    if (profileId) {
+      if (this.data.profiles[profileId]) {
+        return this.data.profiles[profileId] ?? null;
+      }
+      let matches = this.listProfiles().filter((profile) => profile.name === profileId);
+      if (matches.length === 1) {
+        return matches[0];
+      }
+    }
+    if (this.data.currentProfileId && this.data.profiles[this.data.currentProfileId]) {
+      return this.data.profiles[this.data.currentProfileId];
+    }
+    return this.listProfiles()[0] ?? null;
+  }
+  requireProfile(profileId) {
+    let profile = this.getProfile(profileId);
+    if (!profile) {
+      throw new Error("No Slates profile found for this integration.");
+    }
+    return profile;
+  }
+  upsertProfile(d) {
+    let existing = d.profileId ? this.data.profiles[d.profileId] : void 0;
+    let id = existing?.id ?? d.profileId ?? (0, import_crypto.randomUUID)();
+    let createdAt = existing?.createdAt ?? now();
+    let profile = {
+      id,
+      name: d.name,
+      target: d.target,
+      config: d.config ?? existing?.config ?? null,
+      auth: existing?.auth ?? {},
+      session: d.session ?? existing?.session ?? null,
+      metadata: {
+        provider: d.metadata?.provider ?? existing?.metadata?.provider ?? null,
+        actions: d.metadata?.actions ?? existing?.metadata?.actions ?? null
+      },
+      createdAt,
+      updatedAt: now()
+    };
+    this.data.profiles[id] = profile;
+    if (!this.data.currentProfileId) {
+      this.data.currentProfileId = id;
+    }
+    return profile;
+  }
+  upsertOAuthCredential(d) {
+    let existing = d.credentialId ? this.data.oauthCredentials[d.credentialId] : void 0;
+    let id = existing?.id ?? d.credentialId ?? (0, import_crypto.randomUUID)();
+    let credential = {
+      id,
+      name: d.name,
+      authMethodId: d.authMethodId,
+      clientId: d.clientId,
+      clientSecret: d.clientSecret,
+      createdAt: existing?.createdAt ?? now(),
+      updatedAt: now()
+    };
+    this.data.oauthCredentials[id] = credential;
+    return credential;
+  }
+  setCurrentProfile(profileId) {
+    if (!this.data.profiles[profileId]) {
+      throw new Error(`Unknown profile: ${profileId}`);
+    }
+    this.data.currentProfileId = profileId;
+  }
+  removeProfile(profileId) {
+    delete this.data.profiles[profileId];
+    if (this.data.currentProfileId === profileId) {
+      this.data.currentProfileId = this.listProfiles()[0]?.id ?? null;
+    }
+  }
+  setProfileConfig(profileId, config) {
+    let profile = this.requireProfile(profileId);
+    profile.config = config;
+    profile.updatedAt = now();
+    return profile;
+  }
+  setProfileSession(profileId, session) {
+    let profile = this.requireProfile(profileId);
+    profile.session = session;
+    profile.updatedAt = now();
+    return profile;
+  }
+  setProfileMetadata(profileId, metadata) {
+    let profile = this.requireProfile(profileId);
+    profile.metadata = {
+      provider: metadata.provider ?? profile.metadata.provider ?? null,
+      actions: metadata.actions ?? profile.metadata.actions ?? null
+    };
+    profile.updatedAt = now();
+    return profile;
+  }
+  upsertAuth(profileId, auth) {
+    let profile = this.requireProfile(profileId);
+    let existing = profile.auth[auth.authMethodId];
+    profile.auth[auth.authMethodId] = {
+      ...auth,
+      id: auth.id ?? existing?.id ?? (0, import_crypto.randomUUID)(),
+      createdAt: existing?.createdAt ?? now(),
+      updatedAt: now()
+    };
+    profile.updatedAt = now();
+    return profile.auth[auth.authMethodId];
+  }
+  getAuth(profileId, authMethodId) {
+    let profile = this.requireProfile(profileId);
+    if (authMethodId) return profile.auth[authMethodId] ?? null;
+    return Object.values(profile.auth)[0] ?? null;
+  }
+  listAuth(profileId) {
+    let profile = this.requireProfile(profileId);
+    return Object.values(profile.auth).sort(
+      (a, b) => a.authMethodId.localeCompare(b.authMethodId)
+    );
+  }
+};
+var openSlatesCliStore = async (opts = {}) => SlatesCliStore.open(opts);
+
+// src/client.ts
+var resolveEntryPath = (entry, cwd) => {
+  if (import_path2.default.isAbsolute(entry)) return entry;
+  return import_path2.default.resolve(resolveSlatesCliRoot(cwd), entry);
+};
+var loadSlateFromProfile = async (profile, cwd) => {
+  if (profile.target.type !== "local") {
+    throw new Error(`Unsupported profile target type: ${profile.target.type}`);
+  }
+  let modulePath = resolveEntryPath(profile.target.entry, cwd);
+  let loaded = await import((0, import_url.pathToFileURL)(modulePath).href);
+  let exportName = profile.target.exportName;
+  let slate = (exportName ? loaded[exportName] : void 0) ?? loaded.provider ?? loaded.slate ?? loaded.default;
+  if (!slate) {
+    throw new Error(
+      `Could not find a slate export in ${profile.target.entry}. Tried ${exportName ? `\`${exportName}\`, ` : ""}\`provider\`, \`slate\`, and \`default\`.`
+    );
+  }
+  return slate;
+};
+var createSlatesClientFromProfile = async (profile, opts = {}) => {
+  let firstAuth = Object.values(profile.auth)[0];
+  let slate = await loadSlateFromProfile(profile, opts.cwd);
+  let client = (0, import_client.createSlatesClient)({
+    transport: (0, import_client.createLocalSlateTransport)({ slate }),
+    state: {
+      config: profile.config,
+      session: profile.session,
+      auth: firstAuth ? {
+        authenticationMethodId: firstAuth.authMethodId,
+        output: firstAuth.output
+      } : null
+    }
+  });
+  if (firstAuth) {
+    attachAutoRefresh(client, profile, firstAuth, opts.store);
+  }
+  return client;
+};
+var EXPIRY_BUFFER_MS = 60 * 1e3;
+var shouldRefreshOAuthAuth = (auth) => {
+  if (auth.authType !== "auth.oauth") return false;
+  if (!auth.clientId || !auth.clientSecret) return false;
+  if (typeof auth.output?.refreshToken !== "string" || !auth.output.refreshToken) return false;
+  if (typeof auth.output?.expiresAt !== "string" || !auth.output.expiresAt) return false;
+  let expiresAt = Date.parse(auth.output.expiresAt);
+  return Number.isFinite(expiresAt) && expiresAt <= Date.now() + EXPIRY_BUFFER_MS;
+};
+var attachAutoRefresh = (client, profile, storedAuth, store) => {
+  let baseRequest = client.request.bind(client);
+  let inflightRefresh = null;
+  let refreshIfNeeded = async () => {
+    if (inflightRefresh) {
+      await inflightRefresh;
+      return;
+    }
+    if (!shouldRefreshOAuthAuth(storedAuth)) {
+      return;
+    }
+    inflightRefresh = (async () => {
+      let authMethod = await baseRequest("slates/auth.method.get", {
+        authenticationMethodId: storedAuth.authMethodId
+      });
+      if (!authMethod.authenticationMethod.capabilities.handleTokenRefresh?.enabled) {
+        return;
+      }
+      let refreshed = await baseRequest("slates/auth.token_refresh.handle", {
+        authenticationMethodId: storedAuth.authMethodId,
+        output: storedAuth.output,
+        input: storedAuth.input,
+        clientId: storedAuth.clientId ?? "",
+        clientSecret: storedAuth.clientSecret ?? "",
+        scopes: storedAuth.scopes
+      });
+      storedAuth.input = refreshed.input ?? storedAuth.input;
+      storedAuth.output = refreshed.output;
+      storedAuth.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      client.setAuth({
+        authenticationMethodId: storedAuth.authMethodId,
+        output: storedAuth.output
+      });
+      if (store) {
+        store.upsertAuth(profile.id, storedAuth);
+        await store.save();
+      }
+    })();
+    try {
+      await inflightRefresh;
+    } finally {
+      inflightRefresh = null;
+    }
+  };
+  client.request = (async (method, params) => {
+    if (method !== "slates/auth.token_refresh.handle") {
+      await refreshIfNeeded();
+    }
+    return baseRequest(method, params);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SlatesCliStore,
+  createSlatesClientFromProfile,
+  openSlatesCliStore,
+  resolveSlatesCliDir,
+  resolveSlatesCliProfilesDir,
+  resolveSlatesCliRoot
+});

package/dist/index.d.cts

@@ -0,0 +1,122 @@
+import * as _slates_client from '@slates/client';
+import { SlatesJsonObject } from '@slates/client';
+import { SlateAuthenticationMethod, SlatesAction } from '@slates/proto';
+
+interface SlatesStoredAuth {
+    id: string;
+    authMethodId: string;
+    authMethodName?: string;
+    authType: SlateAuthenticationMethod['type'];
+    input: SlatesJsonObject;
+    output: SlatesJsonObject;
+    scopes: string[];
+    oauthCredentialId?: string;
+    clientId?: string;
+    clientSecret?: string;
+    callbackState?: SlatesJsonObject | null;
+    profile?: SlatesJsonObject | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesOAuthCredentialRecord {
+    id: string;
+    name: string;
+    authMethodId: string;
+    clientId: string;
+    clientSecret: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesLocalProfileTarget {
+    type: 'local';
+    entry: string;
+    exportName?: string;
+}
+type SlatesProfileTarget = SlatesLocalProfileTarget;
+interface SlatesCliStoreScope {
+    key: string;
+    name?: string;
+}
+interface SlatesProfileRecord {
+    id: string;
+    name: string;
+    target: SlatesProfileTarget;
+    config: SlatesJsonObject | null;
+    auth: Record<string, SlatesStoredAuth>;
+    session: {
+        id: string;
+        state: SlatesJsonObject;
+    } | null;
+    metadata: {
+        provider?: SlatesJsonObject | null;
+        actions?: SlatesAction[] | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesCliStoreData {
+    version: 3;
+    currentProfileId: string | null;
+    profiles: Record<string, SlatesProfileRecord>;
+    oauthCredentials: Record<string, SlatesOAuthCredentialRecord>;
+}
+
+declare let resolveSlatesCliRoot: (cwd?: string) => string;
+declare let resolveSlatesCliDir: (cwd?: string) => string;
+declare let resolveSlatesCliProfilesDir: (cwd?: string) => string;
+declare class SlatesCliStore {
+    readonly rootDir: string;
+    readonly dirPath: string;
+    readonly storePath: string;
+    readonly scope: SlatesCliStoreScope | null;
+    readonly data: SlatesCliStoreData;
+    constructor(rootDir: string, dirPath: string, storePath: string, scope: SlatesCliStoreScope | null, data: SlatesCliStoreData);
+    static open(opts?: {
+        cwd?: string;
+        scope?: SlatesCliStoreScope;
+        storePath?: string;
+    }): Promise<SlatesCliStore>;
+    save(): Promise<void>;
+    listProfiles(): SlatesProfileRecord[];
+    listOAuthCredentials(authMethodId?: string): SlatesOAuthCredentialRecord[];
+    getOAuthCredential(credentialId?: string | null, authMethodId?: string | null): SlatesOAuthCredentialRecord;
+    getProfile(profileId?: string | null): SlatesProfileRecord;
+    requireProfile(profileId?: string | null): SlatesProfileRecord;
+    upsertProfile(d: {
+        profileId?: string;
+        name: string;
+        target: SlatesProfileTarget;
+        config?: SlatesProfileRecord['config'];
+        session?: SlatesProfileRecord['session'];
+        metadata?: SlatesProfileRecord['metadata'];
+    }): SlatesProfileRecord;
+    upsertOAuthCredential(d: {
+        credentialId?: string;
+        name: string;
+        authMethodId: string;
+        clientId: string;
+        clientSecret: string;
+    }): SlatesOAuthCredentialRecord;
+    setCurrentProfile(profileId: string): void;
+    removeProfile(profileId: string): void;
+    setProfileConfig(profileId: string, config: SlatesProfileRecord['config']): SlatesProfileRecord;
+    setProfileSession(profileId: string, session: SlatesProfileRecord['session']): SlatesProfileRecord;
+    setProfileMetadata(profileId: string, metadata: Partial<SlatesProfileRecord['metadata']>): SlatesProfileRecord;
+    upsertAuth(profileId: string, auth: Omit<SlatesStoredAuth, 'id' | 'createdAt' | 'updatedAt'> & {
+        id?: string;
+    }): SlatesStoredAuth;
+    getAuth(profileId: string, authMethodId?: string | null): SlatesStoredAuth;
+    listAuth(profileId: string): SlatesStoredAuth[];
+}
+declare let openSlatesCliStore: (opts?: {
+    cwd?: string;
+    scope?: SlatesCliStoreScope;
+    storePath?: string;
+}) => Promise<SlatesCliStore>;
+
+declare let createSlatesClientFromProfile: (profile: SlatesProfileRecord, opts?: {
+    cwd?: string;
+    store?: SlatesCliStore;
+}) => Promise<_slates_client.SlatesProtocolClient>;
+
+export { SlatesCliStore, type SlatesCliStoreData, type SlatesCliStoreScope, type SlatesLocalProfileTarget, type SlatesOAuthCredentialRecord, type SlatesProfileRecord, type SlatesProfileTarget, type SlatesStoredAuth, createSlatesClientFromProfile, openSlatesCliStore, resolveSlatesCliDir, resolveSlatesCliProfilesDir, resolveSlatesCliRoot };

package/dist/index.d.ts

@@ -0,0 +1,122 @@
+import * as _slates_client from '@slates/client';
+import { SlatesJsonObject } from '@slates/client';
+import { SlateAuthenticationMethod, SlatesAction } from '@slates/proto';
+
+interface SlatesStoredAuth {
+    id: string;
+    authMethodId: string;
+    authMethodName?: string;
+    authType: SlateAuthenticationMethod['type'];
+    input: SlatesJsonObject;
+    output: SlatesJsonObject;
+    scopes: string[];
+    oauthCredentialId?: string;
+    clientId?: string;
+    clientSecret?: string;
+    callbackState?: SlatesJsonObject | null;
+    profile?: SlatesJsonObject | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesOAuthCredentialRecord {
+    id: string;
+    name: string;
+    authMethodId: string;
+    clientId: string;
+    clientSecret: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesLocalProfileTarget {
+    type: 'local';
+    entry: string;
+    exportName?: string;
+}
+type SlatesProfileTarget = SlatesLocalProfileTarget;
+interface SlatesCliStoreScope {
+    key: string;
+    name?: string;
+}
+interface SlatesProfileRecord {
+    id: string;
+    name: string;
+    target: SlatesProfileTarget;
+    config: SlatesJsonObject | null;
+    auth: Record<string, SlatesStoredAuth>;
+    session: {
+        id: string;
+        state: SlatesJsonObject;
+    } | null;
+    metadata: {
+        provider?: SlatesJsonObject | null;
+        actions?: SlatesAction[] | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesCliStoreData {
+    version: 3;
+    currentProfileId: string | null;
+    profiles: Record<string, SlatesProfileRecord>;
+    oauthCredentials: Record<string, SlatesOAuthCredentialRecord>;
+}
+
+declare let resolveSlatesCliRoot: (cwd?: string) => string;
+declare let resolveSlatesCliDir: (cwd?: string) => string;
+declare let resolveSlatesCliProfilesDir: (cwd?: string) => string;
+declare class SlatesCliStore {
+    readonly rootDir: string;
+    readonly dirPath: string;
+    readonly storePath: string;
+    readonly scope: SlatesCliStoreScope | null;
+    readonly data: SlatesCliStoreData;
+    constructor(rootDir: string, dirPath: string, storePath: string, scope: SlatesCliStoreScope | null, data: SlatesCliStoreData);
+    static open(opts?: {
+        cwd?: string;
+        scope?: SlatesCliStoreScope;
+        storePath?: string;
+    }): Promise<SlatesCliStore>;
+    save(): Promise<void>;
+    listProfiles(): SlatesProfileRecord[];
+    listOAuthCredentials(authMethodId?: string): SlatesOAuthCredentialRecord[];
+    getOAuthCredential(credentialId?: string | null, authMethodId?: string | null): SlatesOAuthCredentialRecord;
+    getProfile(profileId?: string | null): SlatesProfileRecord;
+    requireProfile(profileId?: string | null): SlatesProfileRecord;
+    upsertProfile(d: {
+        profileId?: string;
+        name: string;
+        target: SlatesProfileTarget;
+        config?: SlatesProfileRecord['config'];
+        session?: SlatesProfileRecord['session'];
+        metadata?: SlatesProfileRecord['metadata'];
+    }): SlatesProfileRecord;
+    upsertOAuthCredential(d: {
+        credentialId?: string;
+        name: string;
+        authMethodId: string;
+        clientId: string;
+        clientSecret: string;
+    }): SlatesOAuthCredentialRecord;
+    setCurrentProfile(profileId: string): void;
+    removeProfile(profileId: string): void;
+    setProfileConfig(profileId: string, config: SlatesProfileRecord['config']): SlatesProfileRecord;
+    setProfileSession(profileId: string, session: SlatesProfileRecord['session']): SlatesProfileRecord;
+    setProfileMetadata(profileId: string, metadata: Partial<SlatesProfileRecord['metadata']>): SlatesProfileRecord;
+    upsertAuth(profileId: string, auth: Omit<SlatesStoredAuth, 'id' | 'createdAt' | 'updatedAt'> & {
+        id?: string;
+    }): SlatesStoredAuth;
+    getAuth(profileId: string, authMethodId?: string | null): SlatesStoredAuth;
+    listAuth(profileId: string): SlatesStoredAuth[];
+}
+declare let openSlatesCliStore: (opts?: {
+    cwd?: string;
+    scope?: SlatesCliStoreScope;
+    storePath?: string;
+}) => Promise<SlatesCliStore>;
+
+declare let createSlatesClientFromProfile: (profile: SlatesProfileRecord, opts?: {
+    cwd?: string;
+    store?: SlatesCliStore;
+}) => Promise<_slates_client.SlatesProtocolClient>;
+
+export { SlatesCliStore, type SlatesCliStoreData, type SlatesCliStoreScope, type SlatesLocalProfileTarget, type SlatesOAuthCredentialRecord, type SlatesProfileRecord, type SlatesProfileTarget, type SlatesStoredAuth, createSlatesClientFromProfile, openSlatesCliStore, resolveSlatesCliDir, resolveSlatesCliProfilesDir, resolveSlatesCliRoot };