searchApps(params: Params$Resource$Projects$Searchapps, options: MethodOptions | BodyResponseCallback<Schema$SearchFirebaseAppsResponse>, callback: BodyResponseCallback<Schema$SearchFirebaseAppsResponse>): void;


searchApps(params: Params$Resource$Projects$Searchapps, callback: BodyResponseCallback<Schema$SearchFirebaseAppsResponse>): void;


searchApps(callback: BodyResponseCallback<Schema$SearchFirebaseAppsResponse>): void;


/**
         * firebase.projects.androidApps.create
         * @desc Requests that a new AndroidApp be created.

The result of this call is an `Operation` which can be used to track the provisioning process. The `Operation` is automatically deleted after completion, so there is no need to call `DeleteOperation`.
         * @alias firebase.projects.androidApps.create
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.parent The parent Project for which to list Apps, in the format:
projects/<var>projectId</var>
         * @param {().AndroidApp} params.requestBody Request body data
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
create(params?: Params$Resource$Projects$Androidapps$Create, options?: MethodOptions): GaxiosPromise<Schema$Operation>;


create(params: Params$Resource$Projects$Androidapps$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;


create(params: Params$Resource$Projects$Androidapps$Create, callback: BodyResponseCallback<Schema$Operation>): void;


create(callback: BodyResponseCallback<Schema$Operation>): void;


/**
         * firebase.projects.androidApps.get
         * @desc Gets the AndroidApp identified by the specified resource name.
         * @alias firebase.projects.androidApps.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The fully qualified resource name of the App, in the format:
projects/<var>projectId</var>/androidApps/<var>appId</var>
As an <var>appId</var> is a unique identifier, the Unique Resource from Sub-Collection access pattern may be used here, in the format:
projects/-/androidApps/<var>appId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
get(params?: Params$Resource$Projects$Androidapps$Get, options?: MethodOptions): GaxiosPromise<Schema$AndroidApp>;


get(params: Params$Resource$Projects$Androidapps$Get, options: MethodOptions | BodyResponseCallback<Schema$AndroidApp>, callback: BodyResponseCallback<Schema$AndroidApp>): void;


get(params: Params$Resource$Projects$Androidapps$Get, callback: BodyResponseCallback<Schema$AndroidApp>): void;


get(callback: BodyResponseCallback<Schema$AndroidApp>): void;


/**
         * firebase.projects.androidApps.getConfig
         * @desc Gets the configuration artifact associated with the specified AndroidApp.
         * @alias firebase.projects.androidApps.getConfig
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The resource name of the App configuration to download, in the format:
projects/<var>projectId</var>/androidApps/<var>appId</var>/config
As an <var>appId</var> is a unique identifier, the Unique Resource from Sub-Collection access pattern may be used here, in the format:
projects/-/androidApps/<var>appId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
getConfig(params?: Params$Resource$Projects$Androidapps$Getconfig, options?: MethodOptions): GaxiosPromise<Schema$AndroidAppConfig>;


getConfig(params: Params$Resource$Projects$Androidapps$Getconfig, options: MethodOptions | BodyResponseCallback<Schema$AndroidAppConfig>, callback: BodyResponseCallback<Schema$AndroidAppConfig>): void;


getConfig(params: Params$Resource$Projects$Androidapps$Getconfig, callback: BodyResponseCallback<Schema$AndroidAppConfig>): void;


getConfig(callback: BodyResponseCallback<Schema$AndroidAppConfig>): void;


/**
         * firebase.projects.androidApps.list
         * @desc Lists each AndroidApp associated with the specified parent Project.

The elements are returned in no particular order, but will be a consistent view of the Apps when additional requests are made with a `pageToken`.
         * @alias firebase.projects.androidApps.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {integer=} params.pageSize The maximum number of Apps to return in the response.

The server may return fewer than this at its discretion. If no value is specified (or too large a value is specified), then the server will impose its own limit.
         * @param {string=} params.pageToken Token returned from a previous call to `ListAndroidApps` indicating where in the set of Apps to resume listing.
         * @param {string} params.parent The parent Project for which to list Apps, in the format:
projects/<var>projectId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
list(params?: Params$Resource$Projects$Androidapps$List, options?: MethodOptions): GaxiosPromise<Schema$ListAndroidAppsResponse>;


list(params: Params$Resource$Projects$Androidapps$List, options: MethodOptions | BodyResponseCallback<Schema$ListAndroidAppsResponse>, callback: BodyResponseCallback<Schema$ListAndroidAppsResponse>): void;


list(params: Params$Resource$Projects$Androidapps$List, callback: BodyResponseCallback<Schema$ListAndroidAppsResponse>): void;


list(callback: BodyResponseCallback<Schema$ListAndroidAppsResponse>): void;


/**
         * firebase.projects.androidApps.patch
         * @desc Updates the attributes of the AndroidApp identified by the specified resource name.
         * @alias firebase.projects.androidApps.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The fully qualified resource name of the App, in the format:
projects/<var>projectId</var>/androidApps/<var>appId</var>
         * @param {string=} params.updateMask Specifies which fields to update.
Note that the fields `name`, `appId`, `projectId`, and `packageName` are all immutable.
         * @param {().AndroidApp} params.requestBody Request body data
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
patch(params?: Params$Resource$Projects$Androidapps$Patch, options?: MethodOptions): GaxiosPromise<Schema$AndroidApp>;


patch(params: Params$Resource$Projects$Androidapps$Patch, options: MethodOptions | BodyResponseCallback<Schema$AndroidApp>, callback: BodyResponseCallback<Schema$AndroidApp>): void;


patch(params: Params$Resource$Projects$Androidapps$Patch, callback: BodyResponseCallback<Schema$AndroidApp>): void;


patch(callback: BodyResponseCallback<Schema$AndroidApp>): void;


/**
         * firebase.projects.androidApps.sha.create
         * @desc Adds a SHA certificate to the specified AndroidApp.
         * @alias firebase.projects.androidApps.sha.create
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.parent The parent App to which a SHA certificate will be added, in the format:
projects/<var>projectId</var>/androidApps/<var>appId</var>
As an <var>appId</var> is a unique identifier, the Unique Resource from Sub-Collection access pattern may be used here, in the format:
projects/-/androidApps/<var>appId</var>
         * @param {().ShaCertificate} params.requestBody Request body data
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
create(params?: Params$Resource$Projects$Androidapps$Sha$Create, options?: MethodOptions): GaxiosPromise<Schema$ShaCertificate>;


create(params: Params$Resource$Projects$Androidapps$Sha$Create, options: MethodOptions | BodyResponseCallback<Schema$ShaCertificate>, callback: BodyResponseCallback<Schema$ShaCertificate>): void;


create(params: Params$Resource$Projects$Androidapps$Sha$Create, callback: BodyResponseCallback<Schema$ShaCertificate>): void;


create(callback: BodyResponseCallback<Schema$ShaCertificate>): void;


/**
         * firebase.projects.androidApps.sha.delete
         * @desc Removes a SHA certificate from the specified AndroidApp.
         * @alias firebase.projects.androidApps.sha.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The fully qualified resource name of the `sha-key`, in the format:
projects/<var>projectId</var>/androidApps/<var>appId</var>/sha/<var>shaId</var>
You can obtain the full name from the response of [`ListShaCertificates`](../projects.androidApps.sha/list) or the original [`CreateShaCertificate`](../projects.androidApps.sha/create).
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
delete(params?: Params$Resource$Projects$Androidapps$Sha$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;


delete(params: Params$Resource$Projects$Androidapps$Sha$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;


delete(params: Params$Resource$Projects$Androidapps$Sha$Delete, callback: BodyResponseCallback<Schema$Empty>): void;


/**
         * firebase.projects.androidApps.sha.list
         * @desc Returns the list of SHA-1 and SHA-256 certificates for the specified AndroidApp.
         * @alias firebase.projects.androidApps.sha.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.parent The parent App for which to list SHA certificates, in the format:
projects/<var>projectId</var>/androidApps/<var>appId</var>
As an <var>appId</var> is a unique identifier, the Unique Resource from Sub-Collection access pattern may be used here, in the format:
projects/-/androidApps/<var>appId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
list(params?: Params$Resource$Projects$Androidapps$Sha$List, options?: MethodOptions): GaxiosPromise<Schema$ListShaCertificatesResponse>;


list(params: Params$Resource$Projects$Androidapps$Sha$List, options: MethodOptions | BodyResponseCallback<Schema$ListShaCertificatesResponse>, callback: BodyResponseCallback<Schema$ListShaCertificatesResponse>): void;


list(params: Params$Resource$Projects$Androidapps$Sha$List, callback: BodyResponseCallback<Schema$ListShaCertificatesResponse>): void;


list(callback: BodyResponseCallback<Schema$ListShaCertificatesResponse>): void;


/**
         * firebase.projects.availableLocations.list
         * @desc Returns a list of valid Google Cloud Platform (GCP) resource locations for the specified Project (including a FirebaseProject).

One of these locations can be selected as the Project's [_default_ GCP resource location](https://firebase.google.com/docs/projects/locations), which is the geographical location where project resources, such as Cloud Firestore, will be provisioned by default. However, if the default GCP resource location has already been set for the Project, then this setting cannot be changed.

This call checks for any location restrictions for the specified Project and, thus, might return a subset of all possible GCP resource locations. To list all GCP resource locations (regardless of any restrictions), call the endpoint without specifying a `projectId` (that is, `/v1beta1/{parent=projects/-}/listAvailableLocations`).

To call `ListAvailableLocations` with a specified project, a member must be at minimum a Viewer of the project. Calls without a specified project do not require any specific project permissions.
         * @alias firebase.projects.availableLocations.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {integer=} params.pageSize The maximum number of locations to return in the response.

The server may return fewer than this value at its discretion. If no value is specified (or too large a value is specified), then the server will impose its own limit.

This value cannot be negative.
         * @param {string=} params.pageToken Token returned from a previous call to `ListAvailableLocations` indicating where in the list of locations to resume listing.
         * @param {string} params.parent The Project for which to list GCP resource locations, in the format:
projects/<var>projectId</var>
If no project is specified (that is, `projects/-`), the returned list does not take into account org-specific or project-specific location restrictions.
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
list(params?: Params$Resource$Projects$Availablelocations$List, options?: MethodOptions): GaxiosPromise<Schema$ListAvailableLocationsResponse>;


list(params: Params$Resource$Projects$Availablelocations$List, options: MethodOptions | BodyResponseCallback<Schema$ListAvailableLocationsResponse>, callback: BodyResponseCallback<Schema$ListAvailableLocationsResponse>): void;


list(params: Params$Resource$Projects$Availablelocations$List, callback: BodyResponseCallback<Schema$ListAvailableLocationsResponse>): void;


list(callback: BodyResponseCallback<Schema$ListAvailableLocationsResponse>): void;


/**
         * firebase.projects.defaultLocation.finalize
         * @desc Sets the default Google Cloud Platform (GCP) resource location for the specified FirebaseProject.

This method creates an App Engine application with a [default Cloud Storage bucket](https://cloud.google.com/appengine/docs/standard/python/googlecloudstorageclient/setting-up-cloud-storage#activating_a_cloud_storage_bucket), located in the specified [`location_id`](#body.request_body.FIELDS.location_id). This location must be one of the available [GCP resource locations](https://firebase.google.com/docs/projects/locations).

After the default GCP resource location is finalized, or if it was already set, it cannot be changed. The default GCP resource location for the specified FirebaseProject might already be set because either the GCP `Project` already has an App Engine application or `FinalizeDefaultLocation` was previously called with a specified `location_id`. Any new calls to `FinalizeDefaultLocation` with a different specified `location_id` will return a 409 error.

The result of this call is an [`Operation`](../../v1beta1/operations), which can be used to track the provisioning process. The [`response`](../../v1beta1/operations#Operation.FIELDS.response) type of the `Operation` is google.protobuf.Empty.

The `Operation` can be polled by its `name` using GetOperation until `done` is true. When `done` is true, the `Operation` has either succeeded or failed. If the `Operation` has succeeded, its [`response`](../../v1beta1/operations#Operation.FIELDS.response) will be set to a google.protobuf.Empty; if the `Operation` has failed, its `error` will be set to a google.rpc.Status. The `Operation` is automatically deleted after completion, so there is no need to call DeleteOperation.

All fields listed in the [request body](#request-body) are required.

To call `FinalizeDefaultLocation`, a member must be an Owner of the project.
         * @alias firebase.projects.defaultLocation.finalize
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.parent The resource name of the Project for which the default GCP resource location will be set, in the format:
projects/<var>projectId</var>
         * @param {().FinalizeDefaultLocationRequest} params.requestBody Request body data
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
finalize(params?: Params$Resource$Projects$Defaultlocation$Finalize, options?: MethodOptions): GaxiosPromise<Schema$Operation>;


finalize(params: Params$Resource$Projects$Defaultlocation$Finalize, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;


finalize(params: Params$Resource$Projects$Defaultlocation$Finalize, callback: BodyResponseCallback<Schema$Operation>): void;


finalize(callback: BodyResponseCallback<Schema$Operation>): void;


/**
         * firebase.projects.iosApps.create
         * @desc Requests that a new IosApp be created.

The result of this call is an `Operation` which can be used to track the provisioning process. The `Operation` is automatically deleted after completion, so there is no need to call `DeleteOperation`.
         * @alias firebase.projects.iosApps.create
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.parent The parent Project for which to list Apps, in the format:
projects/<var>projectId</var>
         * @param {().IosApp} params.requestBody Request body data
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
create(params?: Params$Resource$Projects$Iosapps$Create, options?: MethodOptions): GaxiosPromise<Schema$Operation>;


create(params: Params$Resource$Projects$Iosapps$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;


create(params: Params$Resource$Projects$Iosapps$Create, callback: BodyResponseCallback<Schema$Operation>): void;


/**
         * firebase.projects.iosApps.get
         * @desc Gets the IosApp identified by the specified resource name.
         * @alias firebase.projects.iosApps.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The fully qualified resource name of the App, in the format: projects/<var>projectId</var>/iosApps/<var>appId</var>
As an <var>appId</var> is a unique identifier, the Unique Resource from Sub-Collection access pattern may be used here, in the format:
projects/-/iosApps/<var>appId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
get(params?: Params$Resource$Projects$Iosapps$Get, options?: MethodOptions): GaxiosPromise<Schema$IosApp>;


get(params: Params$Resource$Projects$Iosapps$Get, options: MethodOptions | BodyResponseCallback<Schema$IosApp>, callback: BodyResponseCallback<Schema$IosApp>): void;


get(params: Params$Resource$Projects$Iosapps$Get, callback: BodyResponseCallback<Schema$IosApp>): void;


get(callback: BodyResponseCallback<Schema$IosApp>): void;


/**
         * firebase.projects.iosApps.getConfig
         * @desc Gets the configuration artifact associated with the specified IosApp.
         * @alias firebase.projects.iosApps.getConfig
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The resource name of the App configuration to download, in the format:
projects/<var>projectId</var>/iosApps/<var>appId</var>/config
As an <var>appId</var> is a unique identifier, the Unique Resource from Sub-Collection access pattern may be used here, in the format:
projects/-/iosApps/<var>appId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
getConfig(params?: Params$Resource$Projects$Iosapps$Getconfig, options?: MethodOptions): GaxiosPromise<Schema$IosAppConfig>;


getConfig(params: Params$Resource$Projects$Iosapps$Getconfig, options: MethodOptions | BodyResponseCallback<Schema$IosAppConfig>, callback: BodyResponseCallback<Schema$IosAppConfig>): void;


getConfig(params: Params$Resource$Projects$Iosapps$Getconfig, callback: BodyResponseCallback<Schema$IosAppConfig>): void;


getConfig(callback: BodyResponseCallback<Schema$IosAppConfig>): void;


/**
         * firebase.projects.iosApps.list
         * @desc Lists each IosApp associated with the specified parent Project.

The elements are returned in no particular order, but will be a consistent view of the Apps when additional requests are made with a `pageToken`.
         * @alias firebase.projects.iosApps.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {integer=} params.pageSize The maximum number of Apps to return in the response.

The server may return fewer than this at its discretion. If no value is specified (or too large a value is specified), the server will impose its own limit.
         * @param {string=} params.pageToken Token returned from a previous call to `ListIosApps` indicating where in the set of Apps to resume listing.
         * @param {string} params.parent The parent Project for which to list Apps, in the format:
projects/<var>projectId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
list(params?: Params$Resource$Projects$Iosapps$List, options?: MethodOptions): GaxiosPromise<Schema$ListIosAppsResponse>;


list(params: Params$Resource$Projects$Iosapps$List, options: MethodOptions | BodyResponseCallback<Schema$ListIosAppsResponse>, callback: BodyResponseCallback<Schema$ListIosAppsResponse>): void;


list(params: Params$Resource$Projects$Iosapps$List, callback: BodyResponseCallback<Schema$ListIosAppsResponse>): void;


list(callback: BodyResponseCallback<Schema$ListIosAppsResponse>): void;


/**
         * firebase.projects.iosApps.patch
         * @desc Updates the attributes of the IosApp identified by the specified resource name.
         * @alias firebase.projects.iosApps.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The fully qualified resource name of the App, in the format:
projects/<var>projectId</var>/iosApps/<var>appId</var>
         * @param {string=} params.updateMask Specifies which fields to update.
Note that the fields `name`, `appId`, `projectId`, and `bundleId` are all immutable.
         * @param {().IosApp} params.requestBody Request body data
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
patch(params?: Params$Resource$Projects$Iosapps$Patch, options?: MethodOptions): GaxiosPromise<Schema$IosApp>;


patch(params: Params$Resource$Projects$Iosapps$Patch, options: MethodOptions | BodyResponseCallback<Schema$IosApp>, callback: BodyResponseCallback<Schema$IosApp>): void;


patch(params: Params$Resource$Projects$Iosapps$Patch, callback: BodyResponseCallback<Schema$IosApp>): void;


patch(callback: BodyResponseCallback<Schema$IosApp>): void;


/**
         * firebase.projects.webApps.create
         * @desc Requests that a new WebApp be created.

The result of this call is an `Operation` which can be used to track the provisioning process. The `Operation` is automatically deleted after completion, so there is no need to call `DeleteOperation`.
         * @alias firebase.projects.webApps.create
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.parent The parent Project for which to list Apps, in the format:
projects/<var>projectId</var>
         * @param {().WebApp} params.requestBody Request body data
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
create(params?: Params$Resource$Projects$Webapps$Create, options?: MethodOptions): GaxiosPromise<Schema$Operation>;


create(params: Params$Resource$Projects$Webapps$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;


create(params: Params$Resource$Projects$Webapps$Create, callback: BodyResponseCallback<Schema$Operation>): void;


/**
         * firebase.projects.webApps.get
         * @desc Gets the WebApp identified by the specified resource name.
         * @alias firebase.projects.webApps.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The fully qualified resource name of the App, in the format:
projects/<var>projectId</var>/webApps/<var>appId</var>
As an <var>appId</var> is a unique identifier, the Unique Resource from Sub-Collection access pattern may be used here, in the format:
projects/-/webApps/<var>appId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
get(params?: Params$Resource$Projects$Webapps$Get, options?: MethodOptions): GaxiosPromise<Schema$WebApp>;


get(params: Params$Resource$Projects$Webapps$Get, options: MethodOptions | BodyResponseCallback<Schema$WebApp>, callback: BodyResponseCallback<Schema$WebApp>): void;


get(params: Params$Resource$Projects$Webapps$Get, callback: BodyResponseCallback<Schema$WebApp>): void;


get(callback: BodyResponseCallback<Schema$WebApp>): void;


/**
         * firebase.projects.webApps.getConfig
         * @desc Gets the configuration artifact associated with the specified WebApp.
         * @alias firebase.projects.webApps.getConfig
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The resource name of the App configuration to download, in the format:
projects/<var>projectId</var>/webApps/<var>appId</var>/config
As an <var>appId</var> is a unique identifier, the Unique Resource from Sub-Collection access pattern may be used here, in the format:
projects/-/webApps/<var>appId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
getConfig(params?: Params$Resource$Projects$Webapps$Getconfig, options?: MethodOptions): GaxiosPromise<Schema$WebAppConfig>;


getConfig(params: Params$Resource$Projects$Webapps$Getconfig, options: MethodOptions | BodyResponseCallback<Schema$WebAppConfig>, callback: BodyResponseCallback<Schema$WebAppConfig>): void;


getConfig(params: Params$Resource$Projects$Webapps$Getconfig, callback: BodyResponseCallback<Schema$WebAppConfig>): void;


getConfig(callback: BodyResponseCallback<Schema$WebAppConfig>): void;


/**
         * firebase.projects.webApps.list
         * @desc Lists each WebApp associated with the specified parent Project.

The elements are returned in no particular order, but will be a consistent view of the Apps when additional requests are made with a `pageToken`.
         * @alias firebase.projects.webApps.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {integer=} params.pageSize The maximum number of Apps to return in the response.

The server may return fewer than this value at its discretion. If no value is specified (or too large a value is specified), then the server will impose its own limit.
         * @param {string=} params.pageToken Token returned from a previous call to `ListWebApps` indicating where in the set of Apps to resume listing.
         * @param {string} params.parent The parent Project for which to list Apps, in the format:
projects/<var>projectId</var>
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
list(params?: Params$Resource$Projects$Webapps$List, options?: MethodOptions): GaxiosPromise<Schema$ListWebAppsResponse>;


list(params: Params$Resource$Projects$Webapps$List, options: MethodOptions | BodyResponseCallback<Schema$ListWebAppsResponse>, callback: BodyResponseCallback<Schema$ListWebAppsResponse>): void;


list(params: Params$Resource$Projects$Webapps$List, callback: BodyResponseCallback<Schema$ListWebAppsResponse>): void;


list(callback: BodyResponseCallback<Schema$ListWebAppsResponse>): void;


/**
         * firebase.projects.webApps.patch
         * @desc Updates the attributes of the WebApp identified by the specified resource name.
         * @alias firebase.projects.webApps.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.name The fully qualified resource name of the App, for example:
projects/<var>projectId</var>/webApps/<var>appId</var>
         * @param {string=} params.updateMask Specifies which fields to update.
Note that the fields `name`, `appId`, and `projectId` are all immutable.
         * @param {().WebApp} params.requestBody Request body data
         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param {callback} callback The callback that handles the response.
         * @return {object} Request object
         */
patch(params?: Params$Resource$Projects$Webapps$Patch, options?: MethodOptions): GaxiosPromise<Schema$WebApp>;


patch(params: Params$Resource$Projects$Webapps$Patch, options: MethodOptions | BodyResponseCallback<Schema$WebApp>, callback: BodyResponseCallback<Schema$WebApp>): void;


patch(params: Params$Resource$Projects$Webapps$Patch, callback: BodyResponseCallback<Schema$WebApp>): void;


patch(callback: BodyResponseCallback<Schema$WebApp>): void;


/**
 * Updates a device definition.
 * @example
 * Use a bare-bones client and the command you need to make an API call.
 * ```javascript
 * import { GreengrassClient, UpdateDeviceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
 * // const { GreengrassClient, UpdateDeviceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
 * const client = new GreengrassClient(config);
 * const command = new UpdateDeviceDefinitionCommand(input);
 * const response = await client.send(command);
 * ```
 *
 * @see {@link UpdateDeviceDefinitionCommandInput} for command's `input` shape.
 * @see {@link UpdateDeviceDefinitionCommandOutput} for command's `response` shape.
 * @see {@link GreengrassClientResolvedConfig | config} for GreengrassClient's `config` shape.
 *
 */
export class UpdateDeviceDefinitionCommand extends $Command<
  UpdateDeviceDefinitionCommandInput,
  UpdateDeviceDefinitionCommandOutput,
  GreengrassClientResolvedConfig
> {
  // Start section: command_properties
  // End section: command_properties

  constructor(readonly input: UpdateDeviceDefinitionCommandInput) {
    // Start section: command_constructor
    super();
    // End section: command_constructor
  }

  /**
   * @internal
   */
  resolveMiddleware(
    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
    configuration: GreengrassClientResolvedConfig,
    options?: __HttpHandlerOptions
  ): Handler<UpdateDeviceDefinitionCommandInput, UpdateDeviceDefinitionCommandOutput> {
    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));

    const stack = clientStack.concat(this.middlewareStack);

    const { logger } = configuration;
    const clientName = "GreengrassClient";
    const commandName = "UpdateDeviceDefinitionCommand";
    const handlerExecutionContext: HandlerExecutionContext = {
      logger,
      clientName,
      commandName,
      inputFilterSensitiveLog: UpdateDeviceDefinitionRequest.filterSensitiveLog,
      outputFilterSensitiveLog: UpdateDeviceDefinitionResponse.filterSensitiveLog,
    };
    const { requestHandler } = configuration;
    return stack.resolve(
      (request: FinalizeHandlerArguments<any>) =>
        requestHandler.handle(request.request as __HttpRequest, options || {}),
      handlerExecutionContext
    );
  }

  private serialize(input: UpdateDeviceDefinitionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
    return serializeAws_restJson1UpdateDeviceDefinitionCommand(input, context);
  }

  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<UpdateDeviceDefinitionCommandOutput> {
    return deserializeAws_restJson1UpdateDeviceDefinitionCommand(output, context);
  }

  // Start section: command_body_extra
  // End section: command_body_extra
}


export interface UpdateDeviceDefinitionCommandInput extends UpdateDeviceDefinitionRequest {}


export interface UpdateDeviceDefinitionCommandOutput extends UpdateDeviceDefinitionResponse, __MetadataBearer {}


/**
   * @internal
   */
resolveMiddleware(
    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
    configuration: GreengrassClientResolvedConfig,
    options?: __HttpHandlerOptions
  ): Handler<UpdateDeviceDefinitionCommandInput, UpdateDeviceDefinitionCommandOutput> {
    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));

    const stack = clientStack.concat(this.middlewareStack);

    const { logger } = configuration;
    const clientName = "GreengrassClient";
    const commandName = "UpdateDeviceDefinitionCommand";
    const handlerExecutionContext: HandlerExecutionContext = {
      logger,
      clientName,
      commandName,
      inputFilterSensitiveLog: UpdateDeviceDefinitionRequest.filterSensitiveLog,
      outputFilterSensitiveLog: UpdateDeviceDefinitionResponse.filterSensitiveLog,
    };
    const { requestHandler } = configuration;
    return stack.resolve(
      (request: FinalizeHandlerArguments<any>) =>
        requestHandler.handle(request.request as __HttpRequest, options || {}),
      handlerExecutionContext
    );
  }


private serialize(input: UpdateDeviceDefinitionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
    return serializeAws_restJson1UpdateDeviceDefinitionCommand(input, context);
  }


private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<UpdateDeviceDefinitionCommandOutput> {
    return deserializeAws_restJson1UpdateDeviceDefinitionCommand(output, context);
  }


export interface AssociateServiceQuotaTemplateRequest {
  }


export interface AssociateServiceQuotaTemplateResponse {
  }


export interface DeleteServiceQuotaIncreaseRequestFromTemplateRequest {
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The quota identifier.
     */
    QuotaCode: QuotaCode;
    /**
     * The AWS Region.
     */
    AwsRegion: AwsRegion;
  }


export interface DeleteServiceQuotaIncreaseRequestFromTemplateResponse {
  }


export interface DisassociateServiceQuotaTemplateRequest {
  }


export interface DisassociateServiceQuotaTemplateResponse {
  }


export interface ErrorReason {
    /**
     * Service Quotas returns the following error values:    DEPENDENCY_ACCESS_DENIED_ERROR - The caller does not have the required permissions to complete the action. To resolve the error, you must have permission to access the service or quota.    DEPENDENCY_THROTTLING_ERROR - The service is throttling Service Quotas.    DEPENDENCY_SERVICE_ERROR - The service is not available.    SERVICE_QUOTA_NOT_AVAILABLE_ERROR - There was an error in Service Quotas.
     */
    ErrorCode?: ErrorCode;
    /**
     * The error message.
     */
    ErrorMessage?: ErrorMessage;
  }


export interface GetAWSDefaultServiceQuotaRequest {
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The quota identifier.
     */
    QuotaCode: QuotaCode;
  }


export interface GetAWSDefaultServiceQuotaResponse {
    /**
     * Information about the quota.
     */
    Quota?: ServiceQuota;
  }


export interface GetAssociationForServiceQuotaTemplateRequest {
  }


export interface GetAssociationForServiceQuotaTemplateResponse {
    /**
     * The association status. If the status is ASSOCIATED, the quota increase requests in the template are automatically applied to new accounts in your organization.
     */
    ServiceQuotaTemplateAssociationStatus?: ServiceQuotaTemplateAssociationStatus;
  }


export interface GetRequestedServiceQuotaChangeRequest {
    /**
     * The ID of the quota increase request.
     */
    RequestId: RequestId;
  }


export interface GetRequestedServiceQuotaChangeResponse {
    /**
     * Information about the quota increase request.
     */
    RequestedQuota?: RequestedServiceQuotaChange;
  }


export interface GetServiceQuotaIncreaseRequestFromTemplateRequest {
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The quota identifier.
     */
    QuotaCode: QuotaCode;
    /**
     * The AWS Region.
     */
    AwsRegion: AwsRegion;
  }


export interface GetServiceQuotaIncreaseRequestFromTemplateResponse {
    /**
     * Information about the quota increase request.
     */
    ServiceQuotaIncreaseRequestInTemplate?: ServiceQuotaIncreaseRequestInTemplate;
  }


export interface GetServiceQuotaRequest {
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The quota identifier.
     */
    QuotaCode: QuotaCode;
  }


export interface GetServiceQuotaResponse {
    /**
     * Information about the quota.
     */
    Quota?: ServiceQuota;
  }


export interface ListAWSDefaultServiceQuotasRequest {
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The token for the next page of results.
     */
    NextToken?: NextToken;
    /**
     * The maximum number of results to return with a single call. To retrieve the remaining results, if any, make another call with the token returned from this call.
     */
    MaxResults?: MaxResults;
  }


export interface ListAWSDefaultServiceQuotasResponse {
    /**
     * The token to use to retrieve the next page of results. This value is null when there are no more results to return.
     */
    NextToken?: NextToken;
    /**
     * Information about the quotas.
     */
    Quotas?: ServiceQuotaListDefinition;
  }


export interface ListRequestedServiceQuotaChangeHistoryByQuotaRequest {
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The quota identifier.
     */
    QuotaCode: QuotaCode;
    /**
     * The status value of the quota increase request.
     */
    Status?: RequestStatus;
    /**
     * The token for the next page of results.
     */
    NextToken?: NextToken;
    /**
     * The maximum number of results to return with a single call. To retrieve the remaining results, if any, make another call with the token returned from this call.
     */
    MaxResults?: MaxResults;
  }


export interface ListRequestedServiceQuotaChangeHistoryByQuotaResponse {
    /**
     * The token to use to retrieve the next page of results. This value is null when there are no more results to return.
     */
    NextToken?: NextToken;
    /**
     * Information about the quota increase requests.
     */
    RequestedQuotas?: RequestedServiceQuotaChangeHistoryListDefinition;
  }


export interface ListRequestedServiceQuotaChangeHistoryRequest {
    /**
     * The service identifier.
     */
    ServiceCode?: ServiceCode;
    /**
     * The status of the quota increase request.
     */
    Status?: RequestStatus;
    /**
     * The token for the next page of results.
     */
    NextToken?: NextToken;
    /**
     * The maximum number of results to return with a single call. To retrieve the remaining results, if any, make another call with the token returned from this call.
     */
    MaxResults?: MaxResults;
  }


export interface ListRequestedServiceQuotaChangeHistoryResponse {
    /**
     * The token to use to retrieve the next page of results. This value is null when there are no more results to return.
     */
    NextToken?: NextToken;
    /**
     * Information about the quota increase requests.
     */
    RequestedQuotas?: RequestedServiceQuotaChangeHistoryListDefinition;
  }


export interface ListServiceQuotaIncreaseRequestsInTemplateRequest {
    /**
     * The service identifier.
     */
    ServiceCode?: ServiceCode;
    /**
     * The AWS Region.
     */
    AwsRegion?: AwsRegion;
    /**
     * The token for the next page of results.
     */
    NextToken?: NextToken;
    /**
     * The maximum number of results to return with a single call. To retrieve the remaining results, if any, make another call with the token returned from this call.
     */
    MaxResults?: MaxResults;
  }


export interface ListServiceQuotaIncreaseRequestsInTemplateResponse {
    /**
     * Information about the quota increase requests.
     */
    ServiceQuotaIncreaseRequestInTemplateList?: ServiceQuotaIncreaseRequestInTemplateList;
    /**
     * The token to use to retrieve the next page of results. This value is null when there are no more results to return.
     */
    NextToken?: NextToken;
  }


export interface ListServiceQuotasRequest {
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The token for the next page of results.
     */
    NextToken?: NextToken;
    /**
     * The maximum number of results to return with a single call. To retrieve the remaining results, if any, make another call with the token returned from this call.
     */
    MaxResults?: MaxResults;
  }


export interface ListServiceQuotasResponse {
    /**
     * The token to use to retrieve the next page of results. This value is null when there are no more results to return.
     */
    NextToken?: NextToken;
    /**
     * Information about the quotas.
     */
    Quotas?: ServiceQuotaListDefinition;
  }


export interface ListServicesRequest {
    /**
     * The token for the next page of results.
     */
    NextToken?: NextToken;
    /**
     * The maximum number of results to return with a single call. To retrieve the remaining results, if any, make another call with the token returned from this call.
     */
    MaxResults?: MaxResults;
  }


export interface ListServicesResponse {
    /**
     * The token to use to retrieve the next page of results. This value is null when there are no more results to return.
     */
    NextToken?: NextToken;
    /**
     * Information about the services.
     */
    Services?: ServiceInfoListDefinition;
  }


export interface ListTagsForResourceRequest {
    /**
     * The Amazon Resource Name (ARN) for the applied quota for which you want to list tags. You can get this information by using the Service Quotas console, or by listing the quotas using the list-service-quotas AWS CLI command or the ListServiceQuotas AWS API operation.
     */
    ResourceARN: AmazonResourceName;
  }


export interface ListTagsForResourceResponse {
    /**
     * A complex data type that contains zero or more tag elements.
     */
    Tags?: OutputTags;
  }


export interface MetricInfo {
    /**
     * The namespace of the metric.
     */
    MetricNamespace?: QuotaMetricNamespace;
    /**
     * The name of the metric.
     */
    MetricName?: QuotaMetricName;
    /**
     * The metric dimension. This is a name/value pair that is part of the identity of a metric.
     */
    MetricDimensions?: MetricDimensionsMapDefinition;
    /**
     * The metric statistic that we recommend you use when determining quota usage.
     */
    MetricStatisticRecommendation?: Statistic;
  }


export interface PutServiceQuotaIncreaseRequestIntoTemplateRequest {
    /**
     * The quota identifier.
     */
    QuotaCode: QuotaCode;
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The AWS Region.
     */
    AwsRegion: AwsRegion;
    /**
     * The new, increased value for the quota.
     */
    DesiredValue: QuotaValue;
  }


export interface PutServiceQuotaIncreaseRequestIntoTemplateResponse {
    /**
     * Information about the quota increase request.
     */
    ServiceQuotaIncreaseRequestInTemplate?: ServiceQuotaIncreaseRequestInTemplate;
  }


export interface QuotaPeriod {
    /**
     * The value.
     */
    PeriodValue?: PeriodValue;
    /**
     * The time unit.
     */
    PeriodUnit?: PeriodUnit;
  }


export interface RequestServiceQuotaIncreaseRequest {
    /**
     * The service identifier.
     */
    ServiceCode: ServiceCode;
    /**
     * The quota identifier.
     */
    QuotaCode: QuotaCode;
    /**
     * The new, increased value for the quota.
     */
    DesiredValue: QuotaValue;
  }


export interface RequestServiceQuotaIncreaseResponse {
    /**
     * Information about the quota increase request.
     */
    RequestedQuota?: RequestedServiceQuotaChange;
  }


export interface RequestedServiceQuotaChange {
    /**
     * The unique identifier.
     */
    Id?: RequestId;
    /**
     * The case ID.
     */
    CaseId?: CustomerServiceEngagementId;
    /**
     * The service identifier.
     */
    ServiceCode?: ServiceCode;
    /**
     * The service name.
     */
    ServiceName?: ServiceName;
    /**
     * The quota identifier.
     */
    QuotaCode?: QuotaCode;
    /**
     * The quota name.
     */
    QuotaName?: QuotaName;
    /**
     * The new, increased value for the quota.
     */
    DesiredValue?: QuotaValue;
    /**
     * The state of the quota increase request.
     */
    Status?: RequestStatus;
    /**
     * The date and time when the quota increase request was received and the case ID was created.
     */
    Created?: DateTime;
    /**
     * The date and time of the most recent change.
     */
    LastUpdated?: DateTime;
    /**
     * The IAM identity of the requester.
     */
    Requester?: Requester;
    /**
     * The Amazon Resource Name (ARN) of the quota.
     */
    QuotaArn?: QuotaArn;
    /**
     * Indicates whether the quota is global.
     */
    GlobalQuota?: GlobalQuota;
    /**
     * The unit of measurement.
     */
    Unit?: QuotaUnit;
  }


export interface ServiceInfo {
    /**
     * The service identifier.
     */
    ServiceCode?: ServiceCode;
    /**
     * The service name.
     */
    ServiceName?: ServiceName;
  }


export interface ServiceQuota {
    /**
     * The service identifier.
     */
    ServiceCode?: ServiceCode;
    /**
     * The service name.
     */
    ServiceName?: ServiceName;
    /**
     * The Amazon Resource Name (ARN) of the quota.
     */
    QuotaArn?: QuotaArn;
    /**
     * The quota identifier.
     */
    QuotaCode?: QuotaCode;
    /**
     * The quota name.
     */
    QuotaName?: QuotaName;
    /**
     * The quota value.
     */
    Value?: QuotaValue;
    /**
     * The unit of measurement.
     */
    Unit?: QuotaUnit;
    /**
     * Indicates whether the quota value can be increased.
     */
    Adjustable?: QuotaAdjustable;
    /**
     * Indicates whether the quota is global.
     */
    GlobalQuota?: GlobalQuota;
    /**
     * Information about the measurement.
     */
    UsageMetric?: MetricInfo;
    /**
     * The period of time.
     */
    Period?: QuotaPeriod;
    /**
     * The error code and error reason.
     */
    ErrorReason?: ErrorReason;
  }


export interface ServiceQuotaIncreaseRequestInTemplate {
    /**
     * The service identifier.
     */
    ServiceCode?: ServiceCode;
    /**
     * The service name.
     */
    ServiceName?: ServiceName;
    /**
     * The quota identifier.
     */
    QuotaCode?: QuotaCode;
    /**
     * The quota name.
     */
    QuotaName?: QuotaName;
    /**
     * The new, increased value of the quota.
     */
    DesiredValue?: QuotaValue;
    /**
     * The AWS Region.
     */
    AwsRegion?: AwsRegion;
    /**
     * The unit of measurement.
     */
    Unit?: QuotaUnit;
    /**
     * Indicates whether the quota is global.
     */
    GlobalQuota?: GlobalQuota;
  }


export interface Tag {
    /**
     * A string that contains a tag key. The string length should be between 1 and 128 characters. Valid characters include a-z, A-Z, 0-9, space, and the special characters _ - . : / = + @.
     */
    Key: TagKey;
    /**
     * A string that contains an optional tag value. The string length should be between 0 and 256 characters. Valid characters include a-z, A-Z, 0-9, space, and the special characters _ - . : / = + @.
     */
    Value: TagValue;
  }


export interface TagResourceRequest {
    /**
     * The Amazon Resource Name (ARN) for the applied quota. You can get this information by using the Service Quotas console, or by listing the quotas using the list-service-quotas AWS CLI command or the ListServiceQuotas AWS API operation.
     */
    ResourceARN: AmazonResourceName;
    /**
     * The tags that you want to add to the resource.
     */
    Tags: InputTags;
  }


export interface UntagResourceRequest {
    /**
     * The Amazon Resource Name (ARN) for the applied quota that you want to untag. You can get this information by using the Service Quotas console, or by listing the quotas using the list-service-quotas AWS CLI command or the ListServiceQuotas AWS API operation.
     */
    ResourceARN: AmazonResourceName;
    /**
     * The keys of the tags that you want to remove from the resource.
     */
    TagKeys: InputTagKeys;
  }


export type AwsRegion = string;


export type CustomerServiceEngagementId = string;


export type DateTime = Date;


export type ErrorCode = "DEPENDENCY_ACCESS_DENIED_ERROR"|"DEPENDENCY_THROTTLING_ERROR"|"DEPENDENCY_SERVICE_ERROR"|"SERVICE_QUOTA_NOT_AVAILABLE_ERROR"|string;


export type ErrorMessage = string;


export type GlobalQuota = boolean;


export type InputTagKeys = TagKey[];


export type InputTags = Tag[];


export type MetricDimensionName = string;


export type MetricDimensionValue = string;


export type MetricDimensionsMapDefinition = {[key: string]: MetricDimensionValue};


export type OutputTags = Tag[];


export type PeriodUnit = "MICROSECOND"|"MILLISECOND"|"SECOND"|"MINUTE"|"HOUR"|"DAY"|"WEEK"|string;


export type PeriodValue = number;


export type QuotaAdjustable = boolean;


export type QuotaArn = string;


export type QuotaCode = string;


export type QuotaMetricName = string;


export type QuotaMetricNamespace = string;


export type QuotaName = string;


export type QuotaUnit = string;


export type QuotaValue = number;


export type RequestId = string;


export type RequestStatus = "PENDING"|"CASE_OPENED"|"APPROVED"|"DENIED"|"CASE_CLOSED"|string;


export type RequestedServiceQuotaChangeHistoryListDefinition = RequestedServiceQuotaChange[];


export type Requester = string;


export type ServiceCode = string;


export type ServiceInfoListDefinition = ServiceInfo[];


export type ServiceName = string;


export type ServiceQuotaIncreaseRequestInTemplateList = ServiceQuotaIncreaseRequestInTemplate[];


export type ServiceQuotaListDefinition = ServiceQuota[];


export type ServiceQuotaTemplateAssociationStatus = "ASSOCIATED"|"DISASSOCIATED"|string;


export type Statistic = string;


/**
   * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version.
   */
export type apiVersion = "2019-06-24"|"latest"|string;


/**
   * Associates your quota request template with your organization. When a new account is created in your organization, the quota increase requests in the template are automatically applied to the account. You can add a quota increase request for any adjustable quota to your template.
   */
associateServiceQuotaTemplate(params: ServiceQuotas.Types.AssociateServiceQuotaTemplateRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.AssociateServiceQuotaTemplateResponse) => void): Request<ServiceQuotas.Types.AssociateServiceQuotaTemplateResponse, AWSError>;


/**
   * Associates your quota request template with your organization. When a new account is created in your organization, the quota increase requests in the template are automatically applied to the account. You can add a quota increase request for any adjustable quota to your template.
   */
associateServiceQuotaTemplate(callback?: (err: AWSError, data: ServiceQuotas.Types.AssociateServiceQuotaTemplateResponse) => void): Request<ServiceQuotas.Types.AssociateServiceQuotaTemplateResponse, AWSError>;


/**
   * Deletes the quota increase request for the specified quota from your quota request template.
   */
deleteServiceQuotaIncreaseRequestFromTemplate(params: ServiceQuotas.Types.DeleteServiceQuotaIncreaseRequestFromTemplateRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.DeleteServiceQuotaIncreaseRequestFromTemplateResponse) => void): Request<ServiceQuotas.Types.DeleteServiceQuotaIncreaseRequestFromTemplateResponse, AWSError>;


/**
   * Deletes the quota increase request for the specified quota from your quota request template.
   */
deleteServiceQuotaIncreaseRequestFromTemplate(callback?: (err: AWSError, data: ServiceQuotas.Types.DeleteServiceQuotaIncreaseRequestFromTemplateResponse) => void): Request<ServiceQuotas.Types.DeleteServiceQuotaIncreaseRequestFromTemplateResponse, AWSError>;


/**
   * Disables your quota request template. After a template is disabled, the quota increase requests in the template are not applied to new accounts in your organization. Disabling a quota request template does not apply its quota increase requests.
   */
disassociateServiceQuotaTemplate(params: ServiceQuotas.Types.DisassociateServiceQuotaTemplateRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.DisassociateServiceQuotaTemplateResponse) => void): Request<ServiceQuotas.Types.DisassociateServiceQuotaTemplateResponse, AWSError>;


/**
   * Disables your quota request template. After a template is disabled, the quota increase requests in the template are not applied to new accounts in your organization. Disabling a quota request template does not apply its quota increase requests.
   */
disassociateServiceQuotaTemplate(callback?: (err: AWSError, data: ServiceQuotas.Types.DisassociateServiceQuotaTemplateResponse) => void): Request<ServiceQuotas.Types.DisassociateServiceQuotaTemplateResponse, AWSError>;


/**
   * Retrieves the default value for the specified quota. The default value does not reflect any quota increases.
   */
getAWSDefaultServiceQuota(params: ServiceQuotas.Types.GetAWSDefaultServiceQuotaRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.GetAWSDefaultServiceQuotaResponse) => void): Request<ServiceQuotas.Types.GetAWSDefaultServiceQuotaResponse, AWSError>;


/**
   * Retrieves the default value for the specified quota. The default value does not reflect any quota increases.
   */
getAWSDefaultServiceQuota(callback?: (err: AWSError, data: ServiceQuotas.Types.GetAWSDefaultServiceQuotaResponse) => void): Request<ServiceQuotas.Types.GetAWSDefaultServiceQuotaResponse, AWSError>;


/**
   * Retrieves the status of the association for the quota request template.
   */
getAssociationForServiceQuotaTemplate(params: ServiceQuotas.Types.GetAssociationForServiceQuotaTemplateRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.GetAssociationForServiceQuotaTemplateResponse) => void): Request<ServiceQuotas.Types.GetAssociationForServiceQuotaTemplateResponse, AWSError>;


/**
   * Retrieves the status of the association for the quota request template.
   */
getAssociationForServiceQuotaTemplate(callback?: (err: AWSError, data: ServiceQuotas.Types.GetAssociationForServiceQuotaTemplateResponse) => void): Request<ServiceQuotas.Types.GetAssociationForServiceQuotaTemplateResponse, AWSError>;


/**
   * Retrieves information about the specified quota increase request.
   */
getRequestedServiceQuotaChange(params: ServiceQuotas.Types.GetRequestedServiceQuotaChangeRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.GetRequestedServiceQuotaChangeResponse) => void): Request<ServiceQuotas.Types.GetRequestedServiceQuotaChangeResponse, AWSError>;


/**
   * Retrieves information about the specified quota increase request.
   */
getRequestedServiceQuotaChange(callback?: (err: AWSError, data: ServiceQuotas.Types.GetRequestedServiceQuotaChangeResponse) => void): Request<ServiceQuotas.Types.GetRequestedServiceQuotaChangeResponse, AWSError>;


/**
   * Retrieves the applied quota value for the specified quota. For some quotas, only the default values are available. If the applied quota value is not available for a quota, the quota is not retrieved.
   */
getServiceQuota(params: ServiceQuotas.Types.GetServiceQuotaRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.GetServiceQuotaResponse) => void): Request<ServiceQuotas.Types.GetServiceQuotaResponse, AWSError>;


/**
   * Retrieves the applied quota value for the specified quota. For some quotas, only the default values are available. If the applied quota value is not available for a quota, the quota is not retrieved.
   */
getServiceQuota(callback?: (err: AWSError, data: ServiceQuotas.Types.GetServiceQuotaResponse) => void): Request<ServiceQuotas.Types.GetServiceQuotaResponse, AWSError>;


/**
   * Retrieves information about the specified quota increase request in your quota request template.
   */
getServiceQuotaIncreaseRequestFromTemplate(params: ServiceQuotas.Types.GetServiceQuotaIncreaseRequestFromTemplateRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.GetServiceQuotaIncreaseRequestFromTemplateResponse) => void): Request<ServiceQuotas.Types.GetServiceQuotaIncreaseRequestFromTemplateResponse, AWSError>;


/**
   * Retrieves information about the specified quota increase request in your quota request template.
   */
getServiceQuotaIncreaseRequestFromTemplate(callback?: (err: AWSError, data: ServiceQuotas.Types.GetServiceQuotaIncreaseRequestFromTemplateResponse) => void): Request<ServiceQuotas.Types.GetServiceQuotaIncreaseRequestFromTemplateResponse, AWSError>;


/**
   * Lists the default values for the quotas for the specified AWS service. A default value does not reflect any quota increases.
   */
listAWSDefaultServiceQuotas(params: ServiceQuotas.Types.ListAWSDefaultServiceQuotasRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.ListAWSDefaultServiceQuotasResponse) => void): Request<ServiceQuotas.Types.ListAWSDefaultServiceQuotasResponse, AWSError>;


/**
   * Lists the default values for the quotas for the specified AWS service. A default value does not reflect any quota increases.
   */
listAWSDefaultServiceQuotas(callback?: (err: AWSError, data: ServiceQuotas.Types.ListAWSDefaultServiceQuotasResponse) => void): Request<ServiceQuotas.Types.ListAWSDefaultServiceQuotasResponse, AWSError>;


/**
   * Retrieves the quota increase requests for the specified service.
   */
listRequestedServiceQuotaChangeHistory(params: ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryResponse) => void): Request<ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryResponse, AWSError>;


/**
   * Retrieves the quota increase requests for the specified service.
   */
listRequestedServiceQuotaChangeHistory(callback?: (err: AWSError, data: ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryResponse) => void): Request<ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryResponse, AWSError>;


/**
   * Retrieves the quota increase requests for the specified quota.
   */
listRequestedServiceQuotaChangeHistoryByQuota(params: ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryByQuotaRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryByQuotaResponse) => void): Request<ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryByQuotaResponse, AWSError>;


/**
   * Retrieves the quota increase requests for the specified quota.
   */
listRequestedServiceQuotaChangeHistoryByQuota(callback?: (err: AWSError, data: ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryByQuotaResponse) => void): Request<ServiceQuotas.Types.ListRequestedServiceQuotaChangeHistoryByQuotaResponse, AWSError>;


/**
   * Lists the quota increase requests in the specified quota request template.
   */
listServiceQuotaIncreaseRequestsInTemplate(params: ServiceQuotas.Types.ListServiceQuotaIncreaseRequestsInTemplateRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.ListServiceQuotaIncreaseRequestsInTemplateResponse) => void): Request<ServiceQuotas.Types.ListServiceQuotaIncreaseRequestsInTemplateResponse, AWSError>;


/**
   * Lists the quota increase requests in the specified quota request template.
   */
listServiceQuotaIncreaseRequestsInTemplate(callback?: (err: AWSError, data: ServiceQuotas.Types.ListServiceQuotaIncreaseRequestsInTemplateResponse) => void): Request<ServiceQuotas.Types.ListServiceQuotaIncreaseRequestsInTemplateResponse, AWSError>;


/**
   * Lists the applied quota values for the specified AWS service. For some quotas, only the default values are available. If the applied quota value is not available for a quota, the quota is not retrieved.
   */
listServiceQuotas(params: ServiceQuotas.Types.ListServiceQuotasRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.ListServiceQuotasResponse) => void): Request<ServiceQuotas.Types.ListServiceQuotasResponse, AWSError>;


/**
   * Lists the applied quota values for the specified AWS service. For some quotas, only the default values are available. If the applied quota value is not available for a quota, the quota is not retrieved.
   */
listServiceQuotas(callback?: (err: AWSError, data: ServiceQuotas.Types.ListServiceQuotasResponse) => void): Request<ServiceQuotas.Types.ListServiceQuotasResponse, AWSError>;


/**
   * Lists the names and codes for the services integrated with Service Quotas.
   */
listServices(params: ServiceQuotas.Types.ListServicesRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.ListServicesResponse) => void): Request<ServiceQuotas.Types.ListServicesResponse, AWSError>;


/**
   * Lists the names and codes for the services integrated with Service Quotas.
   */
listServices(callback?: (err: AWSError, data: ServiceQuotas.Types.ListServicesResponse) => void): Request<ServiceQuotas.Types.ListServicesResponse, AWSError>;


/**
   * Returns a list of the tags assigned to the specified applied quota.
   */
listTagsForResource(params: ServiceQuotas.Types.ListTagsForResourceRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.ListTagsForResourceResponse) => void): Request<ServiceQuotas.Types.ListTagsForResourceResponse, AWSError>;


/**
   * Returns a list of the tags assigned to the specified applied quota.
   */
listTagsForResource(callback?: (err: AWSError, data: ServiceQuotas.Types.ListTagsForResourceResponse) => void): Request<ServiceQuotas.Types.ListTagsForResourceResponse, AWSError>;


/**
   * Adds a quota increase request to your quota request template.
   */
putServiceQuotaIncreaseRequestIntoTemplate(params: ServiceQuotas.Types.PutServiceQuotaIncreaseRequestIntoTemplateRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.PutServiceQuotaIncreaseRequestIntoTemplateResponse) => void): Request<ServiceQuotas.Types.PutServiceQuotaIncreaseRequestIntoTemplateResponse, AWSError>;


/**
   * Adds a quota increase request to your quota request template.
   */
putServiceQuotaIncreaseRequestIntoTemplate(callback?: (err: AWSError, data: ServiceQuotas.Types.PutServiceQuotaIncreaseRequestIntoTemplateResponse) => void): Request<ServiceQuotas.Types.PutServiceQuotaIncreaseRequestIntoTemplateResponse, AWSError>;


/**
   * Submits a quota increase request for the specified quota.
   */
requestServiceQuotaIncrease(params: ServiceQuotas.Types.RequestServiceQuotaIncreaseRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.RequestServiceQuotaIncreaseResponse) => void): Request<ServiceQuotas.Types.RequestServiceQuotaIncreaseResponse, AWSError>;


/**
   * Submits a quota increase request for the specified quota.
   */
requestServiceQuotaIncrease(callback?: (err: AWSError, data: ServiceQuotas.Types.RequestServiceQuotaIncreaseResponse) => void): Request<ServiceQuotas.Types.RequestServiceQuotaIncreaseResponse, AWSError>;


/**
   * Adds tags to the specified applied quota. You can include one or more tags to add to the quota.
   */
tagResource(params: ServiceQuotas.Types.TagResourceRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.TagResourceResponse) => void): Request<ServiceQuotas.Types.TagResourceResponse, AWSError>;


/**
   * Adds tags to the specified applied quota. You can include one or more tags to add to the quota.
   */
tagResource(callback?: (err: AWSError, data: ServiceQuotas.Types.TagResourceResponse) => void): Request<ServiceQuotas.Types.TagResourceResponse, AWSError>;


/**
   * Removes tags from the specified applied quota. You can specify one or more tags to remove.
   */
untagResource(params: ServiceQuotas.Types.UntagResourceRequest, callback?: (err: AWSError, data: ServiceQuotas.Types.UntagResourceResponse) => void): Request<ServiceQuotas.Types.UntagResourceResponse, AWSError>;


/**
   * Removes tags from the specified applied quota. You can specify one or more tags to remove.
   */
untagResource(callback?: (err: AWSError, data: ServiceQuotas.Types.UntagResourceResponse) => void): Request<ServiceQuotas.Types.UntagResourceResponse, AWSError>;


@Component({
  selector: 'app-quote-form',
  templateUrl: './quote-form.component.html',
  styleUrls: ['./quote-form.component.css']
})
export class QuoteFormComponent implements OnInit {

  newQuote = new Quote(0, "", "", "",new Date());

  @Output() addQuote = new EventEmitter<Quote>();

  submitQuote(){
    this.addQuote.emit(this.newQuote);
  }

  constructor() { }

  ngOnInit(): void {
  }

}


submitQuote(){
    this.addQuote.emit(this.newQuote);
  }


() => {
  let component: TruckInfoComponent;
  let fixture: ComponentFixture<TruckInfoComponent>;

  beforeEach(async () => {
    await TestBed.configureTestingModule({
      declarations: [ TruckInfoComponent ]
    })
    .compileComponents();
  });

  beforeEach(() => {
    fixture = TestBed.createComponent(TruckInfoComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });
}


async () => {
    await TestBed.configureTestingModule({
      declarations: [ TruckInfoComponent ]
    })
    .compileComponents();
  }


() => {
    fixture = TestBed.createComponent(TruckInfoComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();
  }


function pad(num : string | number, size : number) {
  let s = `${num}`;
  while (s.length < size) s = `0${s}`;
  return s;
}


function lerNota(nfse : ElementCompact) : NotaServicoPessoas {
  const emitente = getEmitente(nfse);

  const destinatario = getDestinatario(nfse);

  const notaServico : NotaServicoXml = {
    valor: getValor(nfse),
    emitente: emitente.cpfcnpj,
    destinatario: destinatario.cpfcnpj,
    geral: getInfosGerais(nfse),
    chave: '',
  };

  notaServico.chave = notaServico.emitente + notaServico.geral.numero;

  return { notaServico, emitente, destinatario };
}


export default function contagem(obj : ElementCompact) : NotaServicoPessoas[] {
  const nfses = getNfses(obj);

  return nfses.map(lerNota);
}


(obj : ElementCompact) : ElementCompact[] => [].concat(obj['ns2:NFSE']['ns2:Nfse'])


(nfse : ElementCompact) : Retencoes => {
  const valores = nfse['ns3:Servico']['ns3:Valores'];

  return {
    iss: valores['ns3:ValorIssRetido'] ? valores['ns3:ValorIssRetido']['_text'] : '0.0',
    irpj: valores['ns3:ValorIr'] ? valores['ns3:ValorIr']['_text'] : '0.0',
    csll: valores['ns3:ValorCsll'] ? valores['ns3:ValorCsll']['_text'] : '0.0',
    cofins: valores['ns3:ValorCofins'] ? valores['ns3:ValorCofins']['_text'] : '0.0',
    pis: valores['ns3:ValorPis'] ? valores['ns3:ValorPis']['_text'] : '0.0',
    inss: valores['ns3:ValorInss'] ? valores['ns3:ValorInss']['_text'] : '0.0',
  };
}


(nfse : ElementCompact) : Iss => {
  const valores = nfse['ns3:Servico']['ns3:Valores'];

  return {
    valor: valores['ns3:ValorIss'] ? valores['ns3:ValorIss']['_text'] : '0.0',
    aliquota: valores['ns3:Aliquota'] ? valores['ns3:Aliquota']['_text'] : '0.0',
  };
}


(nfse : ElementCompact) : Valor => {
  const valores = nfse['ns3:Servico']['ns3:Valores'];

  return {
    servico: valores['ns3:ValorServicos']['_text'],
    baseCalculo: valores['ns3:BaseCalculo']['_text'],
    iss: getIss(nfse),
    retencoes: getRetencoes(nfse),
  };
}


(pessoa : ElementCompact) : EnderecoXml => ({
  logradouro: pessoa['ns3:Endereco']['ns3:Endereco'] ? pessoa['ns3:Endereco']['ns3:Endereco']['_text'] : 'uknow',
  numero: pessoa['ns3:Endereco']['ns3:Numero'] ? pessoa['ns3:Endereco']['ns3:Numero']['_text'] : '0',
  complemento: pessoa['ns3:Endereco']['ns3:Complemento'] ? pessoa['ns3:Endereco']['ns3:Complemento']['_text'] || '' : '',
  bairro: pessoa['ns3:Endereco']['ns3:Bairro'] ? pessoa['ns3:Endereco']['ns3:Bairro']['_text'] : '',
  municipio: {
    codigo: pessoa['ns3:Endereco']['ns3:Cidade'] ? pessoa['ns3:Endereco']['ns3:Cidade']['_text'] : '',
  },
  estado: pessoa['ns3:Endereco']['ns3:Estado'] ? pessoa['ns3:Endereco']['ns3:Estado']['_text'] : 'MG',
  pais: {
    nome: 'Brasil',
    codigo: '1058',
  },
  cep: pessoa['ns3:Endereco']['ns3:Cep'] ? pessoa['ns3:Endereco']['ns3:Cep']['_text'] : '',
})


(nfse : ElementCompact) : PessoaXml => {
  const emitenteBruto = nfse['ns3:PrestadorServico'];

  return {
    cpfcnpj: emitenteBruto['ns3:IdentificacaoPrestador']['ns3:Cnpj']['_text'],
    nome: emitenteBruto['ns3:RazaoSocial']['_text'],
    endereco: getEndereco(emitenteBruto),
  };
}


(nfse : ElementCompact) : PessoaXml => {
  const destinatarioBruto = nfse['ns3:TomadorServico'];

  return {
    cpfcnpj: destinatarioBruto['ns3:IdentificacaoTomador']['ns3:CpfCnpj']['ns3:Cpf']
      ? destinatarioBruto['ns3:IdentificacaoTomador']['ns3:CpfCnpj']['ns3:Cpf']['_text']
      : destinatarioBruto['ns3:IdentificacaoTomador']['ns3:CpfCnpj']['ns3:Cnpj']['_text'],
    nome: destinatarioBruto['ns3:RazaoSocial']['_text'],
    endereco: getEndereco(destinatarioBruto),
  };
}


(nfse : ElementCompact) : Geral => {
  const ano = new Date(nfse['ns3:DataEmissao']['_text']).getFullYear();
  const num = nfse['ns3:IdentificacaoNfse']['ns3:Numero']['_text'];

  return {
    numero: `${ano}${pad(num, 11)}`,
    dataHora: nfse['ns3:DataEmissao']['_text'],
    status: nfse.nfseCancelamento ? 'CANCELADA' : 'NORMAL',
    descricao: nfse['ns3:Servico']['ns3:Discriminacao']['_text'].replace(/\|/g, '\n'),
  };
}


type ReactRouterAction = RouterAction | LocationChangeAction;


export type RootAction =
  | CountersAction
  | ReactRouterAction;


export abstract class CustomCommand extends ServerContext {
  constructor(server: GalaxyWorkflowLanguageServer) {
    super(server);
    this.listenToRequests();
  }

  /**
   * This method should call `this.connection.onRequest` to register
   * the proper callback for this command request.
   */
  protected abstract listenToRequests(): void;
}


/**
   * This method should call `this.connection.onRequest` to register
   * the proper callback for this command request.
   */
protected abstract listenToRequests(): void;


props=>props.disabled?"not-allowed":"pointer"


props=>props.theme.colors.primary


props=>props.checked?checkedcss:null


props=>props.disabled?css`
    & + span {
      color:${props.theme.colors.disabledColor};
      cursor: not-allowed;
    }
    `:null


props=>props.disabled?props.theme.colors.borderColor:props.theme.colors.primary


props=>props.disabled?"not-allowed":'pointer'


props=>props.checked?props.theme.colors.primary:props.disabled?props.theme.colors.disabledBackground:'#fff'


props=>props.checked?props.theme.colors.primary:props.theme.colors.borderColor


props => props.checked ? css`
        &::after {
            position: absolute;
            left:2px;

    opacity: 1;
    transition: all 0.2s cubic-bezier(0.12, 0.4, 0.29, 1.46) 0.1s;
    text-align:center;
        content:'✓';
        color:white;
        }
    `: css`
    &::after {
        position: absolute;
        top: 50%;
        left: 22%;
        display: table;
        cursor:${props.disabled?"not-allowed":'pointer'};
        width: ${(16 / 14) * 5} px;
        height:${(16 / 14) * 8} px;
        border-top: 0;
        border-left: 0;
        transform: rotate(45deg) scale(0) translate(-50%, -50%);
        opacity: 0;
        transition: all 0.1s cubic-bezier(0.71, -0.46, 0.88, 0.6), opacity 0.1s;
        content: ' ';
      };
    `


props=>props.disabled?"rgba(0,0,0,0.25)":props.theme.colors.primary


() => {
    let wrapper: ShallowWrapper<BreadcrumbProps>;
    const breadcrumbList: Array<string> = ["First", "Second", "Third"];

    beforeEach(() => {
        wrapper = shallow(<Breadcrumb list={breadcrumbList} />);
    });

    it("Should render", () => {
        expect(wrapper).toBeDefined();
    });

    it("Should render custom className and id", () => {
        const className: string = "myBreadcrumbClass";
        const id: string = "myBreadcrubID";
        wrapper.setProps({ className, id });
        wrapper.find(".breadcrumb-item").first().simulate("click"); // Simulates scenario where there is no onClick
        expect(wrapper.hasClass(className)).toBeTruthy();
        expect(wrapper.find(`#${id}`).length).toBeGreaterThan(0);
    });

    it("Should fire click event when clicked", () => {
        const onClick: jest.Mock = jest.fn();
        wrapper.setProps({ onClick });
        wrapper.find(".breadcrumb-item").first().simulate("click");
        expect(onClick).toBeCalled();
    });
}


() => {
        wrapper = shallow(<Breadcrumb list={breadcrumbList} />);
    }


() => {
        expect(wrapper).toBeDefined();
    }


() => {
        const className: string = "myBreadcrumbClass";
        const id: string = "myBreadcrubID";
        wrapper.setProps({ className, id });
        wrapper.find(".breadcrumb-item").first().simulate("click"); // Simulates scenario where there is no onClick
        expect(wrapper.hasClass(className)).toBeTruthy();
        expect(wrapper.find(`#${id}`).length).toBeGreaterThan(0);
    }


() => {
        const onClick: jest.Mock = jest.fn();
        wrapper.setProps({ onClick });
        wrapper.find(".breadcrumb-item").first().simulate("click");
        expect(onClick).toBeCalled();
    }


(
  success: number,
  failed: number
): string => {
  if (success > 0) {
    const pluralizedSuccess = success > 1 ? 'Linodes' : 'Linode';
    const pluralizedFailure = failed > 1 ? 'Linodes' : 'Linode';
    return `Enabled backups successfully for ${success} ${pluralizedSuccess}
    , but ${failed} ${pluralizedFailure} failed.`;
  }
  // This function will only be called if at least one backup failed.
  else {
    return `There was an error enabling backups for your Linodes.`;
  }
}


(linodes: ExtendedLinode[]) => {
  return linodes.reduce((prevValue: number, linode: ExtendedLinode) => {
    return (
      prevValue +
      pathOr(0, ['typeInfo', 'addons', 'backups', 'price', 'monthly'], linode)
    );
  }, 0);
}


(prevValue: number, linode: ExtendedLinode) => {
    return (
      prevValue +
      pathOr(0, ['typeInfo', 'addons', 'backups', 'price', 'monthly'], linode)
    );
  }


(e: React.MouseEvent<HTMLButtonElement>) => {
    const {
      actions: { enable, enroll },
      accountBackups,
    } = this.props;
    if (accountBackups) {
      enable();
    } else {
      enroll();
    }
  }


(
  dispatch: ThunkDispatch,
  ownProps
) => {
  return {
    actions: {
      enable: () => dispatch(enableAllBackups()),
      close: () => dispatch(handleClose()),
      dismissError: () => dispatch(handleResetError()),
      dismissSuccess: () => dispatch(handleResetSuccess()),
      enroll: () => dispatch(enableAutoEnroll()),
      toggle: () => dispatch(handleAutoEnrollToggle()),
    },
  };
}


() => dispatch(enableAllBackups())


() => dispatch(handleClose())


() => dispatch(handleResetError())


() => dispatch(handleResetSuccess())


() => dispatch(enableAutoEnroll())


() => dispatch(handleAutoEnrollToggle())


(types: LinodeType[], linodes: Linode[]) =>
  linodes.map((linode) => {
    const typeInfo = getTypeInfo(linode.type, types || []);
    return {
      ...linode,
      typeInfo,
    };
  })


(linode) => {
    const typeInfo = getTypeInfo(linode.type, types || []);
    return {
      ...linode,
      typeInfo,
    };
  }


(
  errors: BackupError[],
  linodes: LinodeWithTypeInfo[]
) =>
  linodes.map((linode: LinodeWithTypeInfo) => {
    const linodeError = errors.find(
      (error) => Number(error.linodeId) === Number(linode.id)
    );
    return {
      ...linode,
      linodeError,
    };
  })


(linode: LinodeWithTypeInfo) => {
    const linodeError = errors.find(
      (error) => Number(error.linodeId) === Number(linode.id)
    );
    return {
      ...linode,
      linodeError,
    };
  }


(error) => Number(error.linodeId) === Number(linode.id)


(
  linodes: Linode[],
  errors: BackupError[],
  types: LinodeType[]
) => {
  const linodesWithTypes = addTypeInfo(types, linodes);
  return addErrors(errors, linodesWithTypes);
}


(state: ApplicationState, ownProps: CombinedProps) => {
  const enableErrors = pathOr([], ['backups', 'enableErrors'], state);
  const linodes = getLinodesWithoutBackups(state.__resources);
  return {
    accountBackups: accountBackupsEnabled,
    backupLoadError: pathOr('', ['backups', 'error'], state),
    backupsLoading: pathOr(false, ['backups', 'loading'], state),
    enableErrors,
    enableSuccess: pathOr(false, ['backups', 'enableSuccess'], state),
    updatedCount: pathOr<number>(0, ['backups', 'updatedCount'], state),
    open: pathOr(false, ['backups', 'open'], state),
    loading: pathOr(false, ['backups', 'loading'], state),
    enabling: pathOr(false, ['backups', 'enabling'], state),
    linodesWithoutBackups: enhanceLinodes(
      linodes,
      enableErrors,
      ownProps.typesData
    ),
    autoEnroll: pathOr(false, ['backups', 'autoEnroll'], state),
    enrolling: pathOr(false, ['backups', 'enrolling'], state),
    autoEnrollError: path(['backups', 'autoEnrollError'], state),
  };
}


(state: ApplicationState, ownProps) => ({
  typesData: state.__resources.types.entities,
})


export class BackupDrawer extends React.Component<CombinedProps, {}> {
  componentDidUpdate() {
    const { close, dismissSuccess } = this.props.actions;
    const { autoEnroll, enableSuccess, updatedCount } = this.props;
    if (enableSuccess) {
      const pluralizedLinodes =
        updatedCount > 1 ? 'Linodes have' : 'Linode has';
      const text = autoEnroll
        ? `${updatedCount} ${pluralizedLinodes} been enrolled in automatic backups, and
        all new Linodes will automatically be backed up.`
        : `${updatedCount} ${pluralizedLinodes} been enrolled in automatic backups.`;
      this.props.enqueueSnackbar(text, {
        variant: 'success',
      });
      dismissSuccess();
      close();
    }
  }

  handleSubmit = (e: React.MouseEvent<HTMLButtonElement>) => {
    const {
      actions: { enable, enroll },
      accountBackups,
    } = this.props;
    if (accountBackups) {
      enable();
    } else {
      enroll();
    }
  };

  render() {
    const {
      accountBackups,
      actions: { close, toggle },
      autoEnroll,
      autoEnrollError,
      enableErrors,
      enabling,
      enrolling,
      linodesWithoutBackups,
      loading,
      open,
      updatedCount,
    } = this.props;
    const linodeCount = linodesWithoutBackups.length;
    return (
      <Drawer title="Enable All Backups" open={open} onClose={close}>
        <Grid container direction={'column'}>
          <Grid item>
            <Typography variant="body1">
              Three backup slots are executed and rotated automatically: a daily
              backup, a 2-7 day old backup, and an 8-14 day old backup. See our
              {` `}
              <Link
                to={
                  'https://www.linode.com/docs/platform' +
                  '/disk-images/linode-backup-service/'
                }
              >
                guide on Backups
              </Link>{' '}
              for more information on features and limitations. Confirm to add
              backups to <strong data-qa-backup-count>{linodeCount}</strong>{' '}
              {linodeCount > 1 ? 'Linodes' : 'Linode'}.
            </Typography>
          </Grid>
          {enableErrors && !isEmpty(enableErrors) && (
            <Grid item data-testid={'result-notice'}>
              <Notice error spacingBottom={0}>
                {getFailureNotificationText(updatedCount, enableErrors.length)}
              </Notice>
            </Grid>
          )}
          {/* Don't show this if the setting is already active. */}
          {!accountBackups && (
            <Grid item>
              <AutoEnroll
                enabled={autoEnroll}
                error={autoEnrollError}
                toggle={toggle}
              />
            </Grid>
          )}
          <Grid item>
            <DisplayPrice
              price={getTotalPrice(linodesWithoutBackups)}
              interval="mo"
            />
          </Grid>
          <Grid item>
            <ActionsPanel style={{ padding: 0, margin: 0 }}>
              <Button
                onClick={this.handleSubmit}
                loading={loading || enabling || enrolling}
                buttonType="primary"
                data


interface DispatchProps {
  actions: {
    enable: () => void;
    enroll: () => void;
    close: () => void;
    dismissError: () => void;
    dismissSuccess: () => void;
    toggle: () => void;
  };
}


interface StateProps {
  accountBackups: boolean;
  open: boolean;
  loading: boolean;
  enabling: boolean;
  backupLoadError: string;
  linodesWithoutBackups: ExtendedLinode[];
  backupsLoading: boolean;
  enableSuccess: boolean;
  enableErrors?: BackupError[];
  autoEnroll: boolean;
  autoEnrollError?: string;
  enrolling: boolean;
  updatedCount: number;
}


interface WithTypesProps {
  typesData: LinodeType[];
}


type CombinedProps = DispatchProps &
  StateProps &
  WithTypesProps &
  WithSnackbarProps;


componentDidUpdate() {
    const { close, dismissSuccess } = this.props.actions;
    const { autoEnroll, enableSuccess, updatedCount } = this.props;
    if (enableSuccess) {
      const pluralizedLinodes =
        updatedCount > 1 ? 'Linodes have' : 'Linode has';
      const text = autoEnroll
        ? `${updatedCount} ${pluralizedLinodes} been enrolled in automatic backups, and
        all new Linodes will automatically be backed up.`
        : `${updatedCount} ${pluralizedLinodes} been enrolled in automatic backups.`;
      this.props.enqueueSnackbar(text, {
        variant: 'success',
      });
      dismissSuccess();
      close();
    }
  }


render() {
    const {
      accountBackups,
      actions: { close, toggle },
      autoEnroll,
      autoEnrollError,
      enableErrors,
      enabling,
      enrolling,
      linodesWithoutBackups,
      loading,
      open,
      updatedCount,
    } = this.props;
    const linodeCount = linodesWithoutBackups.length;
    return (
      <Drawer title="Enable All Backups" open={open} onClose={close}>
        <Grid container direction={'column'}>
          <Grid item>
            <Typography variant="body1">
              Three backup slots are executed and rotated automatically: a daily
              backup, a 2-7 day old backup, and an 8-14 day old backup. See our
              {` `}
              <Link
                to={
                  'https://www.linode.com/docs/platform' +
                  '/disk-images/linode-backup-service/'
                }
              >
                guide on Backups
              </Link>{' '}
              for more information on features and limitations. Confirm to add
              backups to <strong data-qa-backup-count>{linodeCount}</strong>{' '}
              {linodeCount > 1 ? 'Linodes' : 'Linode'}.
            </Typography>
          </Grid>
          {enableErrors && !isEmpty(enableErrors) && (
            <Grid item data-testid={'result-notice'}>
              <Notice error spacingBottom={0}>
                {getFailureNotificationText(updatedCount, enableErrors.length)}
              </Notice>
            </Grid>
          )}
          {/* Don't show this if the setting is already active. */}
          {!accountBackups && (
            <Grid item>
              <AutoEnroll
                enabled={autoEnroll}
                error={autoEnrollError}
                toggle={toggle}
              />
            </Grid>
          )}
          <Grid item>
            <DisplayPrice
              price={getTotalPrice(linodesWithoutBackups)}
              interval="mo"
            />
          </Grid>
          <Grid item>
            <ActionsPanel style={{ padding: 0, margin: 0 }}>
              <Button
                onClick={this.handleSubmit}
                loading={loading || enabling || enrolling}


getFailureNotificationText(updatedCount, enableErrors


(goToSection) => (
      <>
        <p>
          이


(goToSection) => (
      <>
        <p>
          입력의


(goToSection) => (
      <p>
        스키마


(goToSection) => (
        <>
          <h2 className={typographyStyles.title}>커스텀


() => (
      <>
        <p>각


(goToSection) => (
      <p>
        <b className={typographyStyles.note}>참고


(goToSection) => ({
    title: "reset",
    description: (
      <>
        <p>
          이 함수는 폼 안의 필드 값과 에러를 초기화(reset) 합니다.


초기화(reset)


(props: IProps) => {
	return (

			<Icon className='num_icon' name={props.icon} size={48} />

				{props.name}

					<CountUp
						className='num'
						start={0}
						end={props.data}
						duration={3}
						decimals={props?.unit === '元' ? 2 : 0}


interface IProps {
	name: string
	data: number
	icon: string
	unit?: string
}


function set<T>(key: LocalStorageKey, value: T): void {
  localStorage.setItem(key, JSON.stringify(value))
}


function get<T>(key: LocalStorageKey): T | null {
  const value = localStorage.getItem(key)
  try {
    return value !== null ? JSON.parse(value) : value
  } catch {
    return (value as unknown) as T
  }
}


export type LocalStorageKey = typeof LOCAL_STORAGE_KEYS[keyof typeof LOCAL_STORAGE_KEYS]


export default function initMonitorSdk (config: userConfig,customPlugins?: any[]){
	config.options = defaultToOptions(config.options); // 设置config的默认值
  //  校验plugins的可执行性，即是否存在monitor方法并且该方法要是一个函数
  if(Array.isArray(customPlugins) && customPlugins.findIndex(item => typeof item.monitor !== 'function') !== -1){
    throw Error(`plugin'monitor must be a function `)
  }
  // 校验config中的属性
	const plugins = pluginAddByOptions(config.options,config.routeMode);
  Array.isArray(customPlugins) && (plugins.push(...customPlugins))
  const monitorSdk = new MonitorWeb(config);
  monitorSdk.use(plugins);
}


item => typeof item.monitor !== 'function'


export interface Config {
  areas: Array<any>;
  categories: Array<any>;
  country: string;
  countryList: Array<any>;
  ethnicities: Array<any>;
  documents: Array<any>;
  suburbs: string;
  upgrades: Upgrades;
  banners: Array<string>;
  blocked_words: string;
}


export interface Upgrades {
  category: any;
  ethnicity: any;
  gold: any;
  listing: any;
  location: any;
}


() => {
  const gridRef = createRef<HTMLDivElement>()
  const [gridItemWidth, setGridItemWidth] = useState<number>()
  const [prevWindowWidth, setPrevWindowWidth] = useState(0)

  useEffect(() => {
    const resizeListener = () => {
      // no need to update when previous width is bigger
      if (prevWindowWidth > window.innerWidth) return
      setPrevWindowWidth(window.innerWidth)
      // get first item width
      const parent = gridRef.current?.childNodes
      if (!parent) return
      setGridItemWidth((parent.item(0) as any).offsetWidth)
    }
    resizeListener()
    window.addEventListener("resize", resizeListener)
    return () => window.removeEventListener("resize", resizeListener)
  }, [gridRef])

  return {
    gridItemWidth,
    gridRef,
  }
}


() => {
    const resizeListener = () => {
      // no need to update when previous width is bigger
      if (prevWindowWidth > window.innerWidth) return
      setPrevWindowWidth(window.innerWidth)
      // get first item width
      const parent = gridRef.current?.childNodes
      if (!parent) return
      setGridItemWidth((parent.item(0) as any).offsetWidth)
    }
    resizeListener()
    window.addEventListener("resize", resizeListener)
    return () => window.removeEventListener("resize", resizeListener)
  }


() => {
      // no need to update when previous width is bigger
      if (prevWindowWidth > window.innerWidth) return
      setPrevWindowWidth(window.innerWidth)
      // get first item width
      const parent = gridRef.current?.childNodes
      if (!parent) return
      setGridItemWidth((parent.item(0) as any).offsetWidth)
    }


() => window.removeEventListener("resize", resizeListener)


export function content(_content: HTMLElement, toc: HTMLElement, renderer: RendererLike<any, any>, file: File<string>) {
  return (
    <Page title={config.page.title.extractor(_content, config, file)}
          favicon={config.page.favicon}
          meta={<Meta {...config.page.meta}/>}
          fonts={<Fonts {...config.page.fonts}/>}

          scripts={config.page.scripts}
          stylesheets={[
            ...config.page.stylesheets || [],
            <style>{`* {line-height: 1.65em} code, code * {line-height: 1.25em}`}


export interface AppState {
  planner?: PlannerState;

  listPage?: ListPage;

  boardView?: BoardViewState;

  iterationPanel: {
    iterationUI: states.IterationUIState
  };

  detailPage: {
    comments: states.CommentState,
    workItem: states.DetailWorkItemState,
    linkType: states.LinkTypeState,
    workItemLink: states.WorkItemLinkState,
    events: states.EventState
  };

  toolbar: {
    filters: states.FilterState
  };

  workItemLink: {
    workItems: states.WorkItemState
  };
}


export interface BoardViewState {
  boards: states.BoardState;
  columnWorkItem: states.ColumnWorkItemState;
  boardUi: states.BoardUIState;
}


export interface ListPage {}


export interface PlannerState {
  iterations: states.IterationState;
  labels: states.LabelState;
  areas: states.AreaState;
  collaborators: states.CollaboratorState;
  users: states.UserState;
  customQueries: states.CustomQueryState;
  groupTypes: states.GroupTypeState;
  space: states.SpaceState;
  workItems: states.WorkItemState;
  workItemStates: states.WIState;
  workItemTypes: states.WorkItemTypeState;
  infotips: states.InfotipState;
}


@NgModule({
    declarations: [
        CoreLoginSitesPage,
    ],
    imports: [
        CoreDirectivesModule,
        IonicPageModule.forChild(CoreLoginSitesPage),
        TranslateModule.forChild()
    ],
    entryComponents: [
        CoreLoginSitesPage
    ]
})
export class CoreLoginSitesPageModule {}


export function registerEndpointRoutes(router: IRouter, endpointAppContext: EndpointAppContext) {
  const logger = getLogger(endpointAppContext);
  router.post(
    {
      path: '/api/endpoint/metadata',
      validate: {
        body: schema.nullable(
          schema.object({
            paging_properties: schema.nullable(
              schema.arrayOf(
                schema.oneOf([
                  /**
                   * the number of results to return for this request per page
                   */
                  schema.object({
                    page_size: schema.number({ defaultValue: 10, min: 1, max: 10000 }),
                  }),
                  /**
                   * the zero based page index of the the total number of pages of page size
                   */
                  schema.object({ page_index: schema.number({ defaultValue: 0, min: 0 }) }),
                ])
              )
            ),
            /**
             * filter to be applied, it could be a kql expression or discrete filter to be implemented
             */
            filter: schema.nullable(schema.oneOf([schema.string()])),
          })
        ),
      },
      options: { authRequired: true, tags: ['access:securitySolution'] },
    },
    async (context, req, res) => {
      try {
        const agentService = endpointAppContext.service.getAgentService();
        if (agentService === undefined) {
          throw new Error('agentService not available');
        }

        const metadataRequestContext: MetadataRequestContext = {
          agentService,
          logger,
          requestHandlerContext: context,
        };

        const unenrolledAgentIds = await findAllUnenrolledAgentIds(
          agentService,
          context.core.savedObjects.client
        );

        const queryParams = await kibanaRequestToMetadataListESQuery(
          req,
          endpointAppContext,
          metadataIndexPattern,
          {
            unenrolledAgentIds: unenrolledAgentIds.concat(IGNORED_ELASTIC_AGENT_IDS),
          }
        );

        const response = (await context.core.elasticsearch.legacy.client.callAsCurrentUser(
          'search',
          queryParams
        )) as SearchResponse<HostMetadata>;

        return res.ok({
          body: await mapToHostResultList(queryParams, response, metadataRequestContext),
        });
      } catch (err) {
        logger.warn(JSON.stringify(err, null, 2));
        return res.internalError({ body: err });
      }
    }
  );

  router.get(
    {
      path: '/api/endpoint/metadata/{id}',
      validate: {
        params: schema.object({ id: schema.string() }),
      },
      options: { authRequired: true, tags: ['access:securitySolution'] },
    },
    async (context, req, res) => {
      const agentService = endpointAppContext.service.getAgentService();
      if (agentService === undefined) {
        return res.internalError({ body: 'agentService not available' });
      }

      const metadataRequestContext: MetadataRequestContext = {
        agentService,
        logger,
        requestHandlerContext: context,
      };

      try {
        const doc = await getHostData(metadataRequestContext, req.params.id);
        if (doc) {
          return res.ok({ body: doc });
        }
        return res.notFound({ body: 'Endpoint Not Found' });
      } catch (err) {
        logger.warn(JSON.stringify(err, null, 2));
        if (err.isBoom) {
          return res.customError({
            statusCode: err.output.statusCode,
            body: { message: err.message },
          });
        }
        return res.internalError({ body: err });
      }
    }
  );
}


export async function getHostData(
  metadataRequestContext: MetadataRequestContext,
  id: string
): Promise<HostInfo | undefined> {
  const query = getESQueryHostMetadataByID(id, metadataIndexPattern);
  const response = (await metadataRequestContext.requestHandlerContext.core.elasticsearch.legacy.client.callAsCurrentUser(
    'search',
    query
  )) as SearchResponse<HostMetadata>;

  if (response.hits.hits.length === 0) {
    return undefined;
  }

  const hostMetadata: HostMetadata = response.hits.hits[0]._source;
  const agent = await findAgent(metadataRequestContext, hostMetadata);

  if (agent && !agent.active) {
    throw Boom.badRequest('the requested endpoint is unenrolled');
  }

  return enrichHostMetadata(hostMetadata, metadataRequestContext);
}


async function findAgent(
  metadataRequestContext: MetadataRequestContext,
  hostMetadata: HostMetadata
): Promise<Agent | undefined> {
  try {
    return await metadataRequestContext.agentService.getAgent(
      metadataRequestContext.requestHandlerContext.core.savedObjects.client,
      hostMetadata.elastic.agent.id
    );
  } catch (e) {
    if (e.isBoom && e.output.statusCode === 404) {
      metadataRequestContext.logger.warn(
        `agent with id ${hostMetadata.elastic.agent.id} not found`
      );
      return undefined;
    } else {
      throw e;
    }
  }
}


async function mapToHostResultList(
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  queryParams: Record<string, any>,
  searchResponse: SearchResponse<HostMetadata>,
  metadataRequestContext: MetadataRequestContext
): Promise<HostResultList> {
  const totalNumberOfHosts = searchResponse?.aggregations?.total?.value || 0;
  if (searchResponse.hits.hits.length > 0) {
    return {
      request_page_size: queryParams.size,
      request_page_index: queryParams.from,
      hosts: await Promise.all(
        searchResponse.hits.hits
          .map((response) => response.inner_hits.most_recent.hits.hits)
          .flatMap((data) => data as HitSource)
          .map(async (entry) => enrichHostMetadata(entry._source, metadataRequestContext))
      ),
      total: totalNumberOfHosts,
    };
  } else {
    return {
      request_page_size: queryParams.size,
      request_page_index: queryParams.from,
      total: totalNumberOfHosts,
      hosts: [],
    };
  }
}