@zcatalyst/auth-admin 0.0.3

package/dist-es/index.js

@@ -0,0 +1,219 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ZCAuth_instances, _ZCAuth_appCollection, _ZCAuth_loadOptionsFromObj, _ZCAuth_loadOptionsFromEnvVar;
+import { CatalystAppError, CatalystError, CONSTANTS, isNonEmptyObject, isNonEmptyString, isNonEmptyStringOrNumber, isNonNullObject, isValidType, ObjectHasProperties } from '@zcatalyst/utils';
+import { AccessTokenCredential, ApplicationCustomCredential, ApplicationDefaultCredential, CatalystCredential, RefreshTokenCredential, TicketCredential } from './credential';
+const { INIT_TYPE, PROJECT_HEADER, DEFAULT_ENV, DEFAULT_APP_NAME, CREDENTIAL_USER, CATALYST_ORIGIN, AUTH_HEADER, COOKIE_HEADER, CREDENTIAL_HEADER, PROJECT_KEY_NAME, ENVIRONMENT_KEY_NAME, ENVIRONMENT, X_ZOHO_CATALYST_ORG_ID } = CONSTANTS;
+let appOptions = {};
+export class ZCAuth {
+    constructor() {
+        _ZCAuth_instances.add(this);
+        this.config = {};
+        _ZCAuth_appCollection.set(this, {});
+    }
+    init(options, { type, appName, scope } = {
+        type: 'auto'
+    }) {
+        switch (type) {
+            case INIT_TYPE.advancedio:
+                if (!options || typeof options.headers !== 'object') {
+                    throw new CatalystAppError('INVALID_APP_OPTIONS', 'the options passed to initialize method is not valid', options);
+                }
+                appOptions = __classPrivateFieldGet(this, _ZCAuth_instances, "m", _ZCAuth_loadOptionsFromObj).call(this, options['headers']);
+                appOptions.credential = new CatalystCredential(options['headers'], scope);
+                break;
+            case INIT_TYPE.basicio:
+                if (!options || typeof options.catalystHeaders !== 'object') {
+                    throw new CatalystAppError('INVALID_APP_OPTIONS', 'the options passed to initialize method is not valid', options);
+                }
+                appOptions = __classPrivateFieldGet(this, _ZCAuth_instances, "m", _ZCAuth_loadOptionsFromObj).call(this, options['catalystHeaders']);
+                appOptions.credential = new CatalystCredential(options['catalystHeaders'], scope);
+                break;
+            case INIT_TYPE.custom:
+                if (!options || !options['credential']) {
+                    throw new CatalystAppError('INVALID_APP_OPTIONS', 'the options passed to initialize method is not valid', options);
+                }
+                if (appName && isNonEmptyString(appName) && appName in __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")) {
+                    throw new CatalystAppError('APP_ALREADY_EXISTS', `The app with name ${appName} already exists. Please use a different name.`, appName);
+                }
+                appOptions = options;
+                appOptions.credential = new ApplicationCustomCredential(options['credential']);
+                break;
+            default:
+                if (options && typeof options.headers === 'object') {
+                    return this.init(options, { type: INIT_TYPE.advancedio, appName, scope });
+                }
+                if (options && typeof options.catalystHeaders === 'object') {
+                    return this.init(options, { type: INIT_TYPE.basicio, appName, scope });
+                }
+                if (options && options['credential']) {
+                    return this.init(options, { type: INIT_TYPE.custom, appName, scope });
+                }
+                throw new CatalystAppError('APP_ERROR', 'Unable to find the type of initialisation. kindly specify one', options);
+        }
+        const catalystApp = new CatalystApp(appOptions);
+        if (appName !== undefined && isNonEmptyString(appName)) {
+            __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")[appName] = catalystApp;
+        }
+        else {
+            __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")[DEFAULT_APP_NAME] = catalystApp;
+        }
+        return catalystApp;
+    }
+    getDefaultCredentials(appName) {
+        if (typeof appName === 'undefined') {
+            appName = DEFAULT_APP_NAME;
+        }
+        if (!isNonEmptyObject(appOptions)) {
+            appOptions = __classPrivateFieldGet(this, _ZCAuth_instances, "m", _ZCAuth_loadOptionsFromEnvVar).call(this);
+            if (!isNonEmptyObject(appOptions)) {
+                throw new CatalystAppError('AUTH_ERROR', 'Unable to get the app credentials, please initialize the app before perform operations.', appOptions);
+            }
+        }
+        if (typeof appOptions.credential === 'undefined') {
+            appOptions.credential = new ApplicationDefaultCredential();
+        }
+        const app = new CatalystApp(appOptions);
+        app.credential.switchUser(CREDENTIAL_USER.admin);
+        __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")[appName] = app;
+        return app;
+    }
+    app(appName) {
+        if (typeof appName === 'undefined') {
+            appName = DEFAULT_APP_NAME;
+        }
+        if (!isNonEmptyString(appName)) {
+            throw new CatalystAppError('INVALID_APP_NAME', 'Invalid app name provided. App name must be a non-empty string.', appName);
+        }
+        else if (!(appName in __classPrivateFieldGet(this, _ZCAuth_appCollection, "f"))) {
+            let errorMessage = appName === DEFAULT_APP_NAME
+                ? 'The default project does not exist. '
+                : `project named "${appName}" does not exist. `;
+            errorMessage += 'Make sure you call init() before getting the desired app';
+            throw new CatalystAppError('no_app', errorMessage, appName);
+        }
+        return __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")[appName];
+    }
+}
+_ZCAuth_appCollection = new WeakMap(), _ZCAuth_instances = new WeakSet(), _ZCAuth_loadOptionsFromObj = function _ZCAuth_loadOptionsFromObj(obj) {
+    const projectId = obj[PROJECT_HEADER.id];
+    const projectKey = obj[PROJECT_HEADER.key];
+    const environment = obj[PROJECT_HEADER.environment] || DEFAULT_ENV;
+    const projectDomain = obj[PROJECT_HEADER.domain] || CATALYST_ORIGIN;
+    const projectSecretKey = obj[PROJECT_HEADER.projectSecretKey];
+    const origin = obj['host'] && obj['host'].trim()
+        ? `http://${obj['host']}`
+        : `https://${projectDomain}`;
+    if (!projectId) {
+        throw new CatalystAppError('PROJECT_ERROR', 'Invalid project details. Failed to parse an object.', obj);
+    }
+    return {
+        projectId,
+        projectKey,
+        environment,
+        projectDomain,
+        projectSecretKey,
+        origin
+    };
+}, _ZCAuth_loadOptionsFromEnvVar = function _ZCAuth_loadOptionsFromEnvVar() {
+    const projectId = process.env[PROJECT_HEADER.id];
+    const projectKey = process.env[PROJECT_HEADER.key];
+    const environment = process.env[PROJECT_HEADER.environment] || DEFAULT_ENV;
+    const projectDomain = process.env[PROJECT_HEADER.domain] || CATALYST_ORIGIN;
+    const projectSecretKey = process.env[PROJECT_HEADER.projectSecretKey];
+    if (!isNonEmptyString(!projectId)) {
+        return {};
+    }
+    try {
+        return {
+            projectId,
+            projectKey,
+            environment,
+            projectDomain,
+            projectSecretKey
+        };
+    }
+    catch (err) {
+        throw new CatalystAppError('INVALID_APP_OPTIONS', 'Failed to parse app options : ' + err, err);
+    }
+};
+export class CatalystApp {
+    constructor(options) {
+        try {
+            isNonNullObject(options, 'options', true);
+            ObjectHasProperties(options, ['credential'], 'options', true);
+            isNonNullObject(options.credential, 'options.credential', true);
+            isValidType(options.credential.getToken, 'function', 'options.credential', true);
+            isNonEmptyStringOrNumber(options.project_id || options.projectId, 'projectId', true);
+        }
+        catch (e) {
+            if (e instanceof CatalystError) {
+                throw new CatalystAppError(e.code, e.message, e);
+            }
+            throw e;
+        }
+        this.credential = options.credential;
+        this.config = {
+            projectId: (options.project_id || options.projectId),
+            projectKey: (options.project_key || options.projectKey),
+            projectDomain: (options.project_domain || options.projectDomain),
+            environment: options.environment || DEFAULT_ENV,
+            projectSecretKey: (options.project_secret_key || options.projectSecretKey),
+            origin: options.origin || CATALYST_ORIGIN
+        };
+    }
+    setOauthHeader(headers, token) {
+        headers[AUTH_HEADER] = 'Zoho-oauthtoken ' + token;
+    }
+    setTicketHeader(headers, token) {
+        headers[AUTH_HEADER] = 'Zoho-ticket ' + token;
+    }
+    async authenticateRequest(req) {
+        const headers = Object.assign({}, req.headers);
+        if (this.credential instanceof AccessTokenCredential ||
+            this.credential instanceof RefreshTokenCredential) {
+            const token = await this.credential.getToken();
+            this.setOauthHeader(headers, token.access_token);
+            req.headers = headers;
+            return;
+        }
+        if (this.credential instanceof TicketCredential) {
+            const token = await this.credential.getToken();
+            this.setTicketHeader(headers, token.ticket);
+            req.headers = headers;
+            return;
+        }
+        if (this.credential instanceof CatalystCredential ||
+            this.credential instanceof ApplicationDefaultCredential) {
+            const token = (await this.credential.getToken());
+            if (isNonEmptyString(token.access_token)) {
+                this.setOauthHeader(headers, token.access_token);
+            }
+            else if (isNonEmptyString(token.ticket)) {
+                this.setTicketHeader(headers, token.ticket);
+            }
+            else if (isNonEmptyString(token.cookie)) {
+                headers[COOKIE_HEADER] = token.cookie;
+                headers[CREDENTIAL_HEADER.zcsrf] = token.zcrf_header;
+            }
+            req.headers = headers;
+        }
+    }
+}
+export function addDefaultAppHeaders(headers, values) {
+    headers[PROJECT_KEY_NAME] = values?.projectKey;
+    headers[ENVIRONMENT_KEY_NAME] = values?.environment;
+    headers[ENVIRONMENT] = values?.environment;
+    if (isNonEmptyString(process.env.X_ZOHO_CATALYST_ORG_ID)) {
+        headers[X_ZOHO_CATALYST_ORG_ID] = process.env.X_ZOHO_CATALYST_ORG_ID;
+    }
+    if (isNonEmptyString(values?.projectSecretKey)) {
+        headers[PROJECT_HEADER.projectSecretKey] = values?.projectSecretKey;
+    }
+    return headers;
+}
+export { AccessTokenCredential, Credential, RefreshTokenCredential, TicketCredential } from './credential';
+export { CatalystAppError };

package/dist-types/credential.d.ts

@@ -0,0 +1,288 @@
+export declare const globalValue: {};
+export declare abstract class Credential {
+    /**
+     * Returns the credential token payload.
+     *
+     * @returns The getToken result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use Credential.getToken in a Node request handler.
+     * ```
+     */
+    abstract getToken(): Promise<{
+        [x: string]: string;
+    }>;
+    /**
+     * Returns the current credential scope.
+     *
+     * @returns The getCurrentUser result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use Credential.getCurrentUser in a Node request handler.
+     * ```
+     */
+    getCurrentUser(): string;
+    /**
+     * Switches the active credential scope.
+     *
+     * @param _givenUser - The _givenUser value.
+     * @returns The switchUser result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use Credential.switchUser in a Node request handler.
+     * ```
+     */
+    switchUser(_givenUser?: string): string | null;
+    /**
+     * Returns the effective user type.
+     *
+     * @returns The getCurrentUserType result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use Credential.getCurrentUserType in a Node request handler.
+     * ```
+     */
+    getCurrentUserType(): string;
+}
+export declare class RefreshTokenCredential extends Credential {
+    refreshToken: string;
+    clientId: string;
+    clientSecret: string;
+    cachedToken: {
+        access_token: string;
+        expires_in: number;
+    } | null;
+    /**
+     * Creates a RefreshTokenCredential instance.
+     * @param refreshObj - The refreshObj value.
+     */
+    constructor(refreshObj: {
+        [x: string]: string;
+    });
+    /**
+     * Returns the credential token payload.
+     *
+     * @returns The getToken result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use RefreshTokenCredential.getToken in a Node request handler.
+     * ```
+     */
+    getToken(): Promise<{
+        ['access_token']: string;
+    }>;
+}
+export declare class AccessTokenCredential extends Credential {
+    accessToken: string;
+    /**
+     * Creates a AccessTokenCredential instance.
+     * @param accessObj - The accessObj value.
+     */
+    constructor(accessObj: Record<string, string>);
+    /**
+     * Returns the credential token payload.
+     *
+     * @returns The getToken result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use AccessTokenCredential.getToken in a Node request handler.
+     * ```
+     */
+    getToken(): Promise<{
+        access_token: string;
+    }>;
+}
+export declare class TicketCredential extends Credential {
+    ticket: string;
+    /**
+     * Creates a TicketCredential instance.
+     * @param ticketObj - The ticketObj value.
+     */
+    constructor(ticketObj: {
+        [x: string]: string;
+    });
+    /**
+     * Returns the credential token payload.
+     *
+     * @returns The getToken result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use TicketCredential.getToken in a Node request handler.
+     * ```
+     */
+    getToken(): Promise<{
+        ['ticket']: string;
+    }>;
+}
+export declare class CookieCredential extends Credential {
+    cookie: string;
+    cookieObj: {
+        [x: string]: string;
+    };
+    /**
+     * Creates a CookieCredential instance.
+     * @param cookieObj - The cookieObj value.
+     */
+    constructor(cookieObj: {
+        [x: string]: string;
+    });
+    private getAsObject;
+    private getZCSRFHeader;
+    /**
+     * Returns the credential token payload.
+     *
+     * @returns The getToken result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use CookieCredential.getToken in a Node request handler.
+     * ```
+     */
+    getToken(): Promise<{
+        ['cookie']: string;
+        ['zcrf_header']: string;
+    }>;
+}
+export declare class CatalystCredential extends Credential {
+    adminCredType: string;
+    userCredType: string | undefined;
+    adminToken: string;
+    userToken: string | undefined;
+    adminCred: TicketCredential | AccessTokenCredential;
+    userCred: TicketCredential | AccessTokenCredential | CookieCredential | undefined;
+    cookieStr: string | undefined;
+    scope: string;
+    userType: string;
+    /**
+     * Creates a CatalystCredential instance.
+     * @param credObj - The credObj value.
+     * @param scope - The scope value.
+     */
+    constructor(credObj: Record<string, string | undefined>, scope?: string);
+    /** @override  * @returns The getToken result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use CatalystCredential.getToken in a Node request handler.
+     * ```
+     */
+    getToken(): Promise<{
+        access_token?: string;
+        ticket?: string;
+        cookie?: string;
+        zcrf_header?: string;
+    }>;
+    /** @override  * @returns The getScope result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use CatalystCredential.getScope in a Node request handler.
+     * ```
+     */
+    getScope(): string;
+    /** @override  * @returns The getCurrentUser result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use CatalystCredential.getCurrentUser in a Node request handler.
+     * ```
+     */
+    getCurrentUser(): string;
+    /** @override  * @returns The getCurrentUserType result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use CatalystCredential.getCurrentUserType in a Node request handler.
+     * ```
+     */
+    getCurrentUserType(): string;
+    /** @override  * @param givenUser - The givenUser value.
+     * @returns The switchUser result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use CatalystCredential.switchUser in a Node request handler.
+     * ```
+     */
+    switchUser(givenUser?: string): string;
+}
+export declare class ApplicationDefaultCredential extends Credential {
+    credential: RefreshTokenCredential | AccessTokenCredential | TicketCredential;
+    /**
+     * Creates a ApplicationDefaultCredential instance.
+     */
+    constructor();
+    /**
+     * Returns the credential token payload.
+     *
+     * @returns The getToken result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use ApplicationDefaultCredential.getToken in a Node request handler.
+     * ```
+     */
+    getToken(): Promise<{
+        access_token?: string;
+        ticket?: string;
+    }>;
+}
+export declare class ApplicationCustomCredential extends Credential {
+    credential: RefreshTokenCredential | AccessTokenCredential | TicketCredential;
+    /**
+     * Creates a ApplicationCustomCredential instance.
+     * @param credObj - The credObj value.
+     */
+    constructor(credObj?: Record<string, string>);
+    /**
+     * Returns the credential token payload.
+     *
+     * @returns The getToken result.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * // Use ApplicationCustomCredential.getToken in a Node request handler.
+     * ```
+     */
+    getToken(): Promise<{
+        access_token?: string;
+        ticket?: string;
+    }>;
+}

package/dist-types/errors.d.ts

@@ -0,0 +1,10 @@
+import { PrefixedCatalystError } from '@zcatalyst/utils';
+export declare class CatalystAuthError extends PrefixedCatalystError {
+    /**
+     * Creates a CatalystAuthError instance.
+     * @param code - The code value.
+     * @param message - The message value.
+     * @param value - The value value.
+     */
+    constructor(code: string, message: string, value?: unknown);
+}

package/dist-types/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Catalyst Authentication for Node.js (admin scope) — initializes a CatalystApp from a request and exposes server-side identity APIs.
+ *
+ * @packageDocumentation
+ */
+import { CatalystAppError, ICatalystAppConfig } from '@zcatalyst/utils';
+import { Credential } from './credential';
+export declare class ZCAuth {
+    #private;
+    config: Record<string, string | number | Credential | Object>;
+    /**
+     * Initializes and stores a Catalyst app instance from request headers or custom credentials.
+     *
+     * @param options - The initialization or request options.
+     * @param options - The initialization or request options.
+     * @param options.type - The initialization type.
+     * @param options.appName - The registered Catalyst app name.
+     * @param options.scope - The credential scope to use.
+     * @returns The initialized Catalyst app instance.
+     * @throws {CatalystAppError} when app initialization or validation fails.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth, ZCAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * const result = app; // use ZCAuth.init in a Node request handler
+     * ```
+     */
+    init(options: Record<string, string | number>, { type, appName, scope }?: {
+        type?: string;
+        appName?: string;
+        scope?: 'admin' | 'user';
+    }): CatalystApp;
+    /**
+     * Returns a Catalyst app initialized from default credentials.
+     *
+     * @param appName - The registered Catalyst app name.
+     * @returns The initialized default Catalyst app instance.
+     * @throws {CatalystAppError} when app initialization or validation fails.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth, ZCAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * const result = app; // use ZCAuth.getDefaultCredentials in a Node request handler
+     * ```
+     */
+    getDefaultCredentials(appName?: string): CatalystApp;
+    /**
+     * Returns a previously initialized Catalyst app by name.
+     *
+     * @param appName - The registered Catalyst app name.
+     * @returns The registered Catalyst app instance.
+     * @throws {CatalystAppError} when app initialization or validation fails.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth, ZCAuth } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * const result = app; // use ZCAuth.app in a Node request handler
+     * ```
+     */
+    app(appName?: string): CatalystApp;
+}
+export declare class CatalystApp {
+    credential: Credential;
+    config: ICatalystAppConfig;
+    /**
+     * Creates a CatalystApp instance.
+     * @param options - The options value.
+     */
+    constructor(options: Record<string, string | number | Credential | Object>);
+    private setOauthHeader;
+    private setTicketHeader;
+    /**
+     * Adds the appropriate authentication headers to a request object.
+     *
+     * @param req - The request object to authenticate.
+     *
+     * @example
+     * ```ts
+     * import { zcAuth, CatalystApp } from '@zcatalyst/auth-admin';
+     * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+     * await app.authenticateRequest({ headers: {} });
+     * ```
+     */
+    authenticateRequest(req: Record<string, unknown>): Promise<void>;
+}
+/**
+ * Adds Catalyst project headers required by SDK service requests.
+ *
+ * @param headers - The headers object to mutate or extend.
+ * @param values - The Catalyst app configuration values.
+ * @returns The updated headers object.
+ *
+ * @example
+ * ```ts
+ * import { zcAuth, addDefaultAppHeaders } from '@zcatalyst/auth-admin';
+ * const app = zcAuth.init({ credential: { access_token: 'token' }, projectId: '123' }, { type: 'custom' });
+ * addDefaultAppHeaders({}, app.config);
+ * ```
+ */
+export declare function addDefaultAppHeaders(headers: Record<string, string>, values?: ICatalystAppConfig): Record<string, string>;
+export { AccessTokenCredential, Credential, RefreshTokenCredential, TicketCredential } from './credential';
+export { CatalystAppError };