@romaintaillandier1978/dotenv-never-lies 0.3.0 → 0.4.0

package/README.md

@@ -5,8 +5,6 @@
 **dotenv-never-lies** valide, type et documente tes variables d’environnement à partir d’un schéma TypeScript / Zod.  
 Il échoue **vite**, **fort**, et **avant la prod**.
 
----
-
 ## Pourquoi ?
 
 Parce que tout ça arrive **tout le temps** :
@@ -54,7 +52,7 @@ Ce package a un périmètre volontairement **limité**.
   Deno, Bun, Cloudflare Workers, edge runtimes : hors scope (pour l’instant).
 
 - ❌ **Ce n’est pas un framework de configuration global**  
-  Il ne gère ni les fichiers YAML/JSON, ni les profiles dynamiques,
+  Il ne gère ni les fichiers YAML/JSON, ni les profils dynamiques,
   ni les overrides magiques par environnement.
 
 - ❌ **Ce n’est pas permissif**  
@@ -67,30 +65,26 @@ qui préfèrent **échouer proprement au démarrage** plutôt que **bugger silen
 
 ---
 
-## Dependency warnings
-
-⚠️ Important
-dotenv-never-lies expose des schémas Zod dans son API publique.
-Zod v4 est requis.
-Mélanger les versions cassera l’inférence de types (et oui, ça fait mal).
-
 ## Installation
 
 ```bash
-yarn add dotenv-never-lies
+npm install @romaintaillandier1978/dotenv-never-lies
 # ou
-npm install dotenv-never-lies
+yarn add @romaintaillandier1978/dotenv-never-lies
 ```
 
-## Expansion des variables (`dotenv-expand`)
+## Dépendances et compatibilité
+
+**[`zod`](https://www.npmjs.com/package/zod)**, dotenv-never-lies expose des schémas Zod dans son API publique.
 
-**dotenv-never-lies** gère automatiquement l’expansion des variables d’environnement,
-via [`dotenv-expand`](https://www.npmjs.com/package/dotenv-expand).
+⚠️ _Important : Zod **v4.2.1** minimum est requis._
+Utiliser Zod v3 entraînera des erreurs de typage ou d’inférence.
 
-Cela permet de définir des variables composées à partir d’autres variables,
-sans duplication ni copier-coller fragile.
+**[`dotenv`](https://www.npmjs.com/package/dotenv)** permet à dotenv-never-lies de gérer automatiquement le parsing des fichiers env
 
-### Exemple
+**[`dotenv-expand`](https://www.npmjs.com/package/dotenv-expand)** permet à dotenv-never-lies de gérer automatiquement l’expansion des variables d’environnement. Cela permet de définir des variables composées à partir d’autres variables, sans duplication ni copier-coller fragile.
+
+**Exemple**
 
 ```env
 FRONT_A=https://a.site.com
@@ -100,13 +94,38 @@ FRONT_C=https://c.site.com
 NODE_CORS_ORIGIN="${FRONT_A};${FRONT_B};${FRONT_C}"
 ```
 
-## Définir un schéma
+## Schéma DNL
+
+Le schéma DNL est ta nouvelle source de vérité.
+
+(`dnl reverse-env` t'aidera à faire le premier squelette)
+
+### emplacement du schéma
 
-env.dnl.ts
+Recommandé : env.dnl.ts
+
+Supporté dans cet ordre pour toutes les commandes CLI :
+
+1. --schema path/to/my-dnl.ts
+2. déclaré dans le package.json :
+
+```json
+{
+    ...
+    "dotenv-never-lies": {
+        "schema": "path/to/my-dnl.ts"
+    }
+    ...
+}
+```
+
+3. un des "env.dnl.ts", "env.dnl.js", "dnl.config.ts", "dnl.config.js"
+
+### définir un schéma
 
 ```typescript
 import { z } from "zod";
-import { define } from "dotenv-never-lies";
+import { define } from "@romaintaillandier1978/dotenv-never-lies";
 
 export default define({
     NODE_ENV: {
@@ -116,35 +135,14 @@ export default define({
 
     NODE_PORT: {
         description: "Port de l’API",
-        schema: z.coerce.number(),
-    },
-
-    FRONT_A: {
-        description: "Mon site A",
-        schema: z.url(),
+        schema: z.coerce.number().default(3000),
     },
 
-    FRONT_B: {
-        description: "Mon site B",
+    FRONT_URL: {
+        description: "Mon site",
         schema: z.url(),
     },
 
-    FRONT_C: {
-        description: "Mon site C",
-        schema: z.url(),
-    },
-
-    NODE_CORS_ORIGIN: {
-        description: "URLs frontend autorisées à appeler cette API",
-        schema: z.string().transform((v) =>
-            v
-                .split(";")
-                .map((s) => s.trim())
-                .filter(Boolean)
-                .map((url) => z.url().parse(url))
-        ),
-    },
-
     JWT_SECRET: {
         description: "JWT Secret",
         schema: z.string(),
@@ -153,6 +151,50 @@ export default define({
 });
 ```
 
+## Gestion des secrets
+
+Rappel : dotenv-never-lies n’est pas un secret manager.
+
+### déclaration dans le schéma DNL
+
+Une variable est considérée comme secrète _si et seulement si elle est marquée explicitement_ dans le schéma avec `secret: true`. (`secret : undefined` est équivalent à `secret: false`)  
+Cette règle est volontairement stricte.
+
+```ts
+JWT_SECRET: {
+    description: "Clé de signature des JWT",
+    schema: z.string(),
+    secret: true,
+}
+```
+
+### Secrets et commandes CLI
+
+assert : valide les secrets comme n’importe quelle variable
+
+reverse-env : lors de la génération du schéma, la commande tente d’identifier automatiquement les variables sensibles (ex. SECRET, KEY, TOKEN, PASSWORD).
+**Cette détection est heuristique et doit toujours être vérifiée et corrigée manuellement.**
+
+export : adapte le comportement selon le format cible (env, docker, CI, Kubernetes…). Voir le tableau ci-dessous pour le détail par format.
+
+### Lors de l’export
+
+Les variables marquées `secret: true` dans le schéma sont traitées différemment selon le format d’export.
+
+| Format        | Secrets inclus par défaut | Masquables (`--hide-secret`) | Excluables (`--exclude-secret`) | Remarques                    |
+| ------------- | ------------------------- | ---------------------------- | ------------------------------- | ---------------------------- |
+| env           | oui                       | oui                          | oui                             | .env classique               |
+| docker-env    | oui                       | oui                          | oui                             | Pour --env-file              |
+| docker-args   | oui                       | oui                          | oui                             | Pour docker run -e           |
+| json          | oui                       | oui                          | oui                             | Debug / tooling              |
+| ts            | oui                       | oui                          | oui                             | Export typé                  |
+| js            | oui                       | oui                          | oui                             | Export runtime               |
+| github-env    | oui                       | oui                          | oui                             | visibles dans les logs       |
+| github-secret | secrets uniquement        | non                          | oui                             | Via gh secret set            |
+| gitlab-env    | oui                       | oui                          | oui                             | Variables CI GitLab          |
+| k8s-configmap | oui                       | oui                          | oui                             | warning si secret non masqué |
+| k8s-secret    | secrets uniquement        | oui                          | oui                             | Kubernetes Secret            |
+
 ## Utilisation runtime
 
 ```typescript
@@ -160,20 +202,26 @@ import envDef from "./env.dnl";
 
 export const ENV = envDef.load();
 
-if(ENV.NODE_ENV === "test"){...}
-
+// if (process.env.NODE_ENV && process.env.NODE_ENV === "test") {
+if (ENV.NODE_ENV === "test") {
+    doAdditionalTest();
+}
 
+const server = http.createServer(app);
+//server.listen(process.env.NODE_PORT||3000, () => {
+server.listen(ENV.NODE_PORT, () => {
+    console.log(`Server started on ${ENV.NODE_PORT}`);
+});
 ```
 
 Résultat :
 
 - ENV.NODE_ENV est un enum
 - ENV.NODE_PORT est un number
-- ENV.FRONT_A ENV.FRONT_B ENV.FRONT_C sont des URLs valides
-- ENV.NODE_CORS_ORIGIN est un string[] contenant des URLs valides
+- FRONT_URL est une URL valides
 - ENV.JWT_SECRET est une string
 
-Si une variable est absente ou invalide → le process s’arrête immédiatement. \
+Si une variable est absente ou invalide → le process s’arrête immédiatement.  
 C’est volontaire.
 
 ## Éviter `process.env` dans le code applicatif
@@ -187,7 +235,7 @@ Cela garantit :
 - des valeurs validées
 - un point d’entrée unique pour la configuration
 
-Pour identifier les usages résiduels de `process.env` dans votre codebase, un simple outil de recherche suffit :
+Pour identifier les usages résiduels de `process.env` dans ta base de code, un simple outil de recherche suffit :
 
 ```bash
 grep -R "process\.env" src
@@ -197,7 +245,7 @@ Le choix de corriger (ou non) ces usages dépend du contexte et reste volontaire
 
 ## CLI
 
-Le CLI permet de valider, charger, générer et documenter les variables d’environnement à partir d’un schéma `dotenv-never-lies`.
+Le CLI permet de valider, charger, générer, exporter et documenter les variables d’environnement à partir d’un schéma `dotenv-never-lies`.
 
 Il est conçu pour être utilisé :
 
@@ -205,31 +253,36 @@ Il est conçu pour être utilisé :
 - en CI (sans surprise)
 - avant que l’application ne démarre (et pas après)
 
-### Valider un fichier `.env` (CI-friendly)
+### Exit codes
+
+`dotenv-never-lies` utilise des codes de sortie explicites, pensés pour la CI :
+
+| Code | Signification                         |
+| ---: | ------------------------------------- |
+|    0 | Succès                                |
+|    1 | Erreur d'usage ou erreur interne      |
+|    2 | Schéma DNL introuvable                |
+|    3 | Validation de l'environnement échouée |
+|    4 | Erreur lors de l'export               |
+
+### assert : Valider un fichier `.env` (CI-friendly)
 
 Valide les variables sans les injecter dans `process.env`.
 
 ```bash
-dnl check --schema env.dnl.ts
+dnl assert --source .env --schema env.dnl.ts
 ```
 
+Sans --source, `dnl assert` valide `process.env`.
+C'est le mode recommandé lorsque les variables sont injectées par le runtime ou la CI.
+
 → échoue si :
 
 - une variable est manquante
 - une valeur est invalide
 - le schéma n’est pas respecté
 
-### Charger les variables dans le process
-
-Charge et valide les variables dans `process.env`.
-
-```bash
-dnl load --schema env.dnl.ts
-```
-
-Usage typique : scripts de démarrage, tooling local.
-
-### Générer un fichier .env à partir du schéma
+### generate : Générer un fichier .env à partir du schéma
 
 Génère un .env documenté à partir du schéma.
 
@@ -243,7 +296,7 @@ Utile pour :
 - partager un template
 - éviter les .env.example obsolètes
 
-### Générer un schéma depuis un .env existant
+### reverse-env : Générer un schéma depuis un .env existant
 
 Crée un fichier env.dnl.ts à partir d’un .env.
 
@@ -256,12 +309,12 @@ Utile pour :
 - migrer un projet existant
 - documenter a posteriori une configuration legacy
 
-### Afficher la documentation des variables
+### explain : Afficher la documentation des variables
 
 Affiche la liste des variables connues et leur description.
 
 ```bash
-dnl print
+dnl explain
 ```
 
 Exemple de sortie :
@@ -275,10 +328,69 @@ JWT_SECRET: JWT Secret
 
 ```
 
-TODO : check CI in real life.
+### export : Exporter les variables vers d’autres formats
+
+La commande export permet de transformer les variables validées par le schéma
+en formats directement exploitables par d’autres outils (Docker, CI, Kubernetes, scripts…).
+
+Le schéma reste la source de vérité.
+Les valeurs sont validées avant export.
+
+```bash
+dnl export <format>
+```
+
+Par défaut, les valeurs sont lues depuis process.env.
+Un fichier .env peut être fourni via --source.
+
+Exemples :  
+Exporter les variables d'environnement au format JSON depuis un fichier .env
+
+```bash
+dnl export json --source .env
+```
+
+Nettoyer un fichier .env (retirer commentaires et lignes inutiles)
+
+```bash
+dnl export env --source .env --out .env.clean
+dnl export env --source .env --out .env --force
+```
+
+Exporter les variables au format docker-args
+
+```bash
+dnl export docker-args --source .env
+```
+
+Résultat :
+
+```bash
+-e "NODE_ENV=production" -e "NODE_PORT=3000"
+```
+
+Exporter pour GitHub Actions (variables)
+
+```bash
+dnl export github-env
+```
+
+Résultat :
+
+```bash
+echo "NODE_ENV=production" >> $GITHUB_ENV
+echo "NODE_PORT=3000" >> $GITHUB_ENV
+```
+
+Il existe encore quelques autres formats et options (voir la doc CLI `dnl export --help`)
 
 ## Usages dans la vraie vie
 
+### GitIgnore
+
+dotenv-never-lies crée des fichiers temporaires dans ton répertoire projet.
+Ajoute `.dnl/` à ton `.gitignore`.
+
 ### Git
 
 #### Git hooks recommandés
@@ -317,3 +429,150 @@ EOF
 
 chmod +x .githooks/pre-commit .githooks/post-merge
 ```
+
+### Gitlab CI
+
+Step de validation des variables d'environnement.
+
+```yaml
+# .gitlab-ci.yml
+check-env:
+    stage: test
+    image: node:20-alpine
+    script:
+        - corepack enable
+        - yarn install --frozen-lockfile
+        - yarn dnl assert --source $DOT_ENV_FILE
+```
+
+### GitHub Actions
+
+```yaml
+# .github/workflows/check-env.yml
+name: Check environment
+
+on: [push, pull_request]
+
+jobs:
+    check-env:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: 20
+
+            - run: corepack enable
+            - run: yarn install --frozen-lockfile
+
+            # Exemple avec un fichier .env fourni par un secret
+            - run: yarn dnl assert --source .env
+```
+
+Le fichier .env peut être généré à partir d’un secret GitHub ou monté dynamiquement.
+
+```yaml
+- run: echo "$ENV_FILE_CONTENT" > .env
+  env:
+      ENV_FILE_CONTENT: ${{ secrets.ENV_FILE }}
+```
+
+### Quelles commandes utiliser ?
+
+|                                 Situation | Commande à utiliser            |
+| ----------------------------------------: | ------------------------------ |
+|                            Nouveau projet | generate                       |
+|              Projet existant avec un .env | reverse-env                    |
+|            Valider la configuration en CI | assert                         |
+| Valider la config injectée par le runtime | assert                         |
+|                  Documenter les variables | explain                        |
+|                    Générer un .env propre | export env                     |
+|                  Préparer un build Docker | export docker-\*               |
+|              Injecter des variables en CI | export github-env / gitlab-env |
+|           Kubernetes (ConfigMap / Secret) | export k8s-\*                  |
+
+Règle simple :
+
+> Le schéma est toujours la source de vérité.  
+> Les commandes ne font que valider, documenter ou transformer.
+
+## FAQ / Choix de design
+
+### Pourquoi être aussi strict ?
+
+Parce que les erreurs de configuration sont des bugs, pas des warnings.
+
+Si une variable est manquante ou invalide :
+
+- l’application ne doit pas démarrer
+- l’erreur doit être immédiate et explicite
+
+Tolérer une config invalide revient à déplacer le bug en production.
+
+### Pourquoi Node.js uniquement ?
+
+Parce que le runtime cible est clair :
+
+- APIs
+- workers
+- jobs
+- CI
+
+Les runtimes edge (Deno, Bun, Cloudflare Workers…) ont :
+
+- des modèles d’environnement différents
+- des contraintes différentes
+- des attentes différentes
+
+Ils sont volontairement hors scope.
+
+### Pourquoi Zod ?
+
+Parce que Zod fournit :
+
+- un typage TypeScript fiable
+- une validation runtime cohérente
+- des transformations expressives
+
+Le schéma est à la fois :
+
+- documentation
+- contrat
+- validation
+- source de typage
+
+Aucun autre outil ne couvre ces quatre points aussi proprement aujourd’hui.
+
+### Pourquoi ne pas utiliser dotenv-safe / env-schema / autre ?
+
+Ces outils :
+
+- valident partiellement
+- typent peu ou mal
+- ne documentent pas vraiment
+- n’offrent pas de CLI cohérent
+
+dotenv-never-lies assume un périmètre plus strict,
+mais fournit une chaîne complète :
+schéma → validation → typage → CI → export.
+
+### Pourquoi ne pas gérer les secrets ?
+
+Parce que ce n’est pas le bon niveau.
+
+dotenv-never-lies :
+
+- identifie les secrets
+- peut les exclure, masquer ou exporter
+
+Mais :
+
+- ne chiffre rien
+- ne stocke rien
+
+Il s’intègre avec les outils existants, il ne les concurrence pas.
+
+# Conclusion :
+
+> dotenv-never-lies ne cherche pas à être flexible. Il cherche à être fiable, explicite et prévisible.

package/dist/cli/commands/assert.d.ts

@@ -1,5 +1,7 @@
-export declare const assertCommand: (opts: {
+type AssertCliOptions = {
     schema: string;
     source: string;
-}) => Promise<void>;
+};
+export declare const assertCommand: (opts?: AssertCliOptions | undefined) => Promise<void>;
+export {};
 //# sourceMappingURL=assert.d.ts.map

package/dist/cli/commands/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/assert.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa,GAAU,MAAM;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,kBAwB3E,CAAC"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/assert.ts"],"names":[],"mappings":"AAOA,KAAK,gBAAgB,GAAG;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,OAAO,gBAAgB,GAAG,SAAS,KAAG,OAAO,CAAC,IAAI,CAsBrF,CAAC"}

package/dist/cli/commands/assert.js

@@ -3,24 +3,22 @@ import dnl from "../../index.js";
 import { loadDef as loadDef } from "../utils/load-schema.js";
 import { resolveSchemaPath } from "../utils/resolve-schema.js";
 import { z } from "zod";
+import { ValidationError } from "../../errors.js";
 export const assertCommand = async (opts) => {
-    const schemaPath = resolveSchemaPath(opts.schema);
+    const schemaPath = resolveSchemaPath(opts?.schema);
     const envDef = (await loadDef(schemaPath));
     try {
         envDef.assert({
-            source: opts.source ? dnl.readEnvFile(path.resolve(process.cwd(), opts.source)) : process.env,
+            source: opts?.source ? dnl.readEnvFile(path.resolve(process.cwd(), opts.source)) : process.env,
         });
         console.log("✅ Environment is valid");
     }
     catch (error) {
         if (error instanceof z.ZodError) {
-            console.error("❌ Invalid environment variables:\n");
-            for (const issue of error.issues) {
-                const key = issue.path.join(".");
-                console.error(`- ${key}`);
-                console.error(`  → ${issue.message}`);
-            }
-            process.exit(1);
+            throw new ValidationError("Invalid environment variables", error.issues.map((issue) => ({
+                key: issue.path.join("."),
+                message: issue.message,
+            })));
         }
         throw error;
     }

package/dist/cli/commands/explain.d.ts

@@ -1,8 +1,13 @@
+import { Explanation } from "../utils/printer.js";
 type ExplainCliOptions = {
     schema?: string | undefined;
     keys?: string[] | undefined;
     format?: "human" | "json" | undefined;
 };
-export declare const explainCommand: (options?: ExplainCliOptions) => Promise<number>;
+export declare const explainCommand: (options?: ExplainCliOptions) => Promise<{
+    format: "human" | "json";
+    result: Explanation[];
+}>;
+export declare const printHuman: (result: Explanation[]) => void;
 export {};
 //# sourceMappingURL=explain.d.ts.map

package/dist/cli/commands/explain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"explain.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/explain.ts"],"names":[],"mappings":"AAKA,KAAK,iBAAiB,GAAG;IACrB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,UAAU,iBAAiB,KAAG,OAAO,CAAC,MAAM,CAmChF,CAAC"}
+{"version":3,"file":"explain.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/explain.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAiB,MAAM,qBAAqB,CAAC;AAGjE,KAAK,iBAAiB,GAAG;IACrB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,UAAU,iBAAiB,KAAG,OAAO,CAAC;IAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,CA2B7H,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,QAAQ,WAAW,EAAE,SAqB/C,CAAC"}

package/dist/cli/commands/explain.js

@@ -1,10 +1,14 @@
 import { loadDef } from "../utils/load-schema.js";
 import { resolveSchemaPath } from "../utils/resolve-schema.js";
 import { toExplanation } from "../utils/printer.js";
+import { UsageError } from "../../errors.js";
 export const explainCommand = async (options) => {
+    const format = options?.format ?? "human";
+    if (format !== "human" && format !== "json") {
+        throw new UsageError(`Invalid format: ${format}`);
+    }
     const schemaPath = resolveSchemaPath(options?.schema);
     const envDef = (await loadDef(schemaPath));
-    const format = options?.format ?? "human";
     const keysToSerialize = new Array();
     if (options?.keys) {
         keysToSerialize.push(...options.keys);
@@ -17,25 +21,14 @@ export const explainCommand = async (options) => {
         result.push(toExplanation(key, value));
     }
     if (result.length === 0) {
-        console.error("No variables found");
-        return 1;
-    }
-    switch (format) {
-        case "json":
-            console.log(JSON.stringify(result, null, 2));
-            return 0;
-        case "human":
-            printHuman(result);
-            return 0;
-        default:
-            console.error(`Invalid format: ${format}`);
-            return 1;
+        throw new UsageError("No matching environment variables found");
     }
+    return { format, result };
 };
-const printHuman = (result) => {
+export const printHuman = (result) => {
     if (result.length > 1) {
         for (const item of result) {
-            console.log(`${item.key}: ${item.description}  --- dnl explain ${item.key} --format human  for more details`);
+            console.log(`${item.key}: ${item.description}  \t\tfor more details :  dnl explain ${item.key}`);
         }
         return;
     }

package/dist/cli/commands/export.d.ts

@@ -0,0 +1,34 @@
+import dnl from "../../index.js";
+export declare const exportFormatsNames: readonly ["docker-env", "docker-args", "env", "k8s-configmap", "k8s-secret", "github-env", "github-secret", "gitlab-env", "json", "ts", "js"];
+export type ExportFormat = (typeof exportFormatsNames)[number];
+export type ExportResult = {
+    content: string;
+    warnings: string[];
+    out?: string;
+};
+export type ExportCliOptions = {
+    format: ExportFormat;
+    schema?: string | undefined;
+    source?: string | undefined;
+    hideSecret?: boolean;
+    excludeSecret?: boolean;
+    includeComments?: boolean;
+    out?: string | undefined;
+    force?: boolean;
+    k8sName?: string | undefined;
+    githubOrg?: string | undefined;
+};
+export declare const exportCommand: (options: ExportCliOptions) => Promise<ExportResult>;
+export declare const contentByFormat: (format: ExportFormat, envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportJson: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportEnv: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportDockerArgs: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportDockerEnv: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportK8sConfigmap: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportK8sSecret: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportTs: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportJs: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportGithubEnv: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportGithubSecret: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+export declare const exportGitlabEnv: (envDef: dnl.EnvDefinitionHelper<any>, options: ExportCliOptions, warnings: string[]) => string;
+//# sourceMappingURL=export.d.ts.map