projen 0.67.25 → 0.67.27

package/lib/dev-env.js

@@ -27,5 +27,5 @@ class DevEnvironmentDockerImage {
 }
 exports.DevEnvironmentDockerImage = DevEnvironmentDockerImage;
 _a = JSII_RTTI_SYMBOL_1;
-DevEnvironmentDockerImage[_a] = { fqn: "projen.DevEnvironmentDockerImage", version: "0.67.25" };
+DevEnvironmentDockerImage[_a] = { fqn: "projen.DevEnvironmentDockerImage", version: "0.67.27" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/docker-compose/docker-compose-port.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Options for port mappings.
+ */
+export interface DockerComposePortMappingOptions {
+    /**
+     * Port mapping protocol.
+     * @default DockerComposeProtocol.TCP
+     */
+    readonly protocol?: DockerComposeProtocol;
+}
+/**
+ * A service port mapping
+ */
+export interface DockerComposeServicePort {
+    /**
+     * Published port number
+     */
+    readonly published: number;
+    /**
+     * Target port number
+     */
+    readonly target: number;
+    /**
+     * Network protocol
+     */
+    readonly protocol: DockerComposeProtocol;
+    /**
+     * Port mapping mode.
+     */
+    readonly mode: string;
+}
+/**
+ * Network protocol for port mapping
+ */
+export declare enum DockerComposeProtocol {
+    /**
+     * TCP protocol
+     */
+    TCP = "tcp",
+    /**
+     * UDP protocol
+     */
+    UDP = "udp"
+}

package/lib/docker-compose/docker-compose-port.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerComposeProtocol = void 0;
+/**
+ * Network protocol for port mapping
+ */
+var DockerComposeProtocol;
+(function (DockerComposeProtocol) {
+    /**
+     * TCP protocol
+     */
+    DockerComposeProtocol["TCP"] = "tcp";
+    /**
+     * UDP protocol
+     */
+    DockerComposeProtocol["UDP"] = "udp";
+})(DockerComposeProtocol = exports.DockerComposeProtocol || (exports.DockerComposeProtocol = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9ja2VyLWNvbXBvc2UtcG9ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kb2NrZXItY29tcG9zZS9kb2NrZXItY29tcG9zZS1wb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQW9DQTs7R0FFRztBQUNILElBQVkscUJBVVg7QUFWRCxXQUFZLHFCQUFxQjtJQUMvQjs7T0FFRztJQUNILG9DQUFXLENBQUE7SUFFWDs7T0FFRztJQUNILG9DQUFXLENBQUE7QUFDYixDQUFDLEVBVlcscUJBQXFCLEdBQXJCLDZCQUFxQixLQUFyQiw2QkFBcUIsUUFVaEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE9wdGlvbnMgZm9yIHBvcnQgbWFwcGluZ3MuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRG9ja2VyQ29tcG9zZVBvcnRNYXBwaW5nT3B0aW9ucyB7XG4gIC8qKlxuICAgKiBQb3J0IG1hcHBpbmcgcHJvdG9jb2wuXG4gICAqIEBkZWZhdWx0IERvY2tlckNvbXBvc2VQcm90b2NvbC5UQ1BcbiAgICovXG4gIHJlYWRvbmx5IHByb3RvY29sPzogRG9ja2VyQ29tcG9zZVByb3RvY29sO1xufVxuXG4vKipcbiAqIEEgc2VydmljZSBwb3J0IG1hcHBpbmdcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBEb2NrZXJDb21wb3NlU2VydmljZVBvcnQge1xuICAvKipcbiAgICogUHVibGlzaGVkIHBvcnQgbnVtYmVyXG4gICAqL1xuICByZWFkb25seSBwdWJsaXNoZWQ6IG51bWJlcjtcblxuICAvKipcbiAgICogVGFyZ2V0IHBvcnQgbnVtYmVyXG4gICAqL1xuICByZWFkb25seSB0YXJnZXQ6IG51bWJlcjtcblxuICAvKipcbiAgICogTmV0d29yayBwcm90b2NvbFxuICAgKi9cbiAgcmVhZG9ubHkgcHJvdG9jb2w6IERvY2tlckNvbXBvc2VQcm90b2NvbDtcblxuICAvKipcbiAgICogUG9ydCBtYXBwaW5nIG1vZGUuXG4gICAqL1xuICByZWFkb25seSBtb2RlOiBzdHJpbmc7XG59XG5cbi8qKlxuICogTmV0d29yayBwcm90b2NvbCBmb3IgcG9ydCBtYXBwaW5nXG4gKi9cbmV4cG9ydCBlbnVtIERvY2tlckNvbXBvc2VQcm90b2NvbCB7XG4gIC8qKlxuICAgKiBUQ1AgcHJvdG9jb2xcbiAgICovXG4gIFRDUCA9IFwidGNwXCIsXG5cbiAgLyoqXG4gICAqIFVEUCBwcm90b2NvbFxuICAgKi9cbiAgVURQID0gXCJ1ZHBcIixcbn1cbiJdfQ==

package/lib/docker-compose/docker-compose-render.d.ts

@@ -0,0 +1,2 @@
+import { DockerComposeService } from "./docker-compose-service";
+export declare function renderDockerComposeFile(serviceDescriptions: Record<string, DockerComposeService>, version: string): object;

package/lib/docker-compose/docker-compose-render.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDockerComposeFile = void 0;
+const util_1 = require("../util");
+function renderDockerComposeFile(serviceDescriptions, version) {
+    // Record volume configuration
+    const volumeConfig = {};
+    const volumeInfo = {
+        addVolumeConfiguration(volumeName, configuration) {
+            if (!volumeConfig[volumeName]) {
+                // First volume configuration takes precedence.
+                volumeConfig[volumeName] = configuration;
+            }
+        },
+    };
+    // Render service configuration
+    const services = {};
+    for (const [serviceName, serviceDescription] of Object.entries(serviceDescriptions ?? {})) {
+        // Resolve the names of each dependency and check that they exist.
+        // Note: They may not exist if the user made a mistake when referencing a
+        // service by name via `DockerCompose.serviceName()`.
+        // @see DockerCompose.serviceName
+        const dependsOn = Array();
+        for (const dependsOnServiceName of serviceDescription.dependsOn ?? []) {
+            const resolvedServiceName = dependsOnServiceName.serviceName;
+            if (resolvedServiceName === serviceName) {
+                throw new Error(`Service ${serviceName} cannot depend on itself`);
+            }
+            if (!serviceDescriptions[resolvedServiceName]) {
+                throw new Error(`Unable to resolve service named ${resolvedServiceName} for ${serviceName}`);
+            }
+            dependsOn.push(resolvedServiceName);
+        }
+        // Give each volume binding a chance to bind any necessary volume
+        // configuration and provide volume mount information for the service.
+        const volumes = [];
+        for (const volumeBinding of serviceDescription.volumes ?? []) {
+            volumes.push(volumeBinding.bind(volumeInfo));
+        }
+        // Create and store the service configuration, taking care not to create
+        // object members with undefined values.
+        services[serviceName] = {
+            ...getObjectWithKeyAndValueIfValueIsDefined("image", serviceDescription.image),
+            ...getObjectWithKeyAndValueIfValueIsDefined("build", serviceDescription.imageBuild),
+            ...getObjectWithKeyAndValueIfValueIsDefined("command", serviceDescription.command),
+            ...(Object.keys(serviceDescription.environment).length > 0
+                ? { environment: serviceDescription.environment }
+                : {}),
+            ...(serviceDescription.ports.length > 0
+                ? { ports: serviceDescription.ports }
+                : {}),
+            ...(dependsOn.length > 0 ? { dependsOn } : {}),
+            ...(volumes.length > 0 ? { volumes } : {}),
+        };
+    }
+    // Explicit with the type here because the decamelize step after this wipes
+    // out types.
+    const input = {
+        version,
+        services,
+        ...(Object.keys(volumeConfig).length > 0 ? { volumes: volumeConfig } : {}),
+    };
+    // Change most keys to snake case.
+    return util_1.decamelizeKeysRecursively(input, {
+        shouldDecamelize: shouldDecamelizeDockerComposeKey,
+        separator: "_",
+    });
+}
+exports.renderDockerComposeFile = renderDockerComposeFile;
+/**
+ * Returns `{ [key]: value }` if `value` is defined, otherwise returns `{}` so
+ * that object spreading can be used to generate a peculiar interface.
+ * @param key
+ * @param value
+ */
+function getObjectWithKeyAndValueIfValueIsDefined(key, value) {
+    return value !== undefined ? { [key]: value } : {};
+}
+/**
+ * Determines whether the key at the given path should be decamelized.
+ * Largely, all keys should be snake cased. But, there are some
+ * exceptions for user-provided names for services, volumes, and
+ * environment variables.
+ *
+ * @param path
+ */
+function shouldDecamelizeDockerComposeKey(path) {
+    const poundPath = path.join("#");
+    // Does not decamelize user's names.
+    // services.namehere:
+    // volumes.namehere:
+    if (/^(services|volumes)#[^#]+$/.test(poundPath)) {
+        return false;
+    }
+    // Does not decamelize environment variables
+    // services.namehere.environment.*
+    if (/^services#[^#]+#environment#/.test(poundPath)) {
+        return false;
+    }
+    // Does not decamelize build arguments
+    // services.namehere.build.args.*
+    if (/^services#[^#]+#build#args#/.test(poundPath)) {
+        return false;
+    }
+    // Otherwise, let it all decamelize.
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"docker-compose-render.js","sourceRoot":"","sources":["../../src/docker-compose/docker-compose-render.ts"],"names":[],"mappings":"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","sourcesContent":["import { DockerComposeBuild } from \"./docker-compose\";\nimport { DockerComposeServicePort } from \"./docker-compose-port\";\nimport { DockerComposeService } from \"./docker-compose-service\";\nimport {\n  DockerComposeVolumeConfig,\n  DockerComposeVolumeMount,\n  IDockerComposeVolumeConfig,\n} from \"./docker-compose-volume\";\nimport { decamelizeKeysRecursively } from \"../util\";\n\n/**\n * Structure of a docker compose file's service before we decamelize.\n * @internal\n */\ninterface DockerComposeFileServiceSchema {\n  readonly dependsOn?: string[];\n  readonly build?: DockerComposeBuild;\n  readonly image?: string;\n  readonly command?: string[];\n  readonly volumes?: DockerComposeVolumeMount[];\n  readonly ports?: DockerComposeServicePort[];\n  readonly environment?: Record<string, string>;\n}\n\n/**\n * Structure of a docker compose file before we decamelize.\n * @internal\n */\ninterface DockerComposeFileSchema {\n  version: string;\n  services: Record<string, DockerComposeFileServiceSchema>;\n  volumes?: Record<string, DockerComposeVolumeConfig>;\n}\n\nexport function renderDockerComposeFile(\n  serviceDescriptions: Record<string, DockerComposeService>,\n  version: string\n): object {\n  // Record volume configuration\n  const volumeConfig: Record<string, DockerComposeVolumeConfig> = {};\n  const volumeInfo: IDockerComposeVolumeConfig = {\n    addVolumeConfiguration(\n      volumeName: string,\n      configuration: DockerComposeVolumeConfig\n    ) {\n      if (!volumeConfig[volumeName]) {\n        // First volume configuration takes precedence.\n        volumeConfig[volumeName] = configuration;\n      }\n    },\n  };\n\n  // Render service configuration\n  const services: Record<string, DockerComposeFileServiceSchema> = {};\n  for (const [serviceName, serviceDescription] of Object.entries(\n    serviceDescriptions ?? {}\n  )) {\n    // Resolve the names of each dependency and check that they exist.\n    // Note: They may not exist if the user made a mistake when referencing a\n    // service by name via `DockerCompose.serviceName()`.\n    // @see DockerCompose.serviceName\n    const dependsOn = Array<string>();\n    for (const dependsOnServiceName of serviceDescription.dependsOn ?? []) {\n      const resolvedServiceName = dependsOnServiceName.serviceName;\n      if (resolvedServiceName === serviceName) {\n        throw new Error(`Service ${serviceName} cannot depend on itself`);\n      }\n      if (!serviceDescriptions[resolvedServiceName]) {\n        throw new Error(\n          `Unable to resolve service named ${resolvedServiceName} for ${serviceName}`\n        );\n      }\n\n      dependsOn.push(resolvedServiceName);\n    }\n\n    // Give each volume binding a chance to bind any necessary volume\n    // configuration and provide volume mount information for the service.\n    const volumes: DockerComposeVolumeMount[] = [];\n    for (const volumeBinding of serviceDescription.volumes ?? []) {\n      volumes.push(volumeBinding.bind(volumeInfo));\n    }\n\n    // Create and store the service configuration, taking care not to create\n    // object members with undefined values.\n    services[serviceName] = {\n      ...getObjectWithKeyAndValueIfValueIsDefined(\n        \"image\",\n        serviceDescription.image\n      ),\n      ...getObjectWithKeyAndValueIfValueIsDefined(\n        \"build\",\n        serviceDescription.imageBuild\n      ),\n      ...getObjectWithKeyAndValueIfValueIsDefined(\n        \"command\",\n        serviceDescription.command\n      ),\n      ...(Object.keys(serviceDescription.environment).length > 0\n        ? { environment: serviceDescription.environment }\n        : {}),\n      ...(serviceDescription.ports.length > 0\n        ? { ports: serviceDescription.ports }\n        : {}),\n      ...(dependsOn.length > 0 ? { dependsOn } : {}),\n      ...(volumes.length > 0 ? { volumes } : {}),\n    };\n  }\n\n  // Explicit with the type here because the decamelize step after this wipes\n  // out types.\n  const input: DockerComposeFileSchema = {\n    version,\n    services,\n    ...(Object.keys(volumeConfig).length > 0 ? { volumes: volumeConfig } : {}),\n  };\n\n  // Change most keys to snake case.\n  return decamelizeKeysRecursively(input, {\n    shouldDecamelize: shouldDecamelizeDockerComposeKey,\n    separator: \"_\",\n  });\n}\n\n/**\n * Returns `{ [key]: value }` if `value` is defined, otherwise returns `{}` so\n * that object spreading can be used to generate a peculiar interface.\n * @param key\n * @param value\n */\nfunction getObjectWithKeyAndValueIfValueIsDefined<K extends string, T>(\n  key: K,\n  value: T\n): { K: T } | {} {\n  return value !== undefined ? { [key]: value } : {};\n}\n\n/**\n * Determines whether the key at the given path should be decamelized.\n * Largely, all keys should be snake cased. But, there are some\n * exceptions for user-provided names for services, volumes, and\n * environment variables.\n *\n * @param path\n */\nfunction shouldDecamelizeDockerComposeKey(path: string[]) {\n  const poundPath = path.join(\"#\");\n\n  // Does not decamelize user's names.\n  // services.namehere:\n  // volumes.namehere:\n  if (/^(services|volumes)#[^#]+$/.test(poundPath)) {\n    return false;\n  }\n\n  // Does not decamelize environment variables\n  // services.namehere.environment.*\n  if (/^services#[^#]+#environment#/.test(poundPath)) {\n    return false;\n  }\n\n  // Does not decamelize build arguments\n  // services.namehere.build.args.*\n  if (/^services#[^#]+#build#args#/.test(poundPath)) {\n    return false;\n  }\n\n  // Otherwise, let it all decamelize.\n  return true;\n}\n"]}

package/lib/docker-compose/docker-compose-service.d.ts

@@ -0,0 +1,117 @@
+import { DockerComposeBuild } from "./docker-compose";
+import { DockerComposePortMappingOptions, DockerComposeServicePort } from "./docker-compose-port";
+import { IDockerComposeVolumeBinding } from "./docker-compose-volume";
+/**
+ * An interface providing the name of a docker compose service.
+ */
+export interface IDockerComposeServiceName {
+    /**
+     * The name of the docker compose service.
+     */
+    readonly serviceName: string;
+}
+/**
+ * A docker-compose service.
+ */
+export declare class DockerComposeService implements IDockerComposeServiceName {
+    /**
+     * Name of the service.
+     */
+    readonly serviceName: string;
+    /**
+     * Docker image.
+     */
+    readonly image?: string;
+    /**
+     * Docker image build instructions.
+     */
+    readonly imageBuild?: DockerComposeBuild;
+    /**
+     * Command to run in the container.
+     */
+    readonly command?: string[];
+    /**
+     * Other services that this service depends on.
+     */
+    readonly dependsOn: IDockerComposeServiceName[];
+    /**
+     * Volumes mounted in the container.
+     */
+    readonly volumes: IDockerComposeVolumeBinding[];
+    /**
+     * Published ports.
+     */
+    readonly ports: DockerComposeServicePort[];
+    /**
+     * Environment variables.
+     */
+    readonly environment: Record<string, string>;
+    constructor(serviceName: string, serviceDescription: DockerComposeServiceDescription);
+    /**
+     * Add a port mapping
+     * @param publishedPort Published port number
+     * @param targetPort Container's port number
+     * @param options Port mapping options
+     */
+    addPort(publishedPort: number, targetPort: number, options?: DockerComposePortMappingOptions): void;
+    /**
+     * Add an environment variable
+     * @param name environment variable name
+     * @param value value of the environment variable
+     */
+    addEnvironment(name: string, value: string): void;
+    /**
+     * Make the service depend on another service.
+     * @param serviceName
+     */
+    addDependsOn(serviceName: IDockerComposeServiceName): void;
+    /**
+     * Add a volume to the service.
+     * @param volume
+     */
+    addVolume(volume: IDockerComposeVolumeBinding): void;
+}
+/**
+ * Description of a docker-compose.yml service.
+ */
+export interface DockerComposeServiceDescription {
+    /**
+     * Use a docker image.
+     * Note: You must specify either `build` or `image` key.
+     * @see imageBuild
+     */
+    readonly image?: string;
+    /**
+     * Build a docker image.
+     * Note: You must specify either `imageBuild` or `image` key.
+     * @see image
+     */
+    readonly imageBuild?: DockerComposeBuild;
+    /**
+     * Provide a command to the docker container.
+     * @default - use the container's default command
+     */
+    readonly command?: string[];
+    /**
+     * Names of other services this service depends on.
+     * @default - no dependencies
+     */
+    readonly dependsOn?: IDockerComposeServiceName[];
+    /**
+     * Mount some volumes into the service.
+     * Use one of the following to create volumes:
+     * @see DockerCompose.bindVolume() to mount a host path
+     * @see DockerCompose.namedVolume() to create & mount a named volume
+     */
+    readonly volumes?: IDockerComposeVolumeBinding[];
+    /**
+     * Map some ports.
+     * @default - no ports are mapped
+     */
+    readonly ports?: DockerComposeServicePort[];
+    /**
+     * Add environment variables.
+     * @default - no environment variables are provided
+     */
+    readonly environment?: Record<string, string>;
+}

package/lib/docker-compose/docker-compose-service.js

@@ -0,0 +1,60 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerComposeService = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const docker_compose_1 = require("./docker-compose");
+/**
+ * A docker-compose service.
+ */
+class DockerComposeService {
+    constructor(serviceName, serviceDescription) {
+        if ((!serviceDescription.imageBuild && !serviceDescription.image) ||
+            (serviceDescription.imageBuild && serviceDescription.image)) {
+            throw new Error(`A service ${serviceName} requires exactly one of a \`imageBuild\` or \`image\` key`);
+        }
+        this.serviceName = serviceName;
+        this.command = serviceDescription.command;
+        this.image = serviceDescription.image;
+        this.imageBuild = serviceDescription.imageBuild;
+        this.dependsOn = serviceDescription.dependsOn ?? [];
+        this.volumes = serviceDescription.volumes ?? [];
+        this.ports = serviceDescription.ports ?? [];
+        this.environment = serviceDescription.environment ?? {};
+    }
+    /**
+     * Add a port mapping
+     * @param publishedPort Published port number
+     * @param targetPort Container's port number
+     * @param options Port mapping options
+     */
+    addPort(publishedPort, targetPort, options) {
+        this.ports?.push(docker_compose_1.DockerCompose.portMapping(publishedPort, targetPort, options));
+    }
+    /**
+     * Add an environment variable
+     * @param name environment variable name
+     * @param value value of the environment variable
+     */
+    addEnvironment(name, value) {
+        this.environment[name] = value;
+    }
+    /**
+     * Make the service depend on another service.
+     * @param serviceName
+     */
+    addDependsOn(serviceName) {
+        this.dependsOn.push(serviceName);
+    }
+    /**
+     * Add a volume to the service.
+     * @param volume
+     */
+    addVolume(volume) {
+        this.volumes.push(volume);
+    }
+}
+exports.DockerComposeService = DockerComposeService;
+_a = JSII_RTTI_SYMBOL_1;
+DockerComposeService[_a] = { fqn: "projen.DockerComposeService", version: "0.67.27" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/docker-compose/docker-compose-volume.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Volume configuration
+ */
+export interface DockerComposeVolumeConfig {
+    /**
+     * Driver to use for the volume
+     * @default - value is not provided
+     */
+    readonly driver?: string;
+    /**
+     * Options to provide to the driver.
+     */
+    readonly driverOpts?: Record<string, string>;
+    /**
+     * Set to true to indicate that the volume is externally created.
+     * @default - unset, indicating that docker-compose creates the volume
+     */
+    readonly external?: boolean;
+    /**
+     * Name of the volume for when the volume name isn't going to work in YAML.
+     * @default - unset, indicating that docker-compose creates volumes as usual
+     */
+    readonly name?: string;
+}
+/**
+ * Volume binding information.
+ */
+export interface IDockerComposeVolumeBinding {
+    /**
+     * Binds the requested volume to the docker-compose volume configuration and
+     * provide mounting instructions for synthesis.
+     * @param volumeConfig the volume configuration
+     * @returns mounting instructions for the service.
+     */
+    bind(volumeConfig: IDockerComposeVolumeConfig): DockerComposeVolumeMount;
+}
+/**
+ * Storage for volume configuration.
+ */
+export interface IDockerComposeVolumeConfig {
+    /**
+     * Add volume configuration to the repository.
+     * @param volumeName
+     * @param configuration
+     */
+    addVolumeConfiguration(volumeName: string, configuration: DockerComposeVolumeConfig): void;
+}
+/**
+ * Service volume mounting information.
+ */
+export interface DockerComposeVolumeMount {
+    /**
+     * Type of volume.
+     */
+    readonly type: string;
+    /**
+     * Volume source
+     */
+    readonly source: string;
+    /**
+     * Volume target
+     */
+    readonly target: string;
+}

package/lib/docker-compose/docker-compose-volume.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/docker-compose/docker-compose.d.ts

@@ -0,0 +1,89 @@
+import { DockerComposePortMappingOptions, DockerComposeServicePort } from "./docker-compose-port";
+import { DockerComposeService, DockerComposeServiceDescription, IDockerComposeServiceName } from "./docker-compose-service";
+import { DockerComposeVolumeConfig, IDockerComposeVolumeBinding } from "./docker-compose-volume";
+import { Component } from "../component";
+import { Project } from "../project";
+/**
+ * Props for DockerCompose.
+ */
+export interface DockerComposeProps {
+    /**
+     * A name to add to the docker-compose.yml filename.
+     * @example 'myname' yields 'docker-compose.myname.yml'
+     * @default - no name is added
+     */
+    readonly nameSuffix?: string;
+    /**
+     * Docker Compose schema version do be used
+     * @default 3.3
+     */
+    readonly schemaVersion?: string;
+    /**
+     * Service descriptions.
+     */
+    readonly services?: Record<string, DockerComposeServiceDescription>;
+}
+/**
+ * Create a docker-compose YAML file.
+ */
+export declare class DockerCompose extends Component {
+    /**
+     * Depends on a service name.
+     */
+    static serviceName(serviceName: string): IDockerComposeServiceName;
+    /**
+     * Create a port mapping.
+     * @param publishedPort Published port number
+     * @param targetPort Container's port number
+     * @param options Port mapping options
+     */
+    static portMapping(publishedPort: number, targetPort: number, options?: DockerComposePortMappingOptions): DockerComposeServicePort;
+    /**
+     * Create a bind volume that binds a host path to the target path in the container.
+     * @param sourcePath Host path name
+     * @param targetPath Target path name
+     */
+    static bindVolume(sourcePath: string, targetPath: string): IDockerComposeVolumeBinding;
+    /**
+     * Create a named volume and mount it to the target path. If you use this
+     * named volume in several services, the volume will be shared. In this
+     * case, the volume configuration of the first-provided options are used.
+     *
+     * @param volumeName Name of the volume
+     * @param targetPath Target path
+     * @param options volume configuration (default: docker compose defaults)
+     */
+    static namedVolume(volumeName: string, targetPath: string, options?: DockerComposeVolumeConfig): IDockerComposeVolumeBinding;
+    private readonly services;
+    private readonly version;
+    constructor(project: Project, props?: DockerComposeProps);
+    /**
+     * Add a service to the docker-compose file.
+     * @param serviceName name of the service
+     * @param description a service description
+     */
+    addService(serviceName: string, description: DockerComposeServiceDescription): DockerComposeService;
+    /**
+     * @internal
+     */
+    _synthesizeDockerCompose(): object;
+}
+/**
+ * Build arguments for creating a docker image.
+ */
+export interface DockerComposeBuild {
+    /**
+     * Docker build context directory.
+     */
+    readonly context: string;
+    /**
+     * A dockerfile to build from.
+     * @default "Dockerfile"
+     */
+    readonly dockerfile?: string;
+    /**
+     * Build args.
+     * @default - none are provided
+     */
+    readonly args?: Record<string, string>;
+}