@ms-cloudpack/remote-cache 0.11.1 → 0.11.2

package/dist/index.js

@@ -4,18 +4,20 @@ import topLevelUrl from 'node:url';
 const require = topLevelCreateRequire(import.meta.url);
 const __filename = topLevelUrl.fileURLToPath(import.meta.url);
 const __dirname = topLevelPath.dirname(__filename);
+import {
+  require_commonjs as require_commonjs5,
+  require_commonjs2 as require_commonjs7,
+  require_dist
+} from "./chunk-JNKRKLGF.js";
 import {
   init_tslib_es6,
   require_commonjs,
-  require_commonjs2,
-  require_commonjs3,
-  require_commonjs4,
-  require_commonjs5,
+  require_commonjs3 as require_commonjs2,
+  require_commonjs4 as require_commonjs3,
+  require_commonjs5 as require_commonjs4,
   require_commonjs6,
-  require_commonjs7,
-  require_dist,
   tslib_es6_exports
-} from "./chunk-XND2VV4N.js";
+} from "./chunk-LEHUXQFL.js";
 import {
   __commonJS,
   __name,
@@ -3209,7 +3211,7 @@ var require_dist2 = __commonJS({
       return coreAuth.isSASCredential(credential) || coreAuth.isNamedKeyCredential(credential) || coreAuth.isTokenCredential(credential);
     }
     __name(isCredential, "isCredential");
-    var logger = logger$1.createClientLogger("data-tables");
+    var logger2 = logger$1.createClientLogger("data-tables");
     function setTokenChallengeAuthenticationPolicy(pipeline, credential, scopes) {
       pipeline.removePolicy({ name: "bearerTokenPolicy" });
       pipeline.addPolicy(coreRestPipeline.bearerTokenAuthenticationPolicy({
@@ -3321,7 +3323,7 @@ var require_dist2 = __commonJS({
         const credential = isCredential(credentialOrOptions) ? credentialOrOptions : void 0;
         const clientOptions = (!isCredential(credentialOrOptions) ? credentialOrOptions : options) || {};
         const internalPipelineOptions = Object.assign(Object.assign({}, clientOptions), { endpoint: clientOptions.endpoint || this.url, loggingOptions: {
-          logger: logger.info,
+          logger: logger2.info,
           additionalAllowedHeaderNames: [...TablesLoggingAllowedHeaderNames]
         }, deserializationOptions: {
           parseXML: coreXml.parseXML
@@ -3384,7 +3386,7 @@ var require_dist2 = __commonJS({
           try {
             await this.table.create({ name }, updatedOptions);
           } catch (e) {
-            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { logger, tableName: name }));
+            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { logger: logger2, tableName: name }));
           }
         });
       }
@@ -3400,7 +3402,7 @@ var require_dist2 = __commonJS({
             await this.table.delete(name, updatedOptions);
           } catch (e) {
             if (e.statusCode === 404) {
-              logger.info("TableServiceClient.deleteTable: Table doesn't exist");
+              logger2.info("TableServiceClient.deleteTable: Table doesn't exist");
             } else {
               throw e;
             }
@@ -4118,7 +4120,7 @@ var require_dist2 = __commonJS({
         this.clientOptions = (!isCredential(credentialOrOptions) ? credentialOrOptions : options) || {};
         this.allowInsecureConnection = (_a = this.clientOptions.allowInsecureConnection) !== null && _a !== void 0 ? _a : false;
         const internalPipelineOptions = Object.assign(Object.assign({}, this.clientOptions), { endpoint: this.clientOptions.endpoint || this.url, loggingOptions: {
-          logger: logger.info,
+          logger: logger2.info,
           additionalAllowedHeaderNames: [...TablesLoggingAllowedHeaderNames]
         }, deserializationOptions: {
           parseXML: coreXml.parseXML
@@ -4176,7 +4178,7 @@ var require_dist2 = __commonJS({
             await this.table.delete(this.tableName, updatedOptions);
           } catch (e) {
             if (e.statusCode === 404) {
-              logger.info("TableClient.deleteTable: Table doesn't exist");
+              logger2.info("TableClient.deleteTable: Table doesn't exist");
             } else {
               throw e;
             }
@@ -4214,7 +4216,7 @@ var require_dist2 = __commonJS({
           try {
             await this.table.create({ name: this.tableName }, updatedOptions);
           } catch (e) {
-            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { logger, tableName: this.tableName }));
+            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { logger: logger2, tableName: this.tableName }));
           }
         });
       }
@@ -4670,6 +4672,22 @@ var require_dist2 = __commonJS({
   }
 });
 
+// src/registerAzureLogger.ts
+import EventEmitter from "events";
+var logger = require_commonjs();
+function registerAzureLogger() {
+  const emitter = new EventEmitter();
+  logger.setLogLevel("verbose");
+  logger.AzureLogger.log = (...messages) => {
+    if (messages[0] === "azure:identity:verbose Node.js MSAL Open Browser =>" && messages[1].includes("Opening browser")) {
+      const url = messages[1].split(" ")[3];
+      emitter.emit("MsalBrowserOpen", url);
+    }
+  };
+  return emitter;
+}
+__name(registerAzureLogger, "registerAzureLogger");
+
 // src/decorators/InMemoryDecorator.ts
 var _InMemoryDecorator = class _InMemoryDecorator {
   cacheClient;
@@ -4755,15 +4773,19 @@ __name(createTableStorageUrl, "createTableStorageUrl");
 // src/createRemoteCacheClient.ts
 var import_storage_blob = __toESM(require_dist(), 1);
 async function createRemoteCacheClient(params) {
+  const azureLogEventHandler = registerAzureLogger();
   const { context, options } = params;
   const { container, loginMethod, storageAccount, cachePath, tenantId } = options;
   const { telemetryClient } = context;
   return telemetryClient.tracer.startActiveSpan("CREATE_REMOTE_CACHE_CLIENT", async () => {
-    const { getCredential } = await import("@ms-cloudpack/auth");
-    const { AzureRemoteCacheClient } = await import("./AzureRemoteCacheClient-RQPQQPU4.js");
+    const { getCredential } = await import("./getCredential-EQJXGMRZ.js");
+    const { AzureRemoteCacheClient } = await import("./AzureRemoteCacheClient-UFUB2BJI.js");
     const { ReporterDecorator } = await import("./ReporterDecorator-VYNWC6CL.js");
     const { getListOfBlobs } = await import("./getListOfBlobs-BGP2V7PV.js");
-    const credential = await getCredential({ loginMethod, cachePath, tenantId }, context);
+    const credential = await getCredential(
+      { loginMethod, cachePath, tenantId },
+      { ...context, azureLogger: azureLogEventHandler }
+    );
     const blobStorageClient = new import_storage_blob.BlobServiceClient(createBlobStorageUrl(storageAccount), credential);
     const containerClient = blobStorageClient.getContainerClient(container);
     const listOfBlobs = await getListOfBlobs(containerClient, context);
@@ -4908,8 +4930,12 @@ var defaultStorageAccount = "cloudpackstorage";
 async function createAppRegistryClient(params) {
   const { context, options } = params;
   const { loginMethod, cachePath, tenantId = defaultTenantId, storageAccount = defaultStorageAccount } = options;
-  const { getCredential } = await import("@ms-cloudpack/auth");
-  const credential = await getCredential({ loginMethod, cachePath, tenantId }, context);
+  const azureLogEventHandler = registerAzureLogger();
+  const { getCredential } = await import("./getCredential-EQJXGMRZ.js");
+  const credential = await getCredential(
+    { loginMethod, cachePath, tenantId },
+    { ...context, azureLogger: azureLogEventHandler }
+  );
   const url = createTableStorageUrl(storageAccount);
   const client = new AzureAppRegistryClient(url, credential);
   return client;

package/lib/AzureAppRegistryClient.d.ts

@@ -1,7 +1,7 @@
 import type { AppRegistration, AppRegistrationVersion } from './types/AppRegistration.js';
 import type { AppRegistryClient } from './types/AppRegistryClient.js';
 import type { PageSettings } from '@azure/core-paging';
-import type { TokenCredential } from '@ms-cloudpack/auth';
+import type { TokenCredential } from '@azure/identity';
 import type { PagedResult } from './types/PagedResult.js';
 export declare class AzureAppRegistryClient implements AppRegistryClient {
     readonly storageUrl: string;

package/lib/authentication/forks/identity-cache-persistence/cachePersistencePlugin.d.ts

@@ -0,0 +1,34 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/identity-cache-persistence` package.
+ * https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity-cache-persistence/src/index.ts
+ */
+import type { IdentityPlugin } from '@azure/identity';
+/**
+ * A plugin that provides persistent token caching for `@azure/identity`
+ * credentials. The plugin API is compatible with `@azure/identity` versions
+ * 2.0.0 and later. Load this plugin using the `useIdentityPlugin`
+ * function, imported from `@azure/identity`.
+ *
+ * In order to enable this functionality, you must also pass
+ * `tokenCachePersistenceOptions` to your credential constructors with an
+ * `enabled` property set to true.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { useIdentityPlugin, DeviceCodeCredential } from "@azure/identity";
+ * import { cachePersistencePlugin } from "@azure/identity-cache-persistence";
+ *
+ * // Load the plugin
+ * useIdentityPlugin(cachePersistencePlugin);
+ *
+ * const credential = new DeviceCodeCredential({
+ *   tokenCachePersistenceOptions: {
+ *     enabled: true
+ *   }
+ * });
+ * ```
+ */
+export declare const cachePersistencePlugin: IdentityPlugin;
+//# sourceMappingURL=cachePersistencePlugin.d.ts.map

package/lib/authentication/forks/identity-cache-persistence/platforms.d.ts

@@ -0,0 +1,50 @@
+import type { TokenCachePersistenceOptions } from '@azure/identity';
+import type { IPersistence } from '../msal-node-extensions/persistence/IPersistence.js';
+/**
+ * Dictionary of values that we use as default as we discover, pick and enable the persistence layer.
+ * @internal
+ */
+export declare const defaultMsalValues: {
+    tokenCache: {
+        name: string;
+        directory: string;
+    };
+    keyRing: {
+        label: string;
+        schema: string;
+        collection: string;
+        attributes: {
+            MsalClientID: string;
+            'Microsoft.Developer.IdentityService': string;
+        };
+        service: string;
+        account: string;
+    };
+    keyChain: {
+        service: string;
+        account: string;
+    };
+};
+/**
+ * Options that are used by the underlying MSAL cache provider.
+ * @internal
+ */
+export type MsalPersistenceOptions = Omit<TokenCachePersistenceOptions, 'enabled'>;
+/**
+ * A function that returns a persistent token cache instance.
+ * @internal
+ */
+type MsalPersistenceFactory = (options?: MsalPersistenceOptions) => Promise<IPersistence>;
+/**
+ * Set of the platforms we attempt to deliver persistence on.
+ *
+ * - On Windows we use DPAPI.
+ * - On OSX (Darwin) and Linux, we try to use the system's Keyring, otherwise if the property `unsafeAllowUnencryptedStorage` is set to true, we use an unencrypted file.
+ *
+ * Other platforms _are not supported_ at this time.
+ *
+ * @internal
+ */
+export declare const msalPersistencePlatforms: Partial<Record<NodeJS.Platform, MsalPersistenceFactory>>;
+export {};
+//# sourceMappingURL=platforms.d.ts.map

package/lib/authentication/forks/identity-cache-persistence/provider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/identity-cache-persistence` package.
+ * https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity-cache-persistence/src/provider.ts
+ */
+import type { MsalPersistenceOptions } from './platforms.js';
+import type { ICachePlugin as CachePlugin } from '@azure/msal-node';
+import type { IPersistence } from '../msal-node-extensions/persistence/IPersistence.js';
+/**
+ * This is used to gain access to the underlying Persistence instance, which we use for testing
+ *
+ * @returns a raw persistence instance
+ * @internal
+ */
+export declare function createPersistence(options: MsalPersistenceOptions): Promise<IPersistence>;
+export declare function createPersistenceCachePlugin(options?: MsalPersistenceOptions): Promise<CachePlugin>;
+//# sourceMappingURL=provider.d.ts.map

package/lib/authentication/forks/msal-node-extensions/error/PersistenceError.d.ts

@@ -0,0 +1,37 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/error/PersistenceError.ts
+ */
+/**
+ * Error thrown when trying to write MSAL cache to persistence.
+ */
+export declare class PersistenceError extends Error {
+    errorCode: string;
+    errorMessage: string;
+    constructor(errorCode: string, errorMessage: string);
+    /**
+     * Error thrown when trying to access the file system.
+     */
+    static createFileSystemError(errorCode: string, errorMessage: string): PersistenceError;
+    /**
+     * Error thrown when trying to encrypt or decrypt data using DPAPI on Windows.
+     */
+    static createFilePersistenceWithDPAPIError(errorMessage: string): PersistenceError;
+    /**
+     * Error thrown when using the cross platform lock.
+     */
+    static createCrossPlatformLockError(errorMessage: string): PersistenceError;
+    /**
+     * Error thrown when trying to write, load, or delete data from NapiRsKeyRingPersistence.
+     */
+    static createNapiRsKeyRingPersistenceError(errorMessage: string): PersistenceError;
+    /**
+     * Throw cache persistence error
+     *
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createCachePersistenceError(errorMessage: string): PersistenceError;
+}
+//# sourceMappingURL=PersistenceError.d.ts.map

package/lib/authentication/forks/msal-node-extensions/lock/CrossPlatformLock.d.ts

@@ -0,0 +1,25 @@
+import type { CrossPlatformLockOptions } from './CrossPlatformLockOptions.js';
+import type { Logger } from '@azure/msal-common';
+/**
+ * Cross-process lock that works on all platforms.
+ */
+export declare class CrossPlatformLock {
+    private readonly lockFilePath;
+    private lockFileHandle;
+    private readonly retryNumber;
+    private readonly retryDelay;
+    private logger;
+    constructor(lockFilePath: string, logger: Logger, lockOptions?: CrossPlatformLockOptions);
+    /**
+     * Locks cache from read or writes by creating file with same path and name as
+     * cache file but with .lockfile extension. If another process has already created
+     * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
+     */
+    lock(): Promise<void>;
+    /**
+     * unlocks cache file by deleting .lockfile.
+     */
+    unlock(): Promise<void>;
+    private sleep;
+}
+//# sourceMappingURL=CrossPlatformLock.d.ts.map

package/lib/authentication/forks/msal-node-extensions/lock/CrossPlatformLockOptions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/lock/CrossPlatformLockOptions.ts
+ */
+/**
+ * Options for CrossPlatform lock.
+ *
+ * retryNumber: Numbers of times we should try to acquire a lock. Defaults to 500.
+ * retryDelay: Time to wait before trying to retry a lock acquisition. Defaults to 100 ms.
+ */
+export type CrossPlatformLockOptions = {
+    retryNumber: number;
+    retryDelay: number;
+};
+//# sourceMappingURL=CrossPlatformLockOptions.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/BasePersistence.d.ts

@@ -0,0 +1,6 @@
+import type { IPersistence } from './IPersistence.js';
+export declare abstract class BasePersistence {
+    abstract createForPersistenceValidation(): Promise<IPersistence>;
+    verifyPersistence(): Promise<boolean>;
+}
+//# sourceMappingURL=BasePersistence.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/FilePersistence.d.ts

@@ -0,0 +1,31 @@
+import type { IPersistence } from './IPersistence.js';
+import type { LoggerOptions } from '@azure/msal-common';
+import { Logger } from '@azure/msal-common';
+import { BasePersistence } from './BasePersistence.js';
+/**
+ * Reads and writes data to file specified by file location. File contents are not
+ * encrypted.
+ *
+ * If file or directory has not been created, it FilePersistence.create() will create
+ * file and any directories in the path recursively.
+ */
+export declare class FilePersistence extends BasePersistence implements IPersistence {
+    private filePath;
+    private logger;
+    private constructor();
+    static create(fileLocation: string, loggerOptions?: LoggerOptions): Promise<FilePersistence>;
+    save(contents: string): Promise<void>;
+    saveBuffer(contents: Uint8Array): Promise<void>;
+    load(): Promise<string | null>;
+    loadBuffer(): Promise<Uint8Array>;
+    delete(): Promise<boolean>;
+    getFilePath(): string;
+    reloadNecessary(lastSync: number): Promise<boolean>;
+    getLogger(): Logger;
+    createForPersistenceValidation(): Promise<FilePersistence>;
+    private static createDefaultLoggerOptions;
+    private timeLastModified;
+    private createCacheFile;
+    private createFileDirectory;
+}
+//# sourceMappingURL=FilePersistence.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/FilePersistenceWithDataProtection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/persistence/FilePersistenceWithDataProtection.ts
+ */
+import type { IPersistence } from './IPersistence.js';
+import { type DataProtectionScope } from 'node-dpapi-prebuilt';
+import type { Logger, LoggerOptions } from '@azure/msal-common';
+import { BasePersistence } from './BasePersistence.js';
+/**
+ * Uses CryptProtectData and CryptUnprotectData on Windows to encrypt and decrypt file contents.
+ *
+ * scope: Scope of the data protection. Either local user or the current machine
+ * optionalEntropy: Password or other additional entropy used to encrypt the data
+ */
+export declare class FilePersistenceWithDataProtection extends BasePersistence implements IPersistence {
+    private filePersistence;
+    private scope;
+    private optionalEntropy;
+    private constructor();
+    static create(fileLocation: string, scope: DataProtectionScope, optionalEntropy?: string, loggerOptions?: LoggerOptions): Promise<FilePersistenceWithDataProtection>;
+    save(contents: string): Promise<void>;
+    load(): Promise<string | null>;
+    delete(): Promise<boolean>;
+    reloadNecessary(lastSync: number): Promise<boolean>;
+    getFilePath(): string;
+    getLogger(): Logger;
+    createForPersistenceValidation(): Promise<FilePersistenceWithDataProtection>;
+}
+//# sourceMappingURL=FilePersistenceWithDataProtection.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/IPersistence.d.ts

@@ -0,0 +1,17 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/persistence/IPersistence.ts
+ */
+import type { Logger } from '@azure/msal-common';
+export interface IPersistence {
+    save(contents: string): Promise<void>;
+    load(): Promise<string | null>;
+    delete(): Promise<boolean>;
+    reloadNecessary(lastSync: number): Promise<boolean>;
+    getFilePath(): string;
+    getLogger(): Logger;
+    verifyPersistence(): Promise<boolean>;
+    createForPersistenceValidation(): Promise<IPersistence>;
+}
+//# sourceMappingURL=IPersistence.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/IPersistenceConfiguration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/persistence/IPersistenceConfiguration.ts
+ */
+import type { LoggerOptions } from '@azure/msal-common';
+import type { DataProtectionScope } from 'node-dpapi-prebuilt';
+export interface IPersistenceConfiguration {
+    cachePath?: string;
+    dataProtectionScope?: DataProtectionScope;
+    serviceName?: string;
+    accountName?: string;
+    usePlaintextFileOnLinux?: boolean;
+    loggerOptions?: LoggerOptions;
+}
+//# sourceMappingURL=IPersistenceConfiguration.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/NapiRsKeyRingPersistence.d.ts

@@ -0,0 +1,19 @@
+import type { Logger, LoggerOptions } from '@azure/msal-common';
+import { BasePersistence } from './BasePersistence.js';
+import type { IPersistence } from './IPersistence.js';
+export declare class NapiRsKeyRingPersistence extends BasePersistence implements IPersistence {
+    readonly service: string;
+    readonly account: string;
+    private readonly entry;
+    private readonly filePersistence;
+    private constructor();
+    static create(fileLocation: string, serviceName: string, accountName: string, loggerOptions?: LoggerOptions): Promise<NapiRsKeyRingPersistence>;
+    save(contents: string): Promise<void>;
+    load(): Promise<string | null>;
+    delete(): Promise<boolean>;
+    reloadNecessary(lastSync: number): Promise<boolean>;
+    getFilePath(): string;
+    getLogger(): Logger;
+    createForPersistenceValidation(): Promise<IPersistence>;
+}
+//# sourceMappingURL=NapiRsKeyRingPersistence.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/PersistenceCachePlugin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/persistence/PersistenceCachePlugin.ts
+ */
+import type { IPersistence } from './IPersistence.js';
+import type { CrossPlatformLockOptions } from '../lock/CrossPlatformLockOptions.js';
+import type { TokenCacheContext, ICachePlugin } from '@azure/msal-common';
+/**
+ * MSAL cache plugin which enables callers to write the MSAL cache to disk on Windows,
+ * macOs, and Linux.
+ */
+export declare class PersistenceCachePlugin implements ICachePlugin {
+    persistence: IPersistence;
+    lastSync: number;
+    currentCache: string | null;
+    lockFilePath: string;
+    private crossPlatformLock;
+    private logger;
+    constructor(persistence: IPersistence, lockOptions?: CrossPlatformLockOptions);
+    /**
+     * Reads from storage and saves an in-memory copy. If persistence has not been updated
+     * since last time data was read, in memory copy is used.
+     *
+     * If cacheContext.cacheHasChanged === true, then file lock is created and not deleted until
+     * afterCacheAccess() is called, to prevent the cache file from changing in between
+     * beforeCacheAccess() and afterCacheAccess().
+     */
+    beforeCacheAccess(cacheContext: TokenCacheContext): Promise<void>;
+    /**
+     * Writes to storage if MSAL in memory copy of cache has been changed.
+     */
+    afterCacheAccess(cacheContext: TokenCacheContext): Promise<void>;
+}
+//# sourceMappingURL=PersistenceCachePlugin.d.ts.map

package/lib/authentication/forks/msal-node-extensions/utils/Constants.d.ts

@@ -0,0 +1,44 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/utils/Constants.ts
+ */
+export declare const Constants: {
+    /**
+     * An existing file was the target of an operation that required that the target not exist
+     */
+    EEXIST_ERROR: string;
+    /**
+     * No such file or directory: Commonly raised by fs operations to indicate that a component
+     * of the specified pathname does not exist. No entity (file or directory) could be found
+     * by the given path
+     */
+    ENOENT_ERROR: string;
+    /**
+     * Operation not permitted. An attempt was made to perform an operation that requires
+     * elevated privileges.
+     */
+    EPERM_ERROR: string;
+    /**
+     * Default service name for using MSAL Keytar
+     */
+    DEFAULT_SERVICE_NAME: string;
+    /**
+     * Test data used to verify underlying persistence mechanism
+     */
+    PERSISTENCE_TEST_DATA: string;
+    DEFAULT_CACHE_FILE_NAME: string;
+};
+export declare const Platform: {
+    readonly WINDOWS: "win32";
+    readonly LINUX: "linux";
+    readonly MACOS: "darwin";
+};
+export type Platform = (typeof Platform)[keyof typeof Platform];
+export declare const ErrorCodes: {
+    readonly INTERATION_REQUIRED_ERROR_CODE: "interaction_required";
+    readonly SERVER_UNAVAILABLE: "server_unavailable";
+    readonly UNKNOWN: "unknown_error";
+};
+export type ErrorCodes = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+//# sourceMappingURL=Constants.d.ts.map

package/lib/authentication/forks/msal-node-extensions/utils/TypeGuards.d.ts

@@ -0,0 +1,10 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/utils/TypeGuards.ts
+ */
+/**
+ * Returns whether or not the given object is a Node.js error
+ */
+export declare const isNodeError: (error: unknown) => error is NodeJS.ErrnoException;
+//# sourceMappingURL=TypeGuards.d.ts.map

package/lib/authentication/getAuthenticationRecord.d.ts

@@ -0,0 +1,8 @@
+import { type AuthenticationRecord } from '@azure/identity';
+/**
+ * Retrieves the authentication record from Cloudpack's global cache folder.
+ * @param cachePath - The path to Cloudpack's cache folder.
+ * @returns - The authentication record if it exists; otherwise, returns `undefined`.
+ */
+export declare function getAuthenticationRecord(cachePath: string): AuthenticationRecord | undefined;
+//# sourceMappingURL=getAuthenticationRecord.d.ts.map

package/lib/authentication/getAuthenticationRecordPath.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Constructs and returns the full path to the authentication record file within the specified cache folder.
+ * @param cachePath - The path to Cloudpack's cache folder.
+ * @returns - The full path to the authentication record file.
+ */
+export declare function getAuthenticationRecordPath(cachePath: string): string;
+//# sourceMappingURL=getAuthenticationRecordPath.d.ts.map

package/lib/authentication/getCredential.d.ts

@@ -0,0 +1,21 @@
+import { type TokenCredential } from '@azure/identity';
+import type { LoginMethod } from '../types/LoginMethod.js';
+import type { TaskReporter } from '@ms-cloudpack/task-reporter';
+import type EventEmitter from 'events';
+import type { TelemetryClient } from '@ms-cloudpack/telemetry';
+/**
+ * Gets a credential for the given login method.
+ * If the login method is 'azure-cli', it will return an AzureCliCredential.
+ * Otherwise, it will return an InteractiveBrowserCredential or a DeviceCodeCredential with persistent token settings.
+ * If an authentication record has never been saved before, it will authenticate the credential and save the authentication record.
+ */
+export declare function getCredential(options: {
+    loginMethod: LoginMethod;
+    cachePath: string;
+    tenantId?: string;
+}, context: {
+    reporter: TaskReporter;
+    azureLogger: EventEmitter;
+    telemetryClient: TelemetryClient;
+}): Promise<TokenCredential>;
+//# sourceMappingURL=getCredential.d.ts.map

package/lib/authentication/lock-file/deleteAuthenticationLockFile.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Deletes the authentication lock file.
+ * If the file does not exist or is currently in use, cannot be deleted due to permission issues, it logs an error message.
+ * @returns - true if the file was successfully deleted, false otherwise.
+ */
+export declare function deleteAuthenticationLockFile(): boolean;
+//# sourceMappingURL=deleteAuthenticationLockFile.d.ts.map

package/lib/authentication/lock-file/doesLockFileExist.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if the authentication lock file exists.
+ * @returns - true if the authentication lock file exists, false otherwise.
+ */
+export declare function doesLockFileExist(): boolean;
+//# sourceMappingURL=doesLockFileExist.d.ts.map

package/lib/authentication/lock-file/getAuthenticationLockFilePath.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @returns The file path of the authentication lock file.
+ * Expected responses:
+ *  - Darwin: `/Users/user/.IdentityService/cloudpack.lockfile`
+ *  - Windows 8+: `C:\Users\user\AppData\Local\.IdentityService\cloudpack.lockfile`
+ *  - Linux: `/home/user/.IdentityService/cloudpack.lockfile`
+ *
+ * The lock file is generated by the @azure/identity and msal-node-extensions packages. Unfortunately, these packages do not provide an API to retrieve the lock file path directly. Therefore, we've implemented a function to obtain their lock file path, albeit without a formal contract.
+ */
+export declare function getAuthenticationLockFilePath(): string;
+/**
+ * Local application data folder
+ * Expected values:
+ * - Darwin: `/Users/user/`
+ * - Windows 8+: `C:\Users\user\AppData\Local`
+ * - Linux: `/home/user/.local/share`
+ */
+export declare function getIdentityServiceCachePath(): string;
+//# sourceMappingURL=getAuthenticationLockFilePath.d.ts.map

package/lib/authentication/lock-file/readAuthenticationLockFile.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads the authentication lock file and parse the content to int.
+ * @returns - The process ID stored in the authentication lock file.
+ */
+export declare function readAuthenticationLockFile(): number;
+//# sourceMappingURL=readAuthenticationLockFile.d.ts.map