@intuned/runtime 1.3.0 → 1.3.1

package/dist/common/runApi/index.js

@@ -4,13 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
-  runApiGenerator: true,
   runApi: true,
   checkAuthSessionWithRetries: true
 };
 exports.checkAuthSessionWithRetries = checkAuthSessionWithRetries;
 exports.runApi = runApi;
-exports.runApiGenerator = runApiGenerator;
 var _downloadDirectory = require("../../runtime/downloadDirectory");
 var _asyncLocalStorage = require("../asyncLocalStorage");
 var _fsExtra = _interopRequireWildcard(require("fs-extra"));
@@ -30,7 +28,7 @@ Object.keys(_errors).forEach(function (key) {
   });
 });
 var _constants = require("../constants");
-var _getPlaywrightConstructs = require("../getPlaywrightConstructs");
+var _playwrightContext = require("../playwrightContext");
 var _types = require("./types");
 Object.keys(_types).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -45,6 +43,7 @@ Object.keys(_types).forEach(function (key) {
 });
 var _formatZodError = require("../formatZodError");
 var _cleanEnvironmentVariables = require("../cleanEnvironmentVariables");
+var _importUsingImportFunction = require("./importUsingImportFunction");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function getObjectSizeInBytes(obj) {
@@ -54,10 +53,10 @@ function getObjectSizeInBytes(obj) {
     return new TextEncoder().encode(String(obj)).length;
   }
 }
-async function* runApiGenerator({
-  retrieveSession = false,
+async function runApi({
   abortSignal,
   importFunction,
+  retrieveSession = false,
   ...input
 }) {
   let traceStarted = false;
@@ -66,7 +65,10 @@ async function* runApiGenerator({
     return (0, _neverthrow.err)(new _errors.InternalInvalidInputError("Input validation failed", (0, _formatZodError.formatZodError)(inputParseResult.error)));
   }
   const {
-    automationFunction,
+    automationFunction: {
+      name,
+      params
+    },
     runOptions,
     tracing,
     auth
@@ -78,166 +80,108 @@ async function* runApiGenerator({
       resolve(abortSymbol);
     });
   });
-  let context;
-  let downloadsPath;
-  async function saveTraceIfNeeded({
-    errorMessage
-  }) {
-    if (!tracing.enabled || !traceStarted) {
-      return;
-    }
-    try {
-      await context?.tracing.stop({
-        path: tracing.filePath
-      });
-    } catch (error) {
-      console.log(errorMessage, error?.message);
-      await (0, _fsExtra.remove)(tracing.filePath);
-    }
-  }
-  async function* runAutomation() {
-    let page;
-    const validatedModuleResult = await importUsingImportFunction(automationFunction.name, importFunction);
+  async function runAutomation() {
+    const validatedModuleResult = await (0, _importUsingImportFunction.importUsingImportFunction)({
+      path: name,
+      importFunction
+    });
     if (validatedModuleResult.isErr()) {
       return (0, _neverthrow.err)(validatedModuleResult.error);
     }
-    const importedModule = validatedModuleResult.value;
-    let checkFn;
-    if (auth?.runCheck) {
-      if (!auth.session) {
-        return (0, _neverthrow.err)(new _errors.AuthRequiredError());
-      }
-      const checkImportResult = await importUsingImportFunction(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`, importFunction);
-      if (checkImportResult.isErr()) {
-        return (0, _neverthrow.err)(checkImportResult.error);
-      }
-      if (checkImportResult.value.type !== "async") {
-        return (0, _neverthrow.err)(new _errors.InvalidCheckError("Check function is not an async function"));
-      }
-      checkFn = checkImportResult.value.func;
-    }
+    const automationFunction = validatedModuleResult.value;
     if (auth && auth.session.type === "state") {
       const state = auth.session.state;
       if (state === undefined || state === null) {
         return (0, _neverthrow.err)(new _errors.AuthRequiredError());
       }
     }
-    if (runOptions.environment === "standalone") {
-      downloadsPath = (0, _downloadDirectory.getDownloadDirectoryPath)();
-      const {
-        headless,
-        proxy
-      } = runOptions;
-      ({
-        page,
-        context
-      } = await (0, _getPlaywrightConstructs.getProductionPlaywrightConstructs)({
-        headless,
-        proxy,
-        downloadsPath,
-        storageState: auth?.session
-      }));
-    } else {
-      const {
-        mode,
-        cdpAddress
-      } = runOptions;
-      ({
-        page,
-        context
-      } = await (0, _getPlaywrightConstructs.getPlaywrightConstructsForMode)(mode, cdpAddress, auth?.session));
-    }
-    if (tracing.enabled) {
-      await context.tracing.start({
-        screenshots: true,
-        snapshots: true,
-        sources: true
-      });
-      traceStarted = true;
-    }
-    (0, _cleanEnvironmentVariables.cleanEnvironmentVariables)();
-    if (checkFn !== undefined) {
-      try {
-        console.log("Running auth check");
-        const authCheckResult = await checkAuthSessionWithRetries(page, context, checkFn, 2);
-        if (authCheckResult.isErr()) {
-          const error = authCheckResult.error;
-          if (["APINotFoundError", "InvalidAPIError"].includes(error.code)) {
-            return (0, _neverthrow.err)(new _errors.InvalidCheckError(`Auth session check function failed`, error));
-          }
-          return authCheckResult;
+    const playwrightContextParameters = {
+      apiName: name,
+      apiParameters: params,
+      importFunction
+    };
+    const runAutomationWithContext = async (context, page) => {
+      async function saveTraceIfNeeded({
+        errorMessage
+      }) {
+        if (!tracing.enabled || !traceStarted) {
+          return;
         }
-        if (!authCheckResult.value) {
-          return (0, _neverthrow.err)(new _errors.AuthCheckFailedError());
+        try {
+          await context?.tracing.stop({
+            path: tracing.filePath
+          });
+        } catch (error) {
+          console.log(errorMessage, error?.message);
+          await (0, _fsExtra.remove)(tracing.filePath);
         }
-      } catch (error) {
-        return (0, _neverthrow.err)(new _errors.AuthCheckFailedError());
       }
-    }
-    const automationFunctionParameters = [...(automationFunction.params !== undefined ? [automationFunction.params] : []), page, context];
-    let result;
-    if (importedModule.type === "async-generator") {
-      const generator = importedModule.generator(...automationFunctionParameters);
-      let next = undefined;
-      while (true) {
-        const generatorResult = await generator.next(...(next ? [next] : []));
-        if (!generatorResult.done) {
-          next = yield generatorResult.value;
-          continue;
-        }
-        result = generatorResult.value;
-        break;
+      if (auth) {
+        await (0, _playwrightContext.loadSessionToContext)({
+          context,
+          session: auth.session
+        });
       }
-    } else {
-      result = await importedModule.func(...automationFunctionParameters);
-    }
-    const MAX_RESULT_SIZE_BYTES = 2 * 1024 * 1024;
-    const resultSizeInBytes = getObjectSizeInBytes(result);
-    if (resultSizeInBytes > MAX_RESULT_SIZE_BYTES) {
-      return (0, _neverthrow.err)(new _errors.ResultTooBigError(resultSizeInBytes, MAX_RESULT_SIZE_BYTES));
-    }
-    return (0, _neverthrow.ok)({
-      result,
-      extendedPayloads: (0, _asyncLocalStorage.getExecutionContext)()?.extendedPayloads,
-      session: retrieveSession ? await (0, _contextStorageStateHelpers.getStorageState)(context) : undefined
-    });
-  }
-  try {
-    const generator = runAutomation();
-    let next = undefined;
-    while (true) {
-      const result = await Promise.race([generator.next(await next), abortPromise]);
-      if (result === abortSymbol) {
-        return (0, _neverthrow.err)(new _errors.AbortedError());
+      const scriptContent = await fs.readFile(_playwrightContext.browserScriptsFile, "utf-8");
+      await context.addInitScript({
+        content: scriptContent
+      });
+      for (const page of context.pages()) {
+        await page.evaluate(scriptContent);
       }
-      if (!result.done) {
-        next = yield result.value;
-        continue;
+      if (tracing.enabled) {
+        await context.tracing.start({
+          screenshots: true,
+          snapshots: true,
+          sources: true
+        });
+        traceStarted = true;
       }
-      return result.value;
-    }
-  } catch (error) {
-    return (0, _neverthrow.err)(new _errors.AutomationError(error));
-  } finally {
-    await saveTraceIfNeeded({
-      errorMessage: "failed to save trace"
-    });
-    await context?.close();
-    if (downloadsPath !== undefined) {
-      await fs.remove(downloadsPath);
+      (0, _cleanEnvironmentVariables.cleanEnvironmentVariables)();
+      const automationFunctionParameters = [...(params !== undefined ? [params] : []), page, context];
+      const MAX_RESULT_SIZE_BYTES = 2 * 1024 * 1024;
+      const resultSizeInBytes = getObjectSizeInBytes(result);
+      if (resultSizeInBytes > MAX_RESULT_SIZE_BYTES) {
+        return (0, _neverthrow.err)(new _errors.ResultTooBigError(resultSizeInBytes, MAX_RESULT_SIZE_BYTES));
+      }
+      try {
+        return (0, _neverthrow.ok)({
+          result: await automationFunction(...automationFunctionParameters),
+          extendedPayloads: (0, _asyncLocalStorage.getExecutionContext)()?.extendedPayloads,
+          session: retrieveSession ? await (0, _contextStorageStateHelpers.getStorageState)(context) : undefined
+        });
+      } catch (error) {
+        return (0, _neverthrow.err)(new _errors.AutomationError(error));
+      } finally {
+        await saveTraceIfNeeded({
+          errorMessage: "failed to save trace"
+        });
+      }
+    };
+    if (runOptions.environment === "standalone") {
+      const downloadsPath = (0, _downloadDirectory.getDownloadDirectoryPath)();
+      try {
+        return await (0, _playwrightContext.withPlaywrightContext)({
+          headless: runOptions.headless,
+          proxy: runOptions.proxy,
+          downloadsPath,
+          ...playwrightContextParameters
+        }, runAutomationWithContext);
+      } finally {
+        await fs.remove(downloadsPath);
+      }
+    } else {
+      return await (0, _playwrightContext.withPlaywrightContext)({
+        cdpAddress: runOptions.cdpAddress,
+        ...playwrightContextParameters
+      }, runAutomationWithContext);
     }
   }
-}
-async function runApi(params) {
-  const generator = runApiGenerator(params);
-  const {
-    value,
-    done
-  } = await generator.next();
-  if (done) {
-    return value;
+  const result = await Promise.race([await runAutomation(), abortPromise]);
+  if (result === abortSymbol) {
+    return (0, _neverthrow.err)(new _errors.AbortedError());
   }
-  return (0, _neverthrow.err)(new _errors.InvalidApiError("Expected API to be async function, got async generator"));
+  return result;
 }
 async function checkAuthSessionWithRetries(page, context, checkFn, retries = 3) {
   if (retries === 0) {
@@ -251,34 +195,4 @@ async function checkAuthSessionWithRetries(page, context, checkFn, retries = 3)
     tryNumber++;
   }
   return (0, _neverthrow.ok)(false);
-}
-async function importUsingImportFunction(path, importFunction) {
-  try {
-    const importedResult = await importFunction(path);
-    if (importedResult.isErr()) {
-      if (importedResult.error.type === "not_found") {
-        return (0, _neverthrow.err)(new _errors.ApiNotFoundError(path));
-      }
-      return (0, _neverthrow.err)(new _errors.AutomationError(importedResult.error.error));
-    }
-    const imported = importedResult.value;
-    if (!imported || !imported.default || !imported.default.constructor) {
-      return (0, _neverthrow.err)(new _errors.InvalidApiError("API file path does not have a default export"));
-    }
-    if (imported.default.constructor.name === "AsyncGeneratorFunction") {
-      return (0, _neverthrow.ok)({
-        type: "async-generator",
-        generator: imported.default
-      });
-    }
-    if (imported.default.constructor.name === "AsyncFunction") {
-      return (0, _neverthrow.ok)({
-        type: "async",
-        func: imported.default
-      });
-    }
-    return (0, _neverthrow.err)(new _errors.InvalidApiError("API file path does not have a default async function/generator export"));
-  } catch (error) {
-    return (0, _neverthrow.err)(new _errors.AutomationError(error));
-  }
 }

package/dist/common/runApi/types.d.ts

@@ -580,7 +580,6 @@ export declare const runApiParametersSchema: z.ZodObject<{
                 }[] | undefined;
             } | null | undefined;
         }>]>;
-        runCheck: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         session: {
             path: string;
@@ -614,7 +613,6 @@ export declare const runApiParametersSchema: z.ZodObject<{
                 }[] | undefined;
             } | null | undefined;
         };
-        runCheck: boolean;
     }, {
         session: {
             path: string;
@@ -648,7 +646,6 @@ export declare const runApiParametersSchema: z.ZodObject<{
                 }[] | undefined;
             } | null | undefined;
         };
-        runCheck?: boolean | undefined;
     }>>;
     runOptions: z.ZodDefault<z.ZodDiscriminatedUnion<"environment", [z.ZodObject<{
         environment: z.ZodLiteral<"standalone">;
@@ -676,12 +673,12 @@ export declare const runApiParametersSchema: z.ZodObject<{
         } | undefined;
     }, {
         environment: "standalone";
-        headless?: boolean | undefined;
         proxy?: {
             server: string;
             username: string;
             password: string;
         } | undefined;
+        headless?: boolean | undefined;
     }>, z.ZodObject<{
         environment: z.ZodLiteral<"cdp">;
         cdpAddress: z.ZodString;
@@ -754,7 +751,6 @@ export declare const runApiParametersSchema: z.ZodObject<{
                 }[] | undefined;
             } | null | undefined;
         };
-        runCheck: boolean;
     } | undefined;
 }, {
     automationFunction: {
@@ -800,16 +796,15 @@ export declare const runApiParametersSchema: z.ZodObject<{
                 }[] | undefined;
             } | null | undefined;
         };
-        runCheck?: boolean | undefined;
     } | undefined;
     runOptions?: {
         environment: "standalone";
-        headless?: boolean | undefined;
         proxy?: {
             server: string;
             username: string;
             password: string;
         } | undefined;
+        headless?: boolean | undefined;
     } | {
         mode: "vanilla" | "playwright" | "playwright-standalone" | "playwright-headless";
         environment: "cdp";
@@ -837,3 +832,4 @@ export type RunApiResultWithSessionOk<R = any> = RunApiResultOk<R> & {
     session: RunApiStorageState;
 };
 export type RunApiResult<R = any, FullResult extends RunApiResultOk<R> = RunApiResultOk<R>> = Result<FullResult, RunAutomationError>;
+export type { ImportFunction } from "./importUsingImportFunction";

package/dist/common/runApi/types.js

@@ -53,8 +53,7 @@ const runApiParametersSchema = exports.runApiParametersSchema = _zod.default.obj
     enabled: false
   }),
   auth: _zod.default.object({
-    session: runApiSessionSchema,
-    runCheck: _zod.default.boolean().default(false)
+    session: runApiSessionSchema
   }).optional(),
   runOptions: _zod.default.discriminatedUnion("environment", [_zod.default.object({
     environment: _zod.default.literal("standalone"),

package/dist/common/setupContextHook.d.ts

@@ -0,0 +1,17 @@
+import type * as playwright from "playwright";
+import { type RunAutomationError } from "./runApi/errors";
+import { type Err, type Ok } from "neverthrow";
+import { type ImportFunction } from "./runApi/importUsingImportFunction";
+export type InitializeContextHookOptions = {
+    apiName: string;
+    apiParameters: any;
+    cdpUrl: string;
+};
+export type SetupContextHook = (options: InitializeContextHookOptions) => Promise<{
+    page: playwright.Page | null;
+    context: playwright.BrowserContext;
+    cleanup?: () => Promise<void>;
+} | null>;
+export declare function loadSetupContextHook({ importFunction, }: {
+    importFunction: ImportFunction;
+}): Promise<Ok<SetupContextHook | null, any> | Err<any, RunAutomationError>>;

package/dist/common/setupContextHook.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadSetupContextHook = loadSetupContextHook;
+var _errors = require("./runApi/errors");
+var _neverthrow = require("neverthrow");
+var _importUsingImportFunction = require("./runApi/importUsingImportFunction");
+const setupContextHookPath = "hooks/setupContext";
+async function loadSetupContextHook({
+  importFunction
+}) {
+  const importedFunctionResult = await (0, _importUsingImportFunction.importUsingImportFunction)({
+    path: setupContextHookPath,
+    importFunction
+  });
+  if (importedFunctionResult.isErr() && importedFunctionResult.error instanceof _errors.ApiNotFoundError) {
+    return (0, _neverthrow.ok)(null);
+  }
+  return importedFunctionResult;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { extendPayload, extendTimeout, runInfo, RunError, requestMultipleChoice, requestOTP, getAuthSessionParameters, } from "./runtime";
+export { extendPayload, extendTimeout, runInfo, RunError, getAuthSessionParameters, attemptStore, } from "./runtime";
 export { runWithContext, getExecutionContext, } from "./common/asyncLocalStorage";
 export { getDownloadDirectoryPath } from "./runtime/downloadDirectory";
-export { getProductionPlaywrightConstructs } from "./common/getPlaywrightConstructs";
+export { withPlaywrightContext } from "./common/playwrightContext";

package/dist/index.js

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "RunError", {
     return _runtime.RunError;
   }
 });
+Object.defineProperty(exports, "attemptStore", {
+  enumerable: true,
+  get: function () {
+    return _runtime.attemptStore;
+  }
+});
 Object.defineProperty(exports, "extendPayload", {
   enumerable: true,
   get: function () {
@@ -39,24 +45,6 @@ Object.defineProperty(exports, "getExecutionContext", {
     return _asyncLocalStorage.getExecutionContext;
   }
 });
-Object.defineProperty(exports, "getProductionPlaywrightConstructs", {
-  enumerable: true,
-  get: function () {
-    return _getPlaywrightConstructs.getProductionPlaywrightConstructs;
-  }
-});
-Object.defineProperty(exports, "requestMultipleChoice", {
-  enumerable: true,
-  get: function () {
-    return _runtime.requestMultipleChoice;
-  }
-});
-Object.defineProperty(exports, "requestOTP", {
-  enumerable: true,
-  get: function () {
-    return _runtime.requestOTP;
-  }
-});
 Object.defineProperty(exports, "runInfo", {
   enumerable: true,
   get: function () {
@@ -69,7 +57,13 @@ Object.defineProperty(exports, "runWithContext", {
     return _asyncLocalStorage.runWithContext;
   }
 });
+Object.defineProperty(exports, "withPlaywrightContext", {
+  enumerable: true,
+  get: function () {
+    return _playwrightContext.withPlaywrightContext;
+  }
+});
 var _runtime = require("./runtime");
 var _asyncLocalStorage = require("./common/asyncLocalStorage");
 var _downloadDirectory = require("./runtime/downloadDirectory");
-var _getPlaywrightConstructs = require("./common/getPlaywrightConstructs");
+var _playwrightContext = require("./common/playwrightContext");

package/dist/runtime/attemptStore.d.ts

@@ -0,0 +1,2 @@
+import { Store } from "./export";
+export declare const attemptStore: Store;

package/dist/runtime/attemptStore.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attemptStore = void 0;
+var _asyncLocalStorage = require("../common/asyncLocalStorage");
+const attemptStore = exports.attemptStore = Object.freeze({
+  get: key => {
+    const context = (0, _asyncLocalStorage.getExecutionContext)();
+    return context?.store ? context.store[key] : undefined;
+  },
+  set: (key, value) => {
+    const context = (0, _asyncLocalStorage.getExecutionContext)();
+    if (!context) {
+      throw new Error("store.set failed due to an internal error.");
+    }
+    if (!context.store) {
+      context.store = {};
+    }
+    context.store[key] = value;
+  }
+});

package/dist/runtime/export.d.ts

@@ -126,6 +126,8 @@ export interface RunErrorOptions {
 }
 
 /**
+ * @deprecated This error is deprecated. it will be treated like any normal error
+ *
  * Represents an error that occurs during a run.
  *
  * @class
@@ -154,65 +156,73 @@ export declare class RunError extends Error {
 }
 
 /**
- * in the create auth session flow, you might to need a multiple choice answer from the user, requestMultipleChoice prompts the user with the question and possible options and returns their selection.
- *
- * **Note:** This function is currently in beta and may be subject to changes.
+ * Retrieves the parameters for the authentication session currently being used.
  *
- * @param {string} message - The message to display to the user.
- * @param {string[]} choices - An array of choices to present to the user.
+ * @returns {AuthSessionParameters} An object containing the parameters for the current authentication session.
  *
  * @example
- * ```typescript requestMultipleChoice
- * // in auth-sessions/create.ts
- *
- * import { requestMultipleChoice } from "@intuned/sdk/runtime"
- *
- * const message = "What is your favorite color?";
- * const choices = ["Red", "Blue", "Green", "Yellow"];
- *
- * const selectedChoice = yield requestMultipleChoice(message, choices);
+ * ```typescript getAuthSessionParameters
+ * import { getAuthSessionParameters } from "@intuned/sdk/runtime"
  *
- * console.log(selectedChoice);
+ * const authSessionParams = getAuthSessionParameters();
+ * console.log(authSessionParams);
  * ```
  */
-export declare function requestMultipleChoice(
-  message: string,
-  choices: string[]
-): unknown;
+export declare function getAuthSessionParameters(): Promise<any>;
 
 /**
- * **Note:** This function is currently in beta and may be subject to changes.
- *
- * requestOTP help you to ask the user for an otp in the create auth-session flow.
- *
- * @param {string} message - The message to display to the user.
+ * @interface Store
+ * @property {function} get - Retrieves a value from the store by key
+ * @property {function} set - Sets a value in the store by key
  *
  * @example
- * ```typescript requestOTP
- * // in auth-sessions/create.ts
- *
- * import { requestOTP } from "@intuned/sdk/runtime"
+ * ```typescript Store usage
+ * import { store } from "@intuned/sdk/runtime"
  *
- * const message = "please submit and OTP from your authenticator app";
+ * // Set a value in the store
+ * store.set('userPreference', { theme: 'dark' });
  *
- * const otp = yield requestOTP(message);
- *
- * console.log(otp);
+ * // Get a value from the store
+ * const preference = store.get('userPreference');
  * ```
  */
-export declare function requestOTP(message: string): unknown;
+export interface Store {
+  /**
+   * Retrieves a value from the store by key.
+   *
+   * @param {string} key - The key to retrieve the value for
+   * @returns {any} The value associated with the key, or undefined if not found
+   */
+  get(key: string): any;
+
+  /**
+   * Sets a value in the store by key.
+   *
+   * @param {string} key - The key to set the value for
+   * @param {any} value - The value to store
+   * @throws {Error} Throws an error if the store operation fails
+   */
+  set(key: string, value: any): void;
+}
 
 /**
- * Retrieves the parameters for the authentication session currently being used.
- *
- * @returns {AuthSessionParameters} An object containing the parameters for the current authentication session.
+ * ## Description
+ * A persistent key-value store that maintains data within the execution context.
+ * This store allows you to share data between different parts of your API execution.
  *
  * @example
- * ```typescript getAuthSessionParameters
- * import { getAuthSessionParameters } from "@intuned/sdk/runtime"
+ * ```typescript Store usage
+ * import { store } from "@intuned/sdk/runtime"
  *
- * const authSessionParams = getAuthSessionParameters();
- * console.log(authSessionParams);
+ * // Set a value in the store
+ * store.set('sessionData', { userId: '123', token: 'abc' });
+ *
+ * // Get a value from the store
+ * const sessionData = store.get('sessionData');
+ * console.log(sessionData.userId); // '123'
+ *
+ * // Handle missing values
+ * const missingData = store.get('nonexistent'); // undefined
  * ```
  */
-export declare function getAuthSessionParameters(): Promise<any>;
+export declare const attemptStore: Store;