text:
// Code generated by go-swagger; DO NOT EDIT.

package application

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
)

// New creates a new application API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

/*
Client for application API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	ApplicationCollectionGet(params *ApplicationCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationCollectionGetOK, error)

	ApplicationComponentCollectionGet(params *ApplicationComponentCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentCollectionGetOK, error)

	ApplicationComponentGet(params *ApplicationComponentGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentGetOK, error)

	ApplicationComponentSnapshotCollectionGet(params *ApplicationComponentSnapshotCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotCollectionGetOK, error)

	ApplicationComponentSnapshotCreate(params *ApplicationComponentSnapshotCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotCreateAccepted, error)

	ApplicationComponentSnapshotDelete(params *ApplicationComponentSnapshotDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotDeleteAccepted, error)

	ApplicationComponentSnapshotGet(params *ApplicationComponentSnapshotGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotGetOK, error)

	ApplicationComponentSnapshotRestore(params *ApplicationComponentSnapshotRestoreParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotRestoreAccepted, error)

	ApplicationCreate(params *ApplicationCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationCreateAccepted, error)

	ApplicationDelete(params *ApplicationDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationDeleteAccepted, error)

	ApplicationGet(params *ApplicationGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationGetOK, error)

	ApplicationModify(params *ApplicationModifyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationModifyAccepted, error)

	ApplicationSnapshotCollectionGet(params *ApplicationSnapshotCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotCollectionGetOK, error)

	ApplicationSnapshotCreate(params *ApplicationSnapshotCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotCreateAccepted, error)

	ApplicationSnapshotDelete(params *ApplicationSnapshotDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotDeleteAccepted, error)

	ApplicationSnapshotGet(params *ApplicationSnapshotGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotGetOK, error)

	ApplicationSnapshotRestore(params *ApplicationSnapshotRestoreParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotRestoreAccepted, error)

	ApplicationTemplateCollectionGet(params *ApplicationTemplateCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationTemplateCollectionGetOK, error)

	ApplicationTemplateGet(params *ApplicationTemplateGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationTemplateGetOK, error)

	ConsistencyGroupCollectionGet(params *ConsistencyGroupCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupCollectionGetOK, error)

	ConsistencyGroupCreate(params *ConsistencyGroupCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupCreateCreated, *ConsistencyGroupCreateAccepted, error)

	ConsistencyGroupDelete(params *ConsistencyGroupDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupDeleteOK, *ConsistencyGroupDeleteAccepted, error)

	ConsistencyGroupGet(params *ConsistencyGroupGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupGetOK, error)

	ConsistencyGroupModify(params *ConsistencyGroupModifyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupModifyOK, *ConsistencyGroupModifyAccepted, error)

	ConsistencyGroupSnapshotCollectionGet(params *ConsistencyGroupSnapshotCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupSnapshotCollectionGetOK, error)

	ConsistencyGroupSnapshotCreate(params *ConsistencyGroupSnapshotCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupSnapshotCreateCreated, *ConsistencyGroupSnapshotCreateAccepted, error)

	ConsistencyGroupSnapshotDelete(params *ConsistencyGroupSnapshotDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupSnapshotDeleteOK, *ConsistencyGroupSnapshotDeleteAccepted, error)

	ConsistencyGroupSnapshotGet(params *ConsistencyGroupSnapshotGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupSnapshotGetOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
	ApplicationCollectionGet Retrieves applications.

### Expensive properties
There is an added cost to retrieving values for these properties. They are not included by default in GET results and must be explicitly requested using the `fields` query parameter. See [`Requesting specific fields`](#Requesting_specific_fields) to learn more.
* `<template>` the property corresponding to the `template.name` of the application
### Query examples
Numerous queries are available for classifying and sorting applications:
 1. Return a list of applications sorted by name.
    ```
    GET /application/applications?order_by=name
    ```

 2. Return a list of applications for a specific SVM.
    ```
    GET /application/applications?svm.name=<name>
    ```

 3. Return a list of all SQL applications.
    ```
    GET /application/applications?template.name=sql*
    ```

 4. Return a list of all applications that can be accessed via SAN.

    ```
    GET /application/applications?template.protocol=san
    ```

 5. Return the top five applications consuming the most IOPS.

    ```
    GET /application/applications?order_by=statistics.iops.total desc&max_records=5
    ```

The above examples are not comprehensive. There are many more properties available for queries. Also, multiple queries can be mixed and matched with other query parameters for a large variety of requests. See the per-property documentation below for the full list of supported query parameters.
### Learn more
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationCollectionGet(params *ApplicationCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationCollectionGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationCollectionGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_collection_get",
		Method:             "GET",
		PathPattern:        "/application/applications",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationCollectionGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationCollectionGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationCollectionGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationComponentCollectionGet Retrieves application components.

### Overview
The application component object exposes how to access an application. Most application interfaces abstract away the underlying ONTAP storage elements, but this interface exposes what is necessary to connect to and uses the storage that is provisioned for an application. See the application component model for a detailed description of each property.
### Query examples
Queries are limited on this API. Most of the details are nested under the `nfs_access`, `cifs_access`, or `san_access` properties, but those properties do not support queries, and properties nested under those properties cannot be requested individually in the current release.

The following query returns all application components with names beginning in _secondary_.

```
GET /application/applications/{application.uuid}/components?name=secondary*
```

The following query returns all application components at the _extreme_ storage service.

```
GET /application/applications/{application.uuid}/components?storage_service.name=extreme
```
### Learn more
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationComponentCollectionGet(params *ApplicationComponentCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentCollectionGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationComponentCollectionGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_component_collection_get",
		Method:             "GET",
		PathPattern:        "/application/applications/{application.uuid}/components",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationComponentCollectionGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationComponentCollectionGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationComponentCollectionGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationComponentGet Retrieves an application component.

### Overview
The application component object exposes how to access an application. Most application interfaces abstract away the underlying ONTAP storage elements, but this interface exposes what is necessary to connect to and uses the storage that is provisioned for an application. See the application component model for a detailed description of each property.
### Access
Each application component can be accessed via NFS, CIFS, or SAN. NFS and CIFS access can be enabled simultaneously. Each access section includes a `backing_storage` property. This property is used to correlate the storage elements with the access elements of the application. The `backing_storage` portion of the access section provides the `type` and `uuid` of the backing storage. There is another `backing_storage` property at the same level as the access properties which contains lists of backing storage elements corresponding to the types listed in the access section.
### Learn more
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationComponentGet(params *ApplicationComponentGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationComponentGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_component_get",
		Method:             "GET",
		PathPattern:        "/application/applications/{application.uuid}/components/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationComponentGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationComponentGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationComponentGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationComponentSnapshotCollectionGet Retrieves Snapshot copies of an application component.

This endpoint is only supported for Maxdata template applications.

Component Snapshot copies are essentially more granular application Snapshot copies. There is no difference beyond the scope of the operation.
### Learn more
* [`DOC /application/applications/{application.uuid}/snapshots`](#docs-application-application_applications_{application.uuid}_snapshots)
* [`GET /application/applications/{uuid}/snapshots`](#operations-application-application_snapshot_collection_get)
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationComponentSnapshotCollectionGet(params *ApplicationComponentSnapshotCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotCollectionGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationComponentSnapshotCollectionGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_component_snapshot_collection_get",
		Method:             "GET",
		PathPattern:        "/application/applications/{application.uuid}/components/{component.uuid}/snapshots",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationComponentSnapshotCollectionGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationComponentSnapshotCollectionGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationComponentSnapshotCollectionGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationComponentSnapshotCreate Creates a Snapshot copy of an application component.

This endpoint is only supported for Maxdata template applications.

### Required properties
* `name`
### Recommended optional properties
* `consistency_type` - Track whether this snapshot is _application_ or _crash_ consistent.
Component Snapshot copies are essentially more granular application Snapshot copies. There is no difference beyond the scope of the operation.
### Learn more
* [`DOC /application/applications/{application.uuid}/snapshots`](#docs-application-application_applications_{application.uuid}_snapshots)
* [`GET /application/applications/{uuid}/snapshots`](#operations-application-application_snapshot_create)
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationComponentSnapshotCreate(params *ApplicationComponentSnapshotCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotCreateAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationComponentSnapshotCreateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_component_snapshot_create",
		Method:             "POST",
		PathPattern:        "/application/applications/{application.uuid}/components/{component.uuid}/snapshots",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationComponentSnapshotCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationComponentSnapshotCreateAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationComponentSnapshotCreateDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationComponentSnapshotDelete Delete a Snapshot copy of an application component.

This endpoint is only supported for Maxdata template applications.

Component Snapshot copies are essentially more granular application Snapshot copies. There is no difference beyond the scope of the operation.
### Learn more
* [`DOC /application/applications/{application.uuid}/snapshots`](#docs-application-application_applications_{application.uuid}_snapshots)
* [`DELETE /application/applications/{uuid}/snapshots`](#operations-application-application_snapshot_delete)
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationComponentSnapshotDelete(params *ApplicationComponentSnapshotDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotDeleteAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationComponentSnapshotDeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_component_snapshot_delete",
		Method:             "DELETE",
		PathPattern:        "/application/applications/{application.uuid}/components/{component.uuid}/snapshots/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationComponentSnapshotDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationComponentSnapshotDeleteAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationComponentSnapshotDeleteDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationComponentSnapshotGet Retrieve a Snapshot copy of an application component.

This endpoint is only supported for Maxdata template applications.

Component Snapshot copies are essentially more granular application Snapshot copies. There is no difference beyond the scope of the operation.
### Learn more
* [`DOC /application/applications/{application.uuid}/snapshots`](#docs-application-application_applications_{application.uuid}_snapshots)
* [`GET /application/applications/{uuid}/snapshots`](#operations-application-application_snapshot_get)
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationComponentSnapshotGet(params *ApplicationComponentSnapshotGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationComponentSnapshotGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_component_snapshot_get",
		Method:             "GET",
		PathPattern:        "/application/applications/{application.uuid}/components/{component.uuid}/snapshots/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationComponentSnapshotGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationComponentSnapshotGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationComponentSnapshotGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationComponentSnapshotRestore Restore a Snapshot copy of an application component.

This endpoint is only supported for Maxdata template applications.

Component Snapshot copies are essentially more granular application Snapshot copies. There is no difference beyond the scope of the operation.
### Learn more
* [`DOC /application/applications/{application.uuid}/snapshots`](#docs-application-application_applications_{application.uuid}_snapshots)
* [`POST /application/applications/{application.uuid}/snapshots/{uuid}/restore`](#operations-application-application_snapshot_restore)
* [`DOC /application`](#docs-application-overview)
* [`Asynchronous operations`](#Synchronous_and_asynchronous_operations)
*/
func (a *Client) ApplicationComponentSnapshotRestore(params *ApplicationComponentSnapshotRestoreParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationComponentSnapshotRestoreAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationComponentSnapshotRestoreParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_component_snapshot_restore",
		Method:             "POST",
		PathPattern:        "/application/applications/{application.uuid}/components/{component.uuid}/snapshots/{uuid}/restore",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationComponentSnapshotRestoreReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationComponentSnapshotRestoreAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationComponentSnapshotRestoreDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationCreate Creates an application.

### Template properties
The application APIs appear to be complex and long in this documentation because we document every possible template, of which there are currently 14. When creating an application, only a single template is used, so it is best to focus only on the template of interest. Other than the properties for the chosen template, only the `name` and `svm` of the application must be provided. The following three sections provided guidelines on using the properties of the templates, but the whole idea behind the templates is to automatically follow the best practices of the given application, so the only way to determine the exact list of required properties and default values is to dig in to the model section of the template. The templates are all top level properties of the application object with names matching the values returned by [`GET /application/templates`](#operations-application-application_template_collection_get).
### Required properties
* `svm.uuid` or `svm.name` - The existing SVM in which to create the application.
* `name` - The name for the application.
* `<template>` - Properties for one template must be provided. In general, the following properties are required, however the naming of these may vary slightly from template to template.
  - `<template>.name` - The generic templates require names for the components of the application. Other templates name the components automatically.
  - `<template>.application_component.size` - This generally refers to the size of an application component, which may be spread across multiple underlying storage objects (volumes, LUNs, etc...).
  - One of the following must be specified:
  - `nas.nfs_access` or an identifier (name or id) of an existing `export-policy`.
  - `nas.cifs_access`
  - `san.application_application.igroup_name`
  - To specify that a NAS application is not to be exposed via NFS nor CIFS:
  - `nas.application_component.export_policy.name` is 'none', and
  - `nas.application.cifs_share_name` is 'none'.
  - The name of the CIFS share can be provided through the `nas.application.cifs_share_name` attribute. If not provided, the CIFS share name will be the same as the `nas.application_component.name` attribute, including any suffix applied due to creating multiple application components in one post.
  - `san.os_type` - All SAN applications require an os_type to be specified in some way. Some templates refer to this as the `hypervisor`.

### Recommended optional properties
* `<template>` - The following properties are available in some templates.
  - `san.new_igroups.*` - SAN applications can use existing initiator groups or create new ones. When creating new initiator groups, `new_igroups.name` is required and the other properties may be used to fully specify the new initiator group.

### Default property values
If not specified in POST, the follow default property values are assigned. It is recommended that most of these properties be provided explicitly rather than relying upon the defaults. The defaults are intended to make it as easy as possible to provision and connect to an application.
* `template.name` - Defaults to match the `<template>` provided. If specified, the value of this property must match the provided template properties.
* `<template>` - The majority of template properties have default values. The defaults may vary from template to template. See the model of each template for complete details. In general the following patterns are common across all template properties. The location of these properties varies from template to template.
  - `<template>.storage_service.name` - _value_
  - `<template>.protection_type.local_rpo` - _hourly_ (Hourly Snapshot copies)
  - `<template>.protection_type.remote_rpo` - _none_ (Not MetroCluster)
  - `san.new_igroups.os_type` - Defaults to match the `os_type` provided for the application, but may need to be provided explicitly when using virtualization.

### Optional components
A common pattern across many templates are objects that are optional, but once any property in the object is specified, other properties within the object become required. Many applications have optional components. For example, provisioning a database without a component to store the logs is supported. If the properties related to the logs are omitted, no storage will be provisioned for logs. But when the additional component is desired, the size is required. Specifying any other property of a component without specifying the size is not supported. In the model of each template, the required components are indicated with a red '*'. When a `size` property is listed as optional, that means the component itself is optional, and the size should be specified to include that component in the application.
### POST body examples
 1. Create a generic SAN application that exposes four LUNs to an existing initiator group, _igroup_1_.

    ```
    {
    "name": "app1",
    "svm": { "name": "svm1" },
    "san": {
    "os_type": "linux",
    "application_components": [
    { "name": "component1", "total_size": "10GB", "lun_count": 4, "igroup_name": "igroup_1" }
    ]
    }
    }
    ```

 2. Create an SQL application that can be accessed via initiator _iqn.2017-01.com.example:foo_ from a new initiator group, _igroup_2_.

    ```
    {
    "name": "app2",
    "svm": { "name": "svm1" },
    "sql_on_san": {
    "db": { "size": "5GB" },
    "log": { "size": "1GB" },
    "temp_db": { "size": "2GB" },
    "igroup_name": "igroup_2",
    "new_igroups": [
    { "name": "igroup_2", "initiators": [ "iqn.2017-01.com.example:foo" ] }
    ]
    }
    }
    ```

 3. The following body creates the exact same SQL application, but manually provides all the defaults that were excluded from the previous call. Note: The model of a _sql_on_san_ application documents all these default values.

    ```
    {
    "name": "app3",
    "svm": { "name": "svm1" },
    "template": { "name": "sql_on_san" },
    "sql_on_san": {
    "os_type": "windows_2008",
    "server_cores_count": 8,
    "db": { "size": "5GB", "storage_service": { "name": "value" } },
    "log": { "size": "1GB", "storage_service": { "name": "value" } },
    "temp_db": { "size": "2GB", "storage_service": { "name": "value" } },
    "igroup_name": "igroup_2",
    "new_igroups": [
    {
    "name": "igroup_2",
    "protocol": "mixed",
    "os_type": "windows",
    "initiators": [ "iqn.a.new.initiator" ]
    }
    ],
    "protection_type": { "local_rpo": "none" }
    }
    }
    ```

### Learn more
* [`DOC /application`](#docs-application-overview)
* [`Asynchronous operations`](#Synchronous_and_asynchronous_operations)
*/
func (a *Client) ApplicationCreate(params *ApplicationCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationCreateAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationCreateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_create",
		Method:             "POST",
		PathPattern:        "/application/applications",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationCreateAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationCreateDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationDelete Deletes an application and all associated data.

### Warning - this deletes it all, including your data
This deletes everything created with the application, including any volumes, LUNs, NFS export policies, CIFS shares, and initiator groups. Initiator groups are only destroyed if they were created as part of an application and are no longer in use by other applications.
### Learn more
* [`DOC /application`](#docs-application-overview)
* [`Asynchronous operations`](#Synchronous_and_asynchronous_operations)
*/
func (a *Client) ApplicationDelete(params *ApplicationDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationDeleteAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationDeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_delete",
		Method:             "DELETE",
		PathPattern:        "/application/applications/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationDeleteAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationDeleteDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationGet Retrieves an application

### Expensive properties
There is an added cost to retrieving values for these properties. They are not included by default in GET results and must be explicitly requested using the `fields` query parameter. See [`Requesting specific fields`](#Requesting_specific_fields) to learn more.
* `<template>` the property corresponding to the `template.name` of the application
### Property overview
An application includes three main groups or properties.
* Generic properties - such as the `name`, `template.name`, and `state` of the application. These properties are all inexpensive to retrieve and their meaning is consistent for every type of application.
* `statistics.*` - application statistics report live usage data about the application and its components. Various space and IOPS details are included at both the application level and at a per component level. The application model includes a detailed description of each property. These properties are slightly more expensive than the generic properties because live data must be collected from every storage element in the application.
* `<template>` - the property corresponding to the value of the `template.name` returns the contents of the application in the same layout that was used to provision the application. This information is very expensive to retrieve because it requires collecting information about all the storage and access settings for every element of the application. There are a few notable limitations to what can be returned in the `<template>` section:
  - The `new_igroups` array of many SAN templates is not returned by GET. This property allows igroup creation in the same call that creates an application, but is not a property of the application itself. The `new_igroups` array is allowed during PATCH operations, but that does not modify the `new_igroups` of the application. It is another way to allow igroup creation while updating the application to use a different igroup.
  - The `vdi_on_san` and `vdi_on_nas` `desktops.count` property is rounded to the nearest 1000 during creation, and is reported with that rounding applied.
  - The `mongo_db_on_san` `dataset.element_count` property is rounded up to an even number, and is reported with that rounding applied.
  - The `sql_on_san` and `sql_on_smb` `server_cores_count` property is limited to 8 for GET operations. Higher values are accepted by POST, but the impact of the `server_cores_count` property on the application layout currently reaches its limit at 8.

### Learn more
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationGet(params *ApplicationGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_get",
		Method:             "GET",
		PathPattern:        "/application/applications/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationModify Updates the properties of an application.

### Overview
Similar to creating an application, modification is done using the template properties of an application. The `storage_service`, `size`, and `igroup_name` of an application may be modified.
### `storage_service`
Storage service modifications are processed in place, meaning that the storage can not be moved to a location with more performance headroom to accommodate the request. If the current backing storage of the application is in a location that can support increased performance, the QoS policies associated with the application will be modified to allow it. If not, an error will be returned. A storage service modification to a lower tier of performance is always allowed, but the reverse modification may not be supported if the cluster is over provisioned and the cluster is unlikely to be able to fulfil the original storage service.
### `size`
Size modifications are processed in a variety of ways depending on the type of application. For NAS applications, volumes are grown or new volumes are added. For SAN applications, LUNs are grown, new LUNs are added to existing volumes, or new LUNs are added to new volumes. If new storage elements are created, they can be found using the [`GET /application/applications/{application.uuid}/components`](#operations-application-application_component_collection_get) interface. The creation time of each storage object is included, and the newly created objects will use the same naming scheme as the previous objects. Resize follows the best practices associated with the type of application being expanded. Reducing the size of an application is not supported.
### `igroup_name`
Modification of the igroup name allows an entire application to be mapped from one initiator group to another. Data access will be interrupted as the LUNs are unmapped from the original igroup and remapped to the new one.
### Application state
During a modification, the `state` property of the application updates to indicate `modifying`. In `modifying` state, statistics are not available and Snapshot copy operations are not allowed. If the modification fails, it is possible for the application to be left in an inconsistent state, with the underlying ONTAP storage elements not matching across a component. When this occurs, the application is left in the `modifying` state until the command is either retried and succeeds or a call to restore the original state is successful.
### Examples
 1. Change the storage service of the database of the Oracle application to _extreme_ and resize the redo logs to _100GB_.
    ```
    {
    "oracle_on_nfs": {
    "db": {
    "storage_service": {
    "name": "extreme"
    }
    },
    "redo_log": {
    "size": "100GB"
    }
    }
    }
    ```

 2. Change the storage service, size, and igroup of a generic application by component name.
    ```
    {
    "san": {
    "application_components": [
    {
    "name": "component1",
    "storage_service": {
    "name": "value"
    }
    },
    {
    "name": "component2",
    "size": "200GB"
    },
    {
    "name": "component3",
    "igroup_name": "igroup5"
    }
    ]
    }
    }
    ```

### Learn more
* [`DOC /application`](#docs-application-overview)
* [`Asynchronous operations`](#Synchronous_and_asynchronous_operations)
*/
func (a *Client) ApplicationModify(params *ApplicationModifyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationModifyAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationModifyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_modify",
		Method:             "PATCH",
		PathPattern:        "/application/applications/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationModifyReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationModifyAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationModifyDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationSnapshotCollectionGet Retrieves Snapshot copies of an application.

### Query examples
The following query returns all Snapshot copies from May 4, 2017 EST. For readability, the colon (`:`) is left in this example. For an actual call, they should be escaped as `%3A`.

```
GET /application/applications/{application.uuid}/snapshots?create_time=2017-05-04T00:00:00-05:00..2017-05-04T23:59:59-05:00
```

The following query returns all Snapshot copies that have been flagged as _application consistent_.

```
GET /application/applications/{application.uuid}/snapshots?consistency_type=application
```
### Learn more
* [`DOC /application/applications/{application.uuid}/snapshots`](#docs-application-application_applications_{application.uuid}_snapshots)
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationSnapshotCollectionGet(params *ApplicationSnapshotCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotCollectionGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationSnapshotCollectionGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_snapshot_collection_get",
		Method:             "GET",
		PathPattern:        "/application/applications/{application.uuid}/snapshots",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationSnapshotCollectionGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationSnapshotCollectionGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationSnapshotCollectionGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationSnapshotCreate Creates a Snapshot copy of the application.

### Required properties
* `name`
### Recommended optional properties
* `consistency_type` - Track whether this snapshot is _application_ or _crash_ consistent.
### Learn more
* [`DOC /application/applications/{application.uuid}/snapshots`](#docs-application-application_applications_{application.uuid}_snapshots)
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationSnapshotCreate(params *ApplicationSnapshotCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotCreateAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationSnapshotCreateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_snapshot_create",
		Method:             "POST",
		PathPattern:        "/application/applications/{application.uuid}/snapshots",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationSnapshotCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationSnapshotCreateAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationSnapshotCreateDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationSnapshotDelete Delete a Snapshot copy of an application

### Query examples
Individual Snapshot copies can be destroyed with no query parameters, or a range of Snapshot copies can be destroyed at one time using a query.

The following query deletes all application Snapshot copies created before May 4, 2017

```
DELETE /application/applications/{application.uuid}/snapshots?create_time=<2017-05-04T00:00:00-05:00
```
*/
func (a *Client) ApplicationSnapshotDelete(params *ApplicationSnapshotDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotDeleteAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationSnapshotDeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_snapshot_delete",
		Method:             "DELETE",
		PathPattern:        "/application/applications/{application.uuid}/snapshots/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationSnapshotDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationSnapshotDeleteAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationSnapshotDeleteDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationSnapshotGet Retrieve a Snapshot copy of an application component.

This endpoint is only supported for Maxdata template applications.

Component Snapshot copies are essentially more granular application Snapshot copies. There is no difference beyond the scope of the operation.
### Learn more
* [`DOC /application/applications/{application.uuid}/snapshots`](#docs-application-application_applications_{application.uuid}_snapshots)
* [`GET /application/applications/{uuid}/snapshots`](#operations-application-application_snapshot_create)
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationSnapshotGet(params *ApplicationSnapshotGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationSnapshotGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_snapshot_get",
		Method:             "GET",
		PathPattern:        "/application/applications/{application.uuid}/snapshots/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationSnapshotGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationSnapshotGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationSnapshotGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationSnapshotRestore Restore an application snapshot

Restoring an application Snapshot copy reverts all storage elements in the Snapshot copy to the state in which the Snapshot copy was in when the Snapshot copy was taken. This restoration does not apply to access settings that might have changed since the Snapshot copy was created.
### Learn more
* [`DOC /application`](#docs-application-overview)
* [`Asynchronous operations`](#Synchronous_and_asynchronous_operations)
*/
func (a *Client) ApplicationSnapshotRestore(params *ApplicationSnapshotRestoreParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationSnapshotRestoreAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationSnapshotRestoreParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_snapshot_restore",
		Method:             "POST",
		PathPattern:        "/application/applications/{application.uuid}/snapshots/{uuid}/restore",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationSnapshotRestoreReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationSnapshotRestoreAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationSnapshotRestoreDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationTemplateCollectionGet Retrieves application templates.

### Query examples
The most useful queries on this API allows searches by name or protocol access. The following query returns all templates that are used to provision an Oracle application.

```
GET /application/templates?name=ora*
```

Similarly, the following query returns all templates that support SAN access.

```
GET /application/templates?protocol=san
```
### Learn more
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationTemplateCollectionGet(params *ApplicationTemplateCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationTemplateCollectionGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationTemplateCollectionGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_template_collection_get",
		Method:             "GET",
		PathPattern:        "/application/templates",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationTemplateCollectionGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationTemplateCollectionGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationTemplateCollectionGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ApplicationTemplateGet Retrieves an application template.

### Template properties
Each application template has a set of properties. These properties are always nested under a property with the same name as the template. For example, when using the `mongo_db_on_san` template, the properties are found nested inside the `mongo_db_on_san` property. The properties nested under the template property are all specific to the template. The model for the application template object includes all the available templates, but only the object that corresponds to the template's name is returned, and only one is provided in any application API.

The model of each template includes a description of each property and its allowed values or usage. Default values are also indicated when available. The template properties returned by this API include an example value for each property.
### Template prerequisites
Each template has a set of prerequisites required for its use. If any of these prerequisites are not met, the `missing_prerequisites` property indicates which prerequisite is missing.
### Learn more
* [`DOC /application`](#docs-application-overview)
*/
func (a *Client) ApplicationTemplateGet(params *ApplicationTemplateGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationTemplateGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationTemplateGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "application_template_get",
		Method:             "GET",
		PathPattern:        "/application/templates/{name}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ApplicationTemplateGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ApplicationTemplateGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationTemplateGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupCollectionGet Retrieve details of a collection or a specific consistency group.

## Notes
When volume granular properties, such as, the storage SLC, Fabric Pool tiering are not the same for all the existing volumes of a consistency group, the corresponding property is not reported at consistency group granularity. It is only reported if all the volumes of the consistency group have the same value for that property.

If this consistency group instance is part of a replication relationship, the "replicated" parameter will be true. Otherwise, it is false. Also, the "replicated" parameter will not be present in the output for Nested-consistency groups, it is included only for single and top-level consistency groups. If this consistency group instance is the source of a replication relationship, the "replication_source" parameter will be true. Otherwise, it is false.
## Expensive properties
There is an added cost to retrieving values for these properties. They are not included by default in GET results and must be explicitly requested using the `fields` query parameter. See [`DOC Requesting specific fields`](#docs-docs-Requesting-specific-fields) to learn more.
* `volumes`
* `luns`
* `namespaces`
*/
func (a *Client) ConsistencyGroupCollectionGet(params *ConsistencyGroupCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupCollectionGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupCollectionGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_collection_get",
		Method:             "GET",
		PathPattern:        "/application/consistency-groups",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupCollectionGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ConsistencyGroupCollectionGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupCollectionGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupCreate Creates a consistency group with one or more consistency groups having:

* new SAN volumes,
* existing SAN, NVMe or NAS FlexVol volumes in a new or existing consistency group
## Required properties
* `svm.uuid` or `svm.name` - Existing SVM in which to create the group.
* `volumes`, `luns` or `namespaces`
## Naming Conventions
### Consistency groups
  - name or consistency_groups[].name, if specified
  - derived from volumes[0].name, if only one volume is specified, same as volume name

### Volume
  - volumes[].name, if specified
  - derived from volume prefix in luns[].name
  - derived from cg[].name, suffixed by "_#" where "#" is a system generated unique number
  - suffixed by "_#" where "#" is a system generated unique number, if provisioning_options.count is provided

### LUN
  - luns[].name, if specified
  - derived from volumes[].name, suffixed by "_#" where "#" is a system generated unique number
  - suffixed by "_#" where "#" is a system generated unique number, if provisioning_options.count is provided

### NVMe Namespace
  - namespaces[].name, if specified
  - derived from volumes[].name, suffixed by "_#" where "#" is a system generated unique number
  - suffixed by "_#" where "#" is a system generated unique number, if provisioning_options.count is provided

## Related ONTAP commands
There are no ONTAP commands for managing consistency group.
*/
func (a *Client) ConsistencyGroupCreate(params *ConsistencyGroupCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupCreateCreated, *ConsistencyGroupCreateAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupCreateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_create",
		Method:             "POST",
		PathPattern:        "/application/consistency-groups",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ConsistencyGroupCreateCreated:
		return value, nil, nil
	case *ConsistencyGroupCreateAccepted:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupCreateDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupDelete Deletes a consistency group.

Note this will not delete any associated volumes or LUNs. To remove those elements, you can use the appropriate object endpoint.
## Related ONTAP commands
There are no ONTAP commands for managing consistency groups.
*/
func (a *Client) ConsistencyGroupDelete(params *ConsistencyGroupDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupDeleteOK, *ConsistencyGroupDeleteAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupDeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_delete",
		Method:             "DELETE",
		PathPattern:        "/application/consistency-groups/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ConsistencyGroupDeleteOK:
		return value, nil, nil
	case *ConsistencyGroupDeleteAccepted:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupDeleteDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupGet Retrieves a single consistency group.

### Expensive properties
There is an added cost to retrieving values for these properties. They are not included by default in GET results and must be explicitly requested using the `fields` query parameter. See [`DOC Requesting specific fields`](#docs-docs-Requesting-specific-fields) to learn more.
* `volumes`
* `luns`
* `namespaces`
## Related ONTAP commands
There are no ONTAP commands for managing consistency groups.
*/
func (a *Client) ConsistencyGroupGet(params *ConsistencyGroupGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_get",
		Method:             "GET",
		PathPattern:        "/application/consistency-groups/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ConsistencyGroupGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupModify Updates a consistency group.

Note that this operation will never delete storage elements. You can specify only elements that should be added to the consistency group regardless of existing storage objects.
## Related ONTAP commands
N/A. There are no ONTAP commands for managing consistency groups.
## Examples:
### Adding namespaces to an existing volume in an existing consistency group
To add two NVMe Namespaces to an existing volume in an existing consistency group, create a new subsystem and bind the new namespaces to it.
```
curl -X PATCH 'https://<mgmt-ip>/api/application/consistency-groups/6f51748a-0a7f-11ec-a449-005056bbcf9f' -d '{ "namespaces": [ { "name": "/vol/vol1/new_namespace", "space": { "size": "10M" }, "os_type": "windows", "provisioning_options": { "count": 2 }, "subsystem_map": { "subsystem": { "name": "mySubsystem", "hosts": [ { "nqn": "nqn.1992-08.com.netapp:sn.d04594ef915b4c73b642169e72e4c0b1:subsystem.host1" }, { "nqn": "nqn.1992-08.com.netapp:sn.d04594ef915b4c73b642169e72e4c0b1:subsystem.host2" } ] } } } ] }'
#### Response:
```

	{
	  "job": {
	    "uuid": "8c9cabf3-0a88-11ec-a449-005056bbcf9f",
	    "_links": {
	      "self": {
	        "href": "/api/cluster/jobs/8c9cabf3-0a88-11ec-a449-005056bbcf9f"
	      }
	    }
	  }
	}

```
*/
func (a *Client) ConsistencyGroupModify(params *ConsistencyGroupModifyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupModifyOK, *ConsistencyGroupModifyAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupModifyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_modify",
		Method:             "PATCH",
		PathPattern:        "/application/consistency-groups/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupModifyReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ConsistencyGroupModifyOK:
		return value, nil, nil
	case *ConsistencyGroupModifyAccepted:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupModifyDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupSnapshotCollectionGet Retrieves Snapshot copies for a consistency group.

## Expensive properties
There is an added cost to retrieving values for these properties. They are not included by default in GET results and must be explicitly requested using the `fields` query parameter. See [`DOC Requesting specific fields`](#docs-docs-Requesting-specific-fields) to learn more.
* `is_partial`
* `missing_voumes.uuid`
* `missing_voumes.name`
*/
func (a *Client) ConsistencyGroupSnapshotCollectionGet(params *ConsistencyGroupSnapshotCollectionGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupSnapshotCollectionGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupSnapshotCollectionGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_snapshot_collection_get",
		Method:             "GET",
		PathPattern:        "/application/consistency-groups/{consistency_group.uuid}/snapshots",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupSnapshotCollectionGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ConsistencyGroupSnapshotCollectionGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupSnapshotCollectionGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupSnapshotCreate Creates a Snapshot copy of an existing consistency group.

### Required properties
* `consistency_group.uuid` - Existing consistency group UUID in which to create the Snapshot copy.
*/
func (a *Client) ConsistencyGroupSnapshotCreate(params *ConsistencyGroupSnapshotCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupSnapshotCreateCreated, *ConsistencyGroupSnapshotCreateAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupSnapshotCreateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_snapshot_create",
		Method:             "POST",
		PathPattern:        "/application/consistency-groups/{consistency_group.uuid}/snapshots",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupSnapshotCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ConsistencyGroupSnapshotCreateCreated:
		return value, nil, nil
	case *ConsistencyGroupSnapshotCreateAccepted:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupSnapshotCreateDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupSnapshotDelete Deletes a Snapshot copy of a consistency group.

## Examples
*/
func (a *Client) ConsistencyGroupSnapshotDelete(params *ConsistencyGroupSnapshotDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupSnapshotDeleteOK, *ConsistencyGroupSnapshotDeleteAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupSnapshotDeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_snapshot_delete",
		Method:             "DELETE",
		PathPattern:        "/application/consistency-groups/{consistency_group.uuid}/snapshots/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupSnapshotDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *ConsistencyGroupSnapshotDeleteOK:
		return value, nil, nil
	case *ConsistencyGroupSnapshotDeleteAccepted:
		return nil, value, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupSnapshotDeleteDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
	ConsistencyGroupSnapshotGet Retrieves details of a specific snapshot for a consistency group.

### Expensive properties
There is an added cost to retrieving values for these properties. They are not included by default in GET results and must be explicitly requested using the `fields` query parameter. See [`DOC Requesting specific fields`](#docs-docs-Requesting-specific-fields) to learn more.
* `is_partial`
* `missing_voumes.uuid`
* `missing_voumes.name`
*/
func (a *Client) ConsistencyGroupSnapshotGet(params *ConsistencyGroupSnapshotGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ConsistencyGroupSnapshotGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewConsistencyGroupSnapshotGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "consistency_group_snapshot_get",
		Method:             "GET",
		PathPattern:        "/application/consistency-groups/{consistency_group.uuid}/snapshots/{uuid}",
		ProducesMediaTypes: []string{"application/hal+json", "application/json"},
		ConsumesMediaTypes: []string{"application/hal+json", "application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ConsistencyGroupSnapshotGetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ConsistencyGroupSnapshotGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ConsistencyGroupSnapshotGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}


I'm getting close to the end of my first phase of research for the Jewish Magic book, so now might be a good time to field some questions. This will help me to figure out what I should read next, and how well I've absorbed what I've read already.
So ask your questions about Jewish magic, and I'll do my best to answer them.


What Causes Acne After Stopping Birth Control?
You are probably well aware of all of the effects which you experience when you start using birth control pills such as less cramps, periods which are lighter, and hopefully no pregnancy scares. However, do you know what happens when you go off the pill? Whether you stop using the pill so you can get pregnant or just because you don't need to use it at the moment, you might be wondering what kind of changes you'll experience when you do so. Remember that these symptoms can differ between women, but it is good to know what they are. Among those changes, having acne breakout is one common concern.
One reason to go on the pill in the first place is to control your acne. However, the unfortunate thing here is that you will likely experience acne after stopping birth control. Breakouts are prevented while you are on the pill because your testosterone levels go down, but this of course goes back up when you stop using it and your acne returns. The best thing to do if you experience severe acne is to visit your dermatologist before you make the switch to see what they can do to help.
Some women will find that their birth control breakout after stopping the use of the pill is due to Polycystic Ovary Syndrome, which is a hormonal disorder that is common and many times followed by acne. If you've been using the pill for quite a while, such as ten years or more, there could be other pathologies that have developed and gone undetected until you come off the pill. For instance, if a woman had mild PCOS which wasn't diagnosed before going on the pill, acne and irregular periods could be controlled or improved so that until the pills are not taken anymore the PCOS would not be apparent.
You'll first need a simple skin-care routine when you are stopping birth control pills acne so that you can reduce inflammation. You should use things such as a creamy cleanser, toner with no alcohol, a lotion that is oil-free and a gentle glycolic serum to dissolve any dead skin that is pore-clogging.
Twice a day, use a mild cleanser or soap to clean your skin gently. You should do this once in the morning and once at night. Do not use any rough scrub pads or harsh soaps, as these can worsen your acne. Go from your jaw to the hairline to wash your entire face, and thoroughly rinse when you are done. Take your make-up off with water and a mild soap and speak with your doctor before using an astringent.
You also should use products that contain benzoyl peroxide, and generally you can find this in either a lotion or soap. This product will clean the dead skin off and help your skin to regenerate clean cells much faster. Find products which have 3% or less of benzoyl peroxide so you don't irritate your skin.
You can treat your acne after stopping birth control with antibiotic gels or lotions, or even retinoic acid, which is an altered form of vitamin A. It will help stop blackheads and whiteheads, and your doctor might even prescribe an antibiotic pill like erythromycin. Antibiotic and retinoic acid pills can make your skin sensitive to the sun so make sure to wear sunscreen and keep in the shade when you use them.
Tea tree oil and neem oil are considered to have properties which are antimicrobial which can kill the bacteria which causes acne. Put a drop of diluted tea tree or neem oil on each spot, or use a cotton swab and wipe it over your problem areas. Tea tree oil can assist in clearing the microbes that are clogging your skin. Do not however, use it undiluted, as this will burn your skin and cause worse acne.
Foods that are highly processed and have a lot of oils will increase greatly how much acne you have on your body. Get the right nutrients from fruits, whole grains, protein and vegetables to help your skin regenerative faster and stop an oil production that is unnecessary.


text:
Home » News » Industry: Bad Precedent Set If DoD Cancels Multiyear Helo Buy
Industry: Bad Precedent Set If DoD Cancels Multiyear Helo Buy
(DEFENSE NEWS 14 APR 14) … Marcus Weisgerber
WASHINGTON – The U.S. Navy, in its fiscal 2015 budget proposal, said it wants to cancel a planned buy of 29 MH-60R Seahawk helicopters in 2016.
The service's reasoning is fairly simple: The Navy is considering retiring the aircraft carrier George Washington due to defense spending cuts. Retiring a carrier means one less carrier air wing – which includes MH-60Rs.
But a major hurdle lies in the helicopter cancellation: The Pentagon signed a multiyear procurement deal with Sikorsky Aircraft and Lockheed Martin – makers of the helicopter – for those 29 machines, meaning the costs associated with terminating the contract could end up being higher than the purchase price, according to Defense Department and industry officials.
The cancellation also could hurt the U.S. Army, which is acquiring UH-60M Black Hawk and HH-60M medical evacuation helicopters through the same multiyear procurement deal.
The Pentagon signed the $8.5 billion deal with Sikorsky for at least 653 helicopters in June 2012. Deliveries run through 2017. The deal included options for 263 more helicopters.
Moreover, it could set a bad precedent that makes contractors wary of inking multiyear procurements, which have saved the Pentagon significant money in acquisition costs over the years.
"The biggest change I think – which is troublesome – is I think this would be the first multiyear in the history of the U.S. government to be broken," said Scott Starrett, vice president of government business development for Sikorsky.
The Pentagon has said it does not want to get rid of a carrier, but budget caps are forcing it to cut ships, aircraft, vehicles and troops.
At a March 12 House Armed Services Committee hearing, Adm. Jon Greenert, chief of naval operations, said the cost of terminating the MH-60R contract is about the same as continuing it and getting the aircraft.
Sen. Carl Levin, chairman of the Senate Armed Services Committee, said at a March 27 hearing that the cost of terminating the MH-60R multiyear deal is "at least $250 million."
"[T]hat action would result in increased cost to the Army, as well," he said.
The Pentagon has been using multiyear procurement arrangements for decades to buy Air Force fighter jets, Navy destroyers, Marine Corps aircraft and Army vehicles. Since 1990, DoD has inked nearly 90 multiyear procurement deals, according to the Congressional Research Service (CRS). Eight multiyear contracts over that period have been for Sikorsky H-60-model helicopters.
The estimated savings by using a multiyear versus annual contract is 5 percent to 15 percent, historically, according to CRS.
"The reasons multiyears exist is they provide great stability for the supply chain on the industrial side … and it provides tremendous saving for the government," Starrett said.
Further complicating matters is the Navy MH-60R multiyear deal includes Army Black Hawk helicopters. If the Navy cancels its Seahawk buy, at least 60 Army aircraft that are part of that deal would be voided.
"The Army Black Hawks and the Navy Seahawks are both under the same contract," Starrett said. "If either party changes their volume enough within the bounds of the contract, it breaks it for everybody."
That means the Army would need to renegotiate for those helicopters, likely at a higher price tag.
"I would expect there would be a price difference in the helicopters," Starrett said.
Sikorsky is working on the terms of its next multiyear procurement plan with the Army for its next batch of Black Hawks, Starrett said.
International MH-60R purchases by Australia and Denmark will not be affected if the Navy terminates its multiyear buy, said George Barton, vice president of business development for Lockheed Martin ship and aviation systems.
Vago Muradian contributed to this report.
Boeing Presses Congress To Have Navy Buy More Super Hornets
Analyst: It's the End of an Era for Military Aviation Industry
For now, Navy cancels search for outlying landing field
Nation Must Preserve Shipbuilding Industry

redpajama_set_name: RedPajamaCommonCrawl


Feature extensions can be used to share common setup and teardown operations between different features and/or specs. Whenever you are missing helper methods in feature definitions, you should use extensions instead. You can declare extension fields in scenarios to perform setup and teardown operations before/after the scenario is executed.
teardown operations before/after the scenario is executed.


text:
A bermudai függetlenségi mozgalom egy politikai törekvés, amelynek célja a Brit tengerentúli területek közé tartozó Bermuda függetlenségének kivívása az Egyesült Királyságtól. Az apró, szubtrópusi éghajlatú szigetcsoport az Atlanti-óceán északnyugati részén fekszik és 1620 óta önálló parlamenttel rendelkezik.

Történet
A lakatlan szigetcsoportot Juan Bermudez fedezte fel, az első lakott település 1615-ben épült Bermudán. A sziget lett Anglia első hagyományos értelembe vett kolóniája, ennek megfelelően már 1620-ban önálló parlamentet kapott, amely így a világ legrégebb óta fönnálló törvényhozó testületei közé tartozik. A végrehajtói hatalmat egészen 1966-ig a sziget mindenkori kormányzója birtokolta, ezután vált meghatározóvá a kormány szerepe. Jelenleg a parlament egy felső és egy alsóházra tagolódik.
Bermuda számos téren nagy autonómiával rendelkezik, az önálló törvényhozáson kívül pénzpolitikája is független az Egyesült Királyságtól, pénzneme a bermudai dollár és az anyaországhoz egyedül a saját külpolitika hiánya és a védelem kérdése köti.

1995-ös függetlenségi népszavazás
1995-ben a bermudai nemzetgyűlés szűk többséggel elfogadta a népszavazás kiírásáról szóló törvényjavaslatot, aminek egyes elemeit kifogásolta az ekkor ellenzéki függetlenségpárti Progresszív Munkáspárt és emiatt szavazóit a referendum bojkottjára szólította föl. A kormányzó Egyesült Bermuda Párt, a mai Egy Bermuda Szövetség közvetlen elődje megosztott volt a kérdést illetően, a kormány vezetője, Sir John Swan támogatta a függetlenséget és a maradáspártiak győzelme után le is mondott posztjáról. A referendumon végül 59%-os részvételi aránnyal nagy többséggel győzött a maradáspárti kampány.

Támogatottsága

Politikai pártok

Bermuda politikája hagyományosan kétpárti berendezkedésű, a jelenleg is kormányon lévő Progresszív Munkáspárt (PLP) és az ellenzéki Egy Bermuda Szövetség (OBA) uralja. A Progresszív Munkáspárt megalakulása óta támogatja az antikolonializmust és ezzel együtt a bermudai nemzeti függetlenséget. A kormánypárt álláspontja szerint a szigetcsoport nem szorul rá a brit támogatásokra, Bermuda gazdasága stabil önállóan is turizmusának és adóparadicsom voltának köszönhetően. A bermudai kormány jelenlegi vezetője, E. David Burt úgy nyilatkozott, hogy ahhoz, hogy elkerüljék a brit befolyás fönnmaradását és azt, hogy a több ezer kilométerre fekvő Londonból irányítsák a területet, a teljes függetlenséget kell elérni minél hamarabb. A főként feketék által alkotott szavazó-bázisú PLP-vel szemben a bermudai fehér lakosság által támogatott Egy Bermuda Szövetség alapvetően maradáspárti politikát folytat, azonban ennek ellenére számos politikusa támogatja az elszakadást.

Közvélemény-kutatások

A közvélemény-kutatások alapján kijelenthető, hogy annak ellenére, hogy a politikai elit legnagyobb része elszakadáspárti, a függetlenség támogatottsága nem növekedett jelentősen az 1995-ös népszavazás óta a lakosság körében. A szeparatizmus támogatottsága rasszonként különbözik, amíg a fekete közösség 26%-a támogatja az elszakadást, addig a fehérek alig 9%-a látná szívesen a szigeteket önálló országként.

Jegyzetek

Bermuda

redpajama_set_name: RedPajamaWikipedia


text:
Quirky. Awkward. Offbeat.
Film Fests
Labels: comedy, TV
The new series (based on the 2006 indie film of the same name) centers on the all-American Novelties company whose call center has suddenly been outsourced to India. Todd Dempsy (Ben Rappaport) is the new company's manager who learns that he's being transferred to India to run the operation. Overwhelmed, Todd discovers that his new staff needs a crash course in all things American if they are to understand the U.S. product line and ramp up sales from halfway around the world. Robert Borden (The Drew Carey Show) is executive producer/writer. Ken Kwapis (The Office) developed the project through his company, In Cahoots, and serves as executive producer/director. Sure the concept isn't new but it looks fun. Coming thursdays this fall on NBC.
Joshua dos Santos ● Friday, May 28, 2010
Looks interesting !!!
Copyright © 2008 - 2019 Reel Artsy / Banner design by Sylvia A Smith. Powered by Blogger.
Most quoted film descriptions are from IMDb.com, official sites, and press releases. ALL NAMES, TRADEMARKS AND IMAGES ARE COPYRIGHT THEIR RESPECTIVE OWNERS.
Blog Archive May 2019 (5) April 2019 (4) March 2019 (1) April 2017 (1) March 2017 (1) October 2016 (2) September 2016 (2) June 2016 (1) March 2016 (1) February 2016 (7) January 2016 (13) December 2015 (2) August 2015 (1) May 2015 (1) January 2015 (1) November 2014 (2) July 2014 (1) June 2014 (1) May 2014 (1) April 2014 (1) February 2013 (2) October 2012 (1) September 2012 (13) August 2012 (2) July 2012 (2) April 2012 (1) March 2012 (4) February 2012 (20) January 2012 (27) December 2011 (13) November 2011 (9) October 2011 (16) September 2011 (17) August 2011 (8) July 2011 (2) June 2011 (8) May 2011 (13) April 2011 (18) March 2011 (26) February 2011 (30) January 2011 (27) December 2010 (21) November 2010 (19) October 2010 (25) September 2010 (28) August 2010 (38) July 2010 (36) June 2010 (47) May 2010 (65) April 2010 (42) March 2010 (57) February 2010 (34) January 2010 (30) December 2009 (33) November 2009 (21) October 2009 (23) September 2009 (31) August 2009 (31) July 2009 (30) June 2009 (25) May 2009 (37) April 2009 (37) March 2009 (40) February 2009 (30) January 2009 (21) December 2008 (21) November 2008 (18) October 2008 (20) September 2008 (4)
Exclusive Interviews:
action (31) Andrew Garfield (4) animation (32) Anne Hathaway (5) Arab films (19) Asian-American films (25) Aubrey Plaza (5) Ava DuVernay (6) awkwardly cute (31) biracial films (25) black films (57) Bollywood (Indian) films (11) Canadian films (9) Carey Mulligan (4) classic films (18) comedy (72) documentaries (47) Emily Blunt (3) Emma Stone (8) Evan Ross (5) Ewan McGregor (4) Fempire (10) film festivals (59) French films (26) German films (4) Greta Gerwig (4) Immigrant Films (9) interracial romance (48) interviews (19) Jesse Eisenberg (9) Jesse Williams (4) Jessica Parker Kennedy (7) Joseph Gordon-Levitt (11) Katerina Graham (6) Latino films (18) Lorene Scafaria (4) magazines (15) Michael Cera (7) Misc. (102) Natalie Portman (16) Native American films (21) New Zealand films (5) Paul Rudd (4) posters (133) Rashida Jones (31) Remembered (7) Rosario Dawson (12) Ryan Gosling (4) Salli Richardson-Whitfield (6) sci-fi (27) soundtracks (23) Trieste Kelly Dunn (3) webisodes (15) women and film (70) Zachary Levi (17) Zoe Kravitz (7) Zoe Lister Jones (4) Zoe Saldana (2) Zooey Deschanel (29)
Reel Artsy © 2014 | Designed by Plantillas Blogger and Aplicaciones Android


Prince Vladimir Youth Association is a Non-Profit organization working to bring youth together by means of culture, philanthropy and the service of assisting the needy.
The objectives of our organization lay in the values established by Prince Vladimir the unifier of peoples to integrate youth through national identity, culture, language, philanthropy and importance of community service.
To promote Russian-American cultural collaboration while demonstrating the prayerful depth and beauty of the Russian music tradition; inspire and educate our young singers and conductors through a vast offering of professional programs.
To unite youth through the strengthening of national self-identity based on their historic homeland through the culture and traditions of Holy Russia.
To do missionary work targeting and preserving the cultural legacy of the historic homeland of young people; to preserve the active use of Russian traditions in daily life both among young people and amid the descendants of Russian people of various generations living abroad.
To organize missionary and cultural conferences, symposiums on questions of morality, social service and culture; arrange pilgrimages and missionary and educational trips in Russia and abroad.
To organize and support youth participation in charitable and social service in their communities and the needy, elderly and lonely; to help in the preservation and restoration of Orthodox churches and monasteries in the US and Russia.
To support the moral upbringing of youth using the finest examples of the Russian emigration of old; preserving and disseminating the best experiences of the Russian Diaspora.