@smoothbricks/cli 0.11.19 → 0.11.21

package/dist/secrets/status.js

@@ -0,0 +1,724 @@
+import * as _assertGuard_1 from "typia/lib/internal/_assertGuard";
+import * as _jsonStringifyNumber_1 from "typia/lib/internal/_jsonStringifyNumber";
+import * as _jsonStringifyArray_1 from "typia/lib/internal/_jsonStringifyArray";
+import * as _jsonStringifyString_1 from "typia/lib/internal/_jsonStringifyString";
+import * as _throwTypeGuardError_1 from "typia/lib/internal/_throwTypeGuardError";
+import * as _validateReport_1 from "typia/lib/internal/_validateReport";
+/**
+ * The value model behind `smoo secrets`: one row per secret name, reconciled
+ * from every source that has an opinion about it, plus the machine-readable
+ * document `smoo secrets status --json` emits.
+ *
+ * Everything here is pure and depends on nothing but typia, which is what lets
+ * `@smoothbricks/cli/secrets` be imported for the types alone — a consumer
+ * driving a UI or a repository's own operations CLI gets the document type and
+ * a validator without pulling in `gh`, the filesystem readers, or commander.
+ * The readers that produce these facts live in ./index.ts; the operator
+ * commands that print them live in ./commands.ts.
+ */
+import typia from 'typia';
+/**
+ * One row per name known to any source, sorted, so a reader sees the whole
+ * picture rather than one source's view of it.
+ */
+export function reconcileSecrets(sources) {
+    const declaredByAnyWorker = Object.values(sources.workerSecrets).flatMap((names) => [...names]);
+    const localSecrets = new Map(sources.localSecrets.map((secret) => [secret.name, secret]));
+    const names = new Set([...declaredByAnyWorker, ...sources.workflowSecrets, ...localSecrets.keys()]);
+    // A repository secret that already carries a known env name is that name's
+    // row, not a row of its own: listing ACME_GITHUB_CLIENT_SECRET beside
+    // GITHUB_CLIENT_SECRET would report one value as two secrets, one of them
+    // permanently "declared by nothing".
+    const carriesKnownEnvName = new Set(names.size > 0 ? [...names].map((name) => sources.secretNames[name] ?? name) : []);
+    // A value only an environment holds is still a value: leaving it out of the
+    // rows is how an operator ends up hunting for a secret that is already set.
+    const addUndeclared = (secret) => {
+        if (!carriesKnownEnvName.has(secret))
+            names.add(secret);
+    };
+    for (const secret of sources.repositorySecrets)
+        addUndeclared(secret);
+    for (const held of Object.values(sources.environmentSecrets ?? {})) {
+        for (const secret of held)
+            addUndeclared(secret);
+    }
+    return [...names]
+        .sort((left, right) => left.localeCompare(right))
+        .map((name) => {
+        const local = localSecrets.get(name);
+        return {
+            name,
+            repositorySecret: sources.secretNames[name] ?? name,
+            declaredByWorkers: Object.entries(sources.workerSecrets)
+                .filter(([, declared]) => declared.includes(name))
+                .map(([label]) => label)
+                .sort((left, right) => left.localeCompare(right)),
+            suppliedByWorkflow: sources.workflowSecrets.includes(name),
+            fetchableLocally: local !== undefined,
+            ...(local === undefined ? {} : { localGroup: { resolves: local.group, derived: local.derivedGroup } }),
+            onRepository: sources.repositorySecrets.includes(sources.secretNames[name] ?? name),
+            heldByEnvironment: Object.entries(sources.environmentSecrets ?? {})
+                .filter(([, held]) => held.includes(sources.secretNames[name] ?? name))
+                .map(([environment]) => environment)
+                .sort((left, right) => left.localeCompare(right)),
+        };
+    });
+}
+/**
+ * The rows a CI deploy cannot satisfy: a Worker declares the name, a workflow
+ * promises to pass it, and the repository has no value to pass. Reported
+ * separately from "declared but not wired into any workflow", because the
+ * remedies differ — set a secret, versus declare it in `smoo.github`.
+ */
+export function unsatisfiedSecrets(rows, boundEnvironments = []) {
+    return rows.filter((row) => {
+        if (!row.suppliedByWorkflow)
+            return false;
+        if (row.onRepository)
+            return false;
+        // With no environment bound, the repository is the only scope a job reads.
+        // With environments bound, each one can carry the value instead - so the
+        // name is satisfied only when every bound environment holds it.
+        if (boundEnvironments.length === 0)
+            return true;
+        return !boundEnvironments.every((environment) => row.heldByEnvironment.includes(environment));
+    });
+}
+/** Bound environments that lack their own value and cannot fall back to the repository. */
+export function environmentsMissing(row, boundEnvironments) {
+    if (row.onRepository)
+        return [];
+    return boundEnvironments.filter((environment) => !row.heldByEnvironment.includes(environment));
+}
+/** Worker-declared names no managed workflow passes: a CI deploy will run without them. */
+export function unwiredSecrets(rows) {
+    return rows.filter((row) => row.declaredByWorkers.length > 0 && !row.suppliedByWorkflow);
+}
+/**
+ * Every stage a scope can name, in the order the document lists them. A
+ * declared secret absent from `smoo.wrangler.secretStages` belongs to all of
+ * them, which is the rule this constant spells out exactly once.
+ */
+const EVERY_STAGE = ['preview', 'production', 'staging'];
+/**
+ * The stages that require a value for one name: the union over every worker
+ * declaring it, since a name two projects share must exist wherever either of
+ * them deploys.
+ */
+function requiredByStages(name, workers, stageScopes) {
+    const required = new Set();
+    for (const worker of workers) {
+        const scoped = stageScopes[worker]?.[name];
+        // No scope declared for a name the worker declares is "every stage": the
+        // map is an exception list, not a registry.
+        for (const stage of scoped ?? EVERY_STAGE)
+            required.add(stage);
+    }
+    return EVERY_STAGE.filter((stage) => required.has(stage));
+}
+/** The document, from facts. Pure: every read happened before this was called. */
+export function projectSecretsStatus(facts) {
+    const secrets = facts.rows.map((row) => ({
+        ...row,
+        requiredByStages: requiredByStages(row.name, row.declaredByWorkers, facts.stageScopes),
+    }));
+    // Only an environment a workflow binds *and* `gh` could list is a scope a job
+    // is known to read: an unreadable one is unknown, not empty.
+    const bound = facts.environments
+        .filter((environment) => environment.bound && environment.readable)
+        .map((environment) => environment.name);
+    return {
+        version: 1,
+        repository: facts.repository,
+        environments: [...facts.environments],
+        secrets,
+        unsatisfied: unsatisfiedSecrets(secrets, bound).map((row) => ({
+            name: row.name,
+            repositorySecret: row.repositorySecret,
+            missingIn: environmentsMissing(row, bound),
+        })),
+    };
+}
+/**
+ * The consumer's boundary: text off a `smoo secrets status --json` run into a
+ * validated document, or typia's own account of every field that disagreed.
+ */
+export const parseSecretsStatusDocument = (() => {
+    const _ip0 = input => "number" === typeof input["secretCount"];
+    const _ip1 = input => "string" === typeof input["name"];
+    const _ip2 = input => "boolean" === typeof input["bound"];
+    const _ip3 = input => "string" === typeof input["repositorySecret"];
+    const _ve0 = "({ name: string; bound: boolean; readable: false; reason: string; } | { name: string; bound: boolean; readable: true; secretCount: number; })";
+    const _vp0 = (input, _path, _exceptionable = true) => "number" === typeof input["secretCount"] || _report(_exceptionable, {
+        path: _path + ".secretCount",
+        expected: "number",
+        value: input["secretCount"]
+    });
+    const _vp1 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _report(_exceptionable, {
+        path: _path + ".name",
+        expected: "string",
+        value: input["name"]
+    });
+    const _vp2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["bound"] || _report(_exceptionable, {
+        path: _path + ".bound",
+        expected: "boolean",
+        value: input["bound"]
+    });
+    const _vp3 = (input, _path, _exceptionable = true) => "string" === typeof input["repositorySecret"] || _report(_exceptionable, {
+        path: _path + ".repositorySecret",
+        expected: "string",
+        value: input["repositorySecret"]
+    });
+    const _ve1 = "({ name: string; bound: boolean; readable: true; secretCount: number; } | { name: string; bound: boolean; readable: false; reason: string; })";
+    const _io0 = input => 1 === input.version && ("object" === typeof input.repository && null !== input.repository && _io1(input.repository)) && (Array.isArray(input.environments) && input.environments.every(elem => "object" === typeof elem && null !== elem && _iu0(elem))) && (Array.isArray(input.secrets) && input.secrets.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && (Array.isArray(input.unsatisfied) && input.unsatisfied.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
+    const _io1 = input => "string" === typeof input.repo && "string" === typeof input.source && _ip0(input);
+    const _io2 = input => _ip1(input) && _ip2(input) && true === input.readable && _ip0(input);
+    const _io3 = input => _ip1(input) && _ip2(input) && false === input.readable && "string" === typeof input.reason;
+    const _io4 = input => _ip1(input) && _ip3(input) && (Array.isArray(input.declaredByWorkers) && input.declaredByWorkers.every(elem => "string" === typeof elem)) && "boolean" === typeof input.suppliedByWorkflow && "boolean" === typeof input.fetchableLocally && (undefined === input.localGroup || "object" === typeof input.localGroup && null !== input.localGroup && _io5(input.localGroup)) && "boolean" === typeof input.onRepository && (Array.isArray(input.heldByEnvironment) && input.heldByEnvironment.every(elem => "string" === typeof elem)) && (Array.isArray(input.requiredByStages) && input.requiredByStages.every(elem => "preview" === elem || "production" === elem || "staging" === elem));
+    const _io5 = input => "string" === typeof input.resolves && "string" === typeof input.derived;
+    const _io6 = input => _ip1(input) && _ip3(input) && (Array.isArray(input.missingIn) && input.missingIn.every(elem => "string" === typeof elem));
+    const _iu0 = input => (() => {
+        if (true === input.readable)
+            return _io2(input);
+        else if (false === input.readable)
+            return _io3(input);
+        else
+            return false;
+    })();
+    const _vo0 = (input, _path, _exceptionable = true) => [1 === input.version || _report(_exceptionable, {
+            path: _path + ".version",
+            expected: "1",
+            value: input.version
+        }), ("object" === typeof input.repository && null !== input.repository || _report(_exceptionable, {
+            path: _path + ".repository",
+            expected: "SecretsStatusRepository",
+            value: input.repository
+        })) && _vo1(input.repository, _path + ".repository", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".repository",
+            expected: "SecretsStatusRepository",
+            value: input.repository
+        }), (Array.isArray(input.environments) || _report(_exceptionable, {
+            path: _path + ".environments",
+            expected: "Array<SecretsStatusEnvironment>",
+            value: input.environments
+        })) && input.environments.map((elem, _index8) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".environments[" + _index8 + "]",
+            expected: _ve0,
+            value: elem
+        })) && _vu0(elem, _path + ".environments[" + _index8 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".environments[" + _index8 + "]",
+            expected: _ve0,
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".environments",
+            expected: "Array<SecretsStatusEnvironment>",
+            value: input.environments
+        }), (Array.isArray(input.secrets) || _report(_exceptionable, {
+            path: _path + ".secrets",
+            expected: "Array<SecretsStatusRow>",
+            value: input.secrets
+        })) && input.secrets.map((elem, _index9) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".secrets[" + _index9 + "]",
+            expected: "SecretsStatusRow",
+            value: elem
+        })) && _vo4(elem, _path + ".secrets[" + _index9 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".secrets[" + _index9 + "]",
+            expected: "SecretsStatusRow",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".secrets",
+            expected: "Array<SecretsStatusRow>",
+            value: input.secrets
+        }), (Array.isArray(input.unsatisfied) || _report(_exceptionable, {
+            path: _path + ".unsatisfied",
+            expected: "Array<UnsatisfiedSecret>",
+            value: input.unsatisfied
+        })) && input.unsatisfied.map((elem, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+            path: _path + ".unsatisfied[" + _index10 + "]",
+            expected: "UnsatisfiedSecret",
+            value: elem
+        })) && _vo6(elem, _path + ".unsatisfied[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".unsatisfied[" + _index10 + "]",
+            expected: "UnsatisfiedSecret",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".unsatisfied",
+            expected: "Array<UnsatisfiedSecret>",
+            value: input.unsatisfied
+        })].every(flag => flag);
+    const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.repo || _report(_exceptionable, {
+            path: _path + ".repo",
+            expected: "string",
+            value: input.repo
+        }), "string" === typeof input.source || _report(_exceptionable, {
+            path: _path + ".source",
+            expected: "string",
+            value: input.source
+        }), _vp0(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo2 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), _vp2(input, _path, true && _exceptionable), true === input.readable || _report(_exceptionable, {
+            path: _path + ".readable",
+            expected: "true",
+            value: input.readable
+        }), _vp0(input, _path, true && _exceptionable)].every(flag => flag);
+    const _vo3 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), _vp2(input, _path, true && _exceptionable), false === input.readable || _report(_exceptionable, {
+            path: _path + ".readable",
+            expected: "false",
+            value: input.readable
+        }), "string" === typeof input.reason || _report(_exceptionable, {
+            path: _path + ".reason",
+            expected: "string",
+            value: input.reason
+        })].every(flag => flag);
+    const _vo4 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), _vp3(input, _path, true && _exceptionable), (Array.isArray(input.declaredByWorkers) || _report(_exceptionable, {
+            path: _path + ".declaredByWorkers",
+            expected: "Array<string>",
+            value: input.declaredByWorkers
+        })) && input.declaredByWorkers.map((elem, _index11) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".declaredByWorkers[" + _index11 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".declaredByWorkers",
+            expected: "Array<string>",
+            value: input.declaredByWorkers
+        }), "boolean" === typeof input.suppliedByWorkflow || _report(_exceptionable, {
+            path: _path + ".suppliedByWorkflow",
+            expected: "boolean",
+            value: input.suppliedByWorkflow
+        }), "boolean" === typeof input.fetchableLocally || _report(_exceptionable, {
+            path: _path + ".fetchableLocally",
+            expected: "boolean",
+            value: input.fetchableLocally
+        }), undefined === input.localGroup || ("object" === typeof input.localGroup && null !== input.localGroup || _report(_exceptionable, {
+            path: _path + ".localGroup",
+            expected: "(undefined | { resolves: string; derived: string; })",
+            value: input.localGroup
+        })) && _vo5(input.localGroup, _path + ".localGroup", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".localGroup",
+            expected: "(undefined | { resolves: string; derived: string; })",
+            value: input.localGroup
+        }), "boolean" === typeof input.onRepository || _report(_exceptionable, {
+            path: _path + ".onRepository",
+            expected: "boolean",
+            value: input.onRepository
+        }), (Array.isArray(input.heldByEnvironment) || _report(_exceptionable, {
+            path: _path + ".heldByEnvironment",
+            expected: "Array<string>",
+            value: input.heldByEnvironment
+        })) && input.heldByEnvironment.map((elem, _index12) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".heldByEnvironment[" + _index12 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".heldByEnvironment",
+            expected: "Array<string>",
+            value: input.heldByEnvironment
+        }), (Array.isArray(input.requiredByStages) || _report(_exceptionable, {
+            path: _path + ".requiredByStages",
+            expected: "Array<SecretStageScope>",
+            value: input.requiredByStages
+        })) && input.requiredByStages.map((elem, _index13) => "preview" === elem || "production" === elem || "staging" === elem || _report(_exceptionable, {
+            path: _path + ".requiredByStages[" + _index13 + "]",
+            expected: "(\"preview\" | \"production\" | \"staging\")",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".requiredByStages",
+            expected: "Array<SecretStageScope>",
+            value: input.requiredByStages
+        })].every(flag => flag);
+    const _vo5 = (input, _path, _exceptionable = true) => ["string" === typeof input.resolves || _report(_exceptionable, {
+            path: _path + ".resolves",
+            expected: "string",
+            value: input.resolves
+        }), "string" === typeof input.derived || _report(_exceptionable, {
+            path: _path + ".derived",
+            expected: "string",
+            value: input.derived
+        })].every(flag => flag);
+    const _vo6 = (input, _path, _exceptionable = true) => [_vp1(input, _path, true && _exceptionable), _vp3(input, _path, true && _exceptionable), (Array.isArray(input.missingIn) || _report(_exceptionable, {
+            path: _path + ".missingIn",
+            expected: "Array<string>",
+            value: input.missingIn
+        })) && input.missingIn.map((elem, _index14) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".missingIn[" + _index14 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".missingIn",
+            expected: "Array<string>",
+            value: input.missingIn
+        })].every(flag => flag);
+    const _vu0 = (input, _path, _exceptionable = true) => (() => {
+        if (true === input.readable)
+            return _vo2(input, _path, true && _exceptionable);
+        else if (false === input.readable)
+            return _vo3(input, _path, true && _exceptionable);
+        else
+            return _report(_exceptionable, {
+                path: _path,
+                expected: _ve1,
+                value: input
+            });
+    })();
+    const __is = input => "object" === typeof input && null !== input && _io0(input);
+    let errors;
+    let _report;
+    const __validate = input => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = _validateReport_1._validateReport(errors);
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                path: _path + "",
+                expected: "SecretsStatusDocument",
+                value: input
+            })) && _vo0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: "SecretsStatusDocument",
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
+        }
+        return {
+            success: true,
+            data: input
+        };
+    };
+    return input => __validate(JSON.parse(input));
+})();
+/**
+ * The emitter's boundary: the projection is checked against its declared type
+ * before it becomes text. A shape bug then fails here, naming the field, rather
+ * than reaching a consumer as a document its validator rejects with no idea who
+ * produced it.
+ */
+export const stringifySecretsStatusDocument = (() => {
+    const _ip0 = input => "number" === typeof input["secretCount"] && Number.isFinite(input["secretCount"]);
+    const _ip1 = input => "string" === typeof input["name"];
+    const _ip2 = input => "boolean" === typeof input["bound"];
+    const _ip3 = input => "string" === typeof input["repositorySecret"];
+    const _ae0 = "({ name: string; bound: boolean; readable: false; reason: string; } | { name: string; bound: boolean; readable: true; secretCount: number; })";
+    const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["secretCount"] && Number.isFinite(input["secretCount"]) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".secretCount",
+        expected: "number",
+        value: input["secretCount"]
+    }, _errorFactory);
+    const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".name",
+        expected: "string",
+        value: input["name"]
+    }, _errorFactory);
+    const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["bound"] || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".bound",
+        expected: "boolean",
+        value: input["bound"]
+    }, _errorFactory);
+    const _ap3 = (input, _path, _exceptionable = true) => "string" === typeof input["repositorySecret"] || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".repositorySecret",
+        expected: "string",
+        value: input["repositorySecret"]
+    }, _errorFactory);
+    const _ae1 = "({ name: string; bound: boolean; readable: true; secretCount: number; } | { name: string; bound: boolean; readable: false; reason: string; })";
+    const _sip0 = input => "number" === typeof input["secretCount"];
+    const _sip1 = input => "string" === typeof input["name"];
+    const _sip2 = input => "boolean" === typeof input["bound"];
+    const _sip3 = input => "string" === typeof input["repositorySecret"];
+    const _ao0 = (input, _path, _exceptionable = true) => (1 === input.version || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".version",
+        expected: "1",
+        value: input.version
+    }, _errorFactory)) && (("object" === typeof input.repository && null !== input.repository || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".repository",
+        expected: "SecretsStatusRepository",
+        value: input.repository
+    }, _errorFactory)) && _ao1(input.repository, _path + ".repository", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".repository",
+        expected: "SecretsStatusRepository",
+        value: input.repository
+    }, _errorFactory)) && ((Array.isArray(input.environments) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".environments",
+        expected: "Array<SecretsStatusEnvironment>",
+        value: input.environments
+    }, _errorFactory)) && input.environments.every((elem, _index8) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".environments[" + _index8 + "]",
+        expected: _ae0,
+        value: elem
+    }, _errorFactory)) && _au0(elem, _path + ".environments[" + _index8 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".environments[" + _index8 + "]",
+        expected: _ae0,
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".environments",
+        expected: "Array<SecretsStatusEnvironment>",
+        value: input.environments
+    }, _errorFactory)) && ((Array.isArray(input.secrets) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".secrets",
+        expected: "Array<SecretsStatusRow>",
+        value: input.secrets
+    }, _errorFactory)) && input.secrets.every((elem, _index9) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".secrets[" + _index9 + "]",
+        expected: "SecretsStatusRow",
+        value: elem
+    }, _errorFactory)) && _ao4(elem, _path + ".secrets[" + _index9 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".secrets[" + _index9 + "]",
+        expected: "SecretsStatusRow",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".secrets",
+        expected: "Array<SecretsStatusRow>",
+        value: input.secrets
+    }, _errorFactory)) && ((Array.isArray(input.unsatisfied) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".unsatisfied",
+        expected: "Array<UnsatisfiedSecret>",
+        value: input.unsatisfied
+    }, _errorFactory)) && input.unsatisfied.every((elem, _index10) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".unsatisfied[" + _index10 + "]",
+        expected: "UnsatisfiedSecret",
+        value: elem
+    }, _errorFactory)) && _ao6(elem, _path + ".unsatisfied[" + _index10 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".unsatisfied[" + _index10 + "]",
+        expected: "UnsatisfiedSecret",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".unsatisfied",
+        expected: "Array<UnsatisfiedSecret>",
+        value: input.unsatisfied
+    }, _errorFactory));
+    const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.repo || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".repo",
+        expected: "string",
+        value: input.repo
+    }, _errorFactory)) && ("string" === typeof input.source || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".source",
+        expected: "string",
+        value: input.source
+    }, _errorFactory)) && _ap0(input, _path, true && _exceptionable);
+    const _ao2 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && (true === input.readable || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".readable",
+        expected: "true",
+        value: input.readable
+    }, _errorFactory)) && _ap0(input, _path, true && _exceptionable);
+    const _ao3 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && (false === input.readable || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".readable",
+        expected: "false",
+        value: input.readable
+    }, _errorFactory)) && ("string" === typeof input.reason || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".reason",
+        expected: "string",
+        value: input.reason
+    }, _errorFactory));
+    const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.declaredByWorkers) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".declaredByWorkers",
+        expected: "Array<string>",
+        value: input.declaredByWorkers
+    }, _errorFactory)) && input.declaredByWorkers.every((elem, _index11) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".declaredByWorkers[" + _index11 + "]",
+        expected: "string",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".declaredByWorkers",
+        expected: "Array<string>",
+        value: input.declaredByWorkers
+    }, _errorFactory)) && ("boolean" === typeof input.suppliedByWorkflow || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".suppliedByWorkflow",
+        expected: "boolean",
+        value: input.suppliedByWorkflow
+    }, _errorFactory)) && ("boolean" === typeof input.fetchableLocally || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".fetchableLocally",
+        expected: "boolean",
+        value: input.fetchableLocally
+    }, _errorFactory)) && (undefined === input.localGroup || ("object" === typeof input.localGroup && null !== input.localGroup || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".localGroup",
+        expected: "(undefined | { resolves: string; derived: string; })",
+        value: input.localGroup
+    }, _errorFactory)) && _ao5(input.localGroup, _path + ".localGroup", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".localGroup",
+        expected: "(undefined | { resolves: string; derived: string; })",
+        value: input.localGroup
+    }, _errorFactory)) && ("boolean" === typeof input.onRepository || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".onRepository",
+        expected: "boolean",
+        value: input.onRepository
+    }, _errorFactory)) && ((Array.isArray(input.heldByEnvironment) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".heldByEnvironment",
+        expected: "Array<string>",
+        value: input.heldByEnvironment
+    }, _errorFactory)) && input.heldByEnvironment.every((elem, _index12) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".heldByEnvironment[" + _index12 + "]",
+        expected: "string",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".heldByEnvironment",
+        expected: "Array<string>",
+        value: input.heldByEnvironment
+    }, _errorFactory)) && ((Array.isArray(input.requiredByStages) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".requiredByStages",
+        expected: "Array<SecretStageScope>",
+        value: input.requiredByStages
+    }, _errorFactory)) && input.requiredByStages.every((elem, _index13) => "preview" === elem || "production" === elem || "staging" === elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".requiredByStages[" + _index13 + "]",
+        expected: "(\"preview\" | \"production\" | \"staging\")",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".requiredByStages",
+        expected: "Array<SecretStageScope>",
+        value: input.requiredByStages
+    }, _errorFactory));
+    const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.resolves || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".resolves",
+        expected: "string",
+        value: input.resolves
+    }, _errorFactory)) && ("string" === typeof input.derived || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".derived",
+        expected: "string",
+        value: input.derived
+    }, _errorFactory));
+    const _ao6 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.missingIn) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".missingIn",
+        expected: "Array<string>",
+        value: input.missingIn
+    }, _errorFactory)) && input.missingIn.every((elem, _index14) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".missingIn[" + _index14 + "]",
+        expected: "string",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.json.createAssertStringify",
+        path: _path + ".missingIn",
+        expected: "Array<string>",
+        value: input.missingIn
+    }, _errorFactory));
+    const _au0 = (input, _path, _exceptionable = true) => (() => {
+        if (true === input.readable)
+            return _ao2(input, _path, true && _exceptionable);
+        else if (false === input.readable)
+            return _ao3(input, _path, true && _exceptionable);
+        else
+            return _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.json.createAssertStringify",
+                path: _path,
+                expected: _ae1,
+                value: input
+            }, _errorFactory);
+    })();
+    const _io0 = input => 1 === input.version && ("object" === typeof input.repository && null !== input.repository && _io1(input.repository)) && (Array.isArray(input.environments) && input.environments.every(elem => "object" === typeof elem && null !== elem && _iu0(elem))) && (Array.isArray(input.secrets) && input.secrets.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && (Array.isArray(input.unsatisfied) && input.unsatisfied.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
+    const _io1 = input => "string" === typeof input.repo && "string" === typeof input.source && _ip0(input);
+    const _io2 = input => _ip1(input) && _ip2(input) && true === input.readable && _ip0(input);
+    const _io3 = input => _ip1(input) && _ip2(input) && false === input.readable && "string" === typeof input.reason;
+    const _io4 = input => _ip1(input) && _ip3(input) && (Array.isArray(input.declaredByWorkers) && input.declaredByWorkers.every(elem => "string" === typeof elem)) && "boolean" === typeof input.suppliedByWorkflow && "boolean" === typeof input.fetchableLocally && (undefined === input.localGroup || "object" === typeof input.localGroup && null !== input.localGroup && _io5(input.localGroup)) && "boolean" === typeof input.onRepository && (Array.isArray(input.heldByEnvironment) && input.heldByEnvironment.every(elem => "string" === typeof elem)) && (Array.isArray(input.requiredByStages) && input.requiredByStages.every(elem => "preview" === elem || "production" === elem || "staging" === elem));
+    const _io5 = input => "string" === typeof input.resolves && "string" === typeof input.derived;
+    const _io6 = input => _ip1(input) && _ip3(input) && (Array.isArray(input.missingIn) && input.missingIn.every(elem => "string" === typeof elem));
+    const _iu0 = input => (() => {
+        if (true === input.readable)
+            return _io2(input);
+        else if (false === input.readable)
+            return _io3(input);
+        else
+            return false;
+    })();
+    const _so0 = input => `{"version":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.version))},"repository":${_so1(input.repository)},"environments":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.environments, elem => _su0(elem))}]`},"secrets":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.secrets, elem => _so4(elem))}]`},"unsatisfied":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.unsatisfied, elem => _so6(elem))}]`}}`;
+    const _so1 = input => `{"repo":${_jsonStringifyString_1._jsonStringifyString(input.repo)},"source":${_jsonStringifyString_1._jsonStringifyString(input.source)},"secretCount":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.secretCount))}}`;
+    const _so2 = input => `{"name":${_jsonStringifyString_1._jsonStringifyString(input.name)},"bound":${String(input.bound)},"readable":${String(input.readable)},"secretCount":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.secretCount))}}`;
+    const _so3 = input => `{"name":${_jsonStringifyString_1._jsonStringifyString(input.name)},"bound":${String(input.bound)},"readable":${String(input.readable)},"reason":${_jsonStringifyString_1._jsonStringifyString(input.reason)}}`;
+    const _so4 = input => `{"name":${_jsonStringifyString_1._jsonStringifyString(input.name)},"repositorySecret":${_jsonStringifyString_1._jsonStringifyString(input.repositorySecret)},"declaredByWorkers":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.declaredByWorkers, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`},"suppliedByWorkflow":${String(input.suppliedByWorkflow)},"fetchableLocally":${String(input.fetchableLocally)},${undefined === input.localGroup ? "" : `"localGroup":${undefined !== input.localGroup ? _so5(input.localGroup) : undefined},`}"onRepository":${String(input.onRepository)},"heldByEnvironment":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.heldByEnvironment, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`},"requiredByStages":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.requiredByStages, elem => "\"" + elem + "\"")}]`}}`;
+    const _so5 = input => `{"resolves":${_jsonStringifyString_1._jsonStringifyString(input.resolves)},"derived":${_jsonStringifyString_1._jsonStringifyString(input.derived)}}`;
+    const _so6 = input => `{"name":${_jsonStringifyString_1._jsonStringifyString(input.name)},"repositorySecret":${_jsonStringifyString_1._jsonStringifyString(input.repositorySecret)},"missingIn":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.missingIn, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`}}`;
+    const _su0 = input => (() => {
+        if (true === input.readable)
+            return _so2(input);
+        else if (false === input.readable)
+            return _so3(input);
+        else
+            _throwTypeGuardError_1._throwTypeGuardError({
+                method: "typia.json.createAssertStringify",
+                expected: "({ name: string; bound: boolean; readable: true; secretCount: number; } | { name: string; bound: boolean; readable: false; reason: string; })",
+                value: input
+            });
+    })();
+    const __is = input => "object" === typeof input && null !== input && _io0(input);
+    let _errorFactory;
+    const _sio1 = input => "string" === typeof input.repo && "string" === typeof input.source && _sip0(input);
+    const _sio2 = input => _sip1(input) && _sip2(input) && true === input.readable && _sip0(input);
+    const _sio3 = input => _sip1(input) && _sip2(input) && false === input.readable && "string" === typeof input.reason;
+    const _sio4 = input => _sip1(input) && _sip3(input) && (Array.isArray(input.declaredByWorkers) && input.declaredByWorkers.every(elem => "string" === typeof elem)) && "boolean" === typeof input.suppliedByWorkflow && "boolean" === typeof input.fetchableLocally && (undefined === input.localGroup || "object" === typeof input.localGroup && null !== input.localGroup && _sio5(input.localGroup)) && "boolean" === typeof input.onRepository && (Array.isArray(input.heldByEnvironment) && input.heldByEnvironment.every(elem => "string" === typeof elem)) && (Array.isArray(input.requiredByStages) && input.requiredByStages.every(elem => "preview" === elem || "production" === elem || "staging" === elem));
+    const _sio5 = input => "string" === typeof input.resolves && "string" === typeof input.derived;
+    const _sio6 = input => _sip1(input) && _sip3(input) && (Array.isArray(input.missingIn) && input.missingIn.every(elem => "string" === typeof elem));
+    const _siu0 = input => (() => {
+        if (true === input.readable)
+            return _sio2(input);
+        else if (false === input.readable)
+            return _sio3(input);
+        else
+            return false;
+    })();
+    const __assert = (input, errorFactory) => {
+        if (false === __is(input)) {
+            _errorFactory = errorFactory;
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
+                method: "typia.json.createAssertStringify",
+                path: _path + "",
+                expected: "SecretsStatusDocument",
+                value: input
+            }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                method: "typia.json.createAssertStringify",
+                path: _path + "",
+                expected: "SecretsStatusDocument",
+                value: input
+            }, _errorFactory))(input, "$input", true);
+        }
+        return input;
+    };
+    const __stringify = input => _so0(input);
+    return (input, errorFactory) => {
+        __assert(input, errorFactory);
+        return __stringify(input);
+    };
+})();