testcontainers 8.16.0 → 9.0.0

package/README.md

@@ -118,7 +118,10 @@ const { GenericContainer } = require("testcontainers");
 const buildContext = path.resolve(__dirname, "dir-containing-dockerfile");
 
 const container = await GenericContainer.fromDockerfile(buildContext)
-  .withBuildArg("ARG_KEY", "ARG_VALUE")
+  .withBuildArgs({
+    ARG_1: "ARG_VALUE_1",    
+    ARG_2: "ARG_VALUE_2",    
+  })
   .build();
 
 const startedContainer = await container
@@ -161,12 +164,12 @@ Enabling container reuse, note that two containers are considered equal if their
 const { GenericContainer } = require("testcontainers");
 
 const container1 = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .withReuse()
   .start();
 
 const container2 = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .withReuse()
   .start();
 
@@ -200,7 +203,7 @@ Creating a container with a command:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .start();
 ```
 
@@ -220,7 +223,7 @@ Execute commands inside a running container:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .start();
 
 const { output, exitCode } = await container.exec(["echo", "hello", "world"]);
@@ -238,7 +241,6 @@ stream
     .on("data", line => console.log(line))
     .on("err", line => console.error(line))
     .on("end", () => console.log("Stream closed"));
-
 ```
 
 Creating a container with bind mounts:
@@ -247,8 +249,14 @@ Creating a container with bind mounts:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withBindMount("/local/file.txt", "/remote/file.txt")
-  .withBindMount("/local/dir", "/remote/dir", "ro")
+  .withBindMounts([{ 
+    source: "/local/file.txt", 
+    target:"/remote/file.txt" 
+  }, {
+    source: "/local/dir",
+    target:"/remote/dir",
+    mode: "ro"
+  }])
   .start();
 ```
 
@@ -263,41 +271,6 @@ const container = await new GenericContainer("postgres")
   .start();
 ```
 
-Creating a container with ulimits:
-
-```javascript
-const { GenericContainer } = require("testcontainers");
-
-const container = await new GenericContainer("aline")
-  .withUlimits({ 
-    memlock: { 
-      hard: -1, 
-      soft: -1 
-    }
-  })
-  .start();
-```
-
-Creating a container with added [capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html):
-
-```javascript
-const { GenericContainer } = require("testcontainers");
-
-const container = await new GenericContainer("aline")
-  .withAddedCapabilities("NET_ADMIN", "IPC_LOCK")
-  .start();
-```
-
-Creating a container with dropped [capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html):
-
-```javascript
-const { GenericContainer } = require("testcontainers");
-
-const container = await new GenericContainer("aline")
-  .withDroppedCapabilities("NET_ADMIN", "IPC_LOCK")
-  .start();
-```
-
 Copy a file to a container before it is started:
 
 ```javascript
@@ -305,8 +278,14 @@ const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("postgres")
   .withExposedPorts(5432)
-  .withCopyFileToContainer("/local/file.txt", "/remote/file1.txt")
-  .withCopyContentToContainer("hello world", "/remote/file2.txt")
+  .withCopyFilesToContainer([{ 
+    source: "/local/file.txt", 
+    target: "/remote/file1.txt"
+  }])
+  .withCopyContentToContainer([{ 
+    content: "hello world",
+    target: "/remote/file2.txt"
+  }])
   .start();
 ```
 
@@ -316,7 +295,10 @@ Creating a container with environment variables:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withEnv("ENV_KEY", "ENV_VALUE")
+  .withEnvironment({ 
+    ENV_1: "ENV_VALUE_1", 
+    ENV_2: "ENV_VALUE_2", 
+  })
   .start();
 ```
 
@@ -340,7 +322,7 @@ const { GenericContainer, Wait } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
   .withHealthCheck({
-    test: "curl -f http://localhost || exit 1",
+    test: ["CMD-SHELL", "curl -f http://localhost || exit 1"],
     interval: 1000,
     timeout: 3000,
     retries: 5,
@@ -350,32 +332,44 @@ const container = await new GenericContainer("alpine")
   .start();
 ```
 
-Creating a container that connects to a specific network:
+To execute the `test` in a shell use the form `["CMD-SHELL", "command"]`, for example:
 
 ```javascript
-const { GenericContainer } = require("testcontainers");
+["CMD-SHELL", "curl -f http://localhost:8000 || exit 1"]
+```
 
-const container = await new GenericContainer("alpine")
-  .withNetworkMode("network_name")
-  .start();
+To execute the `test` without a shell, use the form: `["CMD", "command", "arg1", "arg2"]`, for example:
+
+```javascript
+["CMD", "/usr/bin/wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/hello-world"]
 ```
 
-Create user-defined bridge network and attach the container to it:
+Creating a container within a network:
 
 ```javascript
 const { GenericContainer, Network } = require("testcontainers");
 
 const network = await new Network()
-    .start();
+  .start();
 
 const container = await new GenericContainer("alpine")
-  .withNetworkMode(network.getName())
+  .withNetwork(network)
   .start();
 
 await container.stop();
 await network.stop();
 ```
 
+Creating a container with a network mode:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("alpine")
+  .withNetworkMode("bridge")
+  .start();
+```
+
 Communicate to containers on the same network via aliases:
 
 ```javascript
@@ -385,17 +379,17 @@ const network = await new Network()
     .start();
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
-  .withNetworkMode(network.getName())
+  .withCommand(["sleep", "infinity"])
+  .withNetwork(network)
   .start();
 
 const fooContainer = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
-  .withNetworkMode(network.getName())
+  .withCommand(["sleep", "infinity"])
+  .withNetwork(network)
   .withNetworkAliases("foo", "bar")
   .start();
 
-expect((await container.exec(["nslookup", "foo"])).exitCode).toBe(0);
+expect((await container.exec(["getent", "hosts", "foo"])).exitCode).toBe(0);
 ```
 
 Add hostname mappings:
@@ -404,14 +398,17 @@ Add hostname mappings:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withExtraHosts(
-    { host: "foo", ipAddress: "10.11.12.13" },
-    { host: "bar", ipAddress: "11.12.13.14" }
-  )
+  .withExtraHosts([{
+    host: "foo",
+    ipAddress: "10.11.12.13"
+  }, {
+    host: "bar",
+    ipAddress: "11.12.13.14"
+  }])
   .start();
 
-expect((await container.exec(["nslookup", "foo"])).exitCode).toBe(0);
-expect((await container.exec(["nslookup", "bar"])).exitCode).toBe(0);
+expect((await container.exec(["getent", "hosts", "foo"])).exitCode).toBe(0);
+expect((await container.exec(["getent", "hosts", "bar"])).exitCode).toBe(0);
 ```
 
 Specifying a pull policy. Note that if omitted will use the `DefaultPullPolicy` which will use a locally cached image
@@ -470,6 +467,41 @@ const container = await new GenericContainer("alpine")
   .start();
 ```
 
+Creating a container with added [capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html):
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withAddedCapabilities("NET_ADMIN", "IPC_LOCK")
+  .start();
+```
+
+Creating a container with dropped [capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html):
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withDroppedCapabilities("NET_ADMIN", "IPC_LOCK")
+  .start();
+```
+
+Creating a container with ulimits:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withUlimits({ 
+    memlock: { 
+      hard: -1, 
+      soft: -1 
+    }
+  })
+  .start();
+```
+
 Creating a container with [IPC mode](https://docs.docker.com/engine/reference/run/#ipc-settings---ipc):
 
 ```javascript
@@ -518,7 +550,7 @@ const network = await new Network()
   .start();
 
 const container = await new GenericContainer("alpine")
-  .withNetworkMode(network.getName())
+  .withNetwork(network)
   .start();
 
 const networkIpAddress = container.getIpAddress(network.getName());
@@ -539,7 +571,7 @@ server.listen(8000);
 await TestContainers.exposeHostPorts(8000);
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .start();
 
 const { output } = await container.exec(["curl", `http://host.testcontainers.internal:8000`]);
@@ -638,7 +670,8 @@ Once the environment has started, you can interact with the containers as you wo
 ```javascript
 const { DockerComposeEnvironment } = require("testcontainers");
 
-const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .up();
 
 const container = environment.getContainer("alpine_1");
 const { output, exitCode } = await container.exec(["echo", "hello", "world"]);
@@ -649,7 +682,8 @@ You can supply [multiple compose files](https://docs.docker.com/compose/extends/
 ```javascript
 const { DockerComposeEnvironment } = require("testcontainers");
 
-const environment = await new DockerComposeEnvironment(composeFilePath, [composeFile1, composeFile2]).up();
+const environment = await new DockerComposeEnvironment(composeFilePath, [composeFile1, composeFile2])
+  .up();
 
 await environment.stop();
 ```
@@ -659,7 +693,8 @@ If you have multiple docker-compose environments which share dependencies such a
 ```javascript
 const { DockerComposeEnvironment } = require("testcontainers");
 
-const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .up();
 
 await environment.stop();
 ```
@@ -718,7 +753,7 @@ Then we can set `TAG` as follows:
 const { DockerComposeEnvironment } = require("testcontainers");
 
 const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
-  .withEnv("TAG", "value")
+  .withEnvironment({ "TAG": "VALUE" })
   .up();
 ```
 
@@ -727,7 +762,8 @@ Testcontainers will not wait for an environment to down, to override:
 ```javascript
 const { GenericContainer } = require("testcontainers");
 
-const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .up();
 
 await environment.down({ 
   timeout: 10000 
@@ -739,7 +775,8 @@ Testcontainers will remove associated volumes created by the environment when do
 ```javascript
 const { GenericContainer } = require("testcontainers");
 
-const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .up();
 
 await environment.down({
   removeVolumes: false
@@ -806,10 +843,10 @@ Testcontainers may need to create auxiliary containers to provide its functional
 
 To avoid Docker pull limits, you can host your own images and use them by setting the appropriate environment variables:
 
-| Container | Environment Variable | Default
-| --- | --- | --- |
-| ryuk | `RYUK_CONTAINER_IMAGE` | `testcontainers/ryuk:0.3.2` |
-| SSHd | `SSHD_CONTAINER_IMAGE` | `testcontainers/sshd:1.0.0` |
+| Container | Environment Variable   | Default                     |
+|-----------|------------------------|-----------------------------|
+| ryuk      | `RYUK_CONTAINER_IMAGE` | `testcontainers/ryuk:0.3.2` |
+| SSHd      | `SSHD_CONTAINER_IMAGE` | `testcontainers/sshd:1.0.0` |
 
 ### ryuk
 

package/dist/bound-ports.d.ts

@@ -1,10 +1,10 @@
-import { Port, PortWithOptionalBinding } from "./port";
+import { PortWithOptionalBinding } from "./port";
 import { InspectResult } from "./docker/functions/container/inspect-container";
 export declare class BoundPorts {
     private readonly ports;
-    getBinding(port: Port): Port;
-    setBinding(key: Port, value: Port): void;
-    iterator(): Iterable<[Port, Port]>;
+    getBinding(port: number): number;
+    setBinding(key: number, value: number): void;
+    iterator(): Iterable<[number, number]>;
     filter(ports: PortWithOptionalBinding[]): BoundPorts;
     static fromInspectResult(inspectResult: InspectResult): BoundPorts;
 }

package/dist/docker/docker-client.d.ts

@@ -1,8 +1,7 @@
 import Dockerode from "dockerode";
-import { Host } from "./types";
 import "../testcontainers-properties-file";
 declare type DockerClient = {
-    host: Host;
+    host: string;
     dockerode: Dockerode;
 };
 export declare const dockerClient: () => Promise<DockerClient>;

package/dist/docker/functions/container/container-logs.js

@@ -15,12 +15,7 @@ const demux_stream_1 = require("../demux-stream");
 const docker_client_1 = require("../../docker-client");
 const containerLogs = (container) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const options = {
-            follow: true,
-            stdout: true,
-            stderr: true,
-        };
-        const stream = (yield container.logs(options));
+        const stream = (yield container.logs({ follow: true, stdout: true, stderr: true }));
         stream.socket.unref();
         return (0, demux_stream_1.demuxStream)((yield (0, docker_client_1.dockerClient)()).dockerode, stream);
     }

package/dist/docker/functions/container/create-container.d.ts

@@ -1,19 +1,19 @@
 import { DockerImageName } from "../../../docker-image-name";
 import Dockerode from "dockerode";
 import { PortWithOptionalBinding } from "../../../port";
-import { BindMount, Command, ContainerName, Env, ExtraHost, HealthCheck, Labels, NetworkMode, TmpFs, Ulimits } from "../../types";
+import { BindMount, Environment, ExtraHost, HealthCheck, Labels, TmpFs, Ulimits } from "../../types";
 export declare type CreateContainerOptions = {
     imageName: DockerImageName;
-    env: Env;
-    cmd: Command[];
+    environment: Environment;
+    command: string[];
     entrypoint?: string[];
     bindMounts: BindMount[];
     tmpFs: TmpFs;
     exposedPorts: PortWithOptionalBinding[];
-    name?: ContainerName;
+    name?: string;
     reusable: boolean;
     labels?: Labels;
-    networkMode?: NetworkMode;
+    networkMode?: string;
     healthCheck?: HealthCheck;
     useDefaultLogDriver: boolean;
     privilegedMode: boolean;

package/dist/docker/functions/container/create-container.js

@@ -22,12 +22,11 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
             name: options.name,
             User: options.user,
             Image: options.imageName.toString(),
-            Env: getEnv(options.env),
+            Env: getEnvironment(options.environment),
             ExposedPorts: getExposedPorts(options.exposedPorts),
-            Cmd: options.cmd,
+            Cmd: options.command,
             Entrypoint: options.entrypoint,
             Labels: (0, create_labels_1.createLabels)(options.reusable, options.imageName, options.labels),
-            // @ts-ignore
             Healthcheck: getHealthCheck(options.healthCheck),
             HostConfig: {
                 IpcMode: options.ipcMode,
@@ -51,7 +50,7 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
     }
 });
 exports.createContainer = createContainer;
-const getEnv = (env) => Object.entries(env).reduce((dockerodeEnvironment, [key, value]) => [...dockerodeEnvironment, `${key}=${value}`], []);
+const getEnvironment = (environment) => Object.entries(environment).reduce((dockerodeEnvironment, [key, value]) => [...dockerodeEnvironment, `${key}=${value}`], []);
 const getExposedPorts = (exposedPorts) => {
     const dockerodeExposedPorts = {};
     for (const exposedPort of exposedPorts) {
@@ -75,14 +74,14 @@ const getPortBindings = (exposedPorts) => {
     return dockerodePortBindings;
 };
 const getBindMounts = (bindMounts) => {
-    return bindMounts.map(({ source, target, bindMode }) => `${source}:${target}:${bindMode}`);
+    return bindMounts.map(({ source, target, mode }) => `${source}:${target}:${mode}`);
 };
 const getHealthCheck = (healthCheck) => {
     if (healthCheck === undefined) {
         return undefined;
     }
     return {
-        Test: ["CMD-SHELL", healthCheck.test],
+        Test: healthCheck.test,
         Interval: healthCheck.interval ? toNanos(healthCheck.interval) : 0,
         Timeout: healthCheck.timeout ? toNanos(healthCheck.timeout) : 0,
         Retries: healthCheck.retries || 0,

package/dist/docker/functions/container/exec-container.d.ts

@@ -1,9 +1,9 @@
-import { Command, ExecResult } from "../../types";
+import { ExecResult } from "../../types";
 import Dockerode from "dockerode";
 declare type ExecContainerOptions = {
     tty: boolean;
     stdin: boolean;
     detach: boolean;
 };
-export declare const execContainer: (container: Dockerode.Container, command: Command[], options: ExecContainerOptions, shouldLog?: boolean) => Promise<ExecResult>;
+export declare const execContainer: (container: Dockerode.Container, command: string[], options: ExecContainerOptions, shouldLog?: boolean) => Promise<ExecResult>;
 export {};

package/dist/docker/functions/container/get-container.d.ts

@@ -1,4 +1,3 @@
 import Dockerode from "dockerode";
-import { Id } from "../../types";
-export declare const getContainerById: (id: Id) => Promise<Dockerode.Container>;
+export declare const getContainerById: (id: string) => Promise<Dockerode.Container>;
 export declare const getContainerByHash: (hash: string) => Promise<Dockerode.Container | undefined>;

package/dist/docker/functions/container/inspect-container.d.ts

@@ -1,7 +1,7 @@
-import { ContainerName, HealthCheckStatus, Labels, NetworkSettings, Ports } from "../../types";
+import { HealthCheckStatus, Labels, NetworkSettings, Ports } from "../../types";
 import Dockerode from "dockerode";
 export declare type InspectResult = {
-    name: ContainerName;
+    name: string;
     hostname: string;
     ports: Ports;
     healthCheckStatus: HealthCheckStatus;

package/dist/docker/functions/create-labels.d.ts

@@ -1,3 +1,3 @@
 import { DockerImageName } from "../../docker-image-name";
 import { Labels } from "../types";
-export declare const createLabels: (reusable: boolean, dockerImageName?: DockerImageName | undefined, extraLabels?: Labels) => Labels;
+export declare const createLabels: (reusable: boolean, dockerImageName?: DockerImageName, extraLabels?: Labels) => Labels;

package/dist/docker/functions/image/build-image.d.ts

@@ -1,9 +1,9 @@
 import { DockerImageName } from "../../../docker-image-name";
 import { PullPolicy } from "../../../pull-policy";
-import { BuildArgs, BuildContext, RegistryConfig } from "../../types";
+import { BuildArgs, RegistryConfig } from "../../types";
 export declare type BuildImageOptions = {
     imageName: DockerImageName;
-    context: BuildContext;
+    context: string;
     dockerfileName: string;
     buildArgs: BuildArgs;
     pullPolicy: PullPolicy;

package/dist/docker/functions/run-in-container.d.ts

@@ -1,3 +1,2 @@
-import { Command } from "../types";
 import Dockerode from "dockerode";
-export declare const runInContainer: (dockerode: Dockerode, image: string, command: Command[]) => Promise<string | undefined>;
+export declare const runInContainer: (dockerode: Dockerode, image: string, command: string[]) => Promise<string | undefined>;

package/dist/docker/types.d.ts

@@ -1,19 +1,26 @@
-export declare type Id = string;
-export declare type Host = string;
-export declare type EnvKey = string;
-export declare type EnvValue = string;
-export declare type Env = {
-    [key in EnvKey]: EnvValue;
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from "stream";
+export declare type Environment = {
+    [key in string]: string;
 };
-export declare type Dir = string;
 export declare type BindMode = "rw" | "ro" | "z" | "Z";
 export declare type BindMount = {
-    source: Dir;
-    target: Dir;
-    bindMode: BindMode;
+    source: string;
+    target: string;
+    mode?: BindMode;
+};
+export declare type FileToCopy = {
+    source: string;
+    target: string;
+};
+export declare type Content = string | Buffer | Readable;
+export declare type ContentToCopy = {
+    content: Content;
+    target: string;
 };
 export declare type TmpFs = {
-    [dir in Dir]: Dir;
+    [dir in string]: string;
 };
 export declare type Ulimits = {
     [name: string]: {
@@ -22,18 +29,16 @@ export declare type Ulimits = {
     };
 };
 export declare type HealthCheck = {
-    test: string;
+    test: ["CMD-SHELL", string] | ["CMD", ...string[]];
     interval?: number;
     timeout?: number;
     retries?: number;
     startPeriod?: number;
 };
 export declare type ExtraHost = {
-    host: Host;
+    host: string;
     ipAddress: string;
 };
-export declare type NetworkMode = string;
-export declare type ContainerName = string;
 export declare type Labels = {
     [key: string]: string;
 };
@@ -52,16 +57,12 @@ export declare type RegistryConfig = {
         password: string;
     };
 };
-export declare type BuildContext = string;
 export declare type BuildArgs = {
-    [key in EnvKey]: EnvValue;
+    [key in string]: string;
 };
-export declare type StreamOutput = string;
-export declare type ExitCode = number;
-export declare type Command = string;
 export declare type ExecResult = {
-    output: StreamOutput;
-    exitCode: ExitCode;
+    output: string;
+    exitCode: number;
 };
 export declare type HealthCheckStatus = "none" | "starting" | "unhealthy" | "healthy";
 export declare type NetworkSettings = {

package/dist/docker-compose/default-docker-compose-options.d.ts

@@ -1,3 +1,3 @@
 import { IDockerComposeOptions } from "./docker-compose";
 import { DockerComposeOptions } from "./docker-compose-options";
-export declare const defaultDockerComposeOptions: ({ env, ...options }: DockerComposeOptions) => Partial<IDockerComposeOptions>;
+export declare const defaultDockerComposeOptions: ({ environment, ...options }: DockerComposeOptions) => Partial<IDockerComposeOptions>;

package/dist/docker-compose/default-docker-compose-options.js

@@ -13,14 +13,14 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultDockerComposeOptions = void 0;
 const defaultDockerComposeOptions = (_a) => {
-    var { env = {} } = _a, options = __rest(_a, ["env"]);
+    var { environment = {} } = _a, options = __rest(_a, ["environment"]);
     return {
         log: false,
         cwd: options.filePath,
         config: options.files,
         composeOptions: options.composeOptions,
         commandOptions: options.commandOptions,
-        env: Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: options.projectName }), env),
+        env: Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: options.projectName }), environment),
     };
 };
 exports.defaultDockerComposeOptions = defaultDockerComposeOptions;

package/dist/docker-compose/docker-compose-options.d.ts

@@ -1,9 +1,9 @@
-import { Env } from "../docker/types";
+import { Environment } from "../docker/types";
 export declare type DockerComposeOptions = {
     filePath: string;
     files: string | string[];
     projectName: string;
     commandOptions?: string[];
     composeOptions?: string[];
-    env?: Env;
+    environment?: Environment;
 };

package/dist/docker-compose/functions/docker-compose-up.d.ts

@@ -1,2 +1,2 @@
 import { DockerComposeOptions } from "../docker-compose-options";
-export declare const dockerComposeUp: (options: DockerComposeOptions, services?: string[] | undefined) => Promise<void>;
+export declare const dockerComposeUp: (options: DockerComposeOptions, services?: Array<string>) => Promise<void>;