@ibgib/core-gib 0.0.49 → 0.0.50

package/dist/common/secret/secret-helper.mjs

@@ -0,0 +1,358 @@
+/**
+ * @module secret helper/util/etc. functions
+ *
+ * this is where you will find helper functions like those that generate
+ * and parse ibs for secret.
+ */
+// import * as pathUtils from 'path';
+// import { statSync } from 'node:fs';
+// import { readFile, } from 'node:fs/promises';
+// import * as readline from 'node:readline/promises';
+// import { stdin, stdout } from 'node:process'; // decide if use this or not
+import { extractErrorMsg, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { CLASSNAME_REGEXP, } from '@ibgib/helper-gib/dist/constants.mjs';
+import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
+import { Factory_V1 } from "@ibgib/ts-gib/dist/V1/factory.mjs";
+import { GLOBAL_LOG_A_LOT } from "../../core-constants.mjs";
+import { SecretType, VALID_SECRET_TYPES, } from './secret-types.mjs';
+import { SECRET_ATOM, SECRET_NAME_REGEXP, SECRET_REL8N_NAME, } from './secret-constants.mjs';
+import { INVALID_DATE_STRING } from '../other/other-constants.mjs';
+import { hash16816 } from '../other/ibgib-helper.mjs';
+/**
+ * for verbose logging
+ */
+const logalot = GLOBAL_LOG_A_LOT;
+export function validateCommonSecretData({ data, }) {
+    const lc = `[${validateCommonSecretData.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting...`);
+        }
+        if (!data) {
+            throw new Error(`data required (E: f7d9a12390e2d3821c07c115a289b5af)`);
+        }
+        const errors = [];
+        const { name, /*uuid,*/ classname, expirationUTC, type, } = data;
+        if (name) {
+            if (!name.match(SECRET_NAME_REGEXP)) {
+                errors.push(`name must match regexp: ${SECRET_NAME_REGEXP} (E: 27023cc5e5afb456e4b8ebfd1e653de6)`);
+            }
+        }
+        else {
+            errors.push(`name required. (E: fe088277e7677ad295b5e914ed644ab4)`);
+        }
+        if (type) {
+            if (!VALID_SECRET_TYPES.includes(type)) {
+                errors.push(`type (${type}) is invalid. must be one of ${VALID_SECRET_TYPES.join(', ')} (E: 413a1c899dcc4623a38be35bdf144217)`);
+            }
+        }
+        else {
+            errors.push(`type required. (E: 6126767cc5fd4c898d432b139652e5d1)`);
+        }
+        // if (uuid) {
+        //     if (!uuid.match(UUID_REGEXP)) {
+        //         errors.push(`uuid must match regexp: ${UUID_REGEXP} (E: 1b035a31d191435217010ac272681c82)`);
+        //     }
+        // } else {
+        //     errors.push(`uuid required. (E: 55fee43e758fcf542866bdabe7321633)`);
+        // }
+        if (classname) {
+            if (!classname.match(CLASSNAME_REGEXP)) {
+                errors.push(`classname must match regexp: ${CLASSNAME_REGEXP} (E: 301c325035ad3297c2744fd25ec618dd)`);
+            }
+        }
+        if (expirationUTC) {
+            let date = new Date(expirationUTC);
+            if (date.toString() === INVALID_DATE_STRING) {
+                errors.push(`invalid expirationUTC (${expirationUTC}) (E: 969a126f12b742adbf9d671d3fdd782f)`);
+            }
+        }
+        else {
+            errors.push(`expirationUTC required (E: f1ff3bcec74946908f0f37f9282e917d)`);
+        }
+        return errors;
+    }
+    catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+    finally {
+        if (logalot) {
+            console.log(`${lc} complete.`);
+        }
+    }
+}
+export async function validateCommonSecretIbGib({ ibGib, }) {
+    const lc = `[${validateCommonSecretIbGib.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 596f5952f6a18ebb23ff270520818eaa)`);
+        }
+        const intrinsicErrors = await validateIbGibIntrinsically({ ibGib: ibGib }) ?? [];
+        if (!ibGib.data) {
+            throw new Error(`SecretIbGib.data required (E: df00780071919f55c762ee0756cf46bc)`);
+        }
+        const ibErrors = [];
+        // ib
+        let { atom, type, name, } = parseSecretIb({ ib: ibGib.ib });
+        if (atom !== SECRET_ATOM) {
+            ibErrors.push(`invalid secret atom. must be ${SECRET_ATOM} (E: 56c5874056ff8d07e1875cc38eccf0c3)`);
+        }
+        if (!type) {
+            ibErrors.push(`secret type required (E: 273042f54b363c094b466f85baef3c10)`);
+        }
+        if (!name) {
+            ibErrors.push(`secret name required (E: 670718e47214d0cdfa844d8f7d756477)`);
+        }
+        // data
+        const dataErrors = validateCommonSecretData({ data: ibGib.data });
+        let result = [...(intrinsicErrors ?? []), ...(ibErrors ?? []), ...(dataErrors ?? [])];
+        if (result.length > 0) {
+            return result;
+        }
+        else {
+            return undefined;
+        }
+    }
+    catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+    finally {
+        if (logalot) {
+            console.log(`${lc} complete.`);
+        }
+    }
+}
+export function getSecretIb({ data, }) {
+    const lc = `[${getSecretIb.name}]`;
+    try {
+        const validationErrors = validateCommonSecretData({ data });
+        if (validationErrors.length > 0) {
+            throw new Error(`invalid Secret data: ${validationErrors} (E: 07a71e9ba5d574274e2c6a289a3fbabe)`);
+        }
+        const { name, type } = data;
+        return `${SECRET_ATOM} ${type} ${name}`;
+    }
+    catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}
+/**
+ * Current schema is '[SECRET_ATOM] [type] [name]'
+ *
+ * NOTE this is space-delimited
+ */
+export function parseSecretIb({ ib, }) {
+    const lc = `[${parseSecretIb.name}]`;
+    try {
+        if (!ib) {
+            throw new Error(`Secret ib required (E: 115e8097c30538526536b240ce4b8e87)`);
+        }
+        const [atom, type, name] = ib.split(' ');
+        if (atom !== SECRET_ATOM) {
+            throw new Error(`atom !== ${SECRET_ATOM} (E: 942f3ab95687772a5483ec926ad98124)`);
+        }
+        if (type !== SecretType.password) {
+            console.warn(`${lc} type !== SecretType.password. atow (02/2024) password is the only thing we got. (W: 66511ca217b045629a7816adc4e41fad)`);
+        }
+        if (!name.match(SECRET_NAME_REGEXP)) {
+            throw new Error(`!name.match(SECRET_NAME_REGEXP) (E: 6c95dbb65d3d6d9e0400412bf7ba6824)`);
+        }
+        return { atom, type, name, };
+    }
+    catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}
+export async function createAndRegisterNewSecret({ secretType, secretInfo, metaspace, space, }) {
+    const lc = `[${createAndRegisterNewSecret.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 08a3b2c784ff4689a8abf3ba8f1d7af4)`);
+        }
+        let resSecretIbGib;
+        if (secretType !== SecretType.password) {
+            throw new Error(`unknown secretType (${secretType}). only "password" secret type currently implemented. (E: ce3dd7aef4f48f9799f2d37217eed224)`);
+        }
+        resSecretIbGib = await createAndRegisterNewSecret_password({
+            secretType: secretType,
+            secretInfo: secretInfo,
+            metaspace,
+            space,
+        });
+        return resSecretIbGib;
+    }
+    catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+    finally {
+        if (logalot) {
+            console.log(`${lc} complete.`);
+        }
+    }
+}
+async function createAndRegisterNewSecret_password({ secretType, secretInfo, metaspace, space, }) {
+    const lc = `[${createAndRegisterNewSecret_password.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: ab330733d4b6bb733f5b5655bcd70a24)`);
+        }
+        if (secretType !== 'password') {
+            throw new Error(`(UNEXPECTED) secretType !== 'password'? (E: b086c3494808a38ad967e55a82364824)`);
+        }
+        // create the secret ibgib
+        const data = {
+            ...secretInfo,
+        };
+        const resFirstGen = await Factory_V1.firstGen({
+            ib: getSecretIb({ data }),
+            parentIbGib: Factory_V1.primitive({ ib: SECRET_ATOM }),
+            data,
+            dna: true,
+            nCounter: true,
+            tjp: { timestamp: true, },
+        });
+        const secretIbGib = resFirstGen.newIbGib;
+        // validate right away before anything else
+        const validationErrors = await validateCommonSecretIbGib({ ibGib: secretIbGib }) ?? [];
+        if (validationErrors.length > 0) {
+            throw new Error(`(UNEXPECTED) newly created secretIbGib has validationErrors? validationErrors: ${validationErrors} (E: 458708237973aea6c72121016d98af24)`);
+        }
+        // save first in the space...
+        await metaspace.persistTransformResult({ resTransform: resFirstGen, space });
+        // register the new secret with the ibgib space in general...
+        await metaspace.registerNewIbGib({ ibGib: secretIbGib, space });
+        // register the new secret with the secrets index
+        await metaspace.rel8ToSpecialIbGib({
+            type: "secrets",
+            rel8nName: SECRET_REL8N_NAME,
+            ibGibsToRel8: [secretIbGib],
+            space,
+        });
+        // localIndex_secretIbGibs = await metaspace.getSpecialRel8dIbGibs({
+        //     type: "secrets",
+        //     rel8nName: SECRET_REL8N_NAME,
+        //     space,
+        // });
+        return secretIbGib;
+    }
+    catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+    finally {
+        if (logalot) {
+            console.log(`${lc} complete.`);
+        }
+    }
+}
+/**
+ * executes the hash16816 fn on the incoming {@link password} using parameters
+ * {@link recursionCount}, {@link saltPrependedPerHash} and {@link algorithm}.
+ * Then selects a random contiguous substring of {@link substringLength} of the
+ * resultant hash.
+ *
+ * @returns {@link substringLength} of deterministic hash
+ *
+ * This is a novel idea only useful in a byzantine fault tolerant distributed
+ * computation context, so to understand how this is used, PLEASE...
+ * @see {@link CheckIfPasswordProbablyCorrectInfo}
+ */
+export async function getCheckIfPasswordProbablyCorrectInfo({ password, substringLength, recursionCount, saltPrependedPerHash, algorithm, }) {
+    const lc = `[${getCheckIfPasswordProbablyCorrectInfo.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 9dc41fcf83a6d0e6054d3a9e79803224)`);
+        }
+        if (!substringLength) {
+            throw new Error(`substringLength (${substringLength}) required (E: d1d4fbfaa1562abac7ec42cdd0264224)`);
+        }
+        recursionCount ?? (recursionCount = 16816);
+        algorithm ?? (algorithm = 'SHA-256');
+        const fullHash = await hash16816({
+            s: password,
+            algorithm: 'SHA-256',
+            recursionCount,
+            saltPrependedPerHash,
+        });
+        // we want to pick a random starting point for the substring. on the
+        // consuming end, we don't need to know this random index, we will just
+        // confirm that the fullHash generated when the user enters their
+        // password conatins this substring at all (not where it starts from).
+        // 64 = length of sha256 hash
+        // 64-1 = 0-indexed adjustment
+        const r = Math.random();
+        const substringStartIndex = Math.floor(r * (63 - substringLength));
+        const resSubstring = fullHash.substring(substringStartIndex, substringStartIndex + substringLength);
+        // defensive checks here (atow 02/2024), remove at some point once we
+        // see that this isn't throwing and it's tested well enough
+        if (resSubstring.length !== substringLength) {
+            throw new Error(`(UNEXPECTED) resSubstring.length (${resSubstring.length}) !== substringLength (${substringLength})?\nfullHash: ${fullHash}\nr: ${r}\nsubstringStartIndex: ${substringStartIndex}\nresSubstring: ${resSubstring}(E: c45acd126b4c70041e92f6ad5329c424)`);
+        }
+        const confirmResult = await passwordProbablyCorrect({
+            password, checkInfo: {
+                substring: resSubstring,
+                algorithm,
+                recursionCount,
+                saltPrependedPerHash,
+            }
+        });
+        if (!confirmResult) {
+            throw new Error(`(UNEXPECTED) !confirmResult? uhh... (E: cc757a8ef07b6468793b1bddbafca924)`);
+        }
+        return {
+            substring: resSubstring,
+            saltPrependedPerHash: saltPrependedPerHash ?? '',
+            recursionCount,
+            algorithm,
+        };
+    }
+    catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+    finally {
+        if (logalot) {
+            console.log(`${lc} complete.`);
+        }
+    }
+}
+/**
+ * confirmation side of verifying if a consumer's password is **probably**
+ * correct. Basically computes the silly hash of the password and checks to see
+ * if it contains the given substring.
+ *
+ * @see {@link CheckIfPasswordProbablyCorrectInfo}
+ * @see {@link getCheckIfPasswordProbablyCorrectInfo}
+ */
+export async function passwordProbablyCorrect({ password, checkInfo, }) {
+    const lc = `[${passwordProbablyCorrect.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: ce745a0d8b5de7a24ddc83fe432e4224)`);
+        }
+        const { substring, recursionCount, saltPrependedPerHash, algorithm } = checkInfo;
+        const fullHash = await hash16816({
+            s: password,
+            recursionCount,
+            saltPrependedPerHash,
+            algorithm,
+        });
+        const resProbablyCorrect = fullHash.includes(substring);
+        return resProbablyCorrect;
+    }
+    catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+    finally {
+        if (logalot) {
+            console.log(`${lc} complete.`);
+        }
+    }
+}
+//# sourceMappingURL=secret-helper.mjs.map

package/dist/common/secret/secret-helper.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-helper.mjs","sourceRoot":"","sources":["../../../src/common/secret/secret-helper.mts"],"names":[],"mappings":"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"}

package/dist/common/secret/secret-types.d.mts

@@ -0,0 +1,192 @@
+/**
+ * @module secret types (and enums)
+ */
+import { HashAlgorithm } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { IbGibData_V1, IbGibRel8ns_V1, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+export type SecretType = "password";
+export declare const SecretType: {
+    password: "password";
+};
+export declare const VALID_SECRET_TYPES: "password"[];
+export interface SecretInfo {
+    name: string;
+    description?: string;
+    expirationUTC: string;
+    type: SecretType;
+}
+export interface SecretInfo_Password extends SecretInfo {
+    type: 'password';
+    /**
+     * @see {@link CheckIfPasswordProbablyCorrectInfo}
+     */
+    passwordProbablyCorrectInfo: CheckIfPasswordProbablyCorrectInfo;
+    /**
+     * Public hint to help you remember your secret (or help the bad person
+     * attack your secret).
+     */
+    hint?: string;
+}
+/**
+ * This contains information for doing a **convenience check** of whether or
+ * not the user/consumer has entered a password that is "probably" correct.
+ *
+ * ## READ THIS
+ *
+ * Distributed sovereignty has different requirements than a trusted server
+ * approach when it comes to handling secrets.
+ *
+ * ### trusted servers store entire hashes for authentication
+ *
+ * In a trusted server approach, we will check the password against some hashing
+ * mechanism with varying implementation details. But we will almost certainly
+ * check against the entire hash, because we will decide authentication based on
+ * this proof.
+ *
+ * ### distributed data works differently
+ *
+ * In the distributed model, however, the only utility of a password is in
+ * encryption and signatures. So when a user/consumer enters a password, it
+ * actually **does** something, i.e., creates derivative data. Either it creates
+ * an encrypted file or performs a signature (I hesitate to discuss asymmetric
+ * encryption because I still don't believe in it, and when keystones are
+ * implemented in ibgib, passwords will evolve the stone (it works _somewhat_
+ * similarly to a double-ratchet algorithm but is more hardened and expressive
+ * because it works on top of ibgib's already-established "chaining"
+ * infrastructure)).
+ *
+ * But the question is:
+ *   **How does the user/consumer know that they entered the right password?**
+ *
+ * ### we can't store entire hashes
+ *
+ * In the distributed model, we assume a brute-forcer will have access to the
+ * encrypted data and any metadata we might store. This includes those would-be
+ * hashes and that would be bad - even if they are randomly salted.
+ *
+ * This is because this approach would preclude the ability for the user to
+ * encrypt some large data with mitigations against short-circuit decryption
+ * until the entire data block was decrypted (I refer you to encrypt-gib
+ * documentation here). IOW, the brute-forcer would only have to use the
+ * password and check against the hash, which can be an extremely quick
+ * operation - even if we set iterations insanely high on some KDF, this still
+ * would provide a relatively quick avenue for brute force attacks.
+ *
+ * ### we can store partial hashes
+ *
+ * We won't save the entire hash, just some substring of the hash. (We could
+ * conceivably store other metadata that checks against the hash, e.g., parity
+ * checks like the number of 1s, 2s, etc.).
+ *
+ * ### partial hash dynamics
+ *
+ * * The larger the partial hash, the less likely false collisions are produced.
+ *   * when a user typos a password, we do NOT want a false collision.
+ *   * when a brute-forcer makes a password attempt, we DO want a false
+ *     collision.
+ * * a user's **unique** typos compose the set that we want to avoid false
+ *   collisions.
+ *   * the same typo only counts once.
+ *
+ * So we want to...
+ * * maximize the time wasted in brute forcing
+ *   * or IOW, minimize the information gained by the brute forcer
+ *   * this will statistically slow down brute force attacks that work against
+ *     this information alone.
+ * * minimize the inconvenience by a password failure due to a false collision
+ *   by the legitimate user/consumer.
+ *   * there should be in place a well-hardened fail path for when the false
+ *     password is given but the false collision allows it to pass the initial
+ *     quick check phase.
+ *
+ * ### my implementation notes
+ *
+ * I am not doing this mathematically/rigorously, because that would take way
+ * too long, rather I am working from...
+ * * my personal experience with searching for hashes in the ibgib code bases.
+ *   * Most ibgib codebase error messages are accompanied by a hash to uniquely
+ *     identify the error.
+ *   * I often search the codebase based on a substring of this when I am
+ *     troubleshooting.
+ *   * atow (02/2024) there are 1171 of these hashes in just core-gib.
+ *   * To get a unique hash, the absolute MOST I have to actually enter is 4 or
+ *     5 letters
+ *     * 5 is extremely rare.
+ * * unit testing observations
+ *   * I've found that 4 letters gives false collisions on average every 900-ish
+ *     hashes.
+ *
+ * As such, I am setting the length to 4. But note that in consuming code, we
+ * always just check for the substring, so changing this value in the future
+ * should not affect code a la an exception thrown, but rather, it will just
+ * change this dynamic of good faith typos vs. brute force cracking.
+ *
+ * ## warnings
+ *
+ * NOTHING GIVING ACTUAL AUTHORIZATION SHOULD CHECK AGAINST THIS INFO.
+ * NOTHING GIVING ACTUAL AUTHORIZATION SHOULD CHECK AGAINST THIS INFO.
+ * NOTHING GIVING ACTUAL AUTHORIZATION SHOULD CHECK AGAINST THIS INFO.
+ * NOTHING GIVING ACTUAL AUTHORIZATION SHOULD CHECK AGAINST THIS INFO.
+ */
+export interface CheckIfPasswordProbablyCorrectInfo {
+    /**
+     * NOTHING GIVING ACTUAL AUTHORIZATION SHOULD CHECK AGAINST THIS INFO.
+     * NOTHING GIVING ACTUAL AUTHORIZATION SHOULD CHECK AGAINST THIS INFO.
+     * NOTHING GIVING ACTUAL AUTHORIZATION SHOULD CHECK AGAINST THIS INFO.
+     * @see {CheckIfPasswordProbablyCorrectInfo}
+     *
+     * substring contained in the resultant recursive hash built on the password
+     * and other parameters of this info.
+     *
+     * other parameters:
+     * * {@link recursions}
+     * * {@link saltPrependedPerHash}
+     * * {@link algorithm}
+     */
+    substring: string;
+    /**
+     * the number of times to recursively call the hash function, analogous to a
+     * naive key stretching algorithm.
+     */
+    recursionCount: number;
+    /**
+     * salt that will be prepended to the password/intermediate hash each hash
+     * round.
+     */
+    saltPrependedPerHash: string;
+    /**
+     * hash algorithm to use per hash round.
+     */
+    algorithm: HashAlgorithm;
+}
+/**
+ * ibgib's intrinsic data.
+ *
+ * atow (02/2024) we are doing most of this in {@link SecretInfo} (from ionic-gib port)
+ *
+ * @see {@link SecretInfo}
+ * @see {@link IbGib_V1.data}
+ * @see {@link SecretIbGib_V1}
+ */
+export interface SecretData_V1 extends IbGibData_V1, SecretInfo {
+}
+/**
+ * rel8ns (named edges/links in DAG) go here.
+ *
+ * @see {@link IbGib_V1.rel8ns}
+ * @see {@link SecretIbGib_V1}
+ */
+export interface SecretRel8ns_V1 extends IbGibRel8ns_V1 {
+}
+/**
+ * this is the ibgib object itself.
+ *
+ * If this is a plain ibgib data only object, this acts as a dto. You may also
+ * want to generate a witness ibgib, which is slightly different, for ibgibs
+ * that will have behavior (i.e. methods).
+ *
+ * @see {@link SecretData_V1}
+ * @see {@link SecretRel8ns_V1}
+ */
+export interface SecretIbGib_V1 extends IbGib_V1<SecretData_V1, SecretRel8ns_V1> {
+}
+//# sourceMappingURL=secret-types.d.mts.map

package/dist/common/secret/secret-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-types.d.mts","sourceRoot":"","sources":["../../../src/common/secret/secret-types.mts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEzF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC;AACpC,eAAO,MAAM,UAAU;;CAEtB,CAAA;AACD,eAAO,MAAM,kBAAkB,cAAqC,CAAC;AAErE,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;CACpB;AAED,MAAM,WAAW,mBAAoB,SAAQ,UAAU;IACnD,IAAI,EAAE,UAAU,CAAC;IAEjB;;OAEG;IACH,2BAA2B,EAAE,kCAAkC,CAAC;IAEhE;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoGG;AACH,MAAM,WAAW,kCAAkC;IAC/C;;;;;;;;;;;;;OAaG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;OAEG;IACH,SAAS,EAAE,aAAa,CAAC;CAC5B;AAGD;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAc,SAAQ,YAAY,EAAE,UAAU;CAC9D;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAgB,SAAQ,cAAc;CAatD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAe,SAAQ,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAC;CAE/E"}

package/dist/common/secret/secret-types.mjs

@@ -0,0 +1,8 @@
+/**
+ * @module secret types (and enums)
+ */
+export const SecretType = {
+    password: 'password',
+};
+export const VALID_SECRET_TYPES = Object.values(SecretType).concat();
+//# sourceMappingURL=secret-types.mjs.map

package/dist/common/secret/secret-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-types.mjs","sourceRoot":"","sources":["../../../src/common/secret/secret-types.mts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,QAAQ,EAAE,UAAwB;CACrC,CAAA;AACD,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,CAAC"}

package/dist/common/secret/secret.respec.d.mts

@@ -0,0 +1,7 @@
+/**
+ * @module secret respec
+ *
+ * we gotta test our secret
+ */
+export {};
+//# sourceMappingURL=secret.respec.d.mts.map

package/dist/common/secret/secret.respec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret.respec.d.mts","sourceRoot":"","sources":["../../../src/common/secret/secret.respec.mts"],"names":[],"mappings":"AAAA;;;;GAIG"}