Api-Roll 52: 2017-07-31

generated/googleapis/lib/container/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.container.v1;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
@@ skipping 1712 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListOperationsResponse.fromJson(data));
   }
 
 }
 
 
 
+/** AcceleratorConfig represents a Hardware Accelerator request. */
+class AcceleratorConfig {
+  /** The number of the accelerator cards exposed to an instance. */
+  core.String acceleratorCount;
+  /**
+   * The accelerator type resource name. List of supported accelerators
+   * [here](/compute/docs/gpus/#Introduction)
+   */
+  core.String acceleratorType;
+
+  AcceleratorConfig();
+
+  AcceleratorConfig.fromJson(core.Map _json) {
+    if (_json.containsKey("acceleratorCount")) {
+      acceleratorCount = _json["acceleratorCount"];
+    }
+    if (_json.containsKey("acceleratorType")) {
+      acceleratorType = _json["acceleratorType"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (acceleratorCount != null) {
+      _json["acceleratorCount"] = acceleratorCount;
+    }
+    if (acceleratorType != null) {
+      _json["acceleratorType"] = acceleratorType;
+    }
+    return _json;
+  }
+}
+
 /**
  * Configuration for the addons that can be automatically spun up in the
  * cluster, enabling additional functionality.
  */
 class AddonsConfig {
   /**
    * Configuration for the horizontal pod autoscaling feature, which
    * increases or decreases the number of replica pods a replication controller
    * has based on the resource usage of the existing pods.
    */
   HorizontalPodAutoscaling horizontalPodAutoscaling;
   /**
    * Configuration for the HTTP (L7) load balancing controller addon, which
    * makes it easy to set up HTTP load balancers for services in a cluster.
    */
   HttpLoadBalancing httpLoadBalancing;
+  /** Configuration for the Kubernetes Dashboard. */
+  KubernetesDashboard kubernetesDashboard;
 
   AddonsConfig();
 
   AddonsConfig.fromJson(core.Map _json) {
     if (_json.containsKey("horizontalPodAutoscaling")) {
       horizontalPodAutoscaling = new HorizontalPodAutoscaling.fromJson(_json["horizontalPodAutoscaling"]);
     }
     if (_json.containsKey("httpLoadBalancing")) {
       httpLoadBalancing = new HttpLoadBalancing.fromJson(_json["httpLoadBalancing"]);
     }
+    if (_json.containsKey("kubernetesDashboard")) {
+      kubernetesDashboard = new KubernetesDashboard.fromJson(_json["kubernetesDashboard"]);
+    }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (horizontalPodAutoscaling != null) {
       _json["horizontalPodAutoscaling"] = (horizontalPodAutoscaling).toJson();
     }
     if (httpLoadBalancing != null) {
       _json["httpLoadBalancing"] = (httpLoadBalancing).toJson();
     }
+    if (kubernetesDashboard != null) {
+      _json["kubernetesDashboard"] = (kubernetesDashboard).toJson();
+    }
     return _json;
   }
 }
 
 /**
  * AutoUpgradeOptions defines the set of options for the user to control how
  * the Auto Upgrades will proceed.
  */
 class AutoUpgradeOptions {
   /**
@@ skipping 38 matching lines @@
 
   CancelOperationRequest.fromJson(core.Map _json) {
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     return _json;
   }
 }
 
+/** CidrBlock contains an optional name and one CIDR block. */
+class CidrBlock {
+  /** cidr_block must be specified in CIDR notation. */
+  core.String cidrBlock;
+  /** display_name is an optional field for users to identify CIDR blocks. */
+  core.String displayName;
+
+  CidrBlock();
+
+  CidrBlock.fromJson(core.Map _json) {
+    if (_json.containsKey("cidrBlock")) {
+      cidrBlock = _json["cidrBlock"];
+    }
+    if (_json.containsKey("displayName")) {
+      displayName = _json["displayName"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (cidrBlock != null) {
+      _json["cidrBlock"] = cidrBlock;
+    }
+    if (displayName != null) {
+      _json["displayName"] = displayName;
+    }
+    return _json;
+  }
+}
+
 /** Configuration for client certificates on the cluster. */
 class ClientCertificateConfig {
   /** Issue a client certificate. */
   core.bool issueClientCertificate;
 
   ClientCertificateConfig();
 
   ClientCertificateConfig.fromJson(core.Map _json) {
     if (_json.containsKey("issueClientCertificate")) {
       issueClientCertificate = _json["issueClientCertificate"];
@@ skipping 101 matching lines @@
    * Currently available options:
    *
    * * `logging.googleapis.com` - the Google Cloud Logging service.
    * * `none` - no logs will be exported from the cluster.
    * * if left as an empty string,`logging.googleapis.com` will be used.
    */
   core.String loggingService;
   /** The authentication information for accessing the master endpoint. */
   MasterAuth masterAuth;
   /**
+   * Master authorized networks is a Beta feature.
+   * The configuration options for master authorized networks feature.
+   */
+  MasterAuthorizedNetworksConfig masterAuthorizedNetworksConfig;
+  /**
    * The monitoring service the cluster should use to write metrics.
    * Currently available options:
    *
    * * `monitoring.googleapis.com` - the Google Cloud Monitoring service.
    * * `none` - no metrics will be exported from the cluster.
    * * if left as an empty string, `monitoring.googleapis.com` will be used.
    */
   core.String monitoringService;
   /**
    * The name of this cluster. The name must be unique within this project
@@ skipping 142 matching lines @@
     }
     if (_json.containsKey("locations")) {
       locations = _json["locations"];
     }
     if (_json.containsKey("loggingService")) {
       loggingService = _json["loggingService"];
     }
     if (_json.containsKey("masterAuth")) {
       masterAuth = new MasterAuth.fromJson(_json["masterAuth"]);
     }
+    if (_json.containsKey("masterAuthorizedNetworksConfig")) {
+      masterAuthorizedNetworksConfig = new MasterAuthorizedNetworksConfig.fromJson(_json["masterAuthorizedNetworksConfig"]);
+    }
     if (_json.containsKey("monitoringService")) {
       monitoringService = _json["monitoringService"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
     if (_json.containsKey("network")) {
       network = _json["network"];
     }
     if (_json.containsKey("networkPolicy")) {
@@ skipping 83 matching lines @@
     }
     if (locations != null) {
       _json["locations"] = locations;
     }
     if (loggingService != null) {
       _json["loggingService"] = loggingService;
     }
     if (masterAuth != null) {
       _json["masterAuth"] = (masterAuth).toJson();
     }
+    if (masterAuthorizedNetworksConfig != null) {
+      _json["masterAuthorizedNetworksConfig"] = (masterAuthorizedNetworksConfig).toJson();
+    }
     if (monitoringService != null) {
       _json["monitoringService"] = monitoringService;
     }
     if (name != null) {
       _json["name"] = name;
     }
     if (network != null) {
       _json["network"] = network;
     }
     if (networkPolicy != null) {
@@ skipping 50 matching lines @@
    * The desired list of Google Compute Engine
    * [locations](/compute/docs/zones#available) in which the cluster's nodes
    * should be located. Changing the locations a cluster is in will result
    * in nodes being either created or removed from the cluster, depending on
    * whether locations are being added or removed.
    *
    * This list must always include the cluster's primary zone.
    */
   core.List<core.String> desiredLocations;
   /**
+   * Master authorized networks is a Beta feature.
+   * The desired configuration options for master authorized networks feature.
+   */
+  MasterAuthorizedNetworksConfig desiredMasterAuthorizedNetworksConfig;
+  /**
    * The Kubernetes version to change the master to. The only valid value is the
    * latest supported version. Use "-" to have the server automatically select
    * the latest version.
    */
   core.String desiredMasterVersion;
   /**
    * The monitoring service the cluster should use to write metrics.
    * Currently available options:
    *
    * * "monitoring.googleapis.com" - the Google Cloud Monitoring service
@@ skipping 26 matching lines @@
   ClusterUpdate.fromJson(core.Map _json) {
     if (_json.containsKey("desiredAddonsConfig")) {
       desiredAddonsConfig = new AddonsConfig.fromJson(_json["desiredAddonsConfig"]);
     }
     if (_json.containsKey("desiredImageType")) {
       desiredImageType = _json["desiredImageType"];
     }
     if (_json.containsKey("desiredLocations")) {
       desiredLocations = _json["desiredLocations"];
     }
+    if (_json.containsKey("desiredMasterAuthorizedNetworksConfig")) {
+      desiredMasterAuthorizedNetworksConfig = new MasterAuthorizedNetworksConfig.fromJson(_json["desiredMasterAuthorizedNetworksConfig"]);
+    }
     if (_json.containsKey("desiredMasterVersion")) {
       desiredMasterVersion = _json["desiredMasterVersion"];
     }
     if (_json.containsKey("desiredMonitoringService")) {
       desiredMonitoringService = _json["desiredMonitoringService"];
     }
     if (_json.containsKey("desiredNodePoolAutoscaling")) {
       desiredNodePoolAutoscaling = new NodePoolAutoscaling.fromJson(_json["desiredNodePoolAutoscaling"]);
     }
     if (_json.containsKey("desiredNodePoolId")) {
       desiredNodePoolId = _json["desiredNodePoolId"];
     }
     if (_json.containsKey("desiredNodeVersion")) {
       desiredNodeVersion = _json["desiredNodeVersion"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (desiredAddonsConfig != null) {
       _json["desiredAddonsConfig"] = (desiredAddonsConfig).toJson();
     }
     if (desiredImageType != null) {
       _json["desiredImageType"] = desiredImageType;
     }
     if (desiredLocations != null) {
       _json["desiredLocations"] = desiredLocations;
     }
+    if (desiredMasterAuthorizedNetworksConfig != null) {
+      _json["desiredMasterAuthorizedNetworksConfig"] = (desiredMasterAuthorizedNetworksConfig).toJson();
+    }
     if (desiredMasterVersion != null) {
       _json["desiredMasterVersion"] = desiredMasterVersion;
     }
     if (desiredMonitoringService != null) {
       _json["desiredMonitoringService"] = desiredMonitoringService;
     }
     if (desiredNodePoolAutoscaling != null) {
       _json["desiredNodePoolAutoscaling"] = (desiredNodePoolAutoscaling).toJson();
     }
     if (desiredNodePoolId != null) {
@@ skipping 262 matching lines @@
     if (subnetworkName != null) {
       _json["subnetworkName"] = subnetworkName;
     }
     if (useIpAliases != null) {
       _json["useIpAliases"] = useIpAliases;
     }
     return _json;
   }
 }
 
+/** Configuration for the Kubernetes Dashboard. */
+class KubernetesDashboard {
+  /** Whether the Kubernetes Dashboard is enabled for this cluster. */
+  core.bool disabled;
+
+  KubernetesDashboard();
+
+  KubernetesDashboard.fromJson(core.Map _json) {
+    if (_json.containsKey("disabled")) {
+      disabled = _json["disabled"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (disabled != null) {
+      _json["disabled"] = disabled;
+    }
+    return _json;
+  }
+}
+
 /**
  * Configuration for the legacy Attribute Based Access Control authorization
  * mode.
  */
 class LegacyAbac {
   /**
    * Whether the ABAC authorizer is enabled for this cluster. When enabled,
    * identities in the system, including service accounts, nodes, and
    * controllers, will have statically granted permissions beyond those
    * provided by the RBAC configuration or IAM.
@@ skipping 189 matching lines @@
       _json["password"] = password;
     }
     if (username != null) {
       _json["username"] = username;
     }
     return _json;
   }
 }
 
 /**
+ * Master authorized networks is a Beta feature.
+ * Configuration options for the master authorized networks feature. Enabled
+ * master authorized networks will disallow all external traffic to access
+ * Kubernetes master through HTTPS except traffic from the given CIDR blocks,
+ * Google Compute Engine Public IPs and Google Prod IPs.
+ */
+class MasterAuthorizedNetworksConfig {
+  /**
+   * cidr_blocks define up to 10 external networks that could access
+   * Kubernetes master through HTTPS.
+   */
+  core.List<CidrBlock> cidrBlocks;
+  /** Whether or not master authorized networks is enabled. */
+  core.bool enabled;
+
+  MasterAuthorizedNetworksConfig();
+
+  MasterAuthorizedNetworksConfig.fromJson(core.Map _json) {
+    if (_json.containsKey("cidrBlocks")) {
+      cidrBlocks = _json["cidrBlocks"].map((value) => new CidrBlock.fromJson(value)).toList();
+    }
+    if (_json.containsKey("enabled")) {
+      enabled = _json["enabled"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (cidrBlocks != null) {
+      _json["cidrBlocks"] = cidrBlocks.map((value) => (value).toJson()).toList();
+    }
+    if (enabled != null) {
+      _json["enabled"] = enabled;
+    }
+    return _json;
+  }
+}
+
+/**
  * Configuration options for the NetworkPolicy feature.
  * https://kubernetes.io/docs/concepts/services-networking/networkpolicies/
  */
 class NetworkPolicy {
   /** Whether network policy is enabled on the cluster. */
   core.bool enabled;
   /**
    * The selected network policy provider.
    * Possible string values are:
-   * - "UNKNOWN" : Not set
+   * - "PROVIDER_UNSPECIFIED" : Not set
    * - "CALICO" : Tigera (Calico Felix).
    */
   core.String provider;
 
   NetworkPolicy();
 
   NetworkPolicy.fromJson(core.Map _json) {
     if (_json.containsKey("enabled")) {
       enabled = _json["enabled"];
     }
@@ skipping 10 matching lines @@
     if (provider != null) {
       _json["provider"] = provider;
     }
     return _json;
   }
 }
 
 /** Parameters that describe the nodes in a cluster. */
 class NodeConfig {
   /**
+   * A list of hardware accelerators to be attached to each node.
+   * See https://cloud.google.com/compute/docs/gpus for more information about
+   * support for GPUs.
+   */
+  core.List<AcceleratorConfig> accelerators;
+  /**
    * Size of the disk attached to each node, specified in GB.
    * The smallest allowed disk size is 10GB.
    *
    * If unspecified, the default disk size is 100GB.
    */
   core.int diskSizeGb;
   /**
    * The image type to use for this node. Note that for a given image type,
    * the latest version of it will be used.
    */
@@ skipping 75 matching lines @@
    * The list of instance tags applied to all nodes. Tags are used to identify
    * valid sources or targets for network firewalls and are specified by
    * the client during cluster or node pool creation. Each tag within the list
    * must comply with RFC1035.
    */
   core.List<core.String> tags;
 
   NodeConfig();
 
   NodeConfig.fromJson(core.Map _json) {
+    if (_json.containsKey("accelerators")) {
+      accelerators = _json["accelerators"].map((value) => new AcceleratorConfig.fromJson(value)).toList();
+    }
     if (_json.containsKey("diskSizeGb")) {
       diskSizeGb = _json["diskSizeGb"];
     }
     if (_json.containsKey("imageType")) {
       imageType = _json["imageType"];
     }
     if (_json.containsKey("labels")) {
       labels = _json["labels"];
     }
     if (_json.containsKey("localSsdCount")) {
@@ skipping 14 matching lines @@
     if (_json.containsKey("serviceAccount")) {
       serviceAccount = _json["serviceAccount"];
     }
     if (_json.containsKey("tags")) {
       tags = _json["tags"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (accelerators != null) {
+      _json["accelerators"] = accelerators.map((value) => (value).toJson()).toList();
+    }
     if (diskSizeGb != null) {
       _json["diskSizeGb"] = diskSizeGb;
     }
     if (imageType != null) {
       _json["imageType"] = imageType;
     }
     if (labels != null) {
       _json["labels"] = labels;
     }
     if (localSsdCount != null) {
@@ skipping 839 matching lines @@
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (imageType != null) {
       _json["imageType"] = imageType;
     }
     if (nodeVersion != null) {
       _json["nodeVersion"] = nodeVersion;
     }
     return _json;
   }
 }